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 <cstddef>
16 #include <cstdint>
17
18 #include "gtest/gtest.h"
19
20 // Add the following two macro definitions to test the private and protected method.
21 #define private public
22 #define protected public
23
24 #include "base/geometry/ng/offset_t.h"
25 #include "base/geometry/ng/size_t.h"
26 #include "base/memory/ace_type.h"
27 #include "base/memory/referenced.h"
28 #include "core/components/theme/app_theme.h"
29 #include "core/components_ng/base/frame_node.h"
30 #include "core/components_ng/event/focus_hub.h"
31 #include "core/components_ng/event/touch_event.h"
32 #include "core/components_ng/pattern/button/button_pattern.h"
33 #include "core/components_ng/pattern/flex/flex_layout_pattern.h"
34 #include "core/components_ng/pattern/pattern.h"
35 #include "test/mock/core/common/mock_theme_manager.h"
36 #include "core/components_v2/inspector/inspector_constants.h"
37 #include "core/event/key_event.h"
38 #include "core/pipeline_ng/pipeline_context.h"
39 #include "test/mock/core/pipeline/mock_pipeline_context.h"
40
41 using namespace testing;
42 using namespace testing::ext;
43
44 namespace OHOS::Ace::NG {
45 namespace {
46 constexpr int32_t FOCUS_NODE_SIZE = 2;
47 constexpr int32_t NODE_SIZE = 0;
48 const BlurReason BLUR_REASON_FOCUS_SWITCH = BlurReason::FOCUS_SWITCH;
49 const BlurReason BLUR_REASON_WINDOW_BLUR = BlurReason::WINDOW_BLUR;
50 const std::string RESULT_SUCCESS_ONE = "sucess1";
51 const std::string RESULT_SUCCESS_TWO = "sucess2";
52 } // namespace
53
54 class FocusHubTestNg : public testing::Test {
55 public:
56 static void SetUpTestSuite();
57 static void TearDownTestSuite();
58 void SetUp() override;
59 void TearDown() override;
60 };
61
SetUpTestSuite()62 void FocusHubTestNg::SetUpTestSuite()
63 {
64 MockPipelineContext::SetUp();
65 GTEST_LOG_(INFO) << "FocusHubTestNg SetUpTestCase";
66 }
67
TearDownTestSuite()68 void FocusHubTestNg::TearDownTestSuite()
69 {
70 MockPipelineContext::TearDown();
71 GTEST_LOG_(INFO) << "FocusHubTestNg TearDownTestCase";
72 }
73
SetUp()74 void FocusHubTestNg::SetUp() {}
75
TearDown()76 void FocusHubTestNg::TearDown() {}
77
78 /**
79 * @tc.name: FocusHubCreateTest001
80 * @tc.desc: Create FocusHub.
81 * @tc.type: FUNC
82 */
83 HWTEST_F(FocusHubTestNg, FocusHubCreateTest001, TestSize.Level1)
84 {
85 /**
86 * @tc.steps: step1. Create FocusHub with passing is null as parameter.
87 * @tc.expected: eventHub_ cannot be updated.
88 */
89 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(nullptr);
90 EXPECT_TRUE(focusHub1->GetFrameNode() == nullptr);
91 EXPECT_TRUE(focusHub1->IsEnabled());
92 EXPECT_TRUE(!focusHub1->IsFocusableNode());
93
94 /**
95 * @tc.steps: step2. Create FocusHub with the WeakPtr eventHub_ which does not own frameNode.
96 * @tc.expected: eventHub can be updated, but cannot get frameNode and its related properties.
97 */
98 auto eventHub2 = AceType::MakeRefPtr<EventHub>();
99 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub2);
100 EXPECT_TRUE(focusHub2 != nullptr);
101 EXPECT_TRUE(focusHub2->GetFrameNode() == nullptr);
102 EXPECT_TRUE(focusHub2->GetGeometryNode() == nullptr);
103 EXPECT_EQ(focusHub2->GetFrameName(), "NULL");
104 EXPECT_EQ(focusHub2->GetInspectorKey(), std::nullopt);
105
106 /**
107 * @tc.steps: step3. Invoke GetParentFocusHub without parameter.
108 * @tc.expected: FocusHub will return frameNode' parent focusHub which is also nullptr.
109 */
110 EXPECT_TRUE(focusHub2->GetParentFocusHub() == nullptr);
111
112 /**
113 * @tc.steps: step4. Invoke GetParentFocusHub passing node as parameter which does not have parent.
114 * @tc.expected: FocusHub will return node' parent focusHub which does not exist.
115 */
116 auto node = FrameNode(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
117 EXPECT_TRUE(focusHub2->GetParentFocusHub() == nullptr);
118 }
119
120 /**
121 * @tc.name: FocusHubCreateTest002
122 * @tc.desc: Create FocusHub.
123 * @tc.type: FUNC
124 */
125 HWTEST_F(FocusHubTestNg, FocusHubCreateTest002, TestSize.Level1)
126 {
127 /**
128 * @tc.steps: step1. Create FocusHub with the WeakPtr eventHub_ owning frameNode.
129 * @tc.expected: eventHub can be updated and can get frameNode and its related properties.
130 */
131 auto eventHub = AceType::MakeRefPtr<EventHub>();
132 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
133 eventHub->AttachHost(frameNode);
134 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
135 EXPECT_TRUE(focusHub->GetFrameNode() != nullptr);
136 EXPECT_TRUE(focusHub->GetGeometryNode() != nullptr);
137 EXPECT_EQ(focusHub->GetFrameName(), V2::TEXT_ETS_TAG);
138 EXPECT_EQ(focusHub->GetInspectorKey(), std::nullopt);
139
140 /**
141 * @tc.steps: step2. Invoke GetParentFocusHub without passing parameter.
142 * @tc.expected: FocusHub will return frameNode' parent focusHub which is also nullptr.
143 */
144 EXPECT_TRUE(focusHub->GetParentFocusHub() == nullptr);
145
146 /**
147 * @tc.steps: step3. Create focusHub and its frameNode has parent node.
148 * @tc.expected: FocusHub will return frameNode' parent focusHub.
149 */
150 auto nodeParent = AceType::MakeRefPtr<FrameNode>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>());
151 nodeParent->GetOrCreateFocusHub();
152 frameNode->SetParent(nodeParent);
153 eventHub->AttachHost(frameNode);
154 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub);
155 EXPECT_TRUE(focusHub2->GetParentFocusHub() != nullptr);
156 }
157
158 /**
159 * @tc.name: FocusHubFlushChildrenFocusHubTest003
160 * @tc.desc: Create FocusHub and invoke FlushChildrenFocusHub.
161 * @tc.type: FUNC
162 */
163 HWTEST_F(FocusHubTestNg, FocusHubFlushChildrenFocusHubTest003, TestSize.Level1)
164 {
165 /**
166 * @tc.steps: step1. Create frameNode and add button as its children which focus type is enable.
167 */
168 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
169 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
170 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
171 child->GetOrCreateFocusHub();
172 child2->GetOrCreateFocusHub();
173 frameNode->AddChild(child);
174 frameNode->AddChild(child2);
175
176 /**
177 * @tc.steps: step2. Create FocusHub.
178 */
179 auto eventHub = AceType::MakeRefPtr<EventHub>();
180 eventHub->AttachHost(frameNode);
181 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
182
183 /**
184 * @tc.steps: step3. Invoke FlushChildrenFocusHub to get the focusable children.
185 * @tc.expected: Button is the focusable child which will be emplace_back in focusNodes_.
186 */
187 std::list<RefPtr<FocusHub>> focusNodes;
188 focusHub->FlushChildrenFocusHub(focusNodes);
189 EXPECT_EQ(focusNodes.size(), FOCUS_NODE_SIZE);
190 EXPECT_EQ(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
191
192 /**
193 * @tc.steps: step4. lastWeakFocusNode_ is not nullptr.
194 * @tc.expected: itLastFocusNode_ will be assigned the iter corresponding lastWeakFocusNode_ found in focusNodes_.
195 */
196 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(*(focusNodes.begin())));
197 EXPECT_EQ(focusHub->lastWeakFocusNode_.Upgrade(), *(focusNodes.begin()));
198 }
199
200 /**
201 * @tc.name: FocusHubRemoveSelfTest004
202 * @tc.desc: Create FocusHub and invoke RemoveSelf.
203 * @tc.type: FUNC
204 */
205 HWTEST_F(FocusHubTestNg, FocusHubRemoveSelfTest004, TestSize.Level1)
206 {
207 /**
208 * @tc.steps: step1. Create frameNode and add its parent.
209 */
210 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
211 auto nodeParent = AceType::MakeRefPtr<FrameNode>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>());
212 nodeParent->GetOrCreateFocusHub();
213 frameNode->SetParent(nodeParent);
214
215 /**
216 * @tc.steps: step2. Create FocusHub.
217 */
218 auto eventHub = AceType::MakeRefPtr<EventHub>();
219 eventHub->AttachHost(frameNode);
220 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
221
222 /**
223 * @tc.steps: step3. Remove self.
224 * @tc.expected: The nodeParent children size is 0.
225 */
226 focusHub->RemoveSelf();
227 EXPECT_EQ(nodeParent->GetChildren().size(), NODE_SIZE);
228 }
229
230 /**
231 * @tc.name: FocusHubLostFocusTest005
232 * @tc.desc: Create FocusHub and invoke LostFocus.
233 * @tc.type: FUNC
234 */
235 HWTEST_F(FocusHubTestNg, FocusHubLostFocusTest005, TestSize.Level1)
236 {
237 /**
238 * @tc.steps: step1. Create frameNode and add button as its children which focus type is enable.
239 */
240 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
241
242 /**
243 * @tc.steps: step2. Create FocusHub.
244 */
245 auto eventHub = AceType::MakeRefPtr<EventHub>();
246 eventHub->AttachHost(frameNode);
247 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
248
249 /**
250 * @tc.steps: step3. Invoke LostFocus, when FocusType is DISABLE and the blur reason is FOCUS_SWITCH.
251 * @tc.expected: currentFocus_ is false.
252 */
253 focusHub->currentFocus_ = true;
254 focusHub->LostFocus(BLUR_REASON_FOCUS_SWITCH);
255 EXPECT_EQ(focusHub->blurReason_, BLUR_REASON_FOCUS_SWITCH);
256 EXPECT_FALSE(focusHub->currentFocus_);
257
258 /**
259 * @tc.steps: step4. Invoke LostFocus, when FocusType is NODE and the blur reason is WINDOW_BLUR.
260 * @tc.expected: currentFocus_ is false.
261 */
262 focusHub->currentFocus_ = true;
263 focusHub->focusType_ = FocusType::NODE;
264 focusHub->LostFocus(BLUR_REASON_WINDOW_BLUR);
265 EXPECT_EQ(focusHub->blurReason_, BLUR_REASON_WINDOW_BLUR);
266 EXPECT_FALSE(focusHub->currentFocus_);
267
268 /**
269 * @tc.steps: step5. Invoke LostFocus, when FocusType is SCOPE and the blur reason is WINDOW_BLUR.
270 * @tc.expected: currentFocus_ is false.
271 */
272 focusHub->currentFocus_ = true;
273 focusHub->focusType_ = FocusType::SCOPE;
274 focusHub->LostFocus(BLUR_REASON_WINDOW_BLUR);
275 EXPECT_FALSE(focusHub->currentFocus_);
276 }
277
278 /**
279 * @tc.name: FocusHubHandleKeyEventTest006
280 * @tc.desc: Create FocusHub and invoke HandleKeyEvent.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(FocusHubTestNg, FocusHubHandleKeyEventTest006, TestSize.Level1)
284 {
285 /**
286 * @tc.steps: step1. Create frameNode.
287 */
288 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
289 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
290 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
291 child->GetOrCreateFocusHub();
292 child2->GetOrCreateFocusHub();
293 frameNode->AddChild(child);
294 frameNode->AddChild(child2);
295
296 /**
297 * @tc.steps: step2. Create FocusHub.
298 */
299 auto eventHub = AceType::MakeRefPtr<EventHub>();
300 eventHub->AttachHost(frameNode);
301 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
302
303 /**
304 * @tc.steps: step3. Focus hub does not currently focused and FocusType is DISABLE.
305 * @tc.expected: Do not handle key event.
306 */
307 KeyEvent keyEvent;
308 keyEvent.code = KeyCode::TV_CONTROL_UP;
309 EXPECT_FALSE(focusHub->HandleKeyEvent(keyEvent));
310
311 /**
312 * @tc.steps: step4. Focus hub is currently focused, FocusType is DISABLE and key code is TV_CONTROL_UP.
313 * @tc.expected: OnKeyEventScope -> RequestNextFocus.
314 */
315 focusHub->focusType_ = FocusType::SCOPE;
316 focusHub->currentFocus_ = true;
317 EXPECT_FALSE(focusHub->HandleKeyEvent(keyEvent));
318 }
319
320 /**
321 * @tc.name: FocusHubTestNg007
322 * @tc.desc: Test the function IsFocusableScope.
323 * @tc.type: FUNC
324 */
325 HWTEST_F(FocusHubTestNg, FocusHubTestNg007, TestSize.Level1)
326 {
327 /**
328 * @tc.steps1: initialize parameters.
329 */
330 auto eventHub = AceType::MakeRefPtr<EventHub>();
331 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
332 focusHub->focusable_ = true;
333 focusHub->parentFocusable_ = true;
334
335 /**
336 * @tc.steps2: call the function SetEnabled with false
337 * @tc.expected: The return value of IsFocusableScope is false.
338 */
339 eventHub->SetEnabled(false);
340 EXPECT_FALSE(focusHub->IsFocusableScope());
341
342 /**
343 * @tc.steps3: call the function SetEnabled with true.
344 * @tc.expected: The return value of IsFocusableScope is false.
345 */
346 eventHub->SetEnabled(true);
347 EXPECT_FALSE(focusHub->IsFocusableScope());
348 }
349
350 /**
351 * @tc.name: FocusHubTestNg008
352 * @tc.desc: Test the function SetFocusable.
353 * @tc.type: FUNC
354 */
355 HWTEST_F(FocusHubTestNg, FocusHubTestNg008, TestSize.Level1)
356 {
357 /**
358 * @tc.steps1: initialize parameters.
359 * @tc.expected: The default value of focusable_ is false.
360 */
361 auto eventHub = AceType::MakeRefPtr<EventHub>();
362 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
363 EXPECT_FALSE(focusHub->focusable_);
364
365 /**
366 * @tc.steps2: Set focusable_ to true implicitly.
367 * @tc.expected: The value of focusable_ is true.
368 */
369 focusHub->SetFocusable(true, false);
370 EXPECT_TRUE(focusHub->focusable_);
371
372 /**
373 * @tc.steps3:Set focusable_ to false explicitly.
374 * @tc.expected: The value of focusable_ is false.
375 */
376 focusHub->SetFocusable(false);
377
378 /**
379 * @tc.steps4:Set focusable_ to true implicitly.
380 * @tc.expected: The value of focusable_ is false.
381 */
382 focusHub->SetFocusable(true, false);
383 EXPECT_FALSE(focusHub->focusable_);
384
385 /**
386 * @tc.steps5:Set focusable_ to true explicitly.
387 * @tc.expected: The value of focusable_ is true.
388 */
389 focusHub->SetFocusable(true);
390 EXPECT_TRUE(focusHub->focusable_);
391 }
392
393 /**
394 * @tc.name: FocusHubTestNg009
395 * @tc.desc: Test the function IsFocusable.
396 * @tc.type: FUNC
397 */
398 HWTEST_F(FocusHubTestNg, FocusHubTestNg009, TestSize.Level1)
399 {
400 /**
401 * @tc.steps1: initialize parameters.
402 */
403 auto eventHub = AceType::MakeRefPtr<EventHub>();
404 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
405 eventHub->SetEnabled(false);
406
407 /**
408 * @tc.steps2: call the function IsFocusable with FocusType::NODE
409 * @tc.expected: The return value of IsFocusable is false.
410 */
411 focusHub->SetFocusType(FocusType::NODE);
412 EXPECT_FALSE(focusHub->IsFocusable());
413
414 /**
415 * @tc.steps3: call the function IsFocusable with FocusType::SCOPE
416 * @tc.expected: The return value of IsFocusable is false.
417 */
418 focusHub->SetFocusType(FocusType::SCOPE);
419 EXPECT_FALSE(focusHub->IsFocusable());
420
421 /**
422 * @tc.steps4: call the function IsFocusable with FocusType::DISABLE
423 * @tc.expected: The return value of IsFocusable is false.
424 */
425 focusHub->SetFocusType(FocusType::DISABLE);
426 EXPECT_FALSE(focusHub->IsFocusable());
427 }
428
429 /**
430 * @tc.name: FocusHubTestNg010
431 * @tc.desc: Test the function RequestFocusImmediately.
432 * @tc.type: FUNC
433 */
434 HWTEST_F(FocusHubTestNg, FocusHubTestNg0010, TestSize.Level1)
435 {
436 /**
437 * @tc.steps1: initialize parameters.
438 */
439 auto eventHub = AceType::MakeRefPtr<EventHub>();
440 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
441 auto context = PipelineContext::GetCurrentContext();
442 ASSERT_NE(context, nullptr);
443
444 /**
445 * @tc.steps2: call the function SetFocusType with currentFocus_ = false.
446 * @tc.expected: The return value of RequestFocusImmediately is false.
447 */
448 context->SetIsFocusingByTab(true);
449 focusHub->SetFocusType(FocusType::DISABLE);
450 EXPECT_FALSE(focusHub->RequestFocusImmediately());
451
452 /**
453 * @tc.steps3: call the function SetFocusType with currentFocus_ = true
454 * @tc.expected: The return value of RequestFocusImmediately is true.
455 */
456 context->SetIsFocusingByTab(false);
457 focusHub->SetFocusType(FocusType::DISABLE);
458 focusHub->currentFocus_ = true;
459 EXPECT_TRUE(focusHub->RequestFocusImmediately());
460 }
461
462 /**
463 * @tc.name: FocusHubTestNg011
464 * @tc.desc: Test the function LostFocus.
465 * @tc.type: FUNC
466 */
467 HWTEST_F(FocusHubTestNg, FocusHubTestNg0011, TestSize.Level1)
468 {
469 /**
470 * @tc.steps1: initialize parameters.
471 */
472 auto eventHub = AceType::MakeRefPtr<EventHub>();
473 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
474
475 /**
476 * @tc.steps2: call the function LostFocus with currentFocus_ = false.
477 * @tc.expected: The value of blurReason_ is changed to BlurReason::WINDOW_BLUR.
478 */
479 focusHub->blurReason_ = BlurReason::WINDOW_BLUR;
480 focusHub->currentFocus_ = false;
481 focusHub->LostFocus(BlurReason::FOCUS_SWITCH);
482 EXPECT_EQ(focusHub->blurReason_, BlurReason::WINDOW_BLUR);
483
484 /**
485 * @tc.steps3: call the function LostFocus with currentFocus_ = true.
486 * @tc.expected: The value of blurReason_ is changed to BlurReason::FOCUS_SWITCH.
487 */
488 focusHub->currentFocus_ = true;
489 focusHub->LostFocus(BlurReason::FOCUS_SWITCH);
490 EXPECT_EQ(focusHub->blurReason_, BlurReason::FOCUS_SWITCH);
491 }
492
493 /**
494 * @tc.name: FocusHubTestNg012
495 * @tc.desc: Test the function LostSelfFocus.
496 * @tc.type: FUNC
497 */
498 HWTEST_F(FocusHubTestNg, FocusHubTestNg0012, TestSize.Level1)
499 {
500 /**
501 * @tc.steps1: initialize parameters.
502 */
503 auto eventHub = AceType::MakeRefPtr<EventHub>();
504 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
505
506 /**
507 * @tc.steps2: call the function LostSelfFocus with currentFocus_ = false.
508 * @tc.expected: The value of focusable_ is changed to false.
509 */
510 focusHub->currentFocus_ = false;
511 focusHub->SetFocusable(false);
512 focusHub->LostSelfFocus();
513 EXPECT_FALSE(focusHub->focusable_);
514
515 /**
516 * @tc.steps3: call the function LostSelfFocus with currentFocus_ = true.
517 * @tc.expected: The value of focusable_ is changed to true.
518 */
519 focusHub->currentFocus_ = true;
520 focusHub->LostSelfFocus();
521 EXPECT_TRUE(focusHub->focusable_);
522 }
523
524 /**
525 * @tc.name: FocusHubTestNg013
526 * @tc.desc: Test the function SetShow, SetEnabled, SetEnabledNode and SetEnabledScope.
527 * @tc.type: FUNC
528 */
529 HWTEST_F(FocusHubTestNg, FocusHubTestNg0013, TestSize.Level1)
530 {
531 /**
532 * @tc.steps1: initialize parameters.
533 */
534 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
535 auto eventHub = AceType::MakeRefPtr<EventHub>();
536 eventHub->AttachHost(frameNode);
537 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
538 auto context = PipelineContext::GetCurrentContext();
539 ASSERT_NE(context, nullptr);
540
541 /**
542 * @tc.steps2: call the function SetShow with FocusType::NODE.
543 * @tc.expected: The value of show_ is changed to true.
544 */
545 focusHub->SetFocusType(FocusType::NODE);
546 focusHub->SetShow(true);
547 focusHub->SetEnabled(true);
548 EXPECT_TRUE(focusHub->IsShow());
549
550 /**
551 * @tc.steps3: call the function SetShow with FocusType::SCOPE.
552 * @tc.expected: The value of show_ is changed to false.
553 */
554 focusHub->SetFocusType(FocusType::SCOPE);
555 focusHub->SetShow(false);
556 focusHub->SetEnabled(false);
557 frameNode->layoutProperty_->propVisibility_ = VisibleType::INVISIBLE;
558 EXPECT_FALSE(focusHub->IsShow());
559
560 /**
561 * @tc.steps4: call the function SetShow with FocusType::DISABLE.
562 * @tc.expected: The value of show_ is changed to false.
563 */
564 focusHub->SetFocusType(FocusType::DISABLE);
565 focusHub->SetShow(true);
566 focusHub->SetEnabled(true);
567 EXPECT_FALSE(focusHub->IsShow());
568 }
569
570 /**
571 * @tc.name: FocusHubTestNg014
572 * @tc.desc: Test functions OnFocus, OnFocusNode and OnFocusScope.
573 * @tc.type: FUNC
574 */
575 HWTEST_F(FocusHubTestNg, FocusHubTestNg0014, TestSize.Level1)
576 {
577 /**
578 * @tc.steps1: initialize parameters.
579 */
580 auto eventHub = AceType::MakeRefPtr<EventHub>();
581 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
582
583 /**
584 * @tc.steps2: call the function OnFocus with FocusType::SCOPE.
585 * @tc.expected: The focusNodes_ is empty.
586 */
587 focusHub->SetFocusType(FocusType::SCOPE);
588 focusHub->OnFocus();
589 std::list<RefPtr<FocusHub>> focusNodes;
590 focusHub->FlushChildrenFocusHub(focusNodes);
591 EXPECT_TRUE(focusNodes.empty());
592
593 /**
594 * @tc.steps3: call the function OnFocus with FocusType::NODE.
595 * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
596 */
597 focusHub->SetFocusType(FocusType::NODE);
598 focusHub->OnFocus();
599 bool flagCbk1 = false;
600 bool flagCbk2 = false;
__anon2dd0c4310202() 601 focusHub->onFocusInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
602 focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
__anon2dd0c4310302() 603 focusHub->focusCallbackEvents_->SetOnFocusCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
604 focusHub->OnFocus();
605 EXPECT_TRUE(flagCbk1);
606 EXPECT_TRUE(flagCbk2);
607 }
608
609 /**
610 * @tc.name: FocusHubTestNg015
611 * @tc.desc: Test functions OnBlur, OnBlurNode and OnBlurScope.
612 * @tc.type: FUNC
613 */
614 HWTEST_F(FocusHubTestNg, FocusHubTestNg0015, TestSize.Level1)
615 {
616 /**
617 * @tc.steps1: initialize parameters.
618 */
619 auto eventHub = AceType::MakeRefPtr<EventHub>();
620 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
621
622 /**
623 * @tc.steps2: call the function OnBlur with FocusType::NODE.
624 * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
625 */
626 focusHub->SetFocusType(FocusType::NODE);
627 focusHub->OnBlur();
628 bool flagCbk1 = false;
629 bool flagCbk2 = false;
630 BlurReason flagReason = BlurReason::WINDOW_BLUR;
__anon2dd0c4310402() 631 focusHub->onBlurInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
__anon2dd0c4310502(BlurReason reason) 632 focusHub->onBlurReasonInternal_ = [&flagReason](BlurReason reason) { flagReason = reason; };
__anon2dd0c4310602() 633 focusHub->SetOnBlurCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
634 focusHub->OnBlur();
635 EXPECT_TRUE(flagCbk1);
636 EXPECT_TRUE(flagCbk2);
637 EXPECT_EQ(flagReason, BlurReason::FOCUS_SWITCH);
638
639 /**
640 * @tc.steps3: call the function OnBlur with FocusType::SCOPE.
641 * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
642 */
643 focusHub->SetFocusType(FocusType::SCOPE);
644 focusHub->OnFocus();
645 flagCbk1 = false;
646 flagCbk2 = false;
647 flagReason = BlurReason::WINDOW_BLUR;
__anon2dd0c4310702() 648 focusHub->onBlurInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
__anon2dd0c4310802(BlurReason reason) 649 focusHub->onBlurReasonInternal_ = [&flagReason](BlurReason reason) { flagReason = reason; };
__anon2dd0c4310902() 650 focusHub->SetOnBlurCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
651 focusHub->OnBlur();
652 EXPECT_TRUE(flagCbk1);
653 EXPECT_TRUE(flagCbk2);
654 EXPECT_EQ(flagReason, BlurReason::FOCUS_SWITCH);
655 }
656
657 /**
658 * @tc.name: FocusHubTestNg016
659 * @tc.desc: Test the function OnKeyEvent, OnKeyEventScope and OnKeyEventNode.
660 * @tc.type: FUNC
661 */
662 HWTEST_F(FocusHubTestNg, FocusHubTestNg0016, TestSize.Level1)
663 {
664 /**
665 * @tc.steps1: initialize parameters.
666 */
667 auto eventHub = AceType::MakeRefPtr<EventHub>();
668 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
669 auto context = PipelineContext::GetCurrentContext();
670 ASSERT_NE(context, nullptr);
671 KeyEvent keyEvent;
672 keyEvent.action = KeyAction::DOWN;
673 keyEvent.code = KeyCode::KEY_SPACE;
674
675 /**
676 * @tc.steps2: call the function OnKeyEvent with FocusType::NODE.
677 * @tc.expected: The return value of OnKeyEvent is false.
678 */
679 focusHub->SetFocusType(FocusType::NODE);
680 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
681
682 /**
683 * @tc.steps3: call the function OnKeyEvent with FocusType::SCOPE.
684 * @tc.expected: The return value of OnKeyEvent is false.
685 */
686 focusHub->SetFocusType(FocusType::SCOPE);
687 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
688
689 /**
690 * @tc.steps4: call the function OnKeyEvent with FocusType::DISABLE.
691 * @tc.expected: The return value of OnKeyEvent is false.
692 */
693 focusHub->SetFocusType(FocusType::DISABLE);
694 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
695 }
696
697 /**
698 * @tc.name: FocusHubTestNg017
699 * @tc.desc: Test the function HandleFocusByTabIndex.
700 * @tc.type: FUNC
701 */
702 HWTEST_F(FocusHubTestNg, FocusHubTestNg0017, TestSize.Level1)
703 {
704 /**
705 * @tc.steps1: initialize parameters.
706 */
707 auto eventHub = AceType::MakeRefPtr<EventHub>();
708 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
709 KeyEvent keyEvent;
710
711 /**
712 * @tc.steps2: call the function HandleFocusByTabIndex with code != KeyCode::KEY_TAB and action != KeyAction::DOWN.
713 * @tc.expected: The return value of HandleFocusByTabIndex is false.
714 */
715 keyEvent.action = KeyAction::UNKNOWN;
716 keyEvent.code = KeyCode::KEY_UNKNOWN;
717 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
718
719 /**
720 * @tc.steps3: call the function HandleFocusByTabIndex with code != KeyCode::KEY_TAB and action == KeyAction::DOWN.
721 * @tc.expected: The return value of HandleFocusByTabIndex is false.
722 */
723 keyEvent.action = KeyAction::DOWN;
724 keyEvent.code = KeyCode::KEY_UNKNOWN;
725 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
726
727 /**
728 * @tc.steps4: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action != KeyAction::DOWN.
729 * @tc.expected: The return value of HandleFocusByTabIndex is false.
730 */
731 keyEvent.action = KeyAction::UNKNOWN;
732 keyEvent.code = KeyCode::KEY_TAB;
733 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
734
735 /**
736 * @tc.steps5: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action == KeyAction::DOWN
737 * and curPage == null.
738 * @tc.expected: The return value of HandleFocusByTabIndex is false.
739 */
740 keyEvent.action = KeyAction::DOWN;
741 keyEvent.code = KeyCode::KEY_TAB;
742 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
743
744 /**
745 * @tc.steps6: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action == KeyAction::DOWN
746 * and curPage == focusHub.
747 * @tc.expected: The return value of HandleFocusByTabIndex is false.
748 */
749 keyEvent.action = KeyAction::DOWN;
750 keyEvent.code = KeyCode::KEY_TAB;
751 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
752 }
753
754 /**
755 * @tc.name: FocusHubTestNg018
756 * @tc.desc: Test the function HandleFocusByTabIndex.
757 * @tc.type: FUNC
758 */
759 HWTEST_F(FocusHubTestNg, FocusHubTestNg0018, TestSize.Level1)
760 {
761 /**
762 * @tc.steps1: initialize parameters.
763 */
764 auto eventHub = AceType::MakeRefPtr<EventHub>();
765 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
766 KeyEvent keyEvent;
767
768 /**
769 * @tc.steps2: call the function GetFocusingTabNodeIdx with the empty TabIndexNodeList.
770 * @tc.expected: The return value of the function is NONE_TAB_FOCUSED_INDEX.
771 */
772 TabIndexNodeList tabIndexNodes;
773 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
774
775 /**
776 * @tc.steps3: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
777 * @tc.expected: The return value of the function is DEFAULT_TAB_FOCUSED_INDEX.
778 */
779 int32_t nodeId = 1;
780 focusHub->lastTabIndexNodeId_ = nodeId;
781 tabIndexNodes.emplace_back(focusHub->GetTabIndex(), focusHub);
782 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
783
784 /**
785 * @tc.steps4: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
786 * @tc.expected: The return value of the function is 0.
787 */
788 nodeId = -1;
789 focusHub->lastTabIndexNodeId_ = nodeId;
790 focusHub->currentFocus_ = true;
791 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), 0);
792
793 /**
794 * @tc.steps5: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
795 * @tc.expected: The return value of the function is NONE_TAB_FOCUSED_INDEX.
796 */
797 focusHub->currentFocus_ = false;
798 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
799 }
800
801 /**
802 * @tc.name: FocusHubTestNg019
803 * @tc.desc: Test the function RequestFocusImmediatelyById and GetChildFocusNodeById.
804 * @tc.type: FUNC
805 */
806 HWTEST_F(FocusHubTestNg, FocusHubTestNg0019, TestSize.Level1)
807 {
808 /**
809 * @tc.steps1: initialize parameters.
810 */
811 auto eventHub = AceType::MakeRefPtr<EventHub>();
812 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
813 eventHub->AttachHost(frameNode);
814 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
815
816 /**
817 * @tc.steps2: call the function RequestFocusImmediatelyById with the empty id.
818 * @tc.expected: The return value of the function is false.
819 */
820 const std::string nullStr("");
821 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(nullStr));
822
823 /**
824 * @tc.steps3: call the function RequestFocusImmediatelyById with the idStr.
825 * @tc.expected: The return value of the function is false.
826 */
827 const std::string idStr(V2::TEXT_ETS_TAG);
828 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
829
830 /**
831 * @tc.steps4: call the function RequestFocusImmediatelyById with the idStr and FocusType::NODE.
832 * @tc.expected: The return value of the function is false.
833 */
834 focusHub->SetFocusType(FocusType::NODE);
835 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
836
837 /**
838 * @tc.steps5: call the function RequestFocusImmediatelyById with the idStr and FocusType::SCOPE.
839 * @tc.expected: The return value of the function is false.
840 */
841 focusHub->SetFocusType(FocusType::SCOPE);
842 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
843 }
844
845 /**
846 * @tc.name: FocusHubTestNg020
847 * @tc.desc: Test the function GetChildFocusNodeByType.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(FocusHubTestNg, FocusHubTestNg0020, TestSize.Level1)
851 {
852 /**
853 * @tc.steps1: initialize parameters.
854 */
855 auto eventHub = AceType::MakeRefPtr<EventHub>();
856 eventHub->SetEnabled(true);
857 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
858
859 /**
860 * @tc.steps2: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT.
861 * @tc.expected: The return value of the function is focusHub.
862 */
863 focusHub->SetFocusType(FocusType::NODE);
864 focusHub->SetShow(true);
865 focusHub->focusable_ = true;
866 focusHub->parentFocusable_ = true;
867 focusHub->SetIsDefaultFocus(true);
868 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), focusHub);
869
870 /**
871 * @tc.steps3: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = false.
872 * @tc.expected: The return value of the function is nullptr.
873 */
874 focusHub->focusable_ = false;
875 focusHub->SetShow(false);
876 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), nullptr);
877
878 /**
879 * @tc.steps4: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and IsDefaultFocus = false.
880 * @tc.expected: The return value of the function is nullptr.
881 */
882 focusHub->SetIsDefaultFocus(false);
883 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), nullptr);
884
885 /**
886 * @tc.steps5: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = true.
887 * @tc.expected: The return value of the function is focusHub.
888 */
889 focusHub->SetShow(true);
890 focusHub->focusable_ = true;
891 focusHub->SetIsDefaultGroupFocus(true);
892 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), focusHub);
893
894 /**
895 * @tc.steps6: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = false.
896 * @tc.expected: The return value of the function is nullptr.
897 */
898 focusHub->focusable_ = false;
899 focusHub->SetShow(false);
900 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
901
902 /**
903 * @tc.steps7: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = true and
904 * IsDefaultGroupFocus = false.
905 * @tc.expected: The return value of the function is nullptr.
906 */
907 focusHub->SetShow(true);
908 focusHub->SetIsDefaultGroupFocus(false);
909 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
910
911 /**
912 * @tc.steps8: call the function GetChildFocusNodeByType with FocusType::SCOPE.
913 * @tc.expected: The return value of the function is nullptr.
914 */
915 focusHub->SetFocusType(FocusType::SCOPE);
916 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
917 }
918
919 /**
920 * @tc.name: FocusHubTestNg021
921 * @tc.desc: Test the function GoToFocusByTabNodeIdx.
922 * @tc.type: FUNC
923 */
924 HWTEST_F(FocusHubTestNg, FocusHubTestNg0021, TestSize.Level1)
925 {
926 /**
927 * @tc.steps1: initialize parameters.
928 */
929 auto eventHub = AceType::MakeRefPtr<EventHub>();
930 eventHub->SetEnabled(true);
931 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
932
933 /**
934 * @tc.steps2: call the function GoToFocusByTabNodeIdx with the empty TabIndexNodeList.
935 * @tc.expected: The return value of the function is false.
936 */
937 TabIndexNodeList tabIndexNodes;
938 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 0));
939
940 /**
941 * @tc.steps3: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
942 * @tc.expected: The return value of the function is false.
943 */
944 tabIndexNodes.emplace_back(focusHub->GetTabIndex(), nullptr);
945 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 0));
946
947 /**
948 * @tc.steps4: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
949 * @tc.expected: The return value of the function is false.
950 */
951 tabIndexNodes.emplace_back(focusHub->GetTabIndex(), focusHub);
952 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
953
954 /**
955 * @tc.steps5: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
956 * @tc.expected: The return value of the function is false.
957 */
958 focusHub->SetIsDefaultGroupHasFocused(false);
959 focusHub->SetFocusType(FocusType::SCOPE);
960 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
961
962 /**
963 * @tc.steps6: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
964 * @tc.expected: The return value of the function is false.
965 */
966 focusHub->SetIsDefaultGroupHasFocused(true);
967 focusHub->SetFocusType(FocusType::NODE);
968 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
969
970 /**
971 * @tc.steps7: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
972 * @tc.expected: The return value of the function is true.
973 */
974 focusHub->SetShow(true);
975 focusHub->focusable_ = true;
976 focusHub->parentFocusable_ = true;
977 EXPECT_TRUE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
978 }
979
980 /**
981 * @tc.name: FocusHubTestNg022
982 * @tc.desc: Test the function IsFocusableByTab, IsFocusableNodeByTab and IsFocusableScopeByTab.
983 * @tc.type: FUNC
984 */
985 HWTEST_F(FocusHubTestNg, FocusHubTestNg0022, TestSize.Level1)
986 {
987 /**
988 * @tc.steps1: initialize parameters.
989 */
990 auto eventHub = AceType::MakeRefPtr<EventHub>();
991 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
992
993 /**
994 * @tc.steps2: call the function IsFocusableByTab with FocusType::NODE.
995 * @tc.expected: The return value of the function is true.
996 */
997 focusHub->SetFocusType(FocusType::NODE);
998 EXPECT_TRUE(focusHub->IsFocusableByTab());
999
1000 /**
1001 * @tc.steps3: call the function IsFocusableByTab with FocusType::SCOPE.
1002 * @tc.expected: The return value of the function is true.
1003 */
1004 focusHub->SetFocusType(FocusType::SCOPE);
1005 EXPECT_TRUE(focusHub->IsFocusableByTab());
1006
1007 /**
1008 * @tc.steps4: call the function IsFocusableByTab with FocusType::DISABLE.
1009 * @tc.expected: The return value of the function is false.
1010 */
1011 focusHub->SetFocusType(FocusType::DISABLE);
1012 EXPECT_FALSE(focusHub->IsFocusableByTab());
1013 }
1014
1015 /**
1016 * @tc.name: FocusHubHandleDumpFocusTreeTest023
1017 * @tc.desc: Test the function DumpFocusTree.
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(FocusHubTestNg, FocusHubHandleDumpFocusTreeTest023, TestSize.Level1)
1021 {
1022 /**
1023 * @tc.steps: step1. Create frameNode.
1024 */
1025 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1026
1027 /**
1028 * @tc.steps: step2. Create FocusHub.
1029 */
1030 auto eventHub = AceType::MakeRefPtr<EventHub>();
1031 eventHub->AttachHost(frameNode);
1032 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1033
1034 /**
1035 * @tc.steps: step3. test function DumpFocusNodeTree.
1036 * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty.
1037 */
1038 int32_t depth = 1;
1039 focusHub->focusType_ = FocusType::NODE;
1040 auto ss = std::make_unique<std::ostringstream>();
1041 DumpLog::GetInstance().SetDumpFile(std::move(ss));
1042 focusHub->currentFocus_ = true;
1043 focusHub->DumpFocusTree(depth);
1044 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1045
1046 DumpLog::GetInstance().description_.push_back("test");
1047 focusHub->currentFocus_ = false;
1048 focusHub->focusable_ = false;
1049 focusHub->DumpFocusTree(depth);
1050 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1051
1052 /**
1053 * @tc.steps: step4. test function DumpFocusScopeTree.
1054 * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty.
1055 */
1056 DumpLog::GetInstance().description_.push_back("test");
1057 focusHub->focusType_ = FocusType::SCOPE;
1058 focusHub->currentFocus_ = true;
1059 focusHub->DumpFocusTree(depth);
1060 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1061
1062 DumpLog::GetInstance().description_.push_back("test");
1063 focusHub->currentFocus_ = false;
1064 focusHub->focusable_ = false;
1065 focusHub->DumpFocusTree(depth);
1066 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1067 }
1068
1069 /**
1070 * @tc.name: FocusHubRemoveChildTest001
1071 * @tc.desc: Test the function RemoveChild.
1072 * @tc.type: FUNC
1073 */
1074 HWTEST_F(FocusHubTestNg, FocusHubRemoveChildTest001, TestSize.Level1)
1075 {
1076 /**
1077 * @tc.steps: step1. Create frameNode.
1078 */
1079 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1080 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1081 auto nodeParent = AceType::MakeRefPtr<FrameNode>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>());
1082 frameNode->GetOrCreateFocusHub();
1083 frameNode2->GetOrCreateFocusHub();
1084 nodeParent->GetOrCreateFocusHub();
1085 frameNode->SetParent(nodeParent);
1086 frameNode2->SetParent(nodeParent);
1087
1088 /**
1089 * @tc.steps: step2. Create FocusHub.
1090 */
1091 auto eventHub = AceType::MakeRefPtr<EventHub>();
1092 eventHub->AttachHost(frameNode);
1093 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1094
1095 /**
1096 * @tc.steps: step3. Get parentFocusHub.
1097 */
1098 focusHub->currentFocus_ = true;
1099 auto parent = focusHub->GetParentFocusHub();
1100
1101 /**
1102 * @tc.steps: step4. Test RemoveChild and parentFocusHub RemoveSelf.
1103 * @tc.expected: focusHub and parentFocusHub both lostFocus.
1104 */
1105 parent->currentFocus_ = true;
1106 parent->RemoveChild(focusHub);
1107 EXPECT_EQ(parent->blurReason_, BlurReason::FRAME_DESTROY);
1108 EXPECT_EQ(focusHub->blurReason_, BlurReason::FRAME_DESTROY);
1109 }
1110
1111 /**
1112 * @tc.name: FocusHubSetIsFocusOnTouch001
1113 * @tc.desc: Test the function SetIsFocusOnTouch.
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(FocusHubTestNg, FocusHubSetIsFocusOnTouch001, TestSize.Level1)
1117 {
1118 /**
1119 * @tc.steps1: create frameNode.
1120 */
1121 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1122
1123 /**
1124 * @tc.steps2: create eventHub and focusHub.
1125 */
1126 auto eventHub = AceType::MakeRefPtr<EventHub>();
1127 eventHub->AttachHost(frameNode);
1128 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1129
1130 /**
1131 * @tc.steps3: test SetIsFocusOnTouch.
1132 * @tc.expected: create touchEvents and set FocusOnTouch success.
1133 */
1134 focusHub->SetIsFocusOnTouch(true);
1135 auto gesture = frameNode->GetOrCreateGestureEventHub();
1136 EXPECT_FALSE(gesture->touchEventActuator_->touchEvents_.empty());
1137
1138 /**
1139 * @tc.steps4: test SetIsFocusOnTouch.
1140 * @tc.expected: when touchEvents has been set, return.
1141 */
1142 focusHub->SetIsFocusOnTouch(true);
1143 EXPECT_TRUE(focusHub->focusCallbackEvents_->IsFocusOnTouch().value());
1144
1145 /**
1146 * @tc.steps4: test SetIsFocusOnTouch.
1147 * @tc.expected: set touchEvents false.
1148 */
1149 focusHub->SetIsFocusOnTouch(false);
1150 EXPECT_TRUE(gesture->touchEventActuator_->touchEvents_.empty());
1151
1152 /**
1153 * @tc.steps5: test SetIsFocusOnTouch.
1154 * @tc.expected: set focusOnTouchListener_ success.
1155 */
1156 focusHub->focusCallbackEvents_->SetIsFocusOnTouch(false);
1157 focusHub->focusOnTouchListener_ = nullptr;
1158 focusHub->SetIsFocusOnTouch(true);
1159 EXPECT_TRUE(focusHub->focusOnTouchListener_);
1160 auto touchCallback = focusHub->focusOnTouchListener_;
1161 TouchEventInfo touchEventInfo("onTouchUp");
1162 (*touchCallback)(touchEventInfo);
1163 TouchLocationInfo touchLocationInfo(1);
1164 touchLocationInfo.SetTouchType(TouchType::UP);
1165 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
1166 focusHub->SetFocusType(FocusType::NODE);
1167 focusHub->focusable_ = true;
1168 (*touchCallback)(touchEventInfo);
1169 EXPECT_TRUE(focusHub->currentFocus_);
1170 }
1171
1172 /**
1173 * @tc.name: FocusHubOnKeyEvent002
1174 * @tc.desc: Test the function OnKeyEvent.
1175 * @tc.type: FUNC
1176 */
1177 HWTEST_F(FocusHubTestNg, FocusHubOnKeyEvent002, TestSize.Level1)
1178 {
1179 /**
1180 * @tc.steps1: create frameNode.
1181 */
1182 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1183
1184 /**
1185 * @tc.steps2: create eventHub and focusHub.
1186 */
1187 auto eventHub = AceType::MakeRefPtr<EventHub>();
1188 eventHub->AttachHost(frameNode);
1189 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1190 KeyEvent keyEvent;
1191 keyEvent.action = KeyAction::UP;
1192 keyEvent.code = KeyCode::KEY_SPACE;
1193
1194 /**
1195 * @tc.steps3: call the function OnKeyEvent with FocusType::NODE.
1196 * @tc.expected: The return value of OnKeyEvent is true.
1197 */
1198 focusHub->SetFocusType(FocusType::NODE);
__anon2dd0c4310a02(KeyEventInfo& eventInfo) 1199 auto onKeyEventCallback = [](KeyEventInfo& eventInfo) -> bool {
1200 eventInfo.SetStopPropagation(true);
1201 return false;
1202 };
__anon2dd0c4310b02(const KeyEvent& event) 1203 auto onKeyEvent = [](const KeyEvent& event) -> bool { return true; };
1204 focusHub->SetOnKeyEventInternal(std::move(onKeyEvent));
1205 focusHub->SetOnKeyCallback(std::move(onKeyEventCallback));
1206 EXPECT_TRUE(focusHub->OnKeyEvent(keyEvent));
1207 }
1208
1209 /**
1210 * @tc.name: FocusHubOnKeyEvent003
1211 * @tc.desc: Test the function OnKeyEvent.
1212 * @tc.type: FUNC
1213 */
1214 HWTEST_F(FocusHubTestNg, FocusHubOnKeyEvent003, TestSize.Level1)
1215 {
1216 /**
1217 * @tc.steps1: create frameNode.
1218 */
1219 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1220 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1221 child->GetOrCreateFocusHub();
1222 frameNode->AddChild(child);
1223
1224 /**
1225 * @tc.steps2: create eventHub and focusHub.
1226 */
1227 auto eventHub = AceType::MakeRefPtr<EventHub>();
1228 eventHub->AttachHost(frameNode);
1229 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1230
1231 /**
1232 * @tc.steps3: create lastWeakFocusNode_.
1233 */
1234 std::list<RefPtr<FocusHub>> focusNodes;
1235 focusHub->FlushChildrenFocusHub(focusNodes);
1236 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(*(focusNodes.begin())));
1237
1238 /**
1239 * @tc.steps4: create keyEvent.
1240 */
1241 KeyEvent keyEvent;
1242 keyEvent.action = KeyAction::UP;
1243 keyEvent.code = KeyCode::KEY_SPACE;
1244
1245 /**
1246 * @tc.steps5: create lastFocusNode.
1247 */
1248 focusHub->currentFocus_ = true;
1249 focusHub->SetFocusType(FocusType::SCOPE);
__anon2dd0c4310c02(const KeyEvent& event) 1250 auto onKeyEvent = [](const KeyEvent& event) -> bool { return true; };
1251
1252 /**
1253 * @tc.steps6: call the function OnKeyEvent with FocusType::SCOPE.
1254 * @tc.expected: The return value of OnKeyEvent is true.
1255 */
1256 auto lastFocusNode = focusHub->lastWeakFocusNode_.Upgrade();
1257 lastFocusNode->currentFocus_ = true;
1258 lastFocusNode->SetOnKeyEventInternal(onKeyEvent);
1259 EXPECT_TRUE(focusHub->OnKeyEvent(keyEvent));
1260
1261 /**
1262 * @tc.steps7: call the function OnKeyEvent with FocusType::SCOPE.
1263 * @tc.expected: The return value of OnKeyEvent is true.
1264 */
1265 lastFocusNode->currentFocus_ = false;
1266 focusHub->SetOnKeyEventInternal(onKeyEvent);
1267 EXPECT_TRUE(focusHub->OnKeyEvent(keyEvent));
1268 }
1269
1270 /**
1271 * @tc.name: FocusHubOnKeyEvent004
1272 * @tc.desc: Test the function OnKeyEvent.
1273 * @tc.type: FUNC
1274 */
1275 HWTEST_F(FocusHubTestNg, FocusHubOnKeyEvent004, TestSize.Level1)
1276 {
1277 /**
1278 * @tc.steps1: create frameNode.
1279 */
1280 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1281 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1282 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1283 child->GetOrCreateFocusHub();
1284 child2->GetOrCreateFocusHub();
1285 frameNode->AddChild(child);
1286 frameNode->AddChild(child2);
1287
1288 /**
1289 * @tc.steps2: create eventHub and focusHub.
1290 */
1291 auto eventHub = AceType::MakeRefPtr<EventHub>();
1292 eventHub->AttachHost(frameNode);
1293 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1294 auto childEventHub = AceType::MakeRefPtr<EventHub>();
1295 childEventHub->AttachHost(child);
1296
1297 /**
1298 * @tc.steps3: create lastWeakFocusNode_.
1299 */
1300 std::list<RefPtr<FocusHub>> focusNodes;
1301 focusHub->FlushChildrenFocusHub(focusNodes);
1302 auto childFocusHub = *focusNodes.begin();
1303 childFocusHub->eventHub_ = childEventHub;
1304 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(childFocusHub));
1305
1306 KeyEvent keyEvent;
1307 keyEvent.action = KeyAction::UP;
1308 auto pipeline = PipelineContext::GetCurrentContext();
1309 pipeline->isFocusActive_ = true;
1310
1311 /**
1312 * @tc.steps5: test keyEvent with keyEvent.code == KeyCode::TV_CONTROL_UP.
1313 * @tc.expected: The return value of OnKeyEvent is false.
1314 */
1315 keyEvent.code = KeyCode::TV_CONTROL_UP;
1316 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1317
1318 keyEvent.code = KeyCode::TV_CONTROL_DOWN;
1319 focusHub->SetScopeFocusAlgorithm();
1320 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1321
1322 keyEvent.code = KeyCode::TV_CONTROL_LEFT;
1323 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1324
1325 keyEvent.code = KeyCode::TV_CONTROL_RIGHT;
1326 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1327
1328 keyEvent.code = KeyCode::KEY_TAB;
1329 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1330
1331 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
1332 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1333
1334 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB);
1335 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1336
1337 keyEvent.code = KeyCode::KEY_MOVE_HOME;
1338 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1339
1340 keyEvent.code = KeyCode::KEY_MOVE_END;
1341 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1342
1343 keyEvent.code = KeyCode::KEY_SPACE;
1344 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1345 }
1346
1347 /**
1348 * @tc.name: FocusHubGoToNextFocusLinear001
1349 * @tc.desc: Test the function GoToNextFocusLinear.
1350 * @tc.type: FUNC
1351 */
1352 HWTEST_F(FocusHubTestNg, FocusHubGoToNextFocusLinear001, TestSize.Level1)
1353 {
1354 /**
1355 * @tc.steps: step1. Create frameNode.
1356 */
1357 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1358 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1359 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1360 child->GetOrCreateFocusHub();
1361 child2->GetOrCreateFocusHub();
1362 frameNode->AddChild(child);
1363 frameNode->AddChild(child2);
1364
1365 /**
1366 * @tc.steps: step2. Create FocusHub.
1367 */
1368 auto eventHub = AceType::MakeRefPtr<EventHub>();
1369 eventHub->AttachHost(frameNode);
1370 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1371
1372 focusHub->currentFocus_ = true;
1373
1374 std::list<RefPtr<FocusHub>> focusNodes;
1375 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1376
1377 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1378 EXPECT_TRUE(focusHub->GoToNextFocusLinear(FocusStep::TAB));
1379 }
1380
1381 /**
1382 * @tc.name: FocusHubPaintFocusState001
1383 * @tc.desc: Test the function PaintFocusState.
1384 * @tc.type: FUNC
1385 */
1386 HWTEST_F(FocusHubTestNg, PaintFocusState001, TestSize.Level1)
1387 {
1388 /**
1389 * @tc.steps1: create frameNode.
1390 */
1391 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1392 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1393 child->GetOrCreateFocusHub();
1394 frameNode->AddChild(child);
1395
1396 /**
1397 * @tc.steps2: create eventHub and focusHub.
1398 */
1399 auto eventHub = AceType::MakeRefPtr<EventHub>();
1400 ASSERT_NE(eventHub, nullptr);
1401 eventHub->AttachHost(frameNode);
1402 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1403 ASSERT_NE(focusHub, nullptr);
1404 auto context = PipelineContext::GetCurrentContext();
1405 ASSERT_NE(context, nullptr);
1406 auto renderContext = frameNode->GetRenderContext();
1407 ASSERT_NE(renderContext, nullptr);
1408
1409 /**
1410 * @tc.steps3: create KeyEvent.
1411 */
1412 KeyEvent keyEvent;
1413 keyEvent.action = KeyAction::DOWN;
1414 keyEvent.code = KeyCode::KEY_SPACE;
1415
1416 focusHub->SetFocusType(FocusType::SCOPE);
1417 EXPECT_EQ(focusHub->focusStyleType_, FocusStyleType::NONE);
1418 }
1419
1420 /**
1421 * @tc.name: FocusHubSetIsDefaultFocus001
1422 * @tc.desc: Test the function SetIsDefaultFocus.
1423 * @tc.type: FUNC
1424 */
1425 HWTEST_F(FocusHubTestNg, SetIsDefaultFocus001, TestSize.Level1)
1426 {
1427 /**
1428 * @tc.steps1: create frameNode.
1429 */
1430 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1431
1432 auto eventHub = AceType::MakeRefPtr<EventHub>();
1433 ASSERT_NE(eventHub, nullptr);
1434 eventHub->AttachHost(frameNode);
1435 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1436 ASSERT_NE(focusHub, nullptr);
1437
1438 auto pipeline = PipelineContext::GetCurrentContext();
1439 ASSERT_NE(pipeline, nullptr);
1440 auto manager = pipeline->GetOverlayManager();
1441 ASSERT_NE(manager, nullptr);
1442 auto rootNode = pipeline->GetRootElement();
1443 EXPECT_NE(rootNode, nullptr);
1444
1445 focusHub->focusCallbackEvents_ = nullptr;
1446 focusHub->SetIsDefaultGroupFocus(false);
1447 EXPECT_NE(focusHub->focusCallbackEvents_, nullptr);
1448 }
1449
1450 /**
1451 * @tc.name: FocusHubTestDisableFocus001
1452 * @tc.desc: Test disable functions Onfocus.
1453 * @tc.type: FUNC
1454 */
1455 HWTEST_F(FocusHubTestNg, FocusHubTestDisableFocus001, TestSize.Level1)
1456 {
1457 /**
1458 * @tc.steps1: initialize parameters.
1459 */
1460 auto eventHub = AceType::MakeRefPtr<EventHub>();
1461 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1462
1463 /**
1464 * @tc.steps2: call the function OnFocus with FocusType::NODE.
1465 * @tc.expected: The result is right.
1466 */
1467 focusHub->SetFocusType(FocusType::NODE);
1468 std::string result;
__anon2dd0c4310d02() 1469 auto onFocus = [&result]() { result = RESULT_SUCCESS_ONE; };
1470 focusHub->SetOnFocusCallback(onFocus);
1471 EXPECT_NE(focusHub->GetOnFocusCallback(), nullptr);
1472
1473 focusHub->OnFocus();
1474 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1475
1476 /**
1477 * @tc.steps3: clear the function.
1478 * @tc.expected: The result is nullptr.
1479 */
1480 focusHub->ClearUserOnFocus();
1481 EXPECT_EQ(focusHub->GetOnFocusCallback(), nullptr);
1482
1483 /**
1484 * @tc.steps3: set the function again.
1485 * @tc.expected: The result is right.
1486 */
__anon2dd0c4310e02() 1487 auto onFocus2 = [&result]() { result = RESULT_SUCCESS_TWO; };
1488 focusHub->SetOnFocusCallback(onFocus2);
1489 EXPECT_NE(focusHub->GetOnFocusCallback(), nullptr);
1490
1491 focusHub->OnFocus();
1492 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1493 }
1494
1495 /**
1496 * @tc.name: FocusHubTestDisableBlur001
1497 * @tc.desc: Test disable functions OnBlur.
1498 * @tc.type: FUNC
1499 */
1500 HWTEST_F(FocusHubTestNg, FocusHubTestDisableBlur001, TestSize.Level1)
1501 {
1502 /**
1503 * @tc.steps1: initialize parameters.
1504 */
1505 auto eventHub = AceType::MakeRefPtr<EventHub>();
1506 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1507
1508 /**
1509 * @tc.steps2: call the function OnBlur with FocusType::NODE.
1510 * @tc.expected: The result is right.
1511 */
1512 focusHub->SetFocusType(FocusType::NODE);
1513 std::string result;
__anon2dd0c4310f02() 1514 auto onBlur = [&result]() { result = RESULT_SUCCESS_ONE; };
1515 focusHub->SetOnBlurCallback(onBlur);
1516 EXPECT_NE(focusHub->GetOnBlurCallback(), nullptr);
1517
1518 focusHub->OnBlur();
1519 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1520
1521 /**
1522 * @tc.steps3: clear the function OnBlur.
1523 * @tc.expected: The result is nullptr.
1524 */
1525 focusHub->ClearUserOnBlur();
1526 EXPECT_EQ(focusHub->GetOnBlurCallback(), nullptr);
1527
1528 /**
1529 * @tc.steps3: set the function OnBlur again.
1530 * @tc.expected: The result is right.
1531 */
__anon2dd0c4311002() 1532 auto onBlur2 = [&result]() { result = RESULT_SUCCESS_TWO; };
1533 focusHub->SetOnBlurCallback(onBlur2);
1534 EXPECT_NE(focusHub->GetOnBlurCallback(), nullptr);
1535
1536 focusHub->OnBlur();
1537 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1538 }
1539
1540 /**
1541 * @tc.name: FocusHubTestDisableKey001
1542 * @tc.desc: Test disable functions OnKey.
1543 * @tc.type: FUNC
1544 */
1545 HWTEST_F(FocusHubTestNg, FocusHubTestDisableKey001, TestSize.Level1)
1546 {
1547 /**
1548 * @tc.steps1: initialize parameters.
1549 */
1550 auto eventHub = AceType::MakeRefPtr<EventHub>();
1551 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1552
1553 /**
1554 * @tc.steps2: call the function OnKey with FocusType::NODE.
1555 * @tc.expected: The result is right.
1556 */
1557 focusHub->SetFocusType(FocusType::NODE);
1558 std::string result;
__anon2dd0c4311102(KeyEventInfo& info) 1559 auto onKey = [&result](KeyEventInfo& info) { result = RESULT_SUCCESS_ONE; };
1560 focusHub->SetOnKeyCallback(onKey);
1561 EXPECT_NE(focusHub->GetOnKeyCallback(), nullptr);
1562 KeyEvent keyEvent;
1563 keyEvent.action = KeyAction::UP;
1564 focusHub->OnKeyEvent(keyEvent);
1565 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1566
1567 /**
1568 * @tc.steps3: clear the function OnKey.
1569 * @tc.expected: The result is nullptr.
1570 */
1571 focusHub->ClearUserOnKey();
1572 EXPECT_EQ(focusHub->GetOnKeyCallback(), nullptr);
1573
1574 /**
1575 * @tc.steps4: set the function OnKey again.
1576 * @tc.expected: The result is right.
1577 */
__anon2dd0c4311202(KeyEventInfo& info) 1578 auto onKey2 = [&result](KeyEventInfo& info) { result = RESULT_SUCCESS_TWO; };
1579 focusHub->SetOnKeyCallback(onKey2);
1580 EXPECT_NE(focusHub->GetOnKeyCallback(), nullptr);
1581
1582 focusHub->OnKeyEvent(keyEvent);
1583 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1584 }
1585
1586 /**
1587 * @tc.name: FocusHubTestNg0030
1588 * @tc.desc: Test the function GoToNextFocusLinear.
1589 * @tc.type: FUNC
1590 */
1591 HWTEST_F(FocusHubTestNg, FocusHubTestNg0030, TestSize.Level1)
1592 {
1593 /**
1594 * @tc.steps: step1. Create frameNode.
1595 */
1596 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1597 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1598 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1599 child->GetOrCreateFocusHub();
1600 child2->GetOrCreateFocusHub();
1601 frameNode->AddChild(child);
1602 frameNode->AddChild(child2);
1603 auto eventHub = AceType::MakeRefPtr<EventHub>();
1604 eventHub->AttachHost(frameNode);
1605 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1606 focusHub->currentFocus_ = true;
1607 std::list<RefPtr<FocusHub>> focusNodes;
1608 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1609 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1610 EXPECT_FALSE(focusHub->GoToNextFocusLinear(FocusStep::NONE));
1611 }
1612
1613 /**
1614 * @tc.name: FocusHubTestNg0031
1615 * @tc.desc: Test the function IsNeedPaintFocusState.
1616 * @tc.type: FUNC
1617 */
1618 HWTEST_F(FocusHubTestNg, FocusHubTestNg0031, TestSize.Level1)
1619 {
1620 /**
1621 * @tc.steps: step1. Create frameNode.
1622 */
1623 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1624 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1625 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1626 child->GetOrCreateFocusHub();
1627 child2->GetOrCreateFocusHub();
1628 frameNode->AddChild(child);
1629 frameNode->AddChild(child2);
1630 auto eventHub = AceType::MakeRefPtr<EventHub>();
1631 eventHub->AttachHost(frameNode);
1632 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1633 std::list<RefPtr<FocusHub>> focusNodes;
1634 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1635 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1636 focusHub->IsNeedPaintFocusState();
1637 focusHub->focusType_ = FocusType::NODE;
1638 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
1639 focusHub->IsNeedPaintFocusState();
1640 focusHub->focusType_ = FocusType::NODE;
1641 EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
1642 }
1643
1644 /**
1645 * @tc.name: FocusHubTestNg0032
1646 * @tc.desc: Test the function PaintFocusState.
1647 * @tc.type: FUNC
1648 */
1649 HWTEST_F(FocusHubTestNg, FocusHubTestNg0032, TestSize.Level1)
1650 {
1651 /**
1652 * @tc.steps: step1. Create frameNode.
1653 */
1654 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1655 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1656 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1657 child->GetOrCreateFocusHub();
1658 child2->GetOrCreateFocusHub();
1659 frameNode->AddChild(child);
1660 frameNode->AddChild(child2);
1661 auto eventHub = AceType::MakeRefPtr<EventHub>();
1662 eventHub->AttachHost(frameNode);
1663 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1664 auto context = PipelineContext::GetCurrentContext();
1665 ASSERT_NE(context, nullptr);
1666 context->isFocusActive_ = true;
1667 focusHub->focusType_ = FocusType::NODE;
1668 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
1669 std::list<RefPtr<FocusHub>> focusNodes;
1670 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1671 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1672 EXPECT_FALSE(focusHub->PaintFocusState(true));
1673 EXPECT_FALSE(focusHub->PaintFocusState(false));
1674 }
1675
1676 /**
1677 * @tc.name: FocusHubTestNg0033
1678 * @tc.desc: Test the function AcceptFocusOfSpecifyChild.
1679 * @tc.type: FUNC
1680 */
1681 HWTEST_F(FocusHubTestNg, FocusHubTestNg0033, TestSize.Level1)
1682 {
1683 /**
1684 * @tc.steps: step1. Create frameNode.
1685 */
1686 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1687 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1688 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1689 child->GetOrCreateFocusHub();
1690 child2->GetOrCreateFocusHub();
1691 frameNode->AddChild(child);
1692 frameNode->AddChild(child2);
1693 auto eventHub = AceType::MakeRefPtr<EventHub>();
1694 eventHub->AttachHost(frameNode);
1695 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1696 focusHub->focusType_ = FocusType::DISABLE;
1697 std::list<RefPtr<FocusHub>> focusNodes;
1698 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1699 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1700 focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
1701 focusHub->focusType_ = FocusType::SCOPE;
1702 EXPECT_FALSE(focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB));
1703 EXPECT_FALSE(focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB));
1704 }
1705
1706 /**
1707 * @tc.name: FocusHubTestNg0034
1708 * @tc.desc: Test the function ClearFocusState.
1709 * @tc.type: FUNC
1710 */
1711 HWTEST_F(FocusHubTestNg, FocusHubTestNg0034, TestSize.Level1)
1712 {
1713 /**
1714 * @tc.steps: step1. Create frameNode.
1715 */
1716 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1717 auto eventHub = AceType::MakeRefPtr<EventHub>();
1718 eventHub->AttachHost(frameNode);
1719 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1720 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
1721 std::list<RefPtr<FocusHub>> focusNodes;
1722 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1723 EXPECT_EQ(itNewFocusNode, focusNodes.end());
__anon2dd0c4311302() 1724 focusHub->onClearFocusStateCallback_ = []() {};
1725 focusHub->ClearFocusState(true);
1726 focusHub->ClearFocusState(false);
1727 EXPECT_NE(focusHub->focusStyleType_, FocusStyleType::NONE);
1728 }
1729
1730 /**
1731 * @tc.name: FocusHubTestNg0035
1732 * @tc.desc: Test the function RequestFocusImmediately.
1733 * @tc.type: FUNC
1734 */
1735 HWTEST_F(FocusHubTestNg, FocusHubTestNg0035, TestSize.Level1)
1736 {
1737 auto eventHub = AceType::MakeRefPtr<EventHub>();
1738 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1739 auto context = PipelineContext::GetCurrentContext();
1740 ASSERT_NE(context, nullptr);
1741
1742 context->SetIsFocusingByTab(true);
1743 focusHub->SetFocusType(FocusType::DISABLE);
1744 focusHub->focusType_ = FocusType::NODE;
1745 focusHub->currentFocus_ = false;
__anon2dd0c4311402() 1746 focusHub->onPreFocusCallback_ = []() {};
1747 EXPECT_FALSE(focusHub->RequestFocusImmediately());
1748 EXPECT_FALSE(focusHub->RequestFocusImmediately());
1749 context->SetIsFocusingByTab(false);
1750 focusHub->SetFocusType(FocusType::DISABLE);
1751 focusHub->currentFocus_ = true;
1752 EXPECT_TRUE(focusHub->RequestFocusImmediately());
1753 }
1754
1755 /**
1756 * @tc.name: FocusHubTestNg0036
1757 * @tc.desc: Test the function OnFocusScope.
1758 * @tc.type: FUNC
1759 */
1760 HWTEST_F(FocusHubTestNg, FocusHubTestNg0036, TestSize.Level1)
1761 {
1762 /**
1763 * @tc.steps: step1. Create frameNode.
1764 */
1765 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1766 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1767 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1768 child->GetOrCreateFocusHub();
1769 child2->GetOrCreateFocusHub();
1770 frameNode->AddChild(child);
1771 frameNode->AddChild(child2);
1772 auto eventHub = AceType::MakeRefPtr<EventHub>();
1773 eventHub->AttachHost(frameNode);
1774 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1775 focusHub->currentFocus_ = true;
1776 std::list<RefPtr<FocusHub>> focusNodes;
1777 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1778 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1779 focusHub->OnFocusScope();
1780 EXPECT_TRUE(focusHub->currentFocus_);
1781 }
1782
1783 /**
1784 * @tc.name: FocusHubTestNg0037
1785 * @tc.desc: Test the function IsFocusableScopeByTab.
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(FocusHubTestNg, FocusHubTestNg0037, TestSize.Level1)
1789 {
1790 /**
1791 * @tc.steps: step1. Create frameNode.
1792 */
1793 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1794 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1795 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
1796 child->GetOrCreateFocusHub();
1797 child2->GetOrCreateFocusHub();
1798 frameNode->AddChild(child);
1799 frameNode->AddChild(child2);
1800 auto eventHub = AceType::MakeRefPtr<EventHub>();
1801 eventHub->AttachHost(frameNode);
1802 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1803 focusHub->currentFocus_ = true;
1804 std::list<RefPtr<FocusHub>> focusNodes;
1805 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1806 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1807 EXPECT_TRUE(focusHub->IsFocusableScopeByTab());
1808 }
1809
1810 /**
1811 * @tc.name: FocusHubTestNg0038
1812 * @tc.desc: Test the function IsCurrentFocusWholePath.
1813 * @tc.type: FUNC
1814 */
1815 HWTEST_F(FocusHubTestNg, FocusHubTestNg0038, TestSize.Level1)
1816 {
1817 /**
1818 * @tc.steps: step1. Create frameNode.
1819 */
1820 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1821 auto eventHub = AceType::MakeRefPtr<EventHub>();
1822 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1823 ASSERT_NE(focusHub, nullptr);
1824 EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1825 focusHub->currentFocus_ = true;
1826 EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1827 focusHub->focusType_ = FocusType::NODE;
1828 EXPECT_TRUE(focusHub->IsCurrentFocusWholePath());
1829 focusHub->focusType_ = FocusType::SCOPE;
1830 EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1831 }
1832
1833 /**
1834 * @tc.name: FocusHubTestNg0039
1835 * @tc.desc: Test the function DumpFocusTree.
1836 * @tc.type: FUNC
1837 */
1838 HWTEST_F(FocusHubTestNg, FocusHubTestNg0039, TestSize.Level1)
1839 {
1840 /**
1841 * @tc.steps: step1. Create frameNode.
1842 */
1843 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1844 auto eventHub = AceType::MakeRefPtr<EventHub>();
1845 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1846 ASSERT_NE(focusHub, nullptr);
1847 int32_t depth = 1;
1848 focusHub->focusType_ = FocusType::DISABLE;
1849 focusHub->DumpFocusTree(depth);
1850 }
1851
1852 /**
1853 * @tc.name: FocusHubTestNg0040
1854 * @tc.desc: Test the function AcceptFocusOfLastFocus and AcceptFocusByRectOfLastFocus.
1855 * @tc.type: FUNC
1856 */
1857 HWTEST_F(FocusHubTestNg, FocusHubTestNg0040, TestSize.Level1)
1858 {
1859 /**
1860 * @tc.steps: step1. Create frameNode.
1861 */
1862 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1863 auto eventHub = AceType::MakeRefPtr<EventHub>();
1864 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1865 ASSERT_NE(focusHub, nullptr);
1866 RectF childRect;
1867 focusHub->focusType_ = FocusType::SCOPE;
1868 EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1869 EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1870 focusHub->focusType_ = FocusType::NODE;
1871 EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1872 EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1873 focusHub->focusType_ = FocusType::DISABLE;
1874 EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1875 EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1876 }
1877
1878 /**
1879 * @tc.name: FocusHubTestNg0041
1880 * @tc.desc: Test the function SetShow, SetEnabled, SetEnabledNode and SetEnabledScope.
1881 * @tc.type: FUNC
1882 */
1883 HWTEST_F(FocusHubTestNg, FocusHubTestNg0041, TestSize.Level1)
1884 {
1885 /**
1886 * @tc.steps: step1. Create frameNode.
1887 */
1888 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1889 auto eventHub = AceType::MakeRefPtr<EventHub>();
1890 eventHub->AttachHost(frameNode);
1891 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1892 ASSERT_NE(focusHub, nullptr);
1893 auto frameNode_test = AceType::MakeRefPtr<FrameNode>(V2::ROW_COMPONENT_TAG, -1, AceType::MakeRefPtr<Pattern>());
1894 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode_test));
1895 AceType::DynamicCast<FrameNode>(frameNode->GetParent())
1896 ->GetLayoutProperty()
1897 ->UpdateVisibility(VisibleType::INVISIBLE);
1898 focusHub->IsShow();
1899 }
1900
1901 /**
1902 * @tc.name: FocusHubTestNg0042
1903 * @tc.desc: Test the function OnClick.
1904 * @tc.type: FUNC
1905 */
1906 HWTEST_F(FocusHubTestNg, FocusHubTestNg0042, TestSize.Level1)
1907 {
1908 /**
1909 * @tc.steps: step1. Create frameNode.
1910 */
1911 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1912 auto eventHub = AceType::MakeRefPtr<EventHub>();
1913 eventHub->AttachHost(frameNode);
1914 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1915 ASSERT_NE(focusHub, nullptr);
1916 KeyEvent keyEvent;
__anon2dd0c4311502(GestureEvent&) 1917 focusHub->SetOnClickCallback([](GestureEvent&) { return; });
1918 focusHub->OnClick(keyEvent);
1919 }
1920
1921 /**
1922 * @tc.name: FocusHubTestNg0043
1923 * @tc.desc: Test the function SwitchFocus.
1924 * @tc.type: FUNC
1925 */
1926 HWTEST_F(FocusHubTestNg, FocusHubTestNg0043, TestSize.Level1)
1927 {
1928 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1929 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_COMPONENT_TAG, -1, AceType::MakeRefPtr<Pattern>());
1930 auto nodeParent = AceType::MakeRefPtr<FrameNode>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>());
1931 frameNode->GetOrCreateFocusHub();
1932 frameNode2->GetOrCreateFocusHub();
1933 nodeParent->GetOrCreateFocusHub();
1934 frameNode->SetParent(nodeParent);
1935 frameNode2->SetParent(nodeParent);
1936
1937 auto eventHub = AceType::MakeRefPtr<EventHub>();
1938 eventHub->AttachHost(frameNode);
1939 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1940 auto parent = focusHub->GetParentFocusHub();
1941 parent->focusType_ = FocusType::NODE;
1942 parent->SwitchFocus(focusHub);
1943 parent->focusType_ = FocusType::SCOPE;
1944 parent->SwitchFocus(focusHub);
1945 EXPECT_NE(focusHub->focusType_, FocusType::SCOPE);
1946 parent->currentFocus_ = true;
1947 frameNode->AddChild(frameNode2);
1948 frameNode2->GetEventHub<EventHub>()->focusHub_ = focusHub;
1949 parent->SwitchFocus(focusHub);
1950 EXPECT_TRUE(parent->currentFocus_);
1951 }
1952
1953 /**
1954 * @tc.name: FocusHubTestNg0044
1955 * @tc.desc: Test the function TryRequestFocus.
1956 * @tc.type: FUNC
1957 */
1958 HWTEST_F(FocusHubTestNg, FocusHubTestNg0044, TestSize.Level1)
1959 {
1960 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1961 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_COMPONENT_TAG, -1, AceType::MakeRefPtr<Pattern>());
1962 auto nodeParent = AceType::MakeRefPtr<FrameNode>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>());
1963 frameNode->GetOrCreateFocusHub();
1964 frameNode2->GetOrCreateFocusHub();
1965 nodeParent->GetOrCreateFocusHub();
1966 frameNode->SetParent(nodeParent);
1967 frameNode2->SetParent(nodeParent);
1968
1969 auto eventHub = AceType::MakeRefPtr<EventHub>();
1970 eventHub->AttachHost(frameNode);
1971 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1972 auto parent = focusHub->GetParentFocusHub();
1973 RectF childRect;
1974 parent->focusType_ = FocusType::SCOPE;
1975 parent->TryRequestFocus(focusHub, childRect, FocusStep::TAB);
1976
1977 parent->focusType_ = FocusType::SCOPE;
1978 childRect.width_ = -1;
1979 focusHub->GetGeometryNode() = AceType::MakeRefPtr<GeometryNode>();
1980 parent->TryRequestFocus(focusHub, childRect, FocusStep::NONE);
1981 }
1982
1983 /**
1984 * @tc.name: FocusHubTestNg0045
1985 * @tc.desc: Test the function IsFocusableScopeByTab.
1986 * @tc.type: FUNC
1987 */
1988 HWTEST_F(FocusHubTestNg, FocusHubTestNg0045, TestSize.Level1)
1989 {
1990 /**
1991 * @tc.steps: step1. Create frameNode.
1992 */
1993 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1994 auto eventHub = AceType::MakeRefPtr<EventHub>();
1995 eventHub->AttachHost(frameNode);
1996 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1997 ASSERT_NE(focusHub, nullptr);
1998 focusHub->currentFocus_ = true;
1999 auto parentNode = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
2000 auto parentFocusHub = parentNode->GetOrCreateFocusHub();
2001 parentFocusHub->focusType_ = FocusType::SCOPE;
2002 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode));
2003 focusHub->RefreshFocus();
2004 EXPECT_TRUE(focusHub->currentFocus_);
2005 }
2006
2007 /**
2008 * @tc.name: FocusHubTestNg0046
2009 * @tc.desc: Test the function HandleParentScroll.
2010 * @tc.type: FUNC
2011 */
2012 HWTEST_F(FocusHubTestNg, FocusHubTestNg0046, TestSize.Level1)
2013 {
2014 /**
2015 * @tc.steps: step1. Create frameNode.
2016 */
2017 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2018 auto eventHub = AceType::MakeRefPtr<EventHub>();
2019 eventHub->AttachHost(frameNode);
2020 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2021 ASSERT_NE(focusHub, nullptr);
2022 auto context = PipelineContext::GetCurrentContext();
2023 ASSERT_NE(context, nullptr);
2024 context->isFocusActive_ = true;
2025 focusHub->isFocusUnit_ = true;
2026 auto parentNode = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
2027 auto parentFocusHub = parentNode->GetOrCreateFocusHub();
2028 parentFocusHub->focusType_ = FocusType::SCOPE;
2029 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode));
__anon2dd0c4311602() 2030 focusHub->onPaintFocusStateCallback_ = []() { return true; };
2031 focusHub->PaintAllFocusState();
2032 focusHub->HandleParentScroll();
2033 EXPECT_TRUE(focusHub->isFocusUnit_);
2034 }
2035
2036 /**
2037 * @tc.name: FocusHubTestNg0047
2038 * @tc.desc: Test the function CalculatePosition and PaintAllFocusState.
2039 * @tc.type: FUNC
2040 */
2041 HWTEST_F(FocusHubTestNg, FocusHubTestNg0047, TestSize.Level1)
2042 {
2043 /**
2044 * @tc.steps: step1. Create frameNode.
2045 */
2046 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2047 auto frameNode1 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2048 auto eventHub = AceType::MakeRefPtr<EventHub>();
2049 auto eventHub1 = AceType::MakeRefPtr<EventHub>();
2050 eventHub->AttachHost(frameNode);
2051 eventHub1->AttachHost(frameNode1);
2052 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2053 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(eventHub1);
2054 std::list<RefPtr<FocusHub>> focusNodes;
2055 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2056 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2057 focusHub->ClearAllFocusState();
2058 focusHub->PaintAllFocusState();
2059 focusHub->CalculatePosition();
2060 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
2061 EXPECT_TRUE(focusHub->CalculatePosition());
2062 focusHub1->focusType_ = FocusType::NODE;
2063 EXPECT_FALSE(focusHub->PaintAllFocusState());
2064 EXPECT_TRUE(focusHub->CalculatePosition());
2065 }
2066
2067 /**
2068 * @tc.name: FocusHubTestNg0048
2069 * @tc.desc: Test the function ClearFocusState.
2070 * @tc.type: FUNC
2071 */
2072 HWTEST_F(FocusHubTestNg, FocusHubTestNg0048, TestSize.Level1)
2073 {
2074 /**
2075 * @tc.steps: step1. Create frameNode.
2076 */
2077 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2078 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2079 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
2080 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2081 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2082 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2083 child->GetOrCreateFocusHub();
2084 child2->GetOrCreateFocusHub();
2085 frameNode->AddChild(child);
2086 frameNode->AddChild(child2);
2087 auto eventHub = AceType::MakeRefPtr<EventHub>();
2088 eventHub->AttachHost(frameNode);
2089 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2090 auto context = PipelineContext::GetCurrentContext();
2091 ASSERT_NE(context, nullptr);
2092 RoundRect focusRectInner;
2093 context->isFocusActive_ = true;
2094 focusHub->focusType_ = FocusType::NODE;
2095 EXPECT_FALSE(focusHub->PaintInnerFocusState(focusRectInner));
2096 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
2097 std::list<RefPtr<FocusHub>> focusNodes;
2098 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2099 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2100 EXPECT_TRUE(focusHub->PaintInnerFocusState(focusRectInner));
2101 focusHub->focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
2102 focusHub->focusPaintParamsPtr_->paintColor = Color::RED;
2103 focusHub->focusPaintParamsPtr_->paintWidth = Dimension(10);
2104 EXPECT_TRUE(focusHub->PaintInnerFocusState(focusRectInner));
2105 }
2106
2107 /**
2108 * @tc.name: FocusHubTestNg0049
2109 * @tc.desc: Test the function PaintFocusState.
2110 * @tc.type: FUNC
2111 */
2112 HWTEST_F(FocusHubTestNg, FocusHubTestNg0049, TestSize.Level1)
2113 {
2114 /**
2115 * @tc.steps: step1. Create frameNode.
2116 */
2117 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2118 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2119 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
2120 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2121 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2122 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2123 child->GetOrCreateFocusHub();
2124 child2->GetOrCreateFocusHub();
2125 frameNode->AddChild(child);
2126 frameNode->AddChild(child2);
2127 auto eventHub = AceType::MakeRefPtr<EventHub>();
2128 eventHub->AttachHost(frameNode);
2129 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2130 auto context = PipelineContext::GetCurrentContext();
2131 ASSERT_NE(context, nullptr);
2132 context->isFocusActive_ = true;
2133 focusHub->focusType_ = FocusType::NODE;
2134 std::list<RefPtr<FocusHub>> focusNodes;
2135 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2136 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2137 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
2138 RoundRect paintRect;
__anon2dd0c4311702(RoundRect) 2139 focusHub->getInnerFocusRectFunc_ = [](RoundRect) {};
2140 EXPECT_FALSE(focusHub->PaintFocusState(false));
2141 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_BORDER;
2142 EXPECT_FALSE(focusHub->PaintFocusState(false));
2143 focusHub->focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
2144 focusHub->focusPaintParamsPtr_->paintColor = Color::RED;
2145 focusHub->focusPaintParamsPtr_->paintWidth = Dimension(10);
2146 focusHub->focusPaintParamsPtr_->paintRect = RoundRect(RectF(), 0.0f, 0.0f);
2147 EXPECT_TRUE(focusHub->PaintFocusState(false));
2148 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
2149 EXPECT_TRUE(focusHub->PaintFocusState(false));
2150 focusHub->focusStyleType_ = FocusStyleType::INNER_BORDER;
2151 EXPECT_TRUE(focusHub->PaintFocusState(false));
2152 focusHub->focusPaintParamsPtr_->focusPadding = Dimension(10);
2153 EXPECT_TRUE(focusHub->PaintFocusState(false));
2154 }
2155
2156 /**
2157 * @tc.name: FocusHubTestNg0050
2158 * @tc.desc: Test the function ScrollToLastFocusIndex.
2159 * @tc.type: FUNC
2160 */
2161 HWTEST_F(FocusHubTestNg, FocusHubTestNg0050, TestSize.Level1)
2162 {
2163 /**
2164 * @tc.steps: step1. Create frameNode.
2165 */
2166 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2167 auto eventHub = AceType::MakeRefPtr<EventHub>();
2168 eventHub->AttachHost(frameNode);
2169 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2170 ASSERT_NE(focusHub, nullptr);
2171 focusHub->currentFocus_ = true;
2172 auto parentNode = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
2173 auto parentFocusHub = parentNode->GetOrCreateFocusHub();
2174 parentFocusHub->focusType_ = FocusType::SCOPE;
2175 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode));
2176 focusHub->SetLastFocusNodeIndex(focusHub);
2177 focusHub->ScrollToLastFocusIndex();
2178 focusHub->lastFocusNodeIndex_ = 1;
2179 focusHub->ScrollToLastFocusIndex();
2180 EXPECT_NE(focusHub->focusType_, FocusType::SCOPE);
2181 }
2182
2183 /**
2184 * @tc.name: FocusHubTestNg0051
2185 * @tc.desc: Test the function RequestFocus.
2186 * @tc.type: FUNC
2187 */
2188 HWTEST_F(FocusHubTestNg, FocusHubTestNg0051, TestSize.Level1)
2189 {
2190 /**
2191 * @tc.steps: step1. Create frameNode.
2192 */
2193 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2194 auto eventHub = AceType::MakeRefPtr<EventHub>();
2195 eventHub->AttachHost(frameNode);
2196 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2197 ASSERT_NE(focusHub, nullptr);
2198 focusHub->RequestFocus();
2199 focusHub->currentFocus_ = true;
2200 focusHub->RequestFocus();
2201 EXPECT_TRUE(focusHub->currentFocus_);
2202 }
2203
2204 /**
2205 * @tc.name: FocusHubTestNg0052
2206 * @tc.desc: Test the function FocusToHeadOrTailChild.
2207 * @tc.type: FUNC
2208 */
2209 HWTEST_F(FocusHubTestNg, FocusHubTestNg0052, TestSize.Level1)
2210 {
2211 /**
2212 * @tc.steps: step1. Create frameNode.
2213 */
2214 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2215 auto eventHub = AceType::MakeRefPtr<EventHub>();
2216 eventHub->AttachHost(frameNode);
2217 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2218 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
2219 std::list<RefPtr<FocusHub>> focusNodes;
2220 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2221 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2222 auto parentNode = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
2223 auto parentFocusHub = parentNode->GetOrCreateFocusHub();
2224 parentFocusHub->focusType_ = FocusType::SCOPE;
2225 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode));
2226 focusHub->focusType_ = FocusType::NODE;
2227 EXPECT_FALSE(focusHub->FocusToHeadOrTailChild(true));
2228 focusHub->focusType_ = FocusType::SCOPE;
2229 EXPECT_FALSE(focusHub->FocusToHeadOrTailChild(false));
2230 }
2231
2232 /**
2233 * @tc.name: FocusHubTestNg0053
2234 * @tc.desc: Test the function AcceptFocusByRectOfLastFocusScope.
2235 * @tc.type: FUNC
2236 */
2237 HWTEST_F(FocusHubTestNg, FocusHubTestNg0053, TestSize.Level1)
2238 {
2239 /**
2240 * @tc.steps: step1. Create frameNode.
2241 */
2242 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2243 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2244 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2245 child->GetOrCreateFocusHub();
2246 child2->GetOrCreateFocusHub();
2247 frameNode->AddChild(child);
2248 frameNode->AddChild(child2);
2249 auto eventHub = AceType::MakeRefPtr<EventHub>();
2250 eventHub->AttachHost(frameNode);
2251 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2252 RectF childRect;
2253 std::list<RefPtr<FocusHub>> focusNodes;
2254 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2255 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2256 focusHub->AcceptFocusByRectOfLastFocusScope(childRect);
2257 frameNode->Clean(false, false);
2258 EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocusScope(childRect));
2259 }
2260
2261 /**
2262 * @tc.name: FocusHubTestNg0054
2263 * @tc.desc: Test the function GoToNextFocusLinear.
2264 * @tc.type: FUNC
2265 */
2266 HWTEST_F(FocusHubTestNg, FocusHubTestNg0054, TestSize.Level1)
2267 {
2268 /**
2269 * @tc.steps: step1. Create frameNode.
2270 */
2271 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2272 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2273 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2274 child->GetOrCreateFocusHub();
2275 child2->GetOrCreateFocusHub();
2276 frameNode->AddChild(child);
2277 frameNode->AddChild(child2);
2278 auto eventHub = AceType::MakeRefPtr<EventHub>();
2279 eventHub->AttachHost(frameNode);
2280 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2281 focusHub->currentFocus_ = true;
2282 std::list<RefPtr<FocusHub>> focusNodes;
2283 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2284 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2285 EXPECT_FALSE(focusHub->GoToNextFocusLinear(FocusStep::LEFT));
2286 }
2287
2288 /**
2289 * @tc.name: FocusHubTestNg0055
2290 * @tc.desc: Test the function OnKeyEventScope.
2291 * @tc.type: FUNC
2292 */
2293 HWTEST_F(FocusHubTestNg, FocusHubTestNg0055, TestSize.Level1)
2294 {
2295 /**
2296 * @tc.steps: step1. Create frameNode.
2297 */
2298 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2299 auto frameNode1 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2300 auto eventHub = AceType::MakeRefPtr<EventHub>();
2301 auto eventHub1 = AceType::MakeRefPtr<EventHub>();
2302 eventHub->AttachHost(frameNode);
2303 eventHub1->AttachHost(frameNode1);
2304 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2305 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(eventHub1);
2306 KeyEvent keyEvent;
2307 std::list<RefPtr<FocusHub>> focusNodes;
2308 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2309 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2310 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
2311 auto pipeline = PipelineContext::GetCurrentContext();
2312 focusHub->currentFocus_ = false;
2313 pipeline->isFocusActive_ = true;
2314 keyEvent.action = KeyAction::DOWN;
2315 keyEvent.code = KeyCode::KEY_TAB;
2316 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME);
2317 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
2318 pipeline->isTabJustTriggerOnKeyEvent_ = true;
2319 focusHub->currentFocus_ = true;
2320 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
2321 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
2322 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB);
2323 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
2324 }
2325
2326 /**
2327 * @tc.name: FocusHubTestNg0056
2328 * @tc.desc: Test the function RequestNextFocus.
2329 * @tc.type: FUNC
2330 */
2331 HWTEST_F(FocusHubTestNg, FocusHubTestNg0056, TestSize.Level1)
2332 {
2333 /**
2334 * @tc.steps: step1. Create frameNode.
2335 */
2336 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2337 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2338 child->GetOrCreateFocusHub();
2339 frameNode->AddChild(child);
2340 auto eventHub = AceType::MakeRefPtr<EventHub>();
2341 auto eventHub1 = AceType::MakeRefPtr<EventHub>();
2342 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2343 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(eventHub1);
2344 RectF childRect;
2345 std::list<RefPtr<FocusHub>> focusNodes;
2346 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
2347 EXPECT_EQ(itNewFocusNode, focusNodes.end());
2348 focusHub->focusAlgorithm_.scopeType = ScopeType::PROJECT_AREA;
2349 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
2350 EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::LEFT, childRect));
2351 EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::SHIFT_TAB, childRect));
__anon2dd0c4311802(FocusStep, const WeakPtr<FocusHub>&, WeakPtr<FocusHub>&) 2352 focusHub->focusAlgorithm_.getNextFocusNode = [](FocusStep, const WeakPtr<FocusHub>&, WeakPtr<FocusHub>&) {};
2353 EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::TAB, childRect));
2354 }
2355
2356 /**
2357 * @tc.name: FocusHubTestNg0057
2358 * @tc.desc: Test the function GetNearestNodeByProjectArea.
2359 * @tc.type: FUNC
2360 */
2361 HWTEST_F(FocusHubTestNg, FocusHubTestNg0057, TestSize.Level1)
2362 {
2363 /**
2364 * @tc.steps: step1. Create frameNode.
2365 */
2366 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
2367 auto frameNode2 = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
2368 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2369 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
2370 child->GetOrCreateFocusHub();
2371 child2->GetOrCreateFocusHub();
2372 frameNode->AddChild(child);
2373 frameNode->AddChild(child2);
2374 auto eventHub = AceType::MakeRefPtr<EventHub>();
2375 auto eventHub2 = AceType::MakeRefPtr<EventHub>();
2376 eventHub->AttachHost(frameNode);
2377 eventHub2->AttachHost(frameNode2);
2378 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2379 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub2);
2380 focusHub->currentFocus_ = true;
2381 std::list<RefPtr<FocusHub>> focusNodes;
2382 focusNodes.emplace_back(focusHub2);
2383 EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::NONE), nullptr);
2384 EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::TAB), nullptr);
2385 EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::SHIFT_TAB), nullptr);
2386 }
2387
2388 /**
2389 * @tc.name: FocusHubTestNg058
2390 * @tc.desc: Test the function HandleFocusByTabIndex.
2391 * @tc.type: FUNC
2392 */
2393 HWTEST_F(FocusHubTestNg, FocusHubTestNg0058, TestSize.Level1)
2394 {
2395 /**
2396 * @tc.steps1: initialize parameters.
2397 */
2398 auto eventHub = AceType::MakeRefPtr<EventHub>();
2399 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
2400 KeyEvent keyEvent;
2401 TabIndexNodeList tabIndexNodes;
2402 keyEvent.action = KeyAction::DOWN;
2403 keyEvent.code = KeyCode::KEY_TAB;
2404 focusHub->currentFocus_ = true;
2405 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
2406 }
2407
2408 /**
2409 * @tc.name: FocusHubTestNg059
2410 * @tc.desc: Test the function HandleFocusByTabIndex.
2411 * @tc.type: FUNC
2412 */
2413 HWTEST_F(FocusHubTestNg, FocusHubTestNg0059, TestSize.Level1)
2414 {
2415 /**
2416 * @tc.steps1: create focusHub and construct allNodes.
2417 */
2418 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2419 frameNode->GetOrCreateFocusHub();
2420 auto focusHub = frameNode->GetFocusHub();
2421 frameNode->geometryNode_->SetFrameSize(SizeF(20, 20));
2422 frameNode->geometryNode_->SetFrameOffset(OffsetF(20, 20));
2423 ASSERT_NE(focusHub, nullptr);
2424 std::list<RefPtr<FocusHub>> allNodes;
2425
2426 auto focus1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim<EventHub>(nullptr), FocusType::NODE, true);
2427
2428 auto frameNode2 = FrameNode::CreateFrameNode("frameNode2", 102, AceType::MakeRefPtr<ButtonPattern>());
2429 frameNode2->GetOrCreateFocusHub();
2430 auto focusHub2 = frameNode2->GetFocusHub();
2431 frameNode2->geometryNode_->SetFrameOffset(OffsetF(15, 15));
2432 frameNode2->geometryNode_->SetFrameSize(SizeF(30, 30));
2433
2434 auto frameNode3 = FrameNode::CreateFrameNode("frameNode3", 103, AceType::MakeRefPtr<ButtonPattern>());
2435 frameNode3->GetOrCreateFocusHub();
2436 auto focusHub3 = frameNode3->GetFocusHub();
2437 frameNode3->geometryNode_->SetFrameOffset(OffsetF(20, 20));
2438 frameNode3->geometryNode_->SetFrameSize(SizeF(30, 30));
2439
2440 auto frameNode4 = FrameNode::CreateFrameNode("frameNode4", 104, AceType::MakeRefPtr<ButtonPattern>());
2441 frameNode4->GetOrCreateFocusHub();
2442 auto focusHub4 = frameNode4->GetFocusHub();
2443 frameNode4->geometryNode_->SetFrameOffset(OffsetF(10, 20));
2444 frameNode4->geometryNode_->SetFrameSize(SizeF(20, 20));
2445
2446 auto frameNode5 = FrameNode::CreateFrameNode("frameNode5", 105, AceType::MakeRefPtr<ButtonPattern>());
2447 frameNode5->GetOrCreateFocusHub();
2448 auto focusHub5 = frameNode5->GetFocusHub();
2449 frameNode5->geometryNode_->SetFrameOffset(OffsetF(20, 20));
2450 frameNode5->geometryNode_->SetFrameSize(SizeF(30, 30));
2451
2452 allNodes.push_back(nullptr);
2453 allNodes.push_back(focus1);
2454 allNodes.push_back(focusHub);
2455 allNodes.push_back(focusHub2);
2456 allNodes.push_back(focusHub3);
2457 allNodes.push_back(focusHub4);
2458 allNodes.push_back(focusHub5);
2459
2460 auto res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::UP);
2461 ASSERT_NE(res, nullptr);
2462 res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::DOWN);
2463 ASSERT_NE(res, nullptr);
2464 res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::LEFT);
2465 ASSERT_NE(res, nullptr);
2466 res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::RIGHT);
2467 ASSERT_NE(res, nullptr);
2468 }
2469
2470 /**
2471 * @tc.name: FocusHubTestNg064
2472 * @tc.desc: Test the function CollectTabIndexNodes.
2473 * @tc.type: FUNC
2474 */
2475 HWTEST_F(FocusHubTestNg, FocusHubTestNg0064, TestSize.Level1)
2476 {
2477 /**
2478 * @tc.steps1: create focusHub and construct allNodes.
2479 */
2480 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2481 frameNode->GetOrCreateFocusHub();
2482 auto focusHub = frameNode->GetFocusHub();
2483 ASSERT_NE(focusHub, nullptr);
2484
2485 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2486 frameNode1->GetOrCreateFocusHub();
2487 auto focusHub1 = frameNode1->GetFocusHub();
2488
2489 frameNode->children_.push_back(frameNode1);
2490 focusHub->focusable_ = true;
2491 focusHub->parentFocusable_ = true;
2492 focusHub->focusType_ = FocusType::SCOPE;
2493
2494 focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2495 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2496 focusHub1->focusable_ = true;
2497 focusHub1->parentFocusable_ = true;
2498 focusHub1->focusType_ = FocusType::NODE;
2499 focusHub1->focusCallbackEvents_->tabIndex_ = 1;
2500
2501 TabIndexNodeList list;
2502 focusHub->CollectTabIndexNodes(list);
2503 ASSERT_FALSE(list.empty());
2504
2505 focusHub->focusCallbackEvents_->tabIndex_ = 1;
2506 focusHub->CollectTabIndexNodes(list);
2507 ASSERT_FALSE(list.empty());
2508 }
2509
2510 /**
2511 * @tc.name: FocusHubTestNg065
2512 * @tc.desc: Test the function AcceptFocusByRectOfLastFocusFlex.
2513 * @tc.type: FUNC
2514 */
2515 HWTEST_F(FocusHubTestNg, FocusHubTestNg0065, TestSize.Level1)
2516 {
2517 /**
2518 * @tc.steps1: create focusHub and construct allNodes.
2519 */
2520 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2521 frameNode->GetOrCreateFocusHub();
2522 auto focusHub = frameNode->GetFocusHub();
2523 ASSERT_NE(focusHub, nullptr);
2524
2525 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2526 frameNode1->GetOrCreateFocusHub();
2527 auto focusHub1 = frameNode1->GetFocusHub();
2528
2529 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2530 frameNode2->GetOrCreateFocusHub();
2531 auto focusHub2 = frameNode2->GetFocusHub();
2532
2533 auto frameNode3 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2534 frameNode3->GetOrCreateFocusHub();
2535 auto focusHub3 = frameNode3->GetFocusHub();
2536
2537 auto frameNode4 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2538 frameNode4->GetOrCreateFocusHub();
2539 auto focusHub4 = frameNode4->GetFocusHub();
2540
2541 focusHub1->focusable_ = false;
2542 frameNode2->geometryNode_ = nullptr;
2543 focusHub3->currentFocus_ = true;
2544
2545 focusHub->focusable_ = true;
2546 focusHub->parentFocusable_ = true;
2547 focusHub->focusType_ = FocusType::SCOPE;
2548 frameNode->children_.push_back(frameNode1);
2549 frameNode->children_.push_back(frameNode2);
2550 frameNode->children_.push_back(frameNode3);
2551 frameNode->children_.push_back(frameNode4);
2552
2553 auto res = focusHub->AcceptFocusByRectOfLastFocusFlex(RectF(0, 0, -1, -1));
2554 ASSERT_FALSE(res);
2555 focusHub->AcceptFocusByRectOfLastFocusFlex(RectF());
2556 ASSERT_FALSE(res);
2557 }
2558
2559 /**
2560 * @tc.name: FocusHubTestNg066
2561 * @tc.desc: Test the function AcceptFocusByRectOfLastFocusScope.
2562 * @tc.type: FUNC
2563 */
2564 HWTEST_F(FocusHubTestNg, FocusHubTestNg0066, TestSize.Level1)
2565 {
2566 /**
2567 * @tc.steps1: create focusHub and construct allNodes.
2568 */
2569 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2570 frameNode->GetOrCreateFocusHub();
2571 auto focusHub = frameNode->GetFocusHub();
2572 ASSERT_NE(focusHub, nullptr);
2573
2574 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2575 frameNode1->GetOrCreateFocusHub();
2576 auto focusHub1 = frameNode1->GetFocusHub();
2577
2578 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2579 frameNode2->GetOrCreateFocusHub();
2580 auto focusHub2 = frameNode2->GetFocusHub();
2581
2582 auto frameNode3 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2583 frameNode3->GetOrCreateFocusHub();
2584 auto focusHub3 = frameNode3->GetFocusHub();
2585
2586 auto frameNode4 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2587 frameNode4->GetOrCreateFocusHub();
2588 auto focusHub4 = frameNode4->GetFocusHub();
2589
2590 focusHub1->focusable_ = false;
2591 frameNode2->geometryNode_ = nullptr;
2592 focusHub3->currentFocus_ = true;
2593
2594 focusHub->focusable_ = true;
2595 focusHub->parentFocusable_ = true;
2596 focusHub->focusType_ = FocusType::SCOPE;
2597 frameNode->children_.push_back(frameNode1);
2598 frameNode->children_.push_back(frameNode2);
2599 frameNode->children_.push_back(frameNode3);
2600 frameNode->children_.push_back(frameNode4);
2601
2602 auto res = focusHub->AcceptFocusByRectOfLastFocusScope(RectF(0, 0, -1, -1));
2603 ASSERT_TRUE(res);
2604 focusHub->AcceptFocusByRectOfLastFocusScope(RectF());
2605 ASSERT_TRUE(res);
2606 }
2607
2608 /**
2609 * @tc.name: FocusHubTestNg067
2610 * @tc.desc: Test the function GetChildFocusNodeByType.
2611 * @tc.type: FUNC
2612 */
2613 HWTEST_F(FocusHubTestNg, FocusHubTestNg0067, TestSize.Level1)
2614 {
2615 /**
2616 * @tc.steps1: create focusHub and construct allNodes.
2617 */
2618 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2619 frameNode->GetOrCreateFocusHub();
2620 auto focusHub = frameNode->GetFocusHub();
2621 ASSERT_NE(focusHub, nullptr);
2622
2623 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2624 frameNode1->GetOrCreateFocusHub();
2625 auto focusHub1 = frameNode1->GetFocusHub();
2626
2627 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2628 frameNode2->GetOrCreateFocusHub();
2629 auto focusHub2 = frameNode2->GetFocusHub();
2630
2631 auto frameNode3 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2632 frameNode3->GetOrCreateFocusHub();
2633 auto focusHub3 = frameNode3->GetFocusHub();
2634
2635 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2636 focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2637 focusHub3->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2638
2639 focusHub3->focusCallbackEvents_->isDefaultGroupFocus_ = false;
2640 focusHub1->focusCallbackEvents_->isDefaultGroupFocus_ = true;
2641
2642 focusHub->focusType_ = FocusType::SCOPE;
2643 frameNode->children_.push_back(frameNode3);
2644 frameNode->children_.push_back(frameNode1);
2645
2646 auto res = focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT);
2647 ASSERT_NE(res, nullptr);
2648 }
2649
2650 /**
2651 * @tc.name: FocusHubTestNg068
2652 * @tc.desc: Test the function GoToFocusByTabNodeIdx.
2653 * @tc.type: FUNC
2654 */
2655 HWTEST_F(FocusHubTestNg, FocusHubTestNg0068, TestSize.Level1)
2656 {
2657 /**
2658 * @tc.steps1: create focusHub and construct allNodes.
2659 */
2660 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2661 frameNode->GetOrCreateFocusHub();
2662 auto focusHub = frameNode->GetFocusHub();
2663 ASSERT_NE(focusHub, nullptr);
2664
2665 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2666 frameNode1->GetOrCreateFocusHub();
2667 auto focusHub1 = frameNode1->GetFocusHub();
2668
2669 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2670 frameNode2->GetOrCreateFocusHub();
2671 auto focusHub2 = frameNode2->GetFocusHub();
2672
2673 auto frameNode3 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2674 frameNode3->GetOrCreateFocusHub();
2675 auto focusHub3 = frameNode3->GetFocusHub();
2676
2677 auto frameNode4 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2678 frameNode4->GetOrCreateFocusHub();
2679 auto focusHub4 = frameNode4->GetFocusHub();
2680
2681 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2682 focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2683 focusHub3->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2684 focusHub4->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2685
2686 frameNode4->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode2));
2687 focusHub1->focusType_ = FocusType::SCOPE;
2688 focusHub2->focusType_ = FocusType::SCOPE;
2689 focusHub3->focusCallbackEvents_->isDefaultGroupFocus_ = true;
2690 focusHub4->focusCallbackEvents_->isDefaultGroupFocus_ = true;
2691 focusHub2->focusable_ = false;
2692
2693 frameNode1->children_.push_back(frameNode3);
2694 frameNode2->children_.push_back(frameNode4);
2695
2696 TabIndexNodeList list;
2697 list.push_back({1, AceType::WeakClaim(AceType::RawPtr(focusHub1))});
2698 list.push_back({2, AceType::WeakClaim(AceType::RawPtr(focusHub2))});
2699
2700 focusHub->focusType_ = FocusType::SCOPE;
2701 auto res = focusHub->GoToFocusByTabNodeIdx(list, 0);
2702 ASSERT_TRUE(res);
2703 res = focusHub->GoToFocusByTabNodeIdx(list, 1);
2704 ASSERT_FALSE(res);
2705 }
2706
2707 /**
2708 * @tc.name: FocusHubTestNg069
2709 * @tc.desc: Test the function CollectTabIndexNodes.
2710 * @tc.type: FUNC
2711 */
2712 HWTEST_F(FocusHubTestNg, FocusHubTestNg0069, TestSize.Level1)
2713 {
2714 /**
2715 * @tc.steps1: create focusHub and construct allNodes.
2716 */
2717 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2718 frameNode->GetOrCreateFocusHub();
2719 auto focusHub = frameNode->GetFocusHub();
2720 ASSERT_NE(focusHub, nullptr);
2721
2722 focusHub->focusable_ = false;
2723 focusHub->focusType_ = FocusType::SCOPE;
2724 TabIndexNodeList list;
2725 focusHub->CollectTabIndexNodes(list);
2726 ASSERT_TRUE(list.empty());
2727 }
2728
2729 /**
2730 * @tc.name: FocusHubTestNg070
2731 * @tc.desc: Test the function IsFocusableWholePath.
2732 * @tc.type: FUNC
2733 */
2734 HWTEST_F(FocusHubTestNg, FocusHubTestNg0070, TestSize.Level1)
2735 {
2736 /**
2737 * @tc.steps1: create focusHub and construct allNodes.
2738 */
2739 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2740 frameNode->GetOrCreateFocusHub();
2741 auto focusHub = frameNode->GetFocusHub();
2742 ASSERT_NE(focusHub, nullptr);
2743
2744 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2745 frameNode1->GetOrCreateFocusHub();
2746 auto focusHub1 = frameNode1->GetFocusHub();
2747
2748 focusHub->focusType_ = FocusType::SCOPE;
2749 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
2750 frameNode->children_.push_back(frameNode1);
2751
2752 ASSERT_TRUE(focusHub->IsFocusableNode());
2753 ASSERT_TRUE(focusHub->IsFocusableScope());
2754 auto res = focusHub1->IsFocusableWholePath();
2755 ASSERT_TRUE(res);
2756 }
2757
2758 /**
2759 * @tc.name: FocusHubTestNg071
2760 * @tc.desc: Test the function IsFocusableScopeByTab.
2761 * @tc.type: FUNC
2762 */
2763 HWTEST_F(FocusHubTestNg, FocusHubTestNg0071, TestSize.Level1)
2764 {
2765 /**
2766 * @tc.steps1: create focusHub and construct allNodes.
2767 */
2768 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2769 frameNode->GetOrCreateFocusHub();
2770 auto focusHub = frameNode->GetFocusHub();
2771 ASSERT_NE(focusHub, nullptr);
2772
2773 focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2774 focusHub->focusCallbackEvents_->tabIndex_ = 1;
2775
2776 auto res = focusHub->IsFocusableScopeByTab();
2777 ASSERT_FALSE(res);
2778 }
2779
2780 /**
2781 * @tc.name: FocusHubTestNg072
2782 * @tc.desc: Test the function AcceptFocusOfSpecifyChild.
2783 * @tc.type: FUNC
2784 */
2785 HWTEST_F(FocusHubTestNg, FocusHubTestNg0072, TestSize.Level1)
2786 {
2787 /**
2788 * @tc.steps1: create focusHub and construct allNodes.
2789 */
2790 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2791 frameNode->GetOrCreateFocusHub();
2792 auto focusHub = frameNode->GetFocusHub();
2793 ASSERT_NE(focusHub, nullptr);
2794
2795 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2796 frameNode1->GetOrCreateFocusHub();
2797 auto focusHub1 = frameNode1->GetFocusHub();
2798
2799 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2800 frameNode2->GetOrCreateFocusHub();
2801 auto focusHub2 = frameNode2->GetFocusHub();
2802
2803 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2804 focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
2805
2806 focusHub->focusType_ = FocusType::SCOPE;
2807 focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
2808 frameNode->children_.push_back(frameNode1);
2809 frameNode->children_.push_back(frameNode2);
2810 focusHub1->focusable_ = false;
2811 auto res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
2812 ASSERT_TRUE(res);
2813 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB);
2814 ASSERT_TRUE(res);
2815 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::DOWN);
2816 ASSERT_FALSE(res);
2817 focusHub2->focusable_ = false;
2818 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB);
2819 ASSERT_FALSE(res);
2820 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
2821 ASSERT_FALSE(res);
2822 }
2823
2824 /**
2825 * @tc.name: FocusHubTestNg073
2826 * @tc.desc: Test the function ClearAllFocusState.
2827 * @tc.type: FUNC
2828 */
2829 HWTEST_F(FocusHubTestNg, FocusHubTestNg0073, TestSize.Level1)
2830 {
2831 /**
2832 * @tc.steps1: create focusHub and construct allNodes.
2833 */
2834 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2835 frameNode->GetOrCreateFocusHub();
2836 auto focusHub = frameNode->GetFocusHub();
2837 ASSERT_NE(focusHub, nullptr);
2838
2839 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2840 frameNode1->GetOrCreateFocusHub();
2841 auto focusHub1 = frameNode1->GetFocusHub();
2842
2843 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
2844 focusHub->ClearAllFocusState();
2845 ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
2846
2847 /**
2848 * @tc.steps: step1. Create frameNode.
2849 */
2850 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2851 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2852 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
2853 }
2854
2855 /**
2856 * @tc.name: FocusHubTestNg074
2857 * @tc.desc: Test the function PaintAllFocusState.
2858 * @tc.type: FUNC
2859 */
2860 HWTEST_F(FocusHubTestNg, FocusHubTestNg0074, TestSize.Level1)
2861 {
2862 /**
2863 * @tc.steps1: create focusHub and construct allNodes.
2864 */
2865 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2866 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2867 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
2868 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2869 frameNode->GetOrCreateFocusHub();
2870 auto focusHub = frameNode->GetFocusHub();
2871 ASSERT_NE(focusHub, nullptr);
2872 auto context = PipelineContext::GetCurrentContext();
2873 context->isFocusActive_ = true;
2874
2875 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
2876 auto res = focusHub->PaintAllFocusState();
2877 ASSERT_TRUE(res);
2878 }
2879
2880 /**
2881 * @tc.name: FocusHubTestNg075
2882 * @tc.desc: Test the function PaintFocusState.
2883 * @tc.type: FUNC
2884 */
2885 HWTEST_F(FocusHubTestNg, FocusHubTestNg0075, TestSize.Level1)
2886 {
2887 /**
2888 * @tc.steps1: create focusHub and construct allNodes.
2889 */
2890 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
2891 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
2892 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
2893 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2894 frameNode->GetOrCreateFocusHub();
2895 auto focusHub = frameNode->GetFocusHub();
2896 ASSERT_NE(focusHub, nullptr);
2897 auto context = PipelineContext::GetCurrentContext();
2898 context->isFocusActive_ = true;
2899
__anon2dd0c4311902(RoundRect& rect) 2900 auto func = [](RoundRect& rect) { rect.rect_ = RectF(); };
2901 focusHub->getInnerFocusRectFunc_ = func;
2902 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
2903 auto res = focusHub->PaintFocusState();
2904 ASSERT_TRUE(res);
2905 }
2906
2907 /**
2908 * @tc.name: FocusHubTestNg076
2909 * @tc.desc: Test the function OnFocusScope.
2910 * @tc.type: FUNC
2911 */
2912 HWTEST_F(FocusHubTestNg, FocusHubTestNg0076, TestSize.Level1)
2913 {
2914 /**
2915 * @tc.steps1: create focusHub and construct allNodes.
2916 */
2917 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2918 frameNode->GetOrCreateFocusHub();
2919 auto focusHub = frameNode->GetFocusHub();
2920 ASSERT_NE(focusHub, nullptr);
2921
2922 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2923 frameNode1->GetOrCreateFocusHub();
2924 auto focusHub1 = frameNode1->GetFocusHub();
2925
2926 focusHub1->focusable_ =false;
2927 focusHub->focusType_ = FocusType::SCOPE;
2928 frameNode->children_.push_back(frameNode1);
2929 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
2930 focusHub->OnFocusScope();
2931 ASSERT_FALSE(focusHub1->focusable_);
2932 }
2933
2934 /**
2935 * @tc.name: FocusHubTestNg077
2936 * @tc.desc: Test the function OnFocus.
2937 * @tc.type: FUNC
2938 */
2939 HWTEST_F(FocusHubTestNg, FocusHubTestNg0077, TestSize.Level1)
2940 {
2941 /**
2942 * @tc.steps1: create focusHub and construct allNodes.
2943 */
2944 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2945 frameNode->GetOrCreateFocusHub();
2946 auto focusHub = frameNode->GetFocusHub();
2947 ASSERT_NE(focusHub, nullptr);
2948
2949 focusHub->focusType_ = FocusType::DISABLE;
2950 focusHub->OnFocus();
2951 ASSERT_EQ(focusHub->focusType_, FocusType::DISABLE);
2952 }
2953
2954 /**
2955 * @tc.name: FocusHubTestNg078
2956 * @tc.desc: Test the function CalculatePosition.
2957 * @tc.type: FUNC
2958 */
2959 HWTEST_F(FocusHubTestNg, FocusHubTestNg0078, TestSize.Level1)
2960 {
2961 /**
2962 * @tc.steps1: create focusHub and construct allNodes.
2963 */
2964 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2965 frameNode->GetOrCreateFocusHub();
2966 auto focusHub = frameNode->GetFocusHub();
2967 ASSERT_NE(focusHub, nullptr);
2968
2969 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2970 frameNode1->GetOrCreateFocusHub();
2971 auto focusHub1 = frameNode1->GetFocusHub();
2972 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
2973 frameNode1->geometryNode_ = nullptr;
2974 auto res = focusHub->CalculatePosition();
2975 ASSERT_FALSE(res);
2976 }
2977
2978 /**
2979 * @tc.name: FocusHubTestNg079
2980 * @tc.desc: Test the function TryRequestFocus.
2981 * @tc.type: FUNC
2982 */
2983 HWTEST_F(FocusHubTestNg, FocusHubTestNg0079, TestSize.Level1)
2984 {
2985 /**
2986 * @tc.steps1: create focusHub and construct allNodes.
2987 */
2988 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2989 frameNode->GetOrCreateFocusHub();
2990 auto focusHub = frameNode->GetFocusHub();
2991 ASSERT_NE(focusHub, nullptr);
2992
2993 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
2994 frameNode1->GetOrCreateFocusHub();
2995 auto focusHub1 = frameNode1->GetFocusHub();
2996 auto res = focusHub->TryRequestFocus(focusHub1, RectF(), FocusStep::LEFT);
2997 ASSERT_TRUE(res);
2998 }
2999
3000 /**
3001 * @tc.name: FocusHubTestNg080
3002 * @tc.desc: Test the function GoToNextFocusLinear.
3003 * @tc.type: FUNC
3004 */
3005 HWTEST_F(FocusHubTestNg, FocusHubTestNg0080, TestSize.Level1)
3006 {
3007 /**
3008 * @tc.steps1: create focusHub and construct allNodes.
3009 */
3010 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3011 frameNode->GetOrCreateFocusHub();
3012 auto focusHub = frameNode->GetFocusHub();
3013 ASSERT_NE(focusHub, nullptr);
3014
3015 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3016 frameNode1->GetOrCreateFocusHub();
3017 auto focusHub1 = frameNode1->GetFocusHub();
3018
3019 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3020 frameNode2->GetOrCreateFocusHub();
3021 auto focusHub2 = frameNode2->GetFocusHub();
3022
3023 auto frameNode3 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3024 frameNode3->GetOrCreateFocusHub();
3025 auto focusHub3 = frameNode3->GetFocusHub();
3026
3027 auto frameNode4 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3028 frameNode4->GetOrCreateFocusHub();
3029 auto focusHub4 = frameNode4->GetFocusHub();
3030
3031 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub4));
3032 frameNode->children_.push_back(frameNode1);
3033 frameNode->children_.push_back(frameNode2);
3034 frameNode->children_.push_back(frameNode3);
3035 frameNode->children_.push_back(frameNode4);
3036
3037 focusHub3->focusable_ = false;
3038
3039 auto res = focusHub->GoToNextFocusLinear(FocusStep::SHIFT_TAB, RectF());
3040 ASSERT_TRUE(res);
3041 focusHub2->focusable_ = false;
3042 res = focusHub->GoToNextFocusLinear(FocusStep::SHIFT_TAB, RectF());
3043 ASSERT_TRUE(res);
3044 focusHub1->focusable_ = false;
3045 res = focusHub->GoToNextFocusLinear(FocusStep::SHIFT_TAB, RectF());
3046 ASSERT_FALSE(res);
3047 focusHub->lastWeakFocusNode_ = AceType::WeakClaim<FocusHub>(nullptr);
3048 focusHub4->focusable_ = false;
3049 res = focusHub->GoToNextFocusLinear(FocusStep::TAB, RectF());
3050 ASSERT_FALSE(res);
3051 }
3052
3053 /**
3054 * @tc.name: FocusHubTestNg081
3055 * @tc.desc: Test the function SwitchFocus.
3056 * @tc.type: FUNC
3057 */
3058 HWTEST_F(FocusHubTestNg, FocusHubTestNg0081, TestSize.Level1)
3059 {
3060 /**
3061 * @tc.steps1: create focusHub and construct allNodes.
3062 */
3063 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3064 frameNode->GetOrCreateFocusHub();
3065 auto focusHub = frameNode->GetFocusHub();
3066 ASSERT_NE(focusHub, nullptr);
3067
3068 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3069 frameNode1->GetOrCreateFocusHub();
3070 auto focusHub1 = frameNode1->GetFocusHub();
3071
3072 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3073 frameNode2->GetOrCreateFocusHub();
3074 auto focusHub2 = frameNode2->GetFocusHub();
3075
3076 focusHub->currentFocus_ = true;
3077 focusHub->focusType_ = FocusType::SCOPE;
3078 frameNode->children_.push_back(frameNode1);
3079 frameNode->children_.push_back(frameNode2);
3080 focusHub->lastWeakFocusNode_ = AceType::WeakClaim<FocusHub>(nullptr);
3081 focusHub->SwitchFocus(focusHub2);
3082 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
3083 focusHub1->currentFocus_ = true;
3084 focusHub->SwitchFocus(focusHub2);
3085 ASSERT_FALSE(focusHub1->currentFocus_);
3086 }
3087
3088 /**
3089 * @tc.name: FocusHubTestNg083
3090 * @tc.desc: Test the function FocusToHeadOrTailChild.
3091 * @tc.type: FUNC
3092 */
3093 HWTEST_F(FocusHubTestNg, FocusHubTestNg0083, TestSize.Level1)
3094 {
3095 /**
3096 * @tc.steps1: create focusHub and construct allNodes.
3097 */
3098 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3099 frameNode->GetOrCreateFocusHub();
3100 auto focusHub = frameNode->GetFocusHub();
3101 ASSERT_NE(focusHub, nullptr);
3102
3103 auto res = focusHub->FocusToHeadOrTailChild(true);
3104 ASSERT_TRUE(res);
3105 }
3106
3107 /**
3108 * @tc.name: FocusHubTestNg0084
3109 * @tc.desc: Test the function OnKeyEventScope.
3110 * @tc.type: FUNC
3111 */
3112 HWTEST_F(FocusHubTestNg, FocusHubTestNg0084, TestSize.Level1)
3113 {
3114 /**
3115 * @tc.steps: step1. Create frameNode.
3116 */
3117 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
3118 auto frameNode1 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
3119 auto eventHub = AceType::MakeRefPtr<EventHub>();
3120 auto eventHub1 = AceType::MakeRefPtr<EventHub>();
3121 eventHub->AttachHost(frameNode);
3122 eventHub1->AttachHost(frameNode1);
3123 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
3124 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(eventHub1);
3125 KeyEvent keyEvent;
3126 std::list<RefPtr<FocusHub>> focusNodes;
3127 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
3128 EXPECT_EQ(itNewFocusNode, focusNodes.end());
3129 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
3130 auto pipeline = PipelineContext::GetCurrentContext();
3131 focusHub->currentFocus_ = false;
3132 pipeline->isFocusActive_ = true;
3133 keyEvent.action = KeyAction::DOWN;
3134 keyEvent.code = KeyCode::KEY_TAB;
3135 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME);
3136 pipeline->isTabJustTriggerOnKeyEvent_ = true;
3137 focusHub->currentFocus_ = true;
3138 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
3139 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3140 keyEvent.code = KeyCode::TV_CONTROL_UP;
3141 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3142 keyEvent.code = KeyCode::TV_CONTROL_DOWN;
3143 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3144 keyEvent.code = KeyCode::TV_CONTROL_LEFT;
3145 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3146 keyEvent.code = KeyCode::TV_CONTROL_RIGHT;
3147 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3148 keyEvent.code = KeyCode::KEY_MOVE_HOME;
3149 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3150 keyEvent.code = KeyCode::KEY_MOVE_END;
3151 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3152 keyEvent.code = KeyCode::KEY_FOCUS;
3153 EXPECT_FALSE(focusHub->OnKeyEventScope(keyEvent));
3154 }
3155
3156 /**
3157 * @tc.name: FocusHubTestNg0085
3158 * @tc.desc: Test the function GetMainViewRootScope.
3159 * @tc.type: FUNC
3160 */
3161 HWTEST_F(FocusHubTestNg, FocusHubTestNg0085, TestSize.Level1)
3162 {
3163 /**
3164 * @tc.steps: step1. Create FocusHub with the WeakPtr eventHub_ owning frameNode.
3165 * @tc.expected: eventHub can be updated and frameName = V2::DIALOG_ETS_TAG.
3166 */
3167 auto eventHub = AceType::MakeRefPtr<EventHub>();
3168 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::DIALOG_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
3169 eventHub->AttachHost(frameNode);
3170 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
3171 EXPECT_TRUE(focusHub->GetFrameNode() != nullptr);
3172 EXPECT_TRUE(focusHub->GetGeometryNode() != nullptr);
3173 EXPECT_EQ(focusHub->GetFrameName(), V2::DIALOG_ETS_TAG);
3174 EXPECT_EQ(focusHub->GetInspectorKey(), std::nullopt);
3175 EXPECT_FALSE(focusHub->GetMainViewRootScope());
3176 }
3177
3178 /**
3179 * @tc.name: FocusHubTestNg0086
3180 * @tc.desc: Test the function GetMainViewRootScope.
3181 * @tc.type: FUNC
3182 */
3183 HWTEST_F(FocusHubTestNg, FocusHubTestNg0086, TestSize.Level1)
3184 {
3185 /**
3186 * @tc.steps: step1. Create FocusHub with the WeakPtr eventHub_ owning frameNode.
3187 * @tc.expected: eventHub can be updated and frameName = V2::POPUP_ETS_TAG.
3188 */
3189 auto eventHub = AceType::MakeRefPtr<EventHub>();
3190 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::POPUP_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
3191 eventHub->AttachHost(frameNode);
3192 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
3193 EXPECT_TRUE(focusHub->GetFrameNode() != nullptr);
3194 EXPECT_TRUE(focusHub->GetGeometryNode() != nullptr);
3195 EXPECT_EQ(focusHub->GetFrameName(), V2::POPUP_ETS_TAG);
3196 EXPECT_EQ(focusHub->GetInspectorKey(), std::nullopt);
3197 EXPECT_FALSE(focusHub->GetMainViewRootScope());
3198 }
3199
3200 /**
3201 * @tc.name: LostFocusToViewRoot0087
3202 * @tc.desc: Test the function GetCurrentMainView.
3203 * @tc.type: FUNC
3204 */
3205 HWTEST_F(FocusHubTestNg, FocusHubTestNg0087, TestSize.Level1)
3206 {
3207 /**
3208 * @tc.steps: step1. Create frameNode.
3209 */
3210 auto frameNode = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3211 auto eventHub = AceType::MakeRefPtr<EventHub>();
3212 eventHub->AttachHost(frameNode);
3213 auto focusHub = frameNode->GetFocusHub();
3214 KeyEvent keyEvent;
3215 std::list<RefPtr<FocusHub>> focusNodes;
3216 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
3217 EXPECT_EQ(itNewFocusNode, focusNodes.end());
3218 auto pipeline = PipelineContext::GetCurrentContext();
3219 auto screenNode = pipeline->screenNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
3220 EXPECT_FALSE(focusHub->GetCurrentMainView());
3221 }
3222
3223 /**
3224 * @tc.name: FocusHubTestNg0088
3225 * @tc.desc: Test the function GetChildMainView.
3226 * @tc.type: FUNC
3227 */
3228 HWTEST_F(FocusHubTestNg, FocusHubTestNg0088, TestSize.Level1)
3229 {
3230 /**
3231 * @tc.steps1: create focusHub and construct allNodes.
3232 */
3233 auto frameNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3234 frameNode->GetOrCreateFocusHub();
3235 auto focusHub = frameNode->GetFocusHub();
3236 ASSERT_NE(focusHub, nullptr);
3237 auto frameNode1 = FrameNode::CreateFrameNode(V2::DIALOG_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3238 frameNode1->GetOrCreateFocusHub();
3239 auto focusHub1 = frameNode1->GetFocusHub();
3240 auto frameNode2 = FrameNode::CreateFrameNode(V2::MODAL_PAGE_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3241 frameNode2->GetOrCreateFocusHub();
3242 auto focusHub2 = frameNode2->GetFocusHub();
3243 std::list<RefPtr<FocusHub>> focusNodes;
3244 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
3245 EXPECT_EQ(itNewFocusNode, focusNodes.end());
3246 focusHub->focusType_ = FocusType::SCOPE;
3247 frameNode->children_.push_back(frameNode1);
3248 frameNode->children_.push_back(frameNode2);
3249 EXPECT_TRUE(focusHub->GetChildMainView() != nullptr);
3250 }
3251
3252 /**
3253 * @tc.name: FocusHubTestNg0089
3254 * @tc.desc: Test the function IsOnRootTree.
3255 * @tc.type: FUNC
3256 */
3257 HWTEST_F(FocusHubTestNg, FocusHubTestNg0089, TestSize.Level1)
3258 {
3259 /**
3260 * @tc.steps1: create focusHub and parentName != V2::ROOT_ETS_TAG.
3261 */
3262 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3263 frameNode->GetOrCreateFocusHub();
3264 auto focusHub = frameNode->GetFocusHub();
3265 ASSERT_NE(focusHub, nullptr);
3266 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3267 frameNode1->GetOrCreateFocusHub();
3268 auto focusHub1 = frameNode1->GetFocusHub();
3269 focusHub->focusType_ = FocusType::SCOPE;
3270 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
3271 frameNode->children_.push_back(frameNode1);
3272 ASSERT_TRUE(focusHub->IsFocusableNode());
3273 ASSERT_TRUE(focusHub->IsFocusableScope());
3274 auto res = focusHub1->IsOnRootTree();
3275 ASSERT_FALSE(res);
3276 }
3277
3278 /**
3279 * @tc.name: FocusHubTestNg0090
3280 * @tc.desc: Test the function RequestFocusWithDefaultFocusFirstly.
3281 * @tc.type: FUNC
3282 */
3283 HWTEST_F(FocusHubTestNg, FocusHubTestNg0090, TestSize.Level1)
3284 {
3285 /**
3286 * @tc.steps: step1. Create frameNode.
3287 */
3288 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::MENU_WRAPPER_ETS_TAG, 101, AceType::MakeRefPtr<Pattern>());
3289 auto child = AceType::MakeRefPtr<FrameNode>(V2::MENU_WRAPPER_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3290 child->GetOrCreateFocusHub();
3291 frameNode->AddChild(child);
3292 auto eventHub = AceType::MakeRefPtr<EventHub>();
3293 auto eventHub1 = AceType::MakeRefPtr<EventHub>();
3294 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
3295 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(eventHub1);
3296 focusHub->RequestFocusWithDefaultFocusFirstly();
3297 ASSERT_TRUE(focusHub->currentFocus_ == false);
3298 }
3299
3300 /**
3301 * @tc.name: FocusHubTestNg0091
3302 * @tc.desc: Test the function FocusToHeadOrTailChild.
3303 * @tc.type: FUNC
3304 */
3305 HWTEST_F(FocusHubTestNg, FocusHubTestNg0091, TestSize.Level1)
3306 {
3307 /**
3308 * @tc.steps: step1. Create frameNode.
3309 */
3310 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3311 frameNode->GetOrCreateFocusHub();
3312 auto eventHub = AceType::MakeRefPtr<EventHub>();
3313 eventHub->AttachHost(frameNode);
3314 auto focusHub = frameNode->GetFocusHub();
3315 ASSERT_NE(focusHub, nullptr);
3316 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3317 frameNode1->GetOrCreateFocusHub();
3318 auto focusHub1 = frameNode1->GetFocusHub();
3319 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
3320 focusHub->focusType_ = FocusType::SCOPE;
3321 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
3322 frameNode->children_.push_back(frameNode1);
3323 ASSERT_TRUE(focusHub->IsFocusableNode());
3324 ASSERT_TRUE(focusHub->IsFocusableScope());
3325 focusHub->focusDepend_ = FocusDependence::AUTO;
3326 EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(true));
3327 focusHub->focusDepend_ = FocusDependence::SELF;
3328 EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(false));
3329 focusHub->focusDepend_ = FocusDependence::CHILD;
3330 EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(false));
3331 }
3332
3333 /**
3334 * @tc.name: FocusHubTestNg0092
3335 * @tc.desc: Test the function IsOnRootTree.
3336 * @tc.type: FUNC
3337 */
3338 HWTEST_F(FocusHubTestNg, FocusHubTestNg0092, TestSize.Level1)
3339 {
3340 /**
3341 * @tc.steps1: create focusHub and parentName = V2::ROOT_ETS_TAG.
3342 */
3343 auto frameNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3344 frameNode->GetOrCreateFocusHub();
3345 auto focusHub = frameNode->GetFocusHub();
3346 ASSERT_NE(focusHub, nullptr);
3347 auto frameNode1 = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3348 frameNode1->GetOrCreateFocusHub();
3349 auto focusHub1 = frameNode1->GetFocusHub();
3350 focusHub->focusType_ = FocusType::SCOPE;
3351 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
3352 frameNode->children_.push_back(frameNode1);
3353 ASSERT_TRUE(focusHub->IsFocusableNode());
3354 ASSERT_TRUE(focusHub->IsFocusableScope());
3355 auto res = focusHub1->IsOnRootTree();
3356 ASSERT_TRUE(res);
3357 }
3358
3359 /**
3360 * @tc.name: FocusHubTestNg0093
3361 * @tc.desc: Test the function IsNeedPaintFocusState.
3362 * @tc.type: FUNC
3363 */
3364 HWTEST_F(FocusHubTestNg, FocusHubTestNg0093, TestSize.Level1)
3365 {
3366 /**
3367 * @tc.steps: step1. Create frameNode.
3368 */
3369 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3370 frameNode->GetOrCreateFocusHub();
3371 auto focusHub = frameNode->GetFocusHub();
3372 ASSERT_NE(focusHub, nullptr);
3373 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3374 frameNode1->GetOrCreateFocusHub();
3375 auto focusHub1 = frameNode1->GetFocusHub();
3376 focusHub->focusType_ = FocusType::SCOPE;
3377 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
3378 frameNode->children_.push_back(frameNode1);
3379 ASSERT_TRUE(focusHub->IsFocusableNode());
3380 focusHub->currentFocus_ = true;
3381 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
3382 ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
3383 EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
3384 focusHub->focusDepend_ = FocusDependence::SELF;
3385 EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
3386 focusHub->focusType_ = FocusType::NODE;
3387 EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
3388 }
3389
3390 /**
3391 * @tc.name: FocusHubTestNg0094
3392 * @tc.desc: Test the function HandleFocusByTabIndex.
3393 * @tc.type: FUNC
3394 */
3395 HWTEST_F(FocusHubTestNg, FocusHubTestNg0094, TestSize.Level1)
3396 {
3397 /**
3398 * @tc.steps1: initialize parameters.
3399 */
3400 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3401 frameNode->GetOrCreateFocusHub();
3402 auto focusHub = frameNode->GetFocusHub();
3403 ASSERT_NE(focusHub, nullptr);
3404 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3405 frameNode1->GetOrCreateFocusHub();
3406 auto focusHub1 = frameNode1->GetFocusHub();
3407 frameNode->children_.push_back(frameNode1);
3408 focusHub->focusable_ = true;
3409 focusHub->parentFocusable_ = true;
3410 focusHub->focusType_ = FocusType::SCOPE;
3411 focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
3412 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
3413 focusHub1->focusable_ = true;
3414 focusHub1->parentFocusable_ = true;
3415 focusHub1->focusType_ = FocusType::NODE;
3416 focusHub1->focusCallbackEvents_->tabIndex_ = 1;
3417 KeyEvent keyEvent;
3418 TabIndexNodeList tabIndexNodes;
3419 keyEvent.action = KeyAction::DOWN;
3420 keyEvent.code = KeyCode::KEY_TAB;
3421 auto pipeline = PipelineContext::GetCurrentContext();
3422 pipeline->isTabJustTriggerOnKeyEvent_ = false;
3423 EXPECT_TRUE(focusHub->HandleFocusByTabIndex(keyEvent));
3424 }
3425
3426 /**
3427 * @tc.name: FocusHubTestNg0095
3428 * @tc.desc: Test the function RequestFocusWithDefaultFocusFirstly.
3429 * @tc.type: FUNC
3430 */
3431 HWTEST_F(FocusHubTestNg, FocusHubTestNg0095, TestSize.Level1)
3432 {
3433 /**
3434 * @tc.steps: step1. Create frameNode.
3435 */
3436 auto eventHub = AceType::MakeRefPtr<EventHub>();
3437 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::MENU_WRAPPER_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
3438 eventHub->AttachHost(frameNode);
3439 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
3440 EXPECT_TRUE(focusHub->GetFrameNode() != nullptr);
3441 EXPECT_TRUE(focusHub->GetGeometryNode() != nullptr);
3442 EXPECT_EQ(focusHub->GetFrameName(), V2::MENU_WRAPPER_ETS_TAG);
3443 EXPECT_EQ(focusHub->GetInspectorKey(), std::nullopt);
3444 focusHub->RequestFocusWithDefaultFocusFirstly();
3445 ASSERT_TRUE(focusHub->currentFocus_ == false);
3446 }
3447
3448 /**
3449 * @tc.name: FocusHubTestNg0096
3450 * @tc.desc: Test the function OnFocusScope.
3451 * @tc.type: FUNC
3452 */
3453 HWTEST_F(FocusHubTestNg, FocusHubTestNg0096, TestSize.Level1)
3454 {
3455 /**
3456 * @tc.steps: step1. Create frameNode.
3457 */
3458 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
3459 auto child = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
3460 auto child2 = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>());
3461 child->GetOrCreateFocusHub();
3462 child2->GetOrCreateFocusHub();
3463 frameNode->AddChild(child);
3464 frameNode->AddChild(child2);
3465 auto eventHub = AceType::MakeRefPtr<EventHub>();
3466 auto eventHub2 = AceType::MakeRefPtr<EventHub>();
3467 eventHub->AttachHost(frameNode);
3468 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
3469 focusHub->currentFocus_ = true;
3470 std::list<RefPtr<FocusHub>> focusNodes;
3471 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
3472 EXPECT_EQ(itNewFocusNode, focusNodes.end());
3473 focusHub->OnFocusScope(true);
3474 frameNode->Clean(false, false);
3475 focusNodes.clear();
3476 EXPECT_TRUE(focusNodes.empty());
3477 focusHub->focusDepend_ = FocusDependence::AUTO;
3478 focusHub->OnFocusScope(true);
3479 focusHub->focusDepend_ = FocusDependence::SELF;
3480 focusHub->OnFocusScope(true);
3481 EXPECT_TRUE(focusHub->currentFocus_);
3482 }
3483
3484 /**
3485 * @tc.name: FocusHubTestNg0097
3486 * @tc.desc: Test the function RequestFocusImmediatelyById.
3487 * @tc.type: FUNC
3488 */
3489 HWTEST_F(FocusHubTestNg, FocusHubTestNg0097, TestSize.Level1)
3490 {
3491 /**
3492 * @tc.steps1: create focusHub and construct allNodes.
3493 */
3494 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3495 frameNode->GetOrCreateFocusHub();
3496 auto focusHub = frameNode->GetFocusHub();
3497 ASSERT_NE(focusHub, nullptr);
3498 auto frameNode1 = FrameNode::CreateFrameNode("123", 123, AceType::MakeRefPtr<ButtonPattern>());
3499 frameNode1->GetOrCreateFocusHub();
3500 auto focusHub1 = frameNode1->GetFocusHub();
3501 frameNode1->propInspectorId_ = "123";
3502 auto frameNode2 = FrameNode::CreateFrameNode("frameNode", 102, AceType::MakeRefPtr<ButtonPattern>());
3503 frameNode2->GetOrCreateFocusHub();
3504 auto focusHub2 = frameNode2->GetFocusHub();
3505 frameNode->children_.push_back(frameNode2);
3506 frameNode->children_.push_back(frameNode1);
3507 focusHub->focusType_ = FocusType::SCOPE;
3508 focusHub1->parentFocusable_ = false;
3509 auto res = focusHub->RequestFocusImmediatelyById("123");
3510 ASSERT_FALSE(res);
3511 }
3512
3513 /**
3514 * @tc.name: FocusHubTestNg0098
3515 * @tc.desc: Test functions OnBlurScope.
3516 * @tc.type: FUNC
3517 */
3518 HWTEST_F(FocusHubTestNg, FocusHubTestNg0098, TestSize.Level1)
3519 {
3520 /**
3521 * @tc.steps1: initialize parameters.
3522 */
3523 auto frameNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3524 frameNode->GetOrCreateFocusHub();
3525 auto focusHub = frameNode->GetFocusHub();
3526 ASSERT_NE(focusHub, nullptr);
3527 auto frameNode1 = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 101, AceType::MakeRefPtr<ButtonPattern>());
3528 frameNode1->GetOrCreateFocusHub();
3529 auto focusHub1 = frameNode1->GetFocusHub();
3530 focusHub->focusType_ = FocusType::SCOPE;
3531 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
3532 frameNode->children_.push_back(frameNode1);
3533 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
3534 focusHub->OnBlurScope();
3535 ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
3536 }
3537
3538 /**
3539 * @tc.name: FocusHubTestNg0099
3540 * @tc.desc: Test the function HandleFocusOnMainView.
3541 * @tc.type: FUNC
3542 */
3543 HWTEST_F(FocusHubTestNg, FocusHubTestNg0099, TestSize.Level1)
3544 {
3545 /**
3546 * @tc.steps: step1. Create FocusHub with the WeakPtr eventHub_ owning frameNode.
3547 * @tc.expected: eventHub can be updated and frameName = V2::POPUP_ETS_TAG.
3548 */
3549 auto frameNode = FrameNode::CreateFrameNode("frameNode", -1, AceType::MakeRefPtr<ButtonPattern>());
3550 frameNode->GetOrCreateFocusHub();
3551 auto focusHub = frameNode->GetFocusHub();
3552 ASSERT_NE(focusHub, nullptr);
3553 auto frameNode1 = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3554 frameNode1->GetOrCreateFocusHub();
3555 auto focusHub1 = frameNode1->GetFocusHub();
3556 frameNode->children_.push_back(frameNode1);
3557 auto rootScope = focusHub->GetChildren().front();
3558 rootScope->focusType_ = FocusType::SCOPE;
3559 ASSERT_TRUE(focusHub->IsFocusableNode());
3560 ASSERT_TRUE(focusHub->currentFocus_ == false);
3561 EXPECT_TRUE(focusHub->GetFrameNode() != nullptr);
3562 EXPECT_TRUE(focusHub->GetGeometryNode() != nullptr);
3563 EXPECT_EQ(focusHub->GetFrameName(), "frameNode");
3564 EXPECT_EQ(focusHub->GetInspectorKey(), std::nullopt);
3565 EXPECT_TRUE(focusHub->GetMainViewRootScope());
3566 ASSERT_FALSE(focusHub->HandleFocusOnMainView());
3567 focusHub->GetMainViewRootScope()->currentFocus_ = true;
3568 ASSERT_FALSE(focusHub->HandleFocusOnMainView());
3569 focusHub->GetMainViewRootScope()->focusDepend_ = FocusDependence::SELF;
3570 ASSERT_TRUE(focusHub->HandleFocusOnMainView());
3571 }
3572
3573 /**
3574 * @tc.name: FocusHubTestNg0100
3575 * @tc.desc: Test the function IsImplicitFocusableScope.
3576 * @tc.type: FUNC
3577 */
3578 HWTEST_F(FocusHubTestNg, FocusHubTestNg0100, TestSize.Level1)
3579 {
3580 /**
3581 * @tc.steps1: initialize parameters.
3582 */
3583 auto eventHub = AceType::MakeRefPtr<EventHub>();
3584 eventHub->SetEnabled(true);
3585 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
3586
3587 /**
3588 * @tc.steps2: Set focusHub to scope type.
3589 * @tc.expected: The default value of focusable_ is false.
3590 */
3591 focusHub->focusType_ = FocusType::SCOPE;
3592 EXPECT_FALSE(focusHub->IsImplicitFocusableScope());
3593
3594 /**
3595 * @tc.steps3: Set focusable_ to true implicitly.
3596 * @tc.expected: The value of focusable_ is true.
3597 */
3598 focusHub->SetFocusable(true, false);
3599 EXPECT_TRUE(focusHub->IsImplicitFocusableScope());
3600 }
3601
3602 /**
3603 * @tc.name: LostFocusToViewRoot001
3604 * @tc.desc: Test the function LostFocusToViewRoot.
3605 * @tc.type: FUNC
3606 */
3607 HWTEST_F(FocusHubTestNg, LostFocusToViewRoot001, TestSize.Level1)
3608 {
3609 /**
3610 * @tc.steps1: create focusHub and construct allNodes.
3611 */
3612 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3613 frameNode->GetOrCreateFocusHub();
3614 auto focusHub = frameNode->GetFocusHub();
3615 /**
3616 * @tc.Calling LostFocusToViewRoot to increase coverage
3617 */
3618 focusHub->LostFocusToViewRoot();
3619 ASSERT_TRUE(focusHub->currentFocus_ == false);
3620 }
3621
3622 /*
3623 * @tc.name: SetEnabled01
3624 * @tc.desc: Test the function SetEnabled.
3625 * @tc.type: FUNC
3626 */
3627 HWTEST_F(FocusHubTestNg, SetEnabled001, TestSize.Level1)
3628 {
3629 /**
3630 * @tc.steps1: create focusHub and construct allNodes.
3631 */
3632 auto frameNode = FrameNode::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
3633 frameNode->GetOrCreateFocusHub();
3634 auto focusHub = frameNode->GetFocusHub();
3635 ASSERT_NE(focusHub, nullptr);
3636
3637 focusHub->currentFocus_ = true;
3638
3639 focusHub->SetEnabled(false);
3640 ASSERT_FALSE(focusHub->currentFocus_);
3641 }
3642 } // namespace OHOS::Ace::NG
3643