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