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