1 /* 2 * Copyright (c) 2024 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 "gtest/gtest.h" 16 #include "test/unittest/core/event/focus_hub_test_ng.h" 17 #include "test/mock/core/common/mock_container.h" 18 #include "test/mock/core/pipeline/mock_pipeline_context.h" 19 #include "test/mock/core/render/mock_render_context.h" 20 21 #include "core/components_ng/animation/geometry_transition.h" 22 #include "core/components_ng/base/ui_node.h" 23 #include "core/components_ng/manager/focus/focus_view.h" 24 #include "core/components_ng/pattern/bubble/bubble_pattern.h" 25 #include "core/components_ng/pattern/button/button_pattern.h" 26 #include "core/components_ng/pattern/dialog/dialog_pattern.h" 27 #include "core/components_ng/pattern/linear_layout/linear_layout_pattern.h" 28 #include "core/components_ng/pattern/menu/menu_pattern.h" 29 #include "core/components_ng/pattern/navigation/nav_bar_pattern.h" 30 #include "core/components_ng/pattern/navigation/navigation_pattern.h" 31 #include "core/components_ng/pattern/navrouter/navdestination_pattern.h" 32 #include "core/components_ng/pattern/overlay/modal_presentation_pattern.h" 33 #include "core/components_ng/pattern/overlay/sheet_presentation_pattern.h" 34 #include "core/components_ng/pattern/root/root_pattern.h" 35 #include "core/components_ng/pattern/stage/page_pattern.h" 36 #include "core/components_v2/inspector/inspector_constants.h" 37 #include "test/unittest/core/event/frame_node_on_tree.h" 38 39 using namespace testing; 40 using namespace testing::ext; 41 42 namespace OHOS::Ace::NG { 43 /** 44 * @tc.name: FocusHubTestNg0109 45 * @tc.desc: Test the function IsNestingFocusGroup. 46 * @tc.type: FUNC 47 */ 48 HWTEST_F(FocusHubTestNg, FocusHubTestNg0109, TestSize.Level1) 49 { 50 /** 51 * @tc.steps1: initialize parameters. 52 */ 53 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 54 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 55 56 /** 57 * @tc.steps2: call the function IsNestingFocusGroup with isGroup_ = false 58 * @tc.expected: The return value of IsNestingFocusGroup is false. 59 */ 60 focusHub->isGroup_ = false; 61 ASSERT_FALSE(focusHub->IsNestingFocusGroup()); 62 } 63 64 /** 65 * @tc.name: FocusHubTestNg0110 66 * @tc.desc: Test the function IsNestingFocusGroup. 67 * @tc.type: FUNC 68 */ 69 HWTEST_F(FocusHubTestNg, FocusHubTestNg0110, TestSize.Level1) 70 { 71 /** 72 * @tc.steps1: initialize parameters. 73 */ 74 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 75 auto nodeParent = AceType::MakeRefPtr<FrameNode>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 76 frameNode->GetOrCreateFocusHub(); 77 nodeParent->GetOrCreateFocusHub(); 78 frameNode->SetParent(nodeParent); 79 80 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 81 eventHub->AttachHost(frameNode); 82 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 83 84 /** 85 * @tc.steps2: call the function IsNestingFocusGroup with isGroup_ = false 86 * @tc.expected: The return value of IsNestingFocusGroup is false. 87 */ 88 focusHub->isGroup_ = false; 89 ASSERT_FALSE(focusHub->IsNestingFocusGroup()); 90 91 /** 92 * @tc.steps3: call the function IsNestingFocusGroup with isGroup_ = true and nodeParent.focusHub.isGroup_ false 93 * @tc.expected: The return value of IsNestingFocusGroup is true. 94 */ 95 focusHub->isGroup_ = true; 96 ASSERT_FALSE(focusHub->IsNestingFocusGroup()); 97 98 /** 99 * @tc.steps4: call the function IsNestingFocusGroup with isGroup_ = true and nodeParent.focusHub.isGroup_ true 100 * @tc.expected: The return value of IsNestingFocusGroup is true. 101 */ 102 nodeParent->GetFocusHub()->isGroup_ = true; 103 ASSERT_TRUE(focusHub->IsNestingFocusGroup()); 104 } 105 106 /** 107 * @tc.name: FocusHubTestNg0111 108 * @tc.desc: Test the function IsInFocusGroup. 109 * @tc.type: FUNC 110 */ 111 HWTEST_F(FocusHubTestNg, FocusHubTestNg0111, TestSize.Level1) 112 { 113 /** 114 * @tc.steps1: initialize parameters. 115 */ 116 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 117 auto nodeParent = AceType::MakeRefPtr<FrameNode>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 118 frameNode->GetOrCreateFocusHub(); 119 nodeParent->GetOrCreateFocusHub(); 120 frameNode->SetParent(nodeParent); 121 122 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 123 eventHub->AttachHost(frameNode); 124 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 125 /** 126 * @tc.steps2: call the function IsInFocusGroup with isGroup_ = false 127 * @tc.expected: The return value of IsInFocusGroup is false. 128 */ 129 focusHub->isGroup_ = false; 130 ASSERT_FALSE(focusHub->IsInFocusGroup()); 131 132 /** 133 * @tc.steps3: call the function IsInFocusGroup with isGroup_ = false and nodeParent.focusHub.isGroup_ true 134 * @tc.expected: The return value of IsInFocusGroup is false. 135 */ 136 focusHub->isGroup_ = false; 137 nodeParent->GetFocusHub()->isGroup_ = true; 138 ASSERT_TRUE(focusHub->IsInFocusGroup()); 139 } 140 141 /** 142 * @tc.name: FocusHubTestNg0112 143 * @tc.desc: Test the function GetChildPriorfocusNode. 144 * @tc.type: FUNC 145 */ 146 HWTEST_F(FocusHubTestNg, FocusHubTestNg0112, TestSize.Level1) 147 { 148 /** 149 * @tc.steps1: initialize parameters. 150 */ 151 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 152 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 153 auto focusHubNull = AceType::MakeRefPtr<FocusHub>(WeakPtr<EventHub>(nullptr)); 154 ASSERT_EQ(focusHubNull->GetChildPriorfocusNode(focusHub->focusScopeId_).Upgrade(), nullptr); 155 156 /** 157 * @tc.steps2: call the function GetChildPriorfocusNode with focusScopeId_ empty 158 * @tc.expected: The return value of GetChildPriorfocusNode is nullptr. 159 */ 160 focusHub->isGroup_ = false; 161 auto childFocusHub = focusHub->GetChildPriorfocusNode(focusHub->focusScopeId_); 162 ASSERT_EQ(childFocusHub.Upgrade(), nullptr); 163 164 /** 165 * @tc.steps2: call the function GetChildPriorfocusNode with focusScopeId_ = "1" 166 * @tc.expected: The return value of GetChildPriorfocusNode is nullptr. 167 */ 168 focusHub->isGroup_ = false; 169 focusHub->focusScopeId_ = "1"; 170 childFocusHub = focusHub->GetChildPriorfocusNode(focusHub->focusScopeId_); 171 ASSERT_EQ(childFocusHub.Upgrade(), nullptr); 172 } 173 174 /** 175 * @tc.name: FocusHubTestNg0113 176 * @tc.desc: Test the function SetFocusScopePriority. 177 * @tc.type: FUNC 178 */ 179 HWTEST_F(FocusHubTestNg, FocusHubTestNg0113, TestSize.Level1) 180 { 181 /** 182 * @tc.steps1: initialize parameters. 183 */ 184 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 185 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 186 focusHub->focusPriority_ = FocusPriority::PRIOR; 187 auto focusScopeId = "scope1"; 188 auto focusScopeId2 = "scope2"; 189 190 /** 191 * @tc.steps2: call the function SetFocusScopePriority with isFocusScope_ true and focusScopeId not empty 192 * @tc.expected: The focusHub->focusScopeId_ NE focusScopeId. 193 */ 194 focusHub->isFocusScope_ = true; 195 focusHub->SetFocusScopePriority(focusScopeId, 0); 196 ASSERT_NE(focusHub->focusScopeId_, focusScopeId); 197 198 /** 199 * @tc.steps3: call the function SetFocusScopePriority with isFocusScope_ false 200 * @tc.expected: The focusHub->focusScopeId_ NE focusScopeId. 201 */ 202 focusHub->isFocusScope_ = false; 203 focusHub->focusPriority_ = FocusPriority::PRIOR; 204 focusHub->SetFocusScopePriority(focusScopeId, 0); 205 ASSERT_EQ(focusHub->focusScopeId_, focusScopeId); 206 focusHub->focusPriority_ = FocusPriority::AUTO; 207 focusHub->SetFocusScopePriority(focusScopeId, 0); 208 ASSERT_EQ(focusHub->focusScopeId_, focusScopeId); 209 210 /** 211 * @tc.steps4: call the function SetFocusScopePriority with isFocusScope_ false and focusScopeId_ NE focusScopeId 212 * @tc.expected: The focusHub->focusScopeId_ NE focusScopeId2. 213 */ 214 focusHub->focusPriority_ = FocusPriority::PRIOR; 215 focusHub->SetFocusScopePriority(focusScopeId2, 0); 216 ASSERT_EQ(focusHub->focusScopeId_, focusScopeId2); 217 // focusPriority_ NE FocusPriority::AUTO 218 focusHub->focusPriority_ = FocusPriority::AUTO; 219 focusHub->SetFocusScopePriority(focusScopeId2, 0); 220 ASSERT_EQ(focusHub->focusScopeId_, focusScopeId2); 221 222 /** 223 * @tc.steps5: call the function SetFocusScopePriority with isFocusScope_ false and focusScopeId empty 224 * @tc.expected: The focusHub->focusScopeId_ EQ focusScopeId. 225 */ 226 focusHub->isFocusScope_ = false; 227 focusHub->focusScopeId_ = focusScopeId; 228 focusHub->SetFocusScopePriority("", 2000); 229 ASSERT_EQ(focusHub->focusScopeId_, ""); 230 // focusScopeId_ is empty 231 focusHub->focusPriority_ = FocusPriority::PRIOR; 232 focusHub->SetFocusScopePriority("", 2000); 233 ASSERT_EQ(focusHub->focusPriority_, FocusPriority::AUTO); 234 } 235 236 /** 237 * @tc.name: FocusHubTestNg0114 238 * @tc.desc: Test the function RemoveFocusScopeIdAndPriority. 239 * @tc.type: FUNC 240 */ 241 HWTEST_F(FocusHubTestNg, FocusHubTestNg0114, TestSize.Level1) 242 { 243 /** 244 * @tc.steps1: initialize parameters. 245 */ 246 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 247 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 248 ASSERT_EQ(focusHub->GetFocusManager(), nullptr); 249 250 /** 251 * @tc.steps2: call the function SetFocusScopePriority with isFocusScope_ true 252 * @tc.expected: The focusHub->focusScopeId_ empty. 253 */ 254 focusHub->isFocusScope_ = true; 255 focusHub->focusScopeId_ = ""; 256 focusHub->RemoveFocusScopeIdAndPriority(); 257 focusHub->focusScopeId_ = "scop1"; 258 focusHub->RemoveFocusScopeIdAndPriority(); 259 ASSERT_FALSE(focusHub->focusScopeId_.empty()); 260 261 /** 262 * @tc.steps3: call the function SetFocusScopePriority with isFocusScope_ false and focusPriority_ PRIOR 263 * @tc.expected: The focusHub->focusScopeId_ NE focusScopeId. 264 */ 265 focusHub->isFocusScope_ = false; 266 focusHub->focusPriority_ = FocusPriority::PRIOR; 267 focusHub->focusScopeId_ = ""; 268 focusHub->RemoveFocusScopeIdAndPriority(); 269 ASSERT_EQ(focusHub->focusScopeId_, ""); 270 focusHub->focusScopeId_ = "scop1"; 271 focusHub->RemoveFocusScopeIdAndPriority(); 272 ASSERT_EQ(focusHub->focusScopeId_, "scop1"); 273 274 /** 275 * @tc.steps3: call the function SetFocusScopePriority with isFocusScope_ false and focusPriority_ AUTO 276 * @tc.expected: The focusHub->focusScopeId_ NE focusScopeId. 277 */ 278 focusHub->focusScopeId_ = ""; 279 focusHub->focusPriority_ = FocusPriority::AUTO; 280 focusHub->RemoveFocusScopeIdAndPriority(); 281 ASSERT_EQ(focusHub->focusScopeId_, ""); 282 focusHub->focusScopeId_ = "scop1"; 283 focusHub->RemoveFocusScopeIdAndPriority(); 284 ASSERT_EQ(focusHub->focusScopeId_, "scop1"); 285 } 286 287 /** 288 * @tc.name: FocusHubTestNg0115 289 * @tc.desc: Test the function SetFocusScopeId. 290 * @tc.type: FUNC 291 */ 292 HWTEST_F(FocusHubTestNg, FocusHubTestNg0115, TestSize.Level1) 293 { 294 /** 295 * @tc.steps1: initialize parameters. 296 */ 297 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 298 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 299 ASSERT_NE(focusHub, nullptr); 300 focusHub->focusScopeId_ = "scop1"; 301 302 /** 303 * @tc.steps2: call the function SetFocusScopeId with focusType_ FocusType::DISABLE 304 * @tc.expected: The focusHub->focusScopeId_ not change 305 */ 306 focusHub->focusType_ = FocusType::DISABLE; 307 focusHub->SetFocusScopeId("scop2", true); 308 ASSERT_EQ(focusHub->focusScopeId_, "scop1"); 309 310 /** 311 * @tc.steps3: call the function SetFocusScopeId with focusType_ FocusType::SCOPE and focusScopeId empty 312 * @tc.expected: The focusHub->focusScopeId_ not change 313 */ 314 focusHub->focusType_ = FocusType::SCOPE; 315 // focusScopeId_ empty 316 focusHub->focusScopeId_ = ""; 317 focusHub->SetFocusScopeId("", true); 318 ASSERT_FALSE(focusHub->isFocusScope_); 319 focusHub->focusScopeId_ = "scop1"; 320 focusHub->SetFocusScopeId("", true); 321 ASSERT_EQ(focusHub->focusScopeId_, ""); 322 ASSERT_FALSE(focusHub->isFocusScope_); 323 ASSERT_FALSE(focusHub->isGroup_); 324 } 325 326 /** 327 * @tc.name: FocusHubTestNg0119 328 * @tc.desc: Test the function IsFocusAbleChildOf. 329 * @tc.type: FUNC 330 */ 331 HWTEST_F(FocusHubTestNg, FocusHubTestNg0119, TestSize.Level1) 332 { 333 /** 334 * @tc.steps1: initialize parameters. 335 */ 336 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 337 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 338 ASSERT_NE(focusHub, nullptr); 339 340 ASSERT_FALSE(focusHub->IsFocusAbleChildOf(nullptr)); 341 } 342 343 344 /** 345 * @tc.name: FocusHubTestNg0120 346 * @tc.desc: Test the function SetLastWeakFocusNodeToPreviousNode. 347 * @tc.type: FUNC 348 */ 349 HWTEST_F(FocusHubTestNg, FocusHubTestNg0120, TestSize.Level1) 350 { 351 /** 352 * @tc.steps1: initialize parameters. 353 */ 354 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 355 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 356 ASSERT_NE(focusHub, nullptr); 357 358 focusHub->focusType_ = FocusType::SCOPE; 359 ASSERT_FALSE(focusHub->SetLastWeakFocusNodeToPreviousNode()); 360 focusHub->focusType_ = FocusType::DISABLE; 361 focusHub->isFocusScope_ = true; 362 ASSERT_FALSE(focusHub->SetLastWeakFocusNodeToPreviousNode()); 363 focusHub->focusType_ = FocusType::DISABLE; 364 focusHub->isFocusScope_ = true; 365 ASSERT_FALSE(focusHub->SetLastWeakFocusNodeToPreviousNode()); 366 focusHub->focusType_ = FocusType::SCOPE; 367 focusHub->focusScopeId_ = "scop1"; 368 focusHub->isFocusScope_ = false; 369 ASSERT_FALSE(focusHub->SetLastWeakFocusNodeToPreviousNode()); 370 focusHub->isFocusScope_ = true; 371 ASSERT_FALSE(focusHub->SetLastWeakFocusNodeToPreviousNode()); 372 } 373 374 /** 375 * @tc.name: IsCurrentFocusWholePath001 376 * @tc.desc: Test the function IsCurrentFocusWholePath. 377 * @tc.type: FUNC 378 */ 379 HWTEST_F(FocusHubTestNg, IsCurrentFocusWholePath001, TestSize.Level1) 380 { 381 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 382 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 383 ASSERT_NE(focusHub, nullptr); 384 385 focusHub->currentFocus_ = true; 386 focusHub->focusType_ = FocusType::SCOPE; 387 focusHub->focusDepend_ = FocusDependence::SELF; 388 ASSERT_TRUE(focusHub->IsCurrentFocusWholePath()); 389 focusHub->focusDepend_ = FocusDependence::AUTO; 390 ASSERT_TRUE(focusHub->IsCurrentFocusWholePath()); 391 focusHub->focusDepend_ = FocusDependence::CHILD; 392 ASSERT_FALSE(focusHub->IsCurrentFocusWholePath()); 393 } 394 395 /** 396 * @tc.name: OnKeyPreIme001 397 * @tc.desc: Test the function OnKeyPreIme. 398 * @tc.type: FUNC 399 */ 400 HWTEST_F(FocusHubTestNg, OnKeyPreIme001, TestSize.Level1) 401 { 402 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 403 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 404 ASSERT_NE(focusHub, nullptr); 405 KeyEvent keyEvent; 406 keyEvent.action = KeyAction::DOWN; 407 keyEvent.code = KeyCode::KEY_TAB; 408 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 409 auto info = KeyEventInfo(keyEvent); 410 ASSERT_FALSE(focusHub->OnKeyPreIme(info, keyEvent)); 411 } 412 413 /** 414 * @tc.name: GetProjectAreaOnRect001 415 * @tc.desc: Test the function GetProjectAreaOnRect. 416 * @tc.type: FUNC 417 */ 418 HWTEST_F(FocusHubTestNg, GetProjectAreaOnRect001, TestSize.Level1) 419 { 420 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 421 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 422 ASSERT_NE(focusHub, nullptr); 423 FocusStep step = FocusStep::UP; 424 RectF rect = RectF(1, 1, 0, 10); 425 RectF projectRect = RectF(1, 1, 0, 0); 426 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 427 428 rect = RectF(1, 1, 0, 0); 429 projectRect = RectF(10, 1, 0, 0); 430 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 431 432 step = FocusStep::DOWN; 433 rect = RectF(1, 1, 0, 10); 434 projectRect = RectF(1, 1, 0, 0); 435 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 436 437 rect = RectF(1, 1, 0, 0); 438 projectRect = RectF(10, 1, 0, 0); 439 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 440 441 step = FocusStep::LEFT; 442 rect = RectF(1, 1, 0, 10); 443 projectRect = RectF(1, 1, 0, 0); 444 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 445 446 rect = RectF(1, 1, 0, 0); 447 projectRect = RectF(10, 1, 0, 0); 448 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 449 450 step = FocusStep::RIGHT; 451 rect = RectF(1, 1, 0, 10); 452 projectRect = RectF(1, 1, 0, 0); 453 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 454 455 rect = RectF(1, 1, 0, 0); 456 projectRect = RectF(10, 1, 0, 0); 457 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 458 459 rect = RectF(1, 1, 10, 0); 460 projectRect = RectF(1, 1, 0, 0); 461 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 462 463 rect = RectF(1, 1, 0, 0); 464 projectRect = RectF(1, 1, 10, 0); 465 focusHub->GetProjectAreaOnRect(rect, projectRect, step); 466 ASSERT_EQ(step, FocusStep::RIGHT); 467 } 468 469 /** 470 * @tc.name: GetFirstChildFocusView001 471 * @tc.desc: Test the function GetFirstChildFocusView. 472 * @tc.type: FUNC 473 */ 474 HWTEST_F(FocusHubTestNg, GetFirstChildFocusView001, TestSize.Level1) 475 { 476 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 477 auto nodeParent = 478 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 479 frameNode->GetOrCreateFocusHub(); 480 nodeParent->GetOrCreateFocusHub(); 481 frameNode->SetParent(nodeParent); 482 483 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 484 eventHub->AttachHost(frameNode); 485 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 486 ASSERT_NE(focusHub, nullptr); 487 RefPtr<FocusView> result = focusHub->GetFirstChildFocusView(); 488 ASSERT_EQ(result, nullptr); 489 } 490 491 /** 492 * @tc.name: DumpFocusTree001 493 * @tc.desc: Test the function DumpFocusTree. 494 * @tc.type: FUNC 495 */ 496 HWTEST_F(FocusHubTestNg, DumpFocusTree001, TestSize.Level1) 497 { 498 /** 499 * @tc.steps: step1. Create frameNode. 500 */ 501 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 502 503 /** 504 * @tc.steps: step2. Create FocusHub. 505 */ 506 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 507 eventHub->AttachHost(frameNode); 508 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 509 510 /** 511 * @tc.steps: step3. test function DumpFocusNodeTree. 512 * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty. 513 */ 514 int32_t depth = 1; 515 focusHub->focusScopeId_ = "TEST"; 516 focusHub->isFocusScope_ = true; 517 /** 518 * @tc.steps: step4. test function DumpFocusScopeTree. 519 * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty. 520 */ 521 DumpLog::GetInstance().description_.push_back("test"); 522 focusHub->focusType_ = FocusType::SCOPE; 523 focusHub->focusPriority_ = FocusPriority::PRIOR; 524 focusHub->currentFocus_ = true; 525 focusHub->DumpFocusTree(depth); 526 EXPECT_TRUE(DumpLog::GetInstance().description_.empty()); 527 528 DumpLog::GetInstance().description_.push_back("PREVIOUS"); 529 focusHub->focusPriority_ = FocusPriority::PREVIOUS; 530 focusHub->currentFocus_ = true; 531 focusHub->DumpFocusTree(depth); 532 EXPECT_TRUE(DumpLog::GetInstance().description_.empty()); 533 534 focusHub->focusType_ = FocusType::NODE; 535 focusHub->focusPriority_ = FocusPriority::PRIOR; 536 focusHub->currentFocus_ = true; 537 focusHub->DumpFocusTree(depth); 538 EXPECT_TRUE(DumpLog::GetInstance().description_.empty()); 539 540 DumpLog::GetInstance().description_.push_back("PREVIOUS"); 541 focusHub->focusPriority_ = FocusPriority::PREVIOUS; 542 focusHub->currentFocus_ = true; 543 focusHub->DumpFocusTree(depth); 544 EXPECT_TRUE(DumpLog::GetInstance().description_.empty()); 545 } 546 547 /** 548 * @tc.name: CheckFocusStateStyle001 549 * @tc.desc: Test the function CheckFocusStateStyle. 550 * @tc.type: FUNC 551 */ 552 HWTEST_F(FocusHubTestNg, CheckFocusStateStyle001, TestSize.Level1) 553 { 554 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 555 auto nodeParent = 556 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 557 frameNode->GetOrCreateFocusHub(); 558 nodeParent->GetOrCreateFocusHub(); 559 frameNode->SetParent(nodeParent); 560 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 561 eventHub->AttachHost(frameNode); 562 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 563 ASSERT_NE(focusHub, nullptr); 564 focusHub->CheckFocusStateStyle(true); 565 focusHub->focusType_ = FocusType::NODE; 566 EXPECT_TRUE(focusHub->IsFocusableByTab()); 567 } 568 569 /** 570 * @tc.name: IsSyncRequestFocusableScope001 571 * @tc.desc: Test the function IsSyncRequestFocusableScope. 572 * @tc.type: FUNC 573 */ 574 HWTEST_F(FocusHubTestNg, IsSyncRequestFocusableScope001, TestSize.Level1) 575 { 576 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 577 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 578 eventHub->AttachHost(frameNode); 579 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 580 ASSERT_NE(focusHub, nullptr); 581 focusHub->focusDepend_ = FocusDependence::SELF; 582 focusHub->IsSyncRequestFocusableScope(); 583 focusHub->focusable_ = true; 584 focusHub->parentFocusable_ = true; 585 focusHub->IsSyncRequestFocusableScope(); 586 focusHub->parentFocusable_ = false; 587 EXPECT_FALSE(focusHub->IsSyncRequestFocusableScope()); 588 } 589 590 /** 591 * @tc.name: LostFocusToViewRoot002 592 * @tc.desc: Test the function LostFocusToViewRoot. 593 * @tc.type: FUNC 594 */ 595 HWTEST_F(FocusHubTestNg, LostFocusToViewRoot002, TestSize.Level1) 596 { 597 /** 598 * @tc.steps: step1. construct all kinds of FocusView. 599 */ 600 auto rootNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, -1, AceType::MakeRefPtr<RootPattern>()); 601 auto rootFocusHub = rootNode->GetOrCreateFocusHub(); 602 603 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 604 eventHub->AttachHost(rootNode); 605 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 606 ASSERT_NE(focusHub, nullptr); 607 608 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()); 609 auto pageNode = FrameNodeOnTree::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern); 610 auto pageFocusHub = pageNode->GetOrCreateFocusHub(); 611 rootNode->AddChild(pageNode); 612 613 auto bubblePattern = AceType::MakeRefPtr<BubblePattern>(); 614 auto bubbleNode = FrameNodeOnTree::CreateFrameNode(V2::POPUP_ETS_TAG, -1, bubblePattern); 615 auto bubbleFocusHub = bubbleNode->GetOrCreateFocusHub(); 616 rootNode->AddChild(bubbleNode); 617 618 auto dialogPattern = AceType::MakeRefPtr<DialogPattern>(nullptr, nullptr); 619 auto dialogNode = FrameNodeOnTree::CreateFrameNode(V2::DIALOG_ETS_TAG, -1, dialogPattern); 620 auto dialogFocusHub = dialogNode->GetOrCreateFocusHub(); 621 rootNode->AddChild(dialogNode); 622 623 auto menuPattern = AceType::MakeRefPtr<MenuPattern>(-1, "Menu", MenuType::MENU); 624 auto menuNode = FrameNodeOnTree::CreateFrameNode(V2::MENU_ETS_TAG, -1, menuPattern); 625 auto menuFocusHub = menuNode->GetOrCreateFocusHub(); 626 rootNode->AddChild(menuNode); 627 628 auto modalPattern = AceType::MakeRefPtr<ModalPresentationPattern>(-1, ModalTransition::DEFAULT, nullptr); 629 auto modalNode = FrameNodeOnTree::CreateFrameNode(V2::MODAL_PAGE_TAG, -1, modalPattern); 630 auto modalFocusHub = modalNode->GetOrCreateFocusHub(); 631 rootNode->AddChild(modalNode); 632 633 auto sheetPattern = AceType::MakeRefPtr<SheetPresentationPattern>(-1, "", nullptr); 634 auto sheetNode = FrameNodeOnTree::CreateFrameNode(V2::SHEET_PAGE_TAG, -1, sheetPattern); 635 auto sheetFocusHub = sheetNode->GetOrCreateFocusHub(); 636 rootNode->AddChild(sheetNode); 637 638 auto navigationPattern = AceType::MakeRefPtr<NavigationPattern>(); 639 auto navigationNode = FrameNodeOnTree::CreateFrameNode(V2::NAVIGATION_VIEW_ETS_TAG, -1, navigationPattern); 640 auto navigationFocusHub = navigationNode->GetOrCreateFocusHub(); 641 642 auto navbarPattern = AceType::MakeRefPtr<NavBarPattern>(); 643 auto navbarNode = FrameNodeOnTree::CreateFrameNode(V2::NAVBAR_ETS_TAG, -1, navbarPattern); 644 auto navbarFocusHub = navbarNode->GetOrCreateFocusHub(); 645 646 auto navdestinationPattern = AceType::MakeRefPtr<NavDestinationPattern>(nullptr); 647 auto navdestinationNode = FrameNodeOnTree::CreateFrameNode(V2::POPUP_ETS_TAG, -1, navdestinationPattern); 648 auto navdestinationFocusHub = navdestinationNode->GetOrCreateFocusHub(); 649 650 pageNode->AddChild(navigationNode); 651 navigationNode->AddChild(navbarNode); 652 navigationNode->AddChild(navdestinationNode); 653 pagePattern->FocusViewShow(); 654 focusHub->LostFocusToViewRoot(); 655 EXPECT_NE(FocusView::GetCurrentFocusView(), nullptr); 656 } 657 658 /** 659 * @tc.name: ToJsonValue001 660 * @tc.desc: Test the function ToJsonValue. 661 * @tc.type: FUNC 662 */ 663 HWTEST_F(FocusHubTestNg, ToJsonValue001, TestSize.Level1) 664 { 665 /** 666 * @tc.steps: step1. construct all kinds of FocusView. 667 */ 668 auto rootNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, -1, AceType::MakeRefPtr<RootPattern>()); 669 auto rootFocusHub = rootNode->GetOrCreateFocusHub(); 670 auto json = JsonUtil::Create(true); 671 InspectorFilter filter; 672 673 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 674 eventHub->AttachHost(rootNode); 675 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 676 ASSERT_NE(focusHub, nullptr); 677 focusHub->ToJsonValue(focusHub, json, filter); 678 } 679 680 /** 681 * @tc.name: RemoveChild001 682 * @tc.desc: Test the function RemoveChild. 683 * @tc.type: FUNC 684 */ 685 HWTEST_F(FocusHubTestNg, RemoveChild001, TestSize.Level1) 686 { 687 auto rootNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, -1, AceType::MakeRefPtr<RootPattern>()); 688 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 689 eventHub->AttachHost(rootNode); 690 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 691 ASSERT_NE(focusHub, nullptr); 692 focusHub->RemoveChild(focusHub, BlurReason::FOCUS_SWITCH); 693 } 694 695 /** 696 * @tc.name: OnKeyEventNode001 697 * @tc.desc: Test the function OnKeyEventNode. 698 * @tc.type: FUNC 699 */ 700 HWTEST_F(FocusHubTestNg, OnKeyEventNode001, TestSize.Level1) 701 { 702 auto rootNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, -1, AceType::MakeRefPtr<RootPattern>()); 703 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 704 eventHub->AttachHost(rootNode); 705 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 706 ASSERT_NE(focusHub, nullptr); 707 auto context = PipelineContext::GetCurrentContext(); 708 ASSERT_NE(context, nullptr); 709 KeyEvent keyEvent; 710 keyEvent.action = KeyAction::DOWN; 711 keyEvent.code = KeyCode::KEY_SPACE; 712 keyEvent.isRedispatch = false; 713 keyEvent.isPreIme = true; 714 715 /** 716 * @tc.expected: The return value of OnKeyEvent is false. 717 * @tc.steps2: call the function OnKeyEvent with FocusType::NODE. 718 */ 719 focusHub->SetFocusType(FocusType::NODE); 720 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 721 722 /** 723 * @tc.steps3: call the function OnKeyEvent with FocusType::SCOPE. 724 * @tc.expected: The return value of OnKeyEvent is false. 725 */ 726 focusHub->SetFocusType(FocusType::SCOPE); 727 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 728 729 /** 730 * @tc.steps4: call the function OnKeyEvent with FocusType::DISABLE. 731 * @tc.expected: The return value of OnKeyEvent is false. 732 */ 733 focusHub->SetFocusType(FocusType::DISABLE); 734 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 735 } 736 737 /** 738 * @tc.name: HasBackwardFocusMovementInChildren002 739 * @tc.desc: Test the function HasBackwardFocusMovementInChildren. 740 * @tc.type: FUNC 741 */ 742 HWTEST_F(FocusHubTestNg, HasBackwardFocusMovementInChildren002, TestSize.Level1) 743 { 744 /** 745 * @tc.steps: step1. Create frameNode and add button as its children which focus type is enable. 746 */ 747 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 748 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 749 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 750 child->GetOrCreateFocusHub(); 751 child2->GetOrCreateFocusHub(); 752 frameNode->AddChild(child); 753 frameNode->AddChild(child2); 754 /** 755 * @tc.steps: step2. Create FocusHub. 756 */ 757 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 758 eventHub->AttachHost(frameNode); 759 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 760 EXPECT_FALSE(focusHub->HasForwardFocusMovementInChildren()); 761 EXPECT_FALSE(focusHub->HasBackwardFocusMovementInChildren()); 762 focusHub->ClearFocusMovementFlagsInChildren(); 763 } 764 765 /** 766 * @tc.name: FocusHubTestNgtest001 767 * @tc.desc: Test the function DumpFocusNodeTree. 768 * @tc.type: FUNC 769 */ 770 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest001, TestSize.Level1) 771 { 772 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 773 ASSERT_NE(frameNode, nullptr); 774 auto nodeParent = 775 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 776 ASSERT_NE(nodeParent, nullptr); 777 frameNode->GetOrCreateFocusHub(); 778 nodeParent->GetOrCreateFocusHub(); 779 frameNode->SetParent(nodeParent); 780 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 781 ASSERT_NE(eventHub, nullptr); 782 eventHub->AttachHost(frameNode); 783 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 784 ASSERT_NE(focusHub, nullptr); 785 bool result = true; 786 DumpLog::GetInstance().ostream_.reset(); 787 focusHub->DumpFocusNodeTree(15); 788 EXPECT_TRUE(result); 789 } 790 791 /** 792 * @tc.name: FocusHubTestNgtest002 793 * @tc.desc: Test the function DumpFocusNodeTree. 794 * @tc.type: FUNC 795 */ 796 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest002, TestSize.Level1) 797 { 798 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 799 ASSERT_NE(frameNode, nullptr); 800 auto nodeParent = 801 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 802 ASSERT_NE(nodeParent, nullptr); 803 frameNode->GetOrCreateFocusHub(); 804 nodeParent->GetOrCreateFocusHub(); 805 frameNode->SetParent(nodeParent); 806 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 807 ASSERT_NE(eventHub, nullptr); 808 eventHub->AttachHost(frameNode); 809 frameNode->layoutProperty_->UpdateVisibility(VisibleType::VISIBLE, true); 810 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 811 ASSERT_NE(focusHub, nullptr); 812 auto ss = std::make_unique<std::ostringstream>(); 813 focusHub->focusType_ = FocusType::NODE; 814 focusHub->focusable_ = true; 815 focusHub->parentFocusable_ = true; 816 eventHub->enabled_ = true; 817 DumpLog::GetInstance().SetDumpFile(std::move(ss)); 818 bool result = true; 819 focusHub->DumpFocusNodeTree(1); 820 focusHub->focusScopeId_ = "abc"; 821 focusHub->focusPriority_ = FocusPriority::PRIOR; 822 focusHub->DumpFocusNodeTree(1); 823 focusHub->focusPriority_ = FocusPriority::PREVIOUS; 824 focusHub->DumpFocusNodeTree(1); 825 EXPECT_TRUE(result); 826 } 827 828 /** 829 * @tc.name: FocusHubTestNgtest003 830 * @tc.desc: Test the function DumpFocusScopeTree. 831 * @tc.type: FUNC 832 */ 833 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest003, TestSize.Level1) 834 { 835 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 836 ASSERT_NE(frameNode, nullptr); 837 auto nodeParent = 838 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 839 ASSERT_NE(nodeParent, nullptr); 840 frameNode->GetOrCreateFocusHub(); 841 nodeParent->GetOrCreateFocusHub(); 842 frameNode->SetParent(nodeParent); 843 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 844 ASSERT_NE(eventHub, nullptr); 845 eventHub->AttachHost(frameNode); 846 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 847 ASSERT_NE(focusHub, nullptr); 848 bool result = true; 849 DumpLog::GetInstance().ostream_.reset(); 850 focusHub->DumpFocusScopeTree(15); 851 EXPECT_TRUE(result); 852 } 853 854 /** 855 * @tc.name: FocusHubTestNgtest004 856 * @tc.desc: Test the function DumpFocusScopeTree. 857 * @tc.type: FUNC 858 */ 859 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest004, TestSize.Level1) 860 { 861 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 862 ASSERT_NE(frameNode, nullptr); 863 auto nodeParent = 864 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 865 ASSERT_NE(nodeParent, nullptr); 866 frameNode->GetOrCreateFocusHub(); 867 nodeParent->GetOrCreateFocusHub(); 868 frameNode->SetParent(nodeParent); 869 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 870 ASSERT_NE(eventHub, nullptr); 871 eventHub->AttachHost(frameNode); 872 frameNode->layoutProperty_->UpdateVisibility(VisibleType::VISIBLE, true); 873 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 874 ASSERT_NE(focusHub, nullptr); 875 auto ss = std::make_unique<std::ostringstream>(); 876 focusHub->focusType_ = FocusType::NODE; 877 focusHub->focusable_ = true; 878 focusHub->parentFocusable_ = true; 879 eventHub->enabled_ = true; 880 DumpLog::GetInstance().SetDumpFile(std::move(ss)); 881 bool result = true; 882 focusHub->DumpFocusScopeTree(1); 883 focusHub->isFocusScope_ = true; 884 focusHub->DumpFocusScopeTree(1); 885 focusHub->focusScopeId_ = "abc"; 886 focusHub->focusPriority_ = FocusPriority::PRIOR; 887 focusHub->DumpFocusScopeTree(1); 888 focusHub->focusPriority_ = FocusPriority::PREVIOUS; 889 focusHub->DumpFocusScopeTree(1); 890 EXPECT_TRUE(result); 891 } 892 893 /** 894 * @tc.name: FocusHubTestNgtest005 895 * @tc.desc: Test the function RequestFocusImmediately. 896 * @tc.type: FUNC 897 */ 898 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest005, TestSize.Level1) 899 { 900 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 901 ASSERT_NE(frameNode, nullptr); 902 auto nodeParent = 903 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 904 ASSERT_NE(nodeParent, nullptr); 905 frameNode->GetOrCreateFocusHub(); 906 nodeParent->GetOrCreateFocusHub(); 907 frameNode->SetParent(nodeParent); 908 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 909 ASSERT_NE(eventHub, nullptr); 910 eventHub->AttachHost(frameNode); 911 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 912 ASSERT_NE(focusHub, nullptr); 913 auto context = NG::PipelineContext::GetCurrentContextSafely(); 914 ASSERT_NE(context, nullptr); 915 context->isFocusingByTab_ = false; 916 focusHub->currentFocus_ = false; 917 focusHub->focusType_ = FocusType::NODE; 918 focusHub->focusable_ = true; 919 focusHub->parentFocusable_ = true; 920 eventHub->enabled_ = true; __anon168f60cf0102() 921 focusHub->onPreFocusCallback_ = []() {}; 922 frameNode->layoutProperty_->UpdateVisibility(VisibleType::VISIBLE, true); 923 bool result = true; 924 focusHub->RequestFocusImmediately(); 925 EXPECT_TRUE(result); 926 } 927 928 /** 929 * @tc.name: FocusHubTestNgtest006 930 * @tc.desc: Test the function IsSyncRequestFocusableScope. 931 * @tc.type: FUNC 932 */ 933 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest006, TestSize.Level1) 934 { 935 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 936 ASSERT_NE(frameNode, nullptr); 937 auto nodeParent = 938 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 939 ASSERT_NE(nodeParent, nullptr); 940 frameNode->GetOrCreateFocusHub(); 941 nodeParent->GetOrCreateFocusHub(); 942 frameNode->SetParent(nodeParent); 943 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 944 ASSERT_NE(eventHub, nullptr); 945 eventHub->AttachHost(frameNode); 946 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 947 ASSERT_NE(focusHub, nullptr); 948 bool result = true; 949 eventHub->enabled_ = false; 950 focusHub->IsSyncRequestFocusableScope(); 951 eventHub->enabled_ = true; 952 focusHub->IsSyncRequestFocusableScope(); 953 frameNode->layoutProperty_->UpdateVisibility(VisibleType::INVISIBLE, true); 954 focusHub->IsSyncRequestFocusableScope(); 955 frameNode->layoutProperty_->UpdateVisibility(VisibleType::VISIBLE, true); 956 focusHub->focusable_ = false; 957 focusHub->IsSyncRequestFocusableScope(); 958 focusHub->focusable_ = true; 959 focusHub->parentFocusable_ = false; 960 focusHub->IsSyncRequestFocusableScope(); 961 focusHub->parentFocusable_ = true; 962 focusHub->IsSyncRequestFocusableScope(); 963 focusHub->focusDepend_ = FocusDependence::AUTO; 964 focusHub->IsSyncRequestFocusableScope(); 965 focusHub->focusDepend_ = FocusDependence::SELF; 966 focusHub->IsSyncRequestFocusableScope(); 967 EXPECT_TRUE(result); 968 } 969 970 /** 971 * @tc.name: FocusHubTestNgtest008 972 * @tc.desc: Test the function OnKeyPreIme. 973 * @tc.type: FUNC 974 */ 975 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest008, TestSize.Level1) 976 { 977 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 978 ASSERT_NE(frameNode, nullptr); 979 auto nodeParent = 980 AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 981 ASSERT_NE(nodeParent, nullptr); 982 frameNode->GetOrCreateFocusHub(); 983 nodeParent->GetOrCreateFocusHub(); 984 frameNode->SetParent(nodeParent); 985 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 986 ASSERT_NE(eventHub, nullptr); 987 eventHub->AttachHost(frameNode); 988 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 989 ASSERT_NE(focusHub, nullptr); 990 bool result = true; 991 KeyEvent keyEvent; 992 auto info = KeyEventInfo(keyEvent); 993 focusHub->focusCallbackEvents_ = nullptr; 994 focusHub->OnKeyPreIme(info, keyEvent); __anon168f60cf0202(KeyEventInfo& event) 995 OnKeyConsumeFunc onKeyCallback = [](KeyEventInfo& event) -> bool { return true; }; 996 focusHub->SetOnKeyPreIme(std::move(onKeyCallback)); 997 focusHub->OnKeyPreIme(info, keyEvent); 998 EXPECT_TRUE(result); 999 } 1000 /** 1001 * @tc.name: FocusHubTestNgtest009 1002 * @tc.desc: Test the function OnKeyPreIme. 1003 * @tc.type: FUNC 1004 */ 1005 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest009, TestSize.Level1) 1006 { 1007 auto frameNode = 1008 AceType::MakeRefPtr<FrameNodeOnTree>(V2::EMBEDDED_COMPONENT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1009 ASSERT_NE(frameNode, nullptr); 1010 auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>( 1011 V2::EMBEDDED_COMPONENT_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 1012 ASSERT_NE(nodeParent, nullptr); 1013 frameNode->GetOrCreateFocusHub(); 1014 nodeParent->GetOrCreateFocusHub(); 1015 frameNode->SetParent(nodeParent); 1016 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1017 ASSERT_NE(eventHub, nullptr); 1018 eventHub->AttachHost(frameNode); 1019 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1020 ASSERT_NE(focusHub, nullptr); 1021 bool result = true; 1022 KeyEvent keyEvent; 1023 auto info = KeyEventInfo(keyEvent); 1024 focusHub->focusCallbackEvents_ = nullptr; 1025 focusHub->OnKeyPreIme(info, keyEvent); 1026 EXPECT_TRUE(result); 1027 } 1028 /** 1029 * @tc.name: FocusHubTestNgtest010 1030 * @tc.desc: Test the function OnKeyPreIme. 1031 * @tc.type: FUNC 1032 */ 1033 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest010, TestSize.Level1) 1034 { 1035 auto frameNode = 1036 AceType::MakeRefPtr<FrameNodeOnTree>(V2::UI_EXTENSION_COMPONENT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1037 ASSERT_NE(frameNode, nullptr); 1038 auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>( 1039 V2::UI_EXTENSION_COMPONENT_ETS_TAG, -1, AceType::MakeRefPtr<FlexLayoutPattern>()); 1040 ASSERT_NE(nodeParent, nullptr); 1041 frameNode->GetOrCreateFocusHub(); 1042 nodeParent->GetOrCreateFocusHub(); 1043 frameNode->SetParent(nodeParent); 1044 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1045 ASSERT_NE(eventHub, nullptr); 1046 eventHub->AttachHost(frameNode); 1047 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1048 ASSERT_NE(focusHub, nullptr); 1049 bool result = true; 1050 KeyEvent keyEvent; 1051 auto info = KeyEventInfo(keyEvent); 1052 focusHub->focusCallbackEvents_ = nullptr; 1053 focusHub->OnKeyPreIme(info, keyEvent); 1054 EXPECT_TRUE(result); 1055 } 1056 /** 1057 * @tc.name: FocusHubTestNgtest011 1058 * @tc.desc: Test the function OnKeyEventScope. 1059 * @tc.type: FUNC 1060 */ 1061 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest011, TestSize.Level1) 1062 { 1063 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1064 ASSERT_NE(frameNode, nullptr); 1065 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1066 ASSERT_NE(frameNode1, nullptr); 1067 auto frameNode2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1068 ASSERT_NE(frameNode2, nullptr); 1069 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1070 ASSERT_NE(eventHub, nullptr); 1071 RefPtr<EventHub> eventHub1 = AceType::MakeRefPtr<EventHub>(); 1072 ASSERT_NE(eventHub1, nullptr); 1073 eventHub->AttachHost(frameNode2); 1074 eventHub1->AttachHost(frameNode1); 1075 frameNode->SetParent(frameNode1); 1076 frameNode1->SetParent(frameNode2); 1077 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1078 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub1))); 1079 KeyEvent keyEvent; 1080 std::list<RefPtr<FocusHub>> focusNodes; 1081 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 1082 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 1083 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1084 auto pipeline = PipelineContext::GetCurrentContext(); 1085 focusHub->currentFocus_ = false; 1086 pipeline->isFocusActive_ = true; 1087 keyEvent.action = KeyAction::DOWN; 1088 keyEvent.code = KeyCode::KEY_TAB; 1089 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 1090 keyEvent.code = KeyCode::TV_CONTROL_UP; 1091 focusHub->HandleEvent(keyEvent); 1092 keyEvent.code = KeyCode::TV_CONTROL_DOWN; 1093 focusHub->HandleEvent(keyEvent); 1094 keyEvent.code = KeyCode::TV_CONTROL_LEFT; 1095 focusHub->HandleEvent(keyEvent); 1096 keyEvent.code = KeyCode::TV_CONTROL_RIGHT; 1097 focusHub->HandleEvent(keyEvent); 1098 keyEvent.code = KeyCode::KEY_TAB; 1099 focusHub->HandleEvent(keyEvent); 1100 keyEvent.code = KeyCode::KEY_MOVE_HOME; 1101 focusHub->HandleEvent(keyEvent); 1102 keyEvent.code = KeyCode::KEY_MOVE_END; 1103 focusHub->HandleEvent(keyEvent); 1104 keyEvent.code = KeyCode::KEY_MEDIA_PLAY; 1105 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1106 } 1107 1108 /** 1109 * @tc.name: FocusHubTestNgtest012 1110 * @tc.desc: Test the function DumpFocusScopeTree. 1111 * @tc.type: FUNC 1112 */ 1113 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest012, TestSize.Level1) 1114 { 1115 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1116 ASSERT_NE(frameNode, nullptr); 1117 frameNode->GetOrCreateFocusHub(); 1118 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1119 ASSERT_NE(eventHub, nullptr); 1120 eventHub->AttachHost(frameNode); 1121 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1122 ASSERT_NE(focusHub, nullptr); 1123 bool result = true; 1124 KeyEvent keyEvent; 1125 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 1126 FocusEvent focusEvent(keyEvent); 1127 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1128 MockContainer::SetUp(); 1129 MockContainer::Current()->isDynamicRender_ = true; 1130 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1131 auto* context = frameNode->GetContext(); 1132 context->focusWindowId_ = 1; 1133 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1134 MockContainer::Current()->isDynamicRender_ = false; 1135 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1136 context->focusWindowId_.reset(); 1137 MockContainer::TearDown(); 1138 EXPECT_TRUE(result); 1139 } 1140 1141 /** 1142 * @tc.name: FocusHubTestNgtest013 1143 * @tc.desc: Test the function DumpFocusScopeTree. 1144 * @tc.type: FUNC 1145 */ 1146 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest013, TestSize.Level1) 1147 { 1148 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1149 ASSERT_NE(frameNode, nullptr); 1150 frameNode->GetOrCreateFocusHub(); 1151 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1152 ASSERT_NE(eventHub, nullptr); 1153 eventHub->AttachHost(frameNode); 1154 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1155 ASSERT_NE(focusHub, nullptr); 1156 bool result = true; 1157 KeyEvent keyEvent; 1158 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT); 1159 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB); 1160 FocusEvent focusEvent(keyEvent); 1161 auto* context = frameNode->GetContext(); 1162 context->focusWindowId_.reset(); 1163 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1164 MockContainer::SetUp(); 1165 MockContainer::Current()->isDynamicRender_ = true; 1166 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1167 context->focusWindowId_ = 1; 1168 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1169 MockContainer::Current()->isDynamicRender_ = false; 1170 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1171 context->focusWindowId_.reset(); 1172 MockContainer::TearDown(); 1173 EXPECT_TRUE(result); 1174 } 1175 1176 /** 1177 * @tc.name: FocusHubTestNgtest014 1178 * @tc.desc: Test the function SwitchFocus. 1179 * @tc.type: FUNC 1180 */ 1181 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest014, TestSize.Level1) 1182 { 1183 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1184 ASSERT_NE(eventHub, nullptr); 1185 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1186 ASSERT_NE(focusHub, nullptr); 1187 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1188 ASSERT_NE(focusHub2, nullptr); 1189 focusHub->focusType_ = FocusType::NODE; 1190 bool result = false; 1191 focusHub->SwitchFocus(focusHub2); 1192 EXPECT_FALSE(result); 1193 } 1194 1195 /** 1196 * @tc.name: FocusHubTestNgtest015 1197 * @tc.desc: Test the function FocusToHeadOrTailChild. 1198 * @tc.type: FUNC 1199 */ 1200 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest015, TestSize.Level1) 1201 { 1202 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>()); 1203 ASSERT_NE(frameNode, nullptr); 1204 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1205 ASSERT_NE(frameNode1, nullptr); 1206 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1207 ASSERT_NE(eventHub, nullptr); 1208 eventHub->AttachHost(frameNode1); 1209 frameNode->GetOrCreateFocusHub(); 1210 frameNode1->GetOrCreateFocusHub(); 1211 frameNode->SetParent(frameNode1); 1212 auto focusHub = frameNode->GetFocusHub(); 1213 ASSERT_NE(focusHub, nullptr); 1214 auto focusHub1 = frameNode1->GetFocusHub(); 1215 focusHub->isGroup_ = true; 1216 focusHub->focusType_ = FocusType::NODE; 1217 focusHub1->focusType_ = FocusType::NODE; 1218 focusHub1->focusable_ = true; 1219 focusHub1->parentFocusable_ = true; 1220 eventHub->enabled_ = true; 1221 frameNode1->layoutProperty_->UpdateVisibility(VisibleType::VISIBLE, true); 1222 focusHub1->isGroup_ = true; 1223 focusHub->FocusToHeadOrTailChild(true); 1224 focusHub1->focusType_ = FocusType::SCOPE; 1225 auto res = focusHub->FocusToHeadOrTailChild(true); 1226 EXPECT_TRUE(res); 1227 ; 1228 } 1229 1230 /** 1231 * @tc.name: FocusHubTestNgtest016 1232 * @tc.desc: Test the function CalculatePosition. 1233 * @tc.type: FUNC 1234 */ 1235 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest016, TestSize.Level1) 1236 { 1237 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1238 ASSERT_NE(frameNode, nullptr); 1239 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1240 ASSERT_NE(frameNode1, nullptr); 1241 auto frameNode2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1242 ASSERT_NE(frameNode2, nullptr); 1243 auto frameNode3 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1244 ASSERT_NE(frameNode3, nullptr); 1245 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1246 ASSERT_NE(eventHub, nullptr); 1247 RefPtr<EventHub> eventHub1 = AceType::MakeRefPtr<EventHub>(); 1248 ASSERT_NE(eventHub1, nullptr); 1249 eventHub->AttachHost(frameNode2); 1250 eventHub1->AttachHost(frameNode1); 1251 1252 frameNode->SetParent(frameNode1); 1253 frameNode1->SetParent(frameNode2); 1254 frameNode3->AddChild(frameNode2); 1255 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1256 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub1))); 1257 KeyEvent keyEvent; 1258 bool result = true; 1259 std::list<RefPtr<FocusHub>> focusNodes; 1260 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 1261 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 1262 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1263 auto pipeline = PipelineContext::GetCurrentContext(); 1264 focusHub->focusType_ = FocusType::NODE; 1265 focusHub1->focusType_ = FocusType::NODE; 1266 focusHub->CalculatePosition(); 1267 EXPECT_TRUE(result); 1268 } 1269 1270 /** 1271 * @tc.name: FocusHubTestNgtest017 1272 * @tc.desc: Test the function OnFocusScope. 1273 * @tc.type: FUNC 1274 */ 1275 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest017, TestSize.Level1) 1276 { 1277 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1278 ASSERT_NE(frameNode, nullptr); 1279 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1280 ASSERT_NE(child, nullptr); 1281 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1282 ASSERT_NE(child2, nullptr); 1283 child->GetOrCreateFocusHub(); 1284 child2->GetOrCreateFocusHub(); 1285 frameNode->AddChild(child); 1286 frameNode->AddChild(child2); 1287 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1288 ASSERT_NE(eventHub, nullptr); 1289 RefPtr<EventHub> eventHub2 = AceType::MakeRefPtr<EventHub>(); 1290 ASSERT_NE(eventHub2, nullptr); 1291 eventHub->AttachHost(frameNode); 1292 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1293 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2))); 1294 focusHub->currentFocus_ = true; 1295 std::list<RefPtr<FocusHub>> focusNodes; 1296 bool result = false; 1297 focusHub->focusDepend_ = FocusDependence::AUTO; 1298 focusHub->focusScopeId_ = "123"; 1299 focusHub->isFocusScope_ = true; 1300 focusHub->currentFocus_ = true; 1301 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1302 auto lastFocusNode = focusHub->lastWeakFocusNode_.Upgrade(); 1303 lastFocusNode->currentFocus_ = true; 1304 lastFocusNode->focusType_ = FocusType::NODE; 1305 lastFocusNode->focusCallbackEvents_ = nullptr; 1306 focusHub->isGroup_ = true; 1307 focusHub->focusCallbackEvents_ = nullptr; 1308 focusHub->focusType_ = FocusType::NODE; 1309 focusHub->OnFocusScope(true); 1310 focusHub->OnFocusScope(false); 1311 EXPECT_FALSE(result); 1312 } 1313 1314 /** 1315 * @tc.name: FocusHubTestNgtest018 1316 * @tc.desc: Test the function RequestFocusByPriorityInScope. 1317 * @tc.type: FUNC 1318 */ 1319 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest018, TestSize.Level1) 1320 { 1321 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1322 ASSERT_NE(frameNode, nullptr); 1323 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1324 ASSERT_NE(child, nullptr); 1325 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1326 ASSERT_NE(child2, nullptr); 1327 child->GetOrCreateFocusHub(); 1328 child2->GetOrCreateFocusHub(); 1329 frameNode->AddChild(child); 1330 frameNode->AddChild(child2); 1331 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1332 ASSERT_NE(eventHub, nullptr); 1333 RefPtr<EventHub> eventHub2 = AceType::MakeRefPtr<EventHub>(); 1334 ASSERT_NE(eventHub2, nullptr); 1335 eventHub->AttachHost(frameNode); 1336 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1337 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2))); 1338 focusHub->currentFocus_ = true; 1339 std::list<RefPtr<FocusHub>> focusNodes; 1340 bool result = false; 1341 focusHub->focusDepend_ = FocusDependence::AUTO; 1342 focusHub->RequestFocusByPriorityInScope(); 1343 focusHub->focusScopeId_ = "123"; 1344 focusHub->RequestFocusByPriorityInScope(); 1345 focusHub->isFocusScope_ = true; 1346 focusHub->focusScopeId_.clear(); 1347 focusHub->RequestFocusByPriorityInScope(); 1348 focusHub->focusScopeId_ = "123"; 1349 focusHub->RequestFocusByPriorityInScope(); 1350 focusHub->currentFocus_ = true; 1351 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1352 auto lastFocusNode = focusHub->lastWeakFocusNode_.Upgrade(); 1353 lastFocusNode->currentFocus_ = true; 1354 lastFocusNode->focusType_ = FocusType::NODE; 1355 lastFocusNode->focusCallbackEvents_ = nullptr; 1356 focusHub->isGroup_ = true; 1357 focusHub->focusCallbackEvents_ = nullptr; 1358 focusHub->focusType_ = FocusType::NODE; 1359 focusHub->RequestFocusByPriorityInScope(); 1360 EXPECT_FALSE(result); 1361 } 1362 1363 /** 1364 * @tc.name: FocusHubTestNgtest019 1365 * @tc.desc: Test the function RequestFocusByPriorityInScope. 1366 * @tc.type: FUNC 1367 */ 1368 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest019, TestSize.Level1) 1369 { 1370 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1371 ASSERT_NE(frameNode, nullptr); 1372 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1373 ASSERT_NE(child, nullptr); 1374 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1375 ASSERT_NE(child2, nullptr); 1376 child->GetOrCreateFocusHub(); 1377 child2->GetOrCreateFocusHub(); 1378 frameNode->AddChild(child); 1379 frameNode->AddChild(child2); 1380 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1381 ASSERT_NE(eventHub, nullptr); 1382 RefPtr<EventHub> eventHub2 = AceType::MakeRefPtr<EventHub>(); 1383 ASSERT_NE(eventHub2, nullptr); 1384 eventHub->AttachHost(frameNode); 1385 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1386 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2))); 1387 focusHub->currentFocus_ = true; 1388 std::list<RefPtr<FocusHub>> focusNodes; 1389 bool result = false; 1390 focusHub->focusDepend_ = FocusDependence::AUTO; 1391 focusHub->focusScopeId_ = "123"; 1392 focusHub->isFocusScope_ = true; 1393 focusHub->currentFocus_ = true; 1394 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1395 auto lastFocusNode = focusHub->lastWeakFocusNode_.Upgrade(); 1396 lastFocusNode->currentFocus_ = true; 1397 lastFocusNode->focusType_ = FocusType::DISABLE; 1398 lastFocusNode->focusCallbackEvents_ = nullptr; 1399 focusHub->isGroup_ = true; 1400 focusHub->RequestFocusByPriorityInScope(); 1401 lastFocusNode->focusType_ = FocusType::NODE; 1402 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1403 ASSERT_NE(frameNode1, nullptr); 1404 frameNode1->GetOrCreateFocusHub(); 1405 frameNode->SetParent(frameNode1); 1406 auto focusHub2 = frameNode1->GetFocusHub(); 1407 focusHub2->focusType_ = FocusType::SCOPE; 1408 focusHub2->isGroup_ = true; 1409 focusHub->RequestFocusByPriorityInScope(); 1410 focusHub->isGroup_ = false; 1411 focusHub->RequestFocusByPriorityInScope(); 1412 EXPECT_FALSE(result); 1413 } 1414 1415 /** 1416 * @tc.name: FocusHubTestNgtest020 1417 * @tc.desc: Test the function AcceptFocusOfPriorityChild. 1418 * @tc.type: FUNC 1419 */ 1420 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest020, TestSize.Level1) 1421 { 1422 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1423 ASSERT_NE(frameNode, nullptr); 1424 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1425 ASSERT_NE(eventHub, nullptr); 1426 eventHub->AttachHost(frameNode); 1427 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1428 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1429 bool result = false; 1430 focusHub->focusType_ = FocusType::SCOPE; 1431 focusHub->focusScopeId_ = "123"; 1432 focusHub->AcceptFocusOfPriorityChild(); 1433 focusHub->isFocusScope_ = true; 1434 focusHub->AcceptFocusOfPriorityChild(); 1435 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1436 focusHub->AcceptFocusOfPriorityChild(); 1437 focusHub->isGroup_ = true; 1438 focusHub->AcceptFocusOfPriorityChild(); 1439 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1440 ASSERT_NE(frameNode1, nullptr); 1441 frameNode1->GetOrCreateFocusHub(); 1442 frameNode->SetParent(frameNode1); 1443 auto focusHub2 = frameNode1->GetFocusHub(); 1444 ASSERT_NE(focusHub2, nullptr); 1445 focusHub2->focusType_ = FocusType::SCOPE; 1446 focusHub2->isGroup_ = true; 1447 focusHub->AcceptFocusOfPriorityChild(); 1448 EXPECT_FALSE(result); 1449 } 1450 1451 /** 1452 * @tc.name: FocusHubTestNgtest021 1453 * @tc.desc: Test the function SetLastWeakFocusToPreviousInFocusView. 1454 * @tc.type: FUNC 1455 */ 1456 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest021, TestSize.Level1) 1457 { 1458 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1459 ASSERT_NE(eventHub, nullptr); 1460 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1461 ASSERT_NE(focusHub, nullptr); 1462 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1463 ASSERT_NE(focusHub1, nullptr); 1464 bool result = false; 1465 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1466 focusHub->SetLastWeakFocusToPreviousInFocusView(); 1467 EXPECT_FALSE(result); 1468 } 1469 1470 /** 1471 * @tc.name: FocusHubTestNgtest022 1472 * @tc.desc: Test the function SetLastWeakFocusToPreviousInFocusView. 1473 * @tc.type: FUNC 1474 */ 1475 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest022, TestSize.Level1) 1476 { 1477 /** 1478 * @tc.steps: step1. Create frameNode. 1479 */ 1480 auto frameNode = 1481 FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 108, AceType::MakeRefPtr<LinearLayoutPattern>(true)); 1482 ASSERT_NE(frameNode, nullptr); 1483 auto child = FrameNodeOnTree::GetOrCreateFrameNode( __anon168f60cf0302() 1484 V2::BUTTON_ETS_TAG, 109, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1485 ASSERT_NE(child, nullptr); 1486 auto child2 = FrameNodeOnTree::GetOrCreateFrameNode( __anon168f60cf0402() 1487 V2::BUTTON_ETS_TAG, 110, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1488 ASSERT_NE(child2, nullptr); 1489 child->MountToParent(frameNode); 1490 child2->MountToParent(frameNode); 1491 1492 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 1493 ASSERT_NE(parentFocusHub, nullptr); 1494 parentFocusHub->SetFocusScopeId("scope2", true); 1495 1496 auto child2FocusHub = child2->GetOrCreateFocusHub(); 1497 ASSERT_NE(child2FocusHub, nullptr); 1498 child2FocusHub->SetFocusScopePriority("scope2", 2000); 1499 1500 auto childFocusHub = child->GetOrCreateFocusHub(); 1501 ASSERT_NE(childFocusHub, nullptr); 1502 childFocusHub->SetFocusScopePriority("scope2", 3000); 1503 1504 EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild()); 1505 parentFocusHub->SetLastWeakFocusToPreviousInFocusView(); 1506 } 1507 1508 /** 1509 * @tc.name: FocusHubTestNgtest023 1510 * @tc.desc: Test the function IsFocusAbleChildOf. 1511 * @tc.type: FUNC 1512 */ 1513 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest023, TestSize.Level1) 1514 { 1515 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1516 ASSERT_NE(frameNode, nullptr); 1517 auto frameNodeFir = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1518 ASSERT_NE(frameNodeFir, nullptr); 1519 auto frameNodeSec = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1520 ASSERT_NE(frameNodeSec, nullptr); 1521 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1522 ASSERT_NE(eventHub, nullptr); 1523 auto eventHubFir = AceType::MakeRefPtr<EventHub>(); 1524 ASSERT_NE(eventHubFir, nullptr); 1525 eventHub->AttachHost(frameNode); 1526 eventHubFir->AttachHost(frameNodeFir); 1527 frameNode->eventHub_ = eventHub; 1528 frameNodeFir->eventHub_ = eventHubFir; 1529 frameNode->MountToParent(frameNodeFir); 1530 auto focusHub = frameNode->GetOrCreateFocusHub(); 1531 auto focusHubFir = frameNodeFir->GetOrCreateFocusHub(); 1532 auto focusHubSec = frameNodeSec->GetOrCreateFocusHub(); 1533 bool result = true; 1534 focusHubFir->focusType_ = FocusType::SCOPE; 1535 focusHubFir->SetFocusScopeId("scope2", true); 1536 focusHub->SetFocusScopePriority("scope2", 2000); 1537 focusHub->IsFocusAbleChildOf(focusHubFir); 1538 focusHub->IsFocusAbleChildOf(focusHubSec); 1539 EXPECT_TRUE(result); 1540 } 1541 1542 /** 1543 * @tc.name: FocusHubTestNgtest024 1544 * @tc.desc: Test the function SetLastWeakFocusNodeWholeScope. 1545 * @tc.type: FUNC 1546 */ 1547 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest024, TestSize.Level1) 1548 { 1549 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1550 ASSERT_NE(frameNode, nullptr); 1551 auto frameNodeFir = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1552 ASSERT_NE(frameNodeFir, nullptr); 1553 auto frameNodeSec = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1554 ASSERT_NE(frameNodeSec, nullptr); 1555 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1556 ASSERT_NE(eventHub, nullptr); 1557 auto eventHubFir = AceType::MakeRefPtr<EventHub>(); 1558 ASSERT_NE(eventHubFir, nullptr); 1559 eventHub->AttachHost(frameNode); 1560 eventHubFir->AttachHost(frameNodeFir); 1561 frameNode->eventHub_ = eventHub; 1562 frameNodeFir->eventHub_ = eventHubFir; 1563 frameNode->MountToParent(frameNodeFir); 1564 auto focusHub = frameNode->GetOrCreateFocusHub(); 1565 auto focusHubFir = frameNodeFir->GetOrCreateFocusHub(); 1566 auto focusHubSec = frameNodeSec->GetOrCreateFocusHub(); 1567 bool result = true; 1568 focusHubFir->focusType_ = FocusType::SCOPE; 1569 focusHubFir->SetFocusScopeId("scope2", true); 1570 focusHub->SetFocusScopePriority("scope2", 2000); 1571 focusHub->SetLastWeakFocusNodeWholeScope("scope2"); 1572 focusHub->SetLastWeakFocusNodeWholeScope("scope"); 1573 focusHubFir->isFocusScope_ = false; 1574 focusHub->SetLastWeakFocusNodeWholeScope("scope"); 1575 focusHub->SetLastWeakFocusNodeWholeScope("scope2"); 1576 focusHubSec->SetLastWeakFocusNodeWholeScope("scope2"); 1577 EXPECT_TRUE(result); 1578 } 1579 1580 /** 1581 * @tc.name: FocusHubTestNgtest025 1582 * @tc.desc: Test the function SetFocusScopePriority. 1583 * @tc.type: FUNC 1584 */ 1585 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest025, TestSize.Level1) 1586 { 1587 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1588 ASSERT_NE(frameNode, nullptr); 1589 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1590 ASSERT_NE(eventHub, nullptr); 1591 eventHub->AttachHost(frameNode); 1592 frameNode->eventHub_ = eventHub; 1593 auto focusHub = frameNode->GetOrCreateFocusHub(); 1594 bool result = true; 1595 focusHub->focusScopeId_ = "123"; 1596 focusHub->SetFocusScopePriority("", 2000); 1597 focusHub->focusScopeId_ = "123"; 1598 focusHub->SetFocusScopePriority("scope2", 2000); 1599 focusHub->focusScopeId_.clear(); 1600 focusHub->SetFocusScopePriority("scope2", 3000); 1601 focusHub->SetFocusScopePriority("scope2", 0); 1602 EXPECT_TRUE(result); 1603 } 1604 1605 /** 1606 * @tc.name: FocusHubTestNgtest026 1607 * @tc.desc: Test the function IsInFocusGroup. 1608 * @tc.type: FUNC 1609 */ 1610 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest026, TestSize.Level1) 1611 { 1612 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1613 ASSERT_NE(frameNode, nullptr); 1614 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1615 ASSERT_NE(eventHub, nullptr); 1616 eventHub->AttachHost(frameNode); 1617 frameNode->eventHub_ = eventHub; 1618 auto focusHub = frameNode->GetOrCreateFocusHub(); 1619 bool result = true; 1620 focusHub->isGroup_ = true; 1621 focusHub->IsInFocusGroup(); 1622 auto frameNodeFir = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1623 ASSERT_NE(frameNodeFir, nullptr); 1624 frameNodeFir->GetOrCreateFocusHub(); 1625 frameNode->SetParent(frameNodeFir); 1626 auto focusHubSec = frameNodeFir->GetFocusHub(); 1627 ASSERT_NE(focusHubSec, nullptr); 1628 focusHubSec->focusType_ = FocusType::SCOPE; 1629 focusHubSec->isGroup_ = true; 1630 focusHub->IsInFocusGroup(); 1631 focusHub->isGroup_ = false; 1632 focusHub->IsInFocusGroup(); 1633 EXPECT_TRUE(result); 1634 } 1635 1636 /** 1637 * @tc.name: FocusHubTestNgtest027 1638 * @tc.desc: Test the function ScrollByOffsetToParent. 1639 * @tc.type: FUNC 1640 */ 1641 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest027, TestSize.Level1) 1642 { 1643 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102, AceType::MakeRefPtr<ButtonPattern>()); 1644 ASSERT_NE(frameNode, nullptr); 1645 frameNode->GetOrCreateFocusHub(); 1646 auto focusHub = frameNode->GetFocusHub(); 1647 ASSERT_NE(focusHub, nullptr); 1648 1649 auto listNode = FrameNodeOnTree::CreateFrameNode("frameNode", 104, AceType::MakeRefPtr<ListPattern>()); 1650 ASSERT_NE(listNode, nullptr); 1651 listNode->GetOrCreateFocusHub(); 1652 auto listFocusHub = listNode->GetFocusHub(); 1653 ASSERT_NE(listFocusHub, nullptr); 1654 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 1655 ASSERT_NE(mockRenderContext, nullptr); 1656 auto mockRenderContextSec = AceType::MakeRefPtr<MockRenderContext>(); 1657 ASSERT_NE(mockRenderContextSec, nullptr); 1658 mockRenderContextSec->rect_ = RectF(10, 3, 2, 2); 1659 frameNode->renderContext_ = mockRenderContextSec; 1660 listNode->renderContext_ = mockRenderContext; 1661 mockRenderContext->rect_ = RectF(10, 5, 10, 10); 1662 frameNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1663 frameNode->geometryNode_->SetFrameSize(SizeF(2, 2)); 1664 listNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1665 listNode->geometryNode_->SetFrameSize(SizeF(10, 10)); 1666 1667 ASSERT_TRUE(focusHub->ScrollByOffsetToParent(listNode)); 1668 } 1669 1670 /** 1671 * @tc.name: FocusHubTestNgtest028 1672 * @tc.desc: Test the function ScrollByOffsetToParent. 1673 * @tc.type: FUNC 1674 */ 1675 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest028, TestSize.Level1) 1676 { 1677 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102, AceType::MakeRefPtr<ButtonPattern>()); 1678 ASSERT_NE(frameNode, nullptr); 1679 frameNode->GetOrCreateFocusHub(); 1680 auto focusHub = frameNode->GetFocusHub(); 1681 ASSERT_NE(focusHub, nullptr); 1682 1683 auto listNode = FrameNodeOnTree::CreateFrameNode("frameNode", 104, AceType::MakeRefPtr<ListPattern>()); 1684 ASSERT_NE(listNode, nullptr); 1685 listNode->GetOrCreateFocusHub(); 1686 auto listFocusHub = listNode->GetFocusHub(); 1687 ASSERT_NE(listFocusHub, nullptr); 1688 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 1689 ASSERT_NE(mockRenderContext, nullptr); 1690 auto mockRenderContext2 = AceType::MakeRefPtr<MockRenderContext>(); 1691 ASSERT_NE(mockRenderContext2, nullptr); 1692 mockRenderContext2->rect_ = RectF(10, -5, 5, 5); 1693 frameNode->renderContext_ = mockRenderContext2; 1694 listNode->renderContext_ = mockRenderContext; 1695 mockRenderContext->rect_ = RectF(10, 10, 15, 15); 1696 frameNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1697 frameNode->geometryNode_->SetFrameSize(SizeF(5, 5)); 1698 listNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1699 listNode->geometryNode_->SetFrameSize(SizeF(15, 15)); 1700 ASSERT_TRUE(focusHub->ScrollByOffsetToParent(listNode)); 1701 frameNode->geometryNode_->SetFrameSize(SizeF(25, 25)); 1702 EXPECT_FALSE(focusHub->ScrollByOffsetToParent(listNode)); 1703 } 1704 1705 /** 1706 * @tc.name: FocusHubTestNgtest029 1707 * @tc.desc: Test the function SetNextFocus and RequestUserNextFocus. 1708 * @tc.type: FUNC 1709 */ 1710 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest029, TestSize.Level1) 1711 { 1712 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102, AceType::MakeRefPtr<ButtonPattern>()); 1713 ASSERT_NE(frameNode, nullptr); 1714 frameNode->GetOrCreateFocusHub(); 1715 auto focusHub = frameNode->GetFocusHub(); 1716 ASSERT_NE(focusHub, nullptr); 1717 focusHub->SetNextFocus(FocusIntension::RIGHT, "Node"); 1718 KeyEvent keyEvent; 1719 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT); 1720 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB); 1721 FocusEvent event(keyEvent); 1722 event.intension = FocusIntension::RIGHT; 1723 EXPECT_FALSE(focusHub->RequestUserNextFocus(event)); 1724 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 104, AceType::MakeRefPtr<ButtonPattern>()); 1725 ASSERT_NE(frameNode2, nullptr); 1726 focusHub->SetNextFocus(FocusIntension::LEFT, frameNode2); 1727 event.intension = FocusIntension::LEFT; 1728 EXPECT_TRUE(focusHub->RequestUserNextFocus(event)); 1729 event.intension = FocusIntension::UP; 1730 EXPECT_FALSE(focusHub->RequestUserNextFocus(event)); 1731 auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 106, AceType::MakeRefPtr<ButtonPattern>()); 1732 ASSERT_NE(frameNode3, nullptr); 1733 frameNode3->GetOrCreateFocusHub(); 1734 auto focusHub2 = frameNode3->GetFocusHub(); 1735 auto context = PipelineContext::GetCurrentContext(); 1736 ASSERT_NE(context, nullptr); 1737 context->SetIsFocusingByTab(true); 1738 focusHub2->SetFocusType(FocusType::DISABLE); 1739 focusHub2->currentFocus_ = false; 1740 focusHub->SetNextFocus(FocusIntension::DOWN, frameNode3); 1741 event.intension = FocusIntension::DOWN; 1742 EXPECT_FALSE(focusHub->RequestUserNextFocus(event)); 1743 } 1744 1745 /** 1746 * @tc.name: GetUnicodeTest001 1747 * @tc.desc: Test GetUnicode. 1748 * @tc.type: FUNC 1749 */ 1750 HWTEST_F(FocusHubTestNg, GetUnicodeTest001, TestSize.Level1) 1751 { 1752 KeyEvent keyEvent; 1753 auto defaultInfo = KeyEventInfo(keyEvent); 1754 /** 1755 * @tc.steps: step1. Get the default unicode. 1756 * @tc.expected: default unicode is 0. 1757 */ 1758 EXPECT_EQ(defaultInfo.GetUnicode(), 0); 1759 1760 /** 1761 * @tc.steps: step2. Set the Unicode value to 98. 1762 * @tc.expected: get unicode value is 98. 1763 */ 1764 keyEvent.unicode = 98; 1765 auto info = KeyEventInfo(keyEvent); 1766 EXPECT_EQ(info.GetUnicode(), 98); 1767 } 1768 } // namespace OHOS::Ace::NG 1769