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; __anon2b63b9310102() 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); __anon2b63b9310202(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 auto focusManager = pipeline->GetOrCreateFocusManager(); 1087 ASSERT_NE(focusManager, nullptr); 1088 focusManager->isFocusActive_ = true; 1089 keyEvent.action = KeyAction::DOWN; 1090 keyEvent.code = KeyCode::KEY_TAB; 1091 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 1092 keyEvent.code = KeyCode::TV_CONTROL_UP; 1093 focusHub->HandleEvent(keyEvent); 1094 keyEvent.code = KeyCode::TV_CONTROL_DOWN; 1095 focusHub->HandleEvent(keyEvent); 1096 keyEvent.code = KeyCode::TV_CONTROL_LEFT; 1097 focusHub->HandleEvent(keyEvent); 1098 keyEvent.code = KeyCode::TV_CONTROL_RIGHT; 1099 focusHub->HandleEvent(keyEvent); 1100 keyEvent.code = KeyCode::KEY_TAB; 1101 focusHub->HandleEvent(keyEvent); 1102 keyEvent.code = KeyCode::KEY_MOVE_HOME; 1103 focusHub->HandleEvent(keyEvent); 1104 keyEvent.code = KeyCode::KEY_MOVE_END; 1105 focusHub->HandleEvent(keyEvent); 1106 keyEvent.code = KeyCode::KEY_MEDIA_PLAY; 1107 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1108 } 1109 1110 /** 1111 * @tc.name: FocusHubTestNgtest012 1112 * @tc.desc: Test the function DumpFocusScopeTree. 1113 * @tc.type: FUNC 1114 */ 1115 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest012, TestSize.Level1) 1116 { 1117 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1118 ASSERT_NE(frameNode, nullptr); 1119 frameNode->GetOrCreateFocusHub(); 1120 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1121 ASSERT_NE(eventHub, nullptr); 1122 eventHub->AttachHost(frameNode); 1123 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1124 ASSERT_NE(focusHub, nullptr); 1125 bool result = true; 1126 KeyEvent keyEvent; 1127 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 1128 FocusEvent focusEvent(keyEvent); 1129 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1130 MockContainer::SetUp(); 1131 MockContainer::Current()->isDynamicRender_ = true; 1132 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1133 auto* context = frameNode->GetContext(); 1134 context->focusWindowId_ = 1; 1135 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1136 MockContainer::Current()->isDynamicRender_ = false; 1137 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1138 context->focusWindowId_.reset(); 1139 MockContainer::TearDown(); 1140 EXPECT_TRUE(result); 1141 } 1142 1143 /** 1144 * @tc.name: FocusHubTestNgtest013 1145 * @tc.desc: Test the function DumpFocusScopeTree. 1146 * @tc.type: FUNC 1147 */ 1148 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest013, TestSize.Level1) 1149 { 1150 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1151 ASSERT_NE(frameNode, nullptr); 1152 frameNode->GetOrCreateFocusHub(); 1153 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1154 ASSERT_NE(eventHub, nullptr); 1155 eventHub->AttachHost(frameNode); 1156 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1157 ASSERT_NE(focusHub, nullptr); 1158 bool result = true; 1159 KeyEvent keyEvent; 1160 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT); 1161 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB); 1162 FocusEvent focusEvent(keyEvent); 1163 auto* context = frameNode->GetContext(); 1164 context->focusWindowId_.reset(); 1165 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1166 MockContainer::SetUp(); 1167 MockContainer::Current()->isDynamicRender_ = true; 1168 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1169 context->focusWindowId_ = 1; 1170 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1171 MockContainer::Current()->isDynamicRender_ = false; 1172 focusHub->RequestNextFocusOfKeyTab(focusEvent); 1173 context->focusWindowId_.reset(); 1174 MockContainer::TearDown(); 1175 EXPECT_TRUE(result); 1176 } 1177 1178 /** 1179 * @tc.name: FocusHubTestNgtest014 1180 * @tc.desc: Test the function SwitchFocus. 1181 * @tc.type: FUNC 1182 */ 1183 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest014, TestSize.Level1) 1184 { 1185 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1186 ASSERT_NE(eventHub, nullptr); 1187 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1188 ASSERT_NE(focusHub, nullptr); 1189 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1190 ASSERT_NE(focusHub2, nullptr); 1191 focusHub->focusType_ = FocusType::NODE; 1192 bool result = false; 1193 focusHub->SwitchFocus(focusHub2); 1194 EXPECT_FALSE(result); 1195 } 1196 1197 /** 1198 * @tc.name: FocusHubTestNgtest015 1199 * @tc.desc: Test the function FocusToHeadOrTailChild. 1200 * @tc.type: FUNC 1201 */ 1202 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest015, TestSize.Level1) 1203 { 1204 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>()); 1205 ASSERT_NE(frameNode, nullptr); 1206 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1207 ASSERT_NE(frameNode1, nullptr); 1208 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1209 ASSERT_NE(eventHub, nullptr); 1210 eventHub->AttachHost(frameNode1); 1211 frameNode->GetOrCreateFocusHub(); 1212 frameNode1->GetOrCreateFocusHub(); 1213 frameNode->SetParent(frameNode1); 1214 auto focusHub = frameNode->GetFocusHub(); 1215 ASSERT_NE(focusHub, nullptr); 1216 auto focusHub1 = frameNode1->GetFocusHub(); 1217 focusHub->isGroup_ = true; 1218 focusHub->focusType_ = FocusType::NODE; 1219 focusHub1->focusType_ = FocusType::NODE; 1220 focusHub1->focusable_ = true; 1221 focusHub1->parentFocusable_ = true; 1222 eventHub->enabled_ = true; 1223 frameNode1->layoutProperty_->UpdateVisibility(VisibleType::VISIBLE, true); 1224 focusHub1->isGroup_ = true; 1225 focusHub->FocusToHeadOrTailChild(true); 1226 focusHub1->focusType_ = FocusType::SCOPE; 1227 auto res = focusHub->FocusToHeadOrTailChild(true); 1228 EXPECT_TRUE(res); 1229 ; 1230 } 1231 1232 /** 1233 * @tc.name: FocusHubTestNgtest016 1234 * @tc.desc: Test the function CalculatePosition. 1235 * @tc.type: FUNC 1236 */ 1237 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest016, TestSize.Level1) 1238 { 1239 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1240 ASSERT_NE(frameNode, nullptr); 1241 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1242 ASSERT_NE(frameNode1, nullptr); 1243 auto frameNode2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1244 ASSERT_NE(frameNode2, nullptr); 1245 auto frameNode3 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1246 ASSERT_NE(frameNode3, nullptr); 1247 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1248 ASSERT_NE(eventHub, nullptr); 1249 RefPtr<EventHub> eventHub1 = AceType::MakeRefPtr<EventHub>(); 1250 ASSERT_NE(eventHub1, nullptr); 1251 eventHub->AttachHost(frameNode2); 1252 eventHub1->AttachHost(frameNode1); 1253 1254 frameNode->SetParent(frameNode1); 1255 frameNode1->SetParent(frameNode2); 1256 frameNode3->AddChild(frameNode2); 1257 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1258 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub1))); 1259 KeyEvent keyEvent; 1260 bool result = true; 1261 std::list<RefPtr<FocusHub>> focusNodes; 1262 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 1263 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 1264 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1265 auto pipeline = PipelineContext::GetCurrentContext(); 1266 focusHub->focusType_ = FocusType::NODE; 1267 focusHub1->focusType_ = FocusType::NODE; 1268 focusHub->CalculatePosition(); 1269 EXPECT_TRUE(result); 1270 } 1271 1272 /** 1273 * @tc.name: FocusHubTestNgtest017 1274 * @tc.desc: Test the function OnFocusScope. 1275 * @tc.type: FUNC 1276 */ 1277 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest017, TestSize.Level1) 1278 { 1279 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1280 ASSERT_NE(frameNode, nullptr); 1281 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1282 ASSERT_NE(child, nullptr); 1283 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1284 ASSERT_NE(child2, nullptr); 1285 child->GetOrCreateFocusHub(); 1286 child2->GetOrCreateFocusHub(); 1287 frameNode->AddChild(child); 1288 frameNode->AddChild(child2); 1289 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1290 ASSERT_NE(eventHub, nullptr); 1291 RefPtr<EventHub> eventHub2 = AceType::MakeRefPtr<EventHub>(); 1292 ASSERT_NE(eventHub2, nullptr); 1293 eventHub->AttachHost(frameNode); 1294 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1295 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2))); 1296 focusHub->currentFocus_ = true; 1297 std::list<RefPtr<FocusHub>> focusNodes; 1298 bool result = false; 1299 focusHub->focusDepend_ = FocusDependence::AUTO; 1300 focusHub->focusScopeId_ = "123"; 1301 focusHub->isFocusScope_ = true; 1302 focusHub->currentFocus_ = true; 1303 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1304 auto lastFocusNode = focusHub->lastWeakFocusNode_.Upgrade(); 1305 lastFocusNode->currentFocus_ = true; 1306 lastFocusNode->focusType_ = FocusType::NODE; 1307 lastFocusNode->focusCallbackEvents_ = nullptr; 1308 focusHub->isGroup_ = true; 1309 focusHub->focusCallbackEvents_ = nullptr; 1310 focusHub->focusType_ = FocusType::NODE; 1311 focusHub->OnFocusScope(true); 1312 focusHub->OnFocusScope(false); 1313 EXPECT_FALSE(result); 1314 } 1315 1316 /** 1317 * @tc.name: FocusHubTestNgtest018 1318 * @tc.desc: Test the function RequestFocusByPriorityInScope. 1319 * @tc.type: FUNC 1320 */ 1321 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest018, TestSize.Level1) 1322 { 1323 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1324 ASSERT_NE(frameNode, nullptr); 1325 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1326 ASSERT_NE(child, nullptr); 1327 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1328 ASSERT_NE(child2, nullptr); 1329 child->GetOrCreateFocusHub(); 1330 child2->GetOrCreateFocusHub(); 1331 frameNode->AddChild(child); 1332 frameNode->AddChild(child2); 1333 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1334 ASSERT_NE(eventHub, nullptr); 1335 RefPtr<EventHub> eventHub2 = AceType::MakeRefPtr<EventHub>(); 1336 ASSERT_NE(eventHub2, nullptr); 1337 eventHub->AttachHost(frameNode); 1338 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1339 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2))); 1340 focusHub->currentFocus_ = true; 1341 std::list<RefPtr<FocusHub>> focusNodes; 1342 bool result = false; 1343 focusHub->focusDepend_ = FocusDependence::AUTO; 1344 focusHub->RequestFocusByPriorityInScope(); 1345 focusHub->focusScopeId_ = "123"; 1346 focusHub->RequestFocusByPriorityInScope(); 1347 focusHub->isFocusScope_ = true; 1348 focusHub->focusScopeId_.clear(); 1349 focusHub->RequestFocusByPriorityInScope(); 1350 focusHub->focusScopeId_ = "123"; 1351 focusHub->RequestFocusByPriorityInScope(); 1352 focusHub->currentFocus_ = true; 1353 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1354 auto lastFocusNode = focusHub->lastWeakFocusNode_.Upgrade(); 1355 lastFocusNode->currentFocus_ = true; 1356 lastFocusNode->focusType_ = FocusType::NODE; 1357 lastFocusNode->focusCallbackEvents_ = nullptr; 1358 focusHub->isGroup_ = true; 1359 focusHub->focusCallbackEvents_ = nullptr; 1360 focusHub->focusType_ = FocusType::NODE; 1361 focusHub->RequestFocusByPriorityInScope(); 1362 EXPECT_FALSE(result); 1363 } 1364 1365 /** 1366 * @tc.name: FocusHubTestNgtest019 1367 * @tc.desc: Test the function RequestFocusByPriorityInScope. 1368 * @tc.type: FUNC 1369 */ 1370 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest019, TestSize.Level1) 1371 { 1372 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1373 ASSERT_NE(frameNode, nullptr); 1374 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1375 ASSERT_NE(child, nullptr); 1376 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<ButtonPattern>()); 1377 ASSERT_NE(child2, nullptr); 1378 child->GetOrCreateFocusHub(); 1379 child2->GetOrCreateFocusHub(); 1380 frameNode->AddChild(child); 1381 frameNode->AddChild(child2); 1382 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1383 ASSERT_NE(eventHub, nullptr); 1384 RefPtr<EventHub> eventHub2 = AceType::MakeRefPtr<EventHub>(); 1385 ASSERT_NE(eventHub2, nullptr); 1386 eventHub->AttachHost(frameNode); 1387 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1388 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2))); 1389 focusHub->currentFocus_ = true; 1390 std::list<RefPtr<FocusHub>> focusNodes; 1391 bool result = false; 1392 focusHub->focusDepend_ = FocusDependence::AUTO; 1393 focusHub->focusScopeId_ = "123"; 1394 focusHub->isFocusScope_ = true; 1395 focusHub->currentFocus_ = true; 1396 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1397 auto lastFocusNode = focusHub->lastWeakFocusNode_.Upgrade(); 1398 lastFocusNode->currentFocus_ = true; 1399 lastFocusNode->focusType_ = FocusType::DISABLE; 1400 lastFocusNode->focusCallbackEvents_ = nullptr; 1401 focusHub->isGroup_ = true; 1402 focusHub->RequestFocusByPriorityInScope(); 1403 lastFocusNode->focusType_ = FocusType::NODE; 1404 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1405 ASSERT_NE(frameNode1, nullptr); 1406 frameNode1->GetOrCreateFocusHub(); 1407 frameNode->SetParent(frameNode1); 1408 auto focusHub2 = frameNode1->GetFocusHub(); 1409 focusHub2->focusType_ = FocusType::SCOPE; 1410 focusHub2->isGroup_ = true; 1411 focusHub->RequestFocusByPriorityInScope(); 1412 focusHub->isGroup_ = false; 1413 focusHub->RequestFocusByPriorityInScope(); 1414 EXPECT_FALSE(result); 1415 } 1416 1417 /** 1418 * @tc.name: FocusHubTestNgtest020 1419 * @tc.desc: Test the function AcceptFocusOfPriorityChild. 1420 * @tc.type: FUNC 1421 */ 1422 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest020, TestSize.Level1) 1423 { 1424 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1425 ASSERT_NE(frameNode, nullptr); 1426 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1427 ASSERT_NE(eventHub, nullptr); 1428 eventHub->AttachHost(frameNode); 1429 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1430 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1431 bool result = false; 1432 focusHub->focusType_ = FocusType::SCOPE; 1433 focusHub->focusScopeId_ = "123"; 1434 focusHub->AcceptFocusOfPriorityChild(); 1435 focusHub->isFocusScope_ = true; 1436 focusHub->AcceptFocusOfPriorityChild(); 1437 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1438 focusHub->AcceptFocusOfPriorityChild(); 1439 focusHub->isGroup_ = true; 1440 focusHub->AcceptFocusOfPriorityChild(); 1441 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1442 ASSERT_NE(frameNode1, nullptr); 1443 frameNode1->GetOrCreateFocusHub(); 1444 frameNode->SetParent(frameNode1); 1445 auto focusHub2 = frameNode1->GetFocusHub(); 1446 ASSERT_NE(focusHub2, nullptr); 1447 focusHub2->focusType_ = FocusType::SCOPE; 1448 focusHub2->isGroup_ = true; 1449 focusHub->AcceptFocusOfPriorityChild(); 1450 EXPECT_FALSE(result); 1451 } 1452 1453 /** 1454 * @tc.name: FocusHubTestNgtest021 1455 * @tc.desc: Test the function SetLastWeakFocusToPreviousInFocusView. 1456 * @tc.type: FUNC 1457 */ 1458 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest021, TestSize.Level1) 1459 { 1460 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1461 ASSERT_NE(eventHub, nullptr); 1462 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1463 ASSERT_NE(focusHub, nullptr); 1464 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1465 ASSERT_NE(focusHub1, nullptr); 1466 bool result = false; 1467 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1468 focusHub->SetLastWeakFocusToPreviousInFocusView(); 1469 EXPECT_FALSE(result); 1470 } 1471 1472 /** 1473 * @tc.name: FocusHubTestNgtest022 1474 * @tc.desc: Test the function SetLastWeakFocusToPreviousInFocusView. 1475 * @tc.type: FUNC 1476 */ 1477 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest022, TestSize.Level1) 1478 { 1479 /** 1480 * @tc.steps: step1. Create frameNode. 1481 */ 1482 auto frameNode = 1483 FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 108, AceType::MakeRefPtr<LinearLayoutPattern>(true)); 1484 ASSERT_NE(frameNode, nullptr); 1485 auto child = FrameNodeOnTree::GetOrCreateFrameNode( __anon2b63b9310302() 1486 V2::BUTTON_ETS_TAG, 109, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1487 ASSERT_NE(child, nullptr); 1488 auto child2 = FrameNodeOnTree::GetOrCreateFrameNode( __anon2b63b9310402() 1489 V2::BUTTON_ETS_TAG, 110, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1490 ASSERT_NE(child2, nullptr); 1491 child->MountToParent(frameNode); 1492 child2->MountToParent(frameNode); 1493 1494 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 1495 ASSERT_NE(parentFocusHub, nullptr); 1496 parentFocusHub->SetFocusScopeId("scope2", true); 1497 1498 auto child2FocusHub = child2->GetOrCreateFocusHub(); 1499 ASSERT_NE(child2FocusHub, nullptr); 1500 child2FocusHub->SetFocusScopePriority("scope2", 2000); 1501 1502 auto childFocusHub = child->GetOrCreateFocusHub(); 1503 ASSERT_NE(childFocusHub, nullptr); 1504 childFocusHub->SetFocusScopePriority("scope2", 3000); 1505 1506 EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild()); 1507 parentFocusHub->SetLastWeakFocusToPreviousInFocusView(); 1508 } 1509 1510 /** 1511 * @tc.name: FocusHubTestNgtest023 1512 * @tc.desc: Test the function IsFocusAbleChildOf. 1513 * @tc.type: FUNC 1514 */ 1515 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest023, TestSize.Level1) 1516 { 1517 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1518 ASSERT_NE(frameNode, nullptr); 1519 auto frameNodeFir = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1520 ASSERT_NE(frameNodeFir, nullptr); 1521 auto frameNodeSec = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1522 ASSERT_NE(frameNodeSec, nullptr); 1523 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1524 ASSERT_NE(eventHub, nullptr); 1525 auto eventHubFir = AceType::MakeRefPtr<EventHub>(); 1526 ASSERT_NE(eventHubFir, nullptr); 1527 eventHub->AttachHost(frameNode); 1528 eventHubFir->AttachHost(frameNodeFir); 1529 frameNode->eventHub_ = eventHub; 1530 frameNodeFir->eventHub_ = eventHubFir; 1531 frameNode->MountToParent(frameNodeFir); 1532 auto focusHub = frameNode->GetOrCreateFocusHub(); 1533 auto focusHubFir = frameNodeFir->GetOrCreateFocusHub(); 1534 auto focusHubSec = frameNodeSec->GetOrCreateFocusHub(); 1535 bool result = true; 1536 focusHubFir->focusType_ = FocusType::SCOPE; 1537 focusHubFir->SetFocusScopeId("scope2", true); 1538 focusHub->SetFocusScopePriority("scope2", 2000); 1539 focusHub->IsFocusAbleChildOf(focusHubFir); 1540 focusHub->IsFocusAbleChildOf(focusHubSec); 1541 EXPECT_TRUE(result); 1542 } 1543 1544 /** 1545 * @tc.name: FocusHubTestNgtest024 1546 * @tc.desc: Test the function SetLastWeakFocusNodeWholeScope. 1547 * @tc.type: FUNC 1548 */ 1549 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest024, TestSize.Level1) 1550 { 1551 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1552 ASSERT_NE(frameNode, nullptr); 1553 auto frameNodeFir = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1554 ASSERT_NE(frameNodeFir, nullptr); 1555 auto frameNodeSec = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1556 ASSERT_NE(frameNodeSec, nullptr); 1557 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1558 ASSERT_NE(eventHub, nullptr); 1559 auto eventHubFir = AceType::MakeRefPtr<EventHub>(); 1560 ASSERT_NE(eventHubFir, nullptr); 1561 eventHub->AttachHost(frameNode); 1562 eventHubFir->AttachHost(frameNodeFir); 1563 frameNode->eventHub_ = eventHub; 1564 frameNodeFir->eventHub_ = eventHubFir; 1565 frameNode->MountToParent(frameNodeFir); 1566 auto focusHub = frameNode->GetOrCreateFocusHub(); 1567 auto focusHubFir = frameNodeFir->GetOrCreateFocusHub(); 1568 auto focusHubSec = frameNodeSec->GetOrCreateFocusHub(); 1569 bool result = true; 1570 focusHubFir->focusType_ = FocusType::SCOPE; 1571 focusHubFir->SetFocusScopeId("scope2", true); 1572 focusHub->SetFocusScopePriority("scope2", 2000); 1573 focusHub->SetLastWeakFocusNodeWholeScope("scope2"); 1574 focusHub->SetLastWeakFocusNodeWholeScope("scope"); 1575 focusHubFir->isFocusScope_ = false; 1576 focusHub->SetLastWeakFocusNodeWholeScope("scope"); 1577 focusHub->SetLastWeakFocusNodeWholeScope("scope2"); 1578 focusHubSec->SetLastWeakFocusNodeWholeScope("scope2"); 1579 EXPECT_TRUE(result); 1580 } 1581 1582 /** 1583 * @tc.name: FocusHubTestNgtest025 1584 * @tc.desc: Test the function SetFocusScopePriority. 1585 * @tc.type: FUNC 1586 */ 1587 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest025, TestSize.Level1) 1588 { 1589 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1590 ASSERT_NE(frameNode, nullptr); 1591 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1592 ASSERT_NE(eventHub, nullptr); 1593 eventHub->AttachHost(frameNode); 1594 frameNode->eventHub_ = eventHub; 1595 auto focusHub = frameNode->GetOrCreateFocusHub(); 1596 bool result = true; 1597 focusHub->focusScopeId_ = "123"; 1598 focusHub->SetFocusScopePriority("", 2000); 1599 focusHub->focusScopeId_ = "123"; 1600 focusHub->SetFocusScopePriority("scope2", 2000); 1601 focusHub->focusScopeId_.clear(); 1602 focusHub->SetFocusScopePriority("scope2", 3000); 1603 focusHub->SetFocusScopePriority("scope2", 0); 1604 EXPECT_TRUE(result); 1605 } 1606 1607 /** 1608 * @tc.name: FocusHubTestNgtest026 1609 * @tc.desc: Test the function IsInFocusGroup. 1610 * @tc.type: FUNC 1611 */ 1612 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest026, TestSize.Level1) 1613 { 1614 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1615 ASSERT_NE(frameNode, nullptr); 1616 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1617 ASSERT_NE(eventHub, nullptr); 1618 eventHub->AttachHost(frameNode); 1619 frameNode->eventHub_ = eventHub; 1620 auto focusHub = frameNode->GetOrCreateFocusHub(); 1621 bool result = true; 1622 focusHub->isGroup_ = true; 1623 focusHub->IsInFocusGroup(); 1624 auto frameNodeFir = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1625 ASSERT_NE(frameNodeFir, nullptr); 1626 frameNodeFir->GetOrCreateFocusHub(); 1627 frameNode->SetParent(frameNodeFir); 1628 auto focusHubSec = frameNodeFir->GetFocusHub(); 1629 ASSERT_NE(focusHubSec, nullptr); 1630 focusHubSec->focusType_ = FocusType::SCOPE; 1631 focusHubSec->isGroup_ = true; 1632 focusHub->IsInFocusGroup(); 1633 focusHub->isGroup_ = false; 1634 focusHub->IsInFocusGroup(); 1635 EXPECT_TRUE(result); 1636 } 1637 1638 /** 1639 * @tc.name: FocusHubTestNgtest027 1640 * @tc.desc: Test the function ScrollByOffsetToParent. 1641 * @tc.type: FUNC 1642 */ 1643 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest027, TestSize.Level1) 1644 { 1645 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102, AceType::MakeRefPtr<ButtonPattern>()); 1646 ASSERT_NE(frameNode, nullptr); 1647 frameNode->GetOrCreateFocusHub(); 1648 auto focusHub = frameNode->GetFocusHub(); 1649 ASSERT_NE(focusHub, nullptr); 1650 1651 auto listNode = FrameNodeOnTree::CreateFrameNode("frameNode", 104, AceType::MakeRefPtr<ListPattern>()); 1652 ASSERT_NE(listNode, nullptr); 1653 listNode->GetOrCreateFocusHub(); 1654 auto listFocusHub = listNode->GetFocusHub(); 1655 ASSERT_NE(listFocusHub, nullptr); 1656 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 1657 ASSERT_NE(mockRenderContext, nullptr); 1658 auto mockRenderContextSec = AceType::MakeRefPtr<MockRenderContext>(); 1659 ASSERT_NE(mockRenderContextSec, nullptr); 1660 mockRenderContextSec->rect_ = RectF(10, 3, 2, 2); 1661 frameNode->renderContext_ = mockRenderContextSec; 1662 listNode->renderContext_ = mockRenderContext; 1663 mockRenderContext->rect_ = RectF(10, 5, 10, 10); 1664 frameNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1665 frameNode->geometryNode_->SetFrameSize(SizeF(2, 2)); 1666 listNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1667 listNode->geometryNode_->SetFrameSize(SizeF(10, 10)); 1668 1669 ASSERT_TRUE(focusHub->ScrollByOffsetToParent(listNode)); 1670 } 1671 1672 /** 1673 * @tc.name: FocusHubTestNgtest028 1674 * @tc.desc: Test the function ScrollByOffsetToParent. 1675 * @tc.type: FUNC 1676 */ 1677 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest028, TestSize.Level1) 1678 { 1679 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102, AceType::MakeRefPtr<ButtonPattern>()); 1680 ASSERT_NE(frameNode, nullptr); 1681 frameNode->GetOrCreateFocusHub(); 1682 auto focusHub = frameNode->GetFocusHub(); 1683 ASSERT_NE(focusHub, nullptr); 1684 1685 auto listNode = FrameNodeOnTree::CreateFrameNode("frameNode", 104, AceType::MakeRefPtr<ListPattern>()); 1686 ASSERT_NE(listNode, nullptr); 1687 listNode->GetOrCreateFocusHub(); 1688 auto listFocusHub = listNode->GetFocusHub(); 1689 ASSERT_NE(listFocusHub, nullptr); 1690 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 1691 ASSERT_NE(mockRenderContext, nullptr); 1692 auto mockRenderContext2 = AceType::MakeRefPtr<MockRenderContext>(); 1693 ASSERT_NE(mockRenderContext2, nullptr); 1694 mockRenderContext2->rect_ = RectF(10, -5, 5, 5); 1695 frameNode->renderContext_ = mockRenderContext2; 1696 listNode->renderContext_ = mockRenderContext; 1697 mockRenderContext->rect_ = RectF(10, 10, 15, 15); 1698 frameNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1699 frameNode->geometryNode_->SetFrameSize(SizeF(5, 5)); 1700 listNode->geometryNode_ = AceType::MakeRefPtr<GeometryNode>(); 1701 listNode->geometryNode_->SetFrameSize(SizeF(15, 15)); 1702 ASSERT_TRUE(focusHub->ScrollByOffsetToParent(listNode)); 1703 frameNode->geometryNode_->SetFrameSize(SizeF(25, 25)); 1704 EXPECT_FALSE(focusHub->ScrollByOffsetToParent(listNode)); 1705 } 1706 1707 /** 1708 * @tc.name: FocusHubTestNgtest029 1709 * @tc.desc: Test the function SetNextFocus and RequestUserNextFocus. 1710 * @tc.type: FUNC 1711 */ 1712 HWTEST_F(FocusHubTestNg, FocusHubTestNgtest029, TestSize.Level1) 1713 { 1714 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102, AceType::MakeRefPtr<ButtonPattern>()); 1715 ASSERT_NE(frameNode, nullptr); 1716 frameNode->GetOrCreateFocusHub(); 1717 auto focusHub = frameNode->GetFocusHub(); 1718 ASSERT_NE(focusHub, nullptr); 1719 focusHub->SetNextFocus(FocusIntension::RIGHT, "Node"); 1720 KeyEvent keyEvent; 1721 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT); 1722 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB); 1723 FocusEvent event(keyEvent); 1724 event.intension = FocusIntension::RIGHT; 1725 EXPECT_FALSE(focusHub->RequestUserNextFocus(event)); 1726 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 104, AceType::MakeRefPtr<ButtonPattern>()); 1727 ASSERT_NE(frameNode2, nullptr); 1728 focusHub->SetNextFocus(FocusIntension::LEFT, frameNode2); 1729 event.intension = FocusIntension::LEFT; 1730 EXPECT_TRUE(focusHub->RequestUserNextFocus(event)); 1731 event.intension = FocusIntension::UP; 1732 EXPECT_FALSE(focusHub->RequestUserNextFocus(event)); 1733 auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 106, AceType::MakeRefPtr<ButtonPattern>()); 1734 ASSERT_NE(frameNode3, nullptr); 1735 frameNode3->GetOrCreateFocusHub(); 1736 auto focusHub2 = frameNode3->GetFocusHub(); 1737 auto context = PipelineContext::GetCurrentContext(); 1738 ASSERT_NE(context, nullptr); 1739 context->SetIsFocusingByTab(true); 1740 focusHub2->SetFocusType(FocusType::DISABLE); 1741 focusHub2->currentFocus_ = false; 1742 focusHub->SetNextFocus(FocusIntension::DOWN, frameNode3); 1743 event.intension = FocusIntension::DOWN; 1744 EXPECT_FALSE(focusHub->RequestUserNextFocus(event)); 1745 } 1746 1747 /** 1748 * @tc.name: GetUnicodeTest001 1749 * @tc.desc: Test GetUnicode. 1750 * @tc.type: FUNC 1751 */ 1752 HWTEST_F(FocusHubTestNg, GetUnicodeTest001, TestSize.Level1) 1753 { 1754 KeyEvent keyEvent; 1755 auto defaultInfo = KeyEventInfo(keyEvent); 1756 /** 1757 * @tc.steps: step1. Get the default unicode. 1758 * @tc.expected: default unicode is 0. 1759 */ 1760 EXPECT_EQ(defaultInfo.GetUnicode(), 0); 1761 1762 /** 1763 * @tc.steps: step2. Set the Unicode value to 98. 1764 * @tc.expected: get unicode value is 98. 1765 */ 1766 keyEvent.unicode = 98; 1767 auto info = KeyEventInfo(keyEvent); 1768 EXPECT_EQ(info.GetUnicode(), 98); 1769 } 1770 } // namespace OHOS::Ace::NG 1771