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 "test/unittest/core/event/focus_hub_test_ng.h" 16 17 using namespace testing; 18 using namespace testing::ext; 19 20 namespace OHOS::Ace::NG { 21 /** 22 * @tc.name: FocusHubTestNg0043 23 * @tc.desc: Test the function SwitchFocus. 24 * @tc.type: FUNC 25 */ 26 HWTEST_F(FocusHubTestNg, FocusHubTestNg0043, TestSize.Level1) 27 { 28 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 29 AceType::MakeRefPtr<Pattern>()); 30 auto frameNode2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_COMPONENT_TAG, -1, 31 AceType::MakeRefPtr<Pattern>()); 32 auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1, 33 AceType::MakeRefPtr<FlexLayoutPattern>()); 34 frameNode->GetOrCreateFocusHub(); 35 frameNode2->GetOrCreateFocusHub(); 36 nodeParent->GetOrCreateFocusHub(); 37 frameNode->SetParent(nodeParent); 38 frameNode2->SetParent(nodeParent); 39 40 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 41 eventHub->AttachHost(frameNode); 42 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 43 auto parent = focusHub->GetParentFocusHub(); 44 parent->focusType_ = FocusType::NODE; 45 parent->SwitchFocus(focusHub); 46 parent->focusType_ = FocusType::SCOPE; 47 parent->SwitchFocus(focusHub); 48 EXPECT_NE(focusHub->focusType_, FocusType::SCOPE); 49 parent->currentFocus_ = true; 50 frameNode->AddChild(frameNode2); 51 frameNode2->focusHub_ = focusHub; 52 parent->SwitchFocus(focusHub); 53 EXPECT_TRUE(parent->currentFocus_); 54 } 55 56 /** 57 * @tc.name: FocusHubTestNg0046 58 * @tc.desc: Test the function TriggerFocusScroll. 59 * @tc.type: FUNC 60 */ 61 HWTEST_F(FocusHubTestNg, FocusHubTestNg0046, TestSize.Level1) 62 { 63 /** 64 * @tc.steps: step1. Create frameNode. 65 */ 66 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 67 AceType::MakeRefPtr<Pattern>()); 68 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 69 eventHub->AttachHost(frameNode); 70 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 71 ASSERT_NE(focusHub, nullptr); 72 auto context = PipelineContext::GetCurrentContext(); 73 ASSERT_NE(context, nullptr); 74 context->isFocusActive_ = true; 75 focusHub->isFocusUnit_ = true; 76 auto parentNode = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1, 77 AceType::MakeRefPtr<Pattern>()); 78 auto parentFocusHub = parentNode->GetOrCreateFocusHub(); 79 parentFocusHub->focusType_ = FocusType::SCOPE; 80 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode)); __anonb1b74d190102() 81 focusHub->onPaintFocusStateCallback_ = []() { return true; }; 82 focusHub->PaintAllFocusState(); 83 focusHub->TriggerFocusScroll(); 84 focusHub->focusType_ = FocusType::DISABLE; 85 focusHub->isFocusUnit_ = false; 86 focusHub->TriggerFocusScroll(); 87 EXPECT_FALSE(focusHub->isFocusUnit_); 88 } 89 90 /** 91 * @tc.name: FocusHubTestNg0047 92 * @tc.desc: Test the function CalculatePosition and PaintAllFocusState. 93 * @tc.type: FUNC 94 */ 95 HWTEST_F(FocusHubTestNg, FocusHubTestNg0047, TestSize.Level1) 96 { 97 /** 98 * @tc.steps: step1. Create frameNode. 99 */ 100 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 101 AceType::MakeRefPtr<Pattern>()); 102 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 103 AceType::MakeRefPtr<Pattern>()); 104 auto eventHub = AceType::MakeRefPtr<EventHub>(); 105 auto eventHub1 = AceType::MakeRefPtr<EventHub>(); 106 eventHub->AttachHost(frameNode); 107 eventHub1->AttachHost(frameNode1); 108 auto focusHub = frameNode->GetOrCreateFocusHub(); 109 auto focusHub1 = frameNode1->GetOrCreateFocusHub(); 110 std::list<RefPtr<FocusHub>> focusNodes; 111 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 112 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 113 focusHub->ClearAllFocusState(); 114 focusHub->PaintAllFocusState(); 115 focusHub->CalculatePosition(); 116 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 117 EXPECT_FALSE(focusHub->CalculatePosition()); 118 focusHub->focusStyleType_ = FocusStyleType::NONE; 119 focusHub->isFocusActiveWhenFocused_ = true; 120 EXPECT_FALSE(focusHub->PaintAllFocusState()); 121 EXPECT_FALSE(focusHub->CalculatePosition()); 122 } 123 124 /** 125 * @tc.name: FocusHubTestNg0048 126 * @tc.desc: Test the function ClearFocusState. 127 * @tc.type: FUNC 128 */ 129 HWTEST_F(FocusHubTestNg, FocusHubTestNg0048, TestSize.Level1) 130 { 131 /** 132 * @tc.steps: step1. Create frameNode. 133 */ 134 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 135 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); 136 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>())); 137 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 138 AceType::MakeRefPtr<Pattern>()); 139 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 140 AceType::MakeRefPtr<ButtonPattern>()); 141 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 142 AceType::MakeRefPtr<ButtonPattern>()); 143 child->GetOrCreateFocusHub(); 144 child2->GetOrCreateFocusHub(); 145 frameNode->AddChild(child); 146 frameNode->AddChild(child2); 147 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 148 eventHub->AttachHost(frameNode); 149 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 150 auto context = PipelineContext::GetCurrentContext(); 151 ASSERT_NE(context, nullptr); 152 RoundRect focusRectInner; 153 context->isFocusActive_ = true; 154 focusHub->focusType_ = FocusType::NODE; 155 EXPECT_FALSE(focusHub->PaintInnerFocusState(focusRectInner)); 156 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER; 157 std::list<RefPtr<FocusHub>> focusNodes; 158 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 159 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 160 EXPECT_TRUE(focusHub->PaintInnerFocusState(focusRectInner)); 161 focusHub->focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>(); 162 focusHub->focusPaintParamsPtr_->paintColor = Color::RED; 163 focusHub->focusPaintParamsPtr_->paintWidth = Dimension(10); 164 EXPECT_TRUE(focusHub->PaintInnerFocusState(focusRectInner)); 165 } 166 167 /** 168 * @tc.name: FocusHubTestNg0049 169 * @tc.desc: Test the function PaintFocusState. 170 * @tc.type: FUNC 171 */ 172 HWTEST_F(FocusHubTestNg, FocusHubTestNg0049, TestSize.Level1) 173 { 174 /** 175 * @tc.steps: step1. Create frameNode. 176 */ 177 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 178 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); 179 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>())); 180 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 181 AceType::MakeRefPtr<Pattern>()); 182 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 183 AceType::MakeRefPtr<ButtonPattern>()); 184 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 185 AceType::MakeRefPtr<ButtonPattern>()); 186 child->GetOrCreateFocusHub(); 187 child2->GetOrCreateFocusHub(); 188 frameNode->AddChild(child); 189 frameNode->AddChild(child2); 190 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 191 eventHub->AttachHost(frameNode); 192 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 193 auto context = PipelineContext::GetCurrentContext(); 194 ASSERT_NE(context, nullptr); 195 context->isFocusActive_ = true; 196 focusHub->focusType_ = FocusType::NODE; 197 std::list<RefPtr<FocusHub>> focusNodes; 198 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 199 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 200 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION; 201 RoundRect paintRect; __anonb1b74d190202(RoundRect) 202 focusHub->getInnerFocusRectFunc_ = [](RoundRect) {}; 203 EXPECT_FALSE(focusHub->PaintFocusState(false)); 204 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_BORDER; 205 EXPECT_FALSE(focusHub->PaintFocusState(false)); 206 focusHub->focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>(); 207 focusHub->focusPaintParamsPtr_->paintColor = Color::RED; 208 focusHub->focusPaintParamsPtr_->paintWidth = Dimension(10); 209 focusHub->focusPaintParamsPtr_->paintRect = RoundRect(RectF(), 0.0f, 0.0f); 210 EXPECT_TRUE(focusHub->PaintFocusState(false)); 211 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER; 212 EXPECT_TRUE(focusHub->PaintFocusState(false)); 213 focusHub->focusStyleType_ = FocusStyleType::INNER_BORDER; 214 EXPECT_TRUE(focusHub->PaintFocusState(false)); 215 focusHub->focusPaintParamsPtr_->focusPadding = Dimension(10); 216 EXPECT_TRUE(focusHub->PaintFocusState(false)); 217 } 218 219 /** 220 * @tc.name: FocusHubTestNg0050 221 * @tc.desc: Test the function ScrollToLastFocusIndex. 222 * @tc.type: FUNC 223 */ 224 HWTEST_F(FocusHubTestNg, FocusHubTestNg0050, TestSize.Level1) 225 { 226 /** 227 * @tc.steps: step1. Create frameNode. 228 */ 229 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 230 AceType::MakeRefPtr<Pattern>()); 231 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 232 eventHub->AttachHost(frameNode); 233 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 234 ASSERT_NE(focusHub, nullptr); 235 focusHub->currentFocus_ = true; 236 auto parentNode = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1, 237 AceType::MakeRefPtr<Pattern>()); 238 auto parentFocusHub = parentNode->GetOrCreateFocusHub(); 239 parentFocusHub->focusType_ = FocusType::SCOPE; 240 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode)); 241 focusHub->SetLastFocusNodeIndex(focusHub); 242 focusHub->ScrollToLastFocusIndex(); 243 focusHub->lastFocusNodeIndex_ = 1; 244 focusHub->ScrollToLastFocusIndex(); 245 EXPECT_NE(focusHub->focusType_, FocusType::SCOPE); 246 } 247 248 /** 249 * @tc.name: FocusHubTestNg0051 250 * @tc.desc: Test the function RequestFocus. 251 * @tc.type: FUNC 252 */ 253 HWTEST_F(FocusHubTestNg, FocusHubTestNg0051, TestSize.Level1) 254 { 255 /** 256 * @tc.steps: step1. Create frameNode. 257 */ 258 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 259 AceType::MakeRefPtr<Pattern>()); 260 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 261 eventHub->AttachHost(frameNode); 262 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 263 ASSERT_NE(focusHub, nullptr); 264 focusHub->RequestFocus(); 265 focusHub->currentFocus_ = true; 266 focusHub->RequestFocus(); 267 EXPECT_TRUE(focusHub->currentFocus_); 268 } 269 270 /** 271 * @tc.name: FocusHubTestNg0052 272 * @tc.desc: Test the function FocusToHeadOrTailChild. 273 * @tc.type: FUNC 274 */ 275 HWTEST_F(FocusHubTestNg, FocusHubTestNg0052, TestSize.Level1) 276 { 277 /** 278 * @tc.steps: step1. Create frameNode. 279 */ 280 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 281 AceType::MakeRefPtr<Pattern>()); 282 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 283 eventHub->AttachHost(frameNode); 284 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 285 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION; 286 std::list<RefPtr<FocusHub>> focusNodes; 287 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 288 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 289 auto parentNode = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1, 290 AceType::MakeRefPtr<Pattern>()); 291 auto parentFocusHub = parentNode->GetOrCreateFocusHub(); 292 parentFocusHub->focusType_ = FocusType::SCOPE; 293 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode)); 294 focusHub->focusType_ = FocusType::NODE; 295 EXPECT_FALSE(focusHub->FocusToHeadOrTailChild(true)); 296 focusHub->focusType_ = FocusType::SCOPE; 297 EXPECT_FALSE(focusHub->FocusToHeadOrTailChild(false)); 298 } 299 300 /** 301 * @tc.name: FocusHubTestNg0054 302 * @tc.desc: Test the function GoToNextFocusLinear. 303 * @tc.type: FUNC 304 */ 305 HWTEST_F(FocusHubTestNg, FocusHubTestNg0054, TestSize.Level1) 306 { 307 /** 308 * @tc.steps: step1. Create frameNode. 309 */ 310 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 311 AceType::MakeRefPtr<Pattern>()); 312 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 313 AceType::MakeRefPtr<ButtonPattern>()); 314 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 315 AceType::MakeRefPtr<ButtonPattern>()); 316 child->GetOrCreateFocusHub(); 317 child2->GetOrCreateFocusHub(); 318 frameNode->AddChild(child); 319 frameNode->AddChild(child2); 320 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 321 eventHub->AttachHost(frameNode); 322 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 323 focusHub->currentFocus_ = true; 324 std::list<RefPtr<FocusHub>> focusNodes; 325 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 326 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 327 EXPECT_FALSE(focusHub->GoToNextFocusLinear(FocusStep::LEFT)); 328 } 329 330 /** 331 * @tc.name: FocusHubTestNg0055 332 * @tc.desc: Test the function OnKeyEventScope. 333 * @tc.type: FUNC 334 */ 335 HWTEST_F(FocusHubTestNg, FocusHubTestNg0055, TestSize.Level1) 336 { 337 /** 338 * @tc.steps: step1. Create frameNode. 339 */ 340 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 341 AceType::MakeRefPtr<Pattern>()); 342 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 343 AceType::MakeRefPtr<Pattern>()); 344 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 345 RefPtr<EventHub> eventHub1 = AceType::MakeRefPtr<EventHub>(); 346 eventHub->AttachHost(frameNode); 347 eventHub1->AttachHost(frameNode1); 348 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 349 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub1))); 350 KeyEvent keyEvent; 351 std::list<RefPtr<FocusHub>> focusNodes; 352 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 353 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 354 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 355 auto pipeline = PipelineContext::GetCurrentContext(); 356 focusHub->currentFocus_ = false; 357 pipeline->isFocusActive_ = true; 358 keyEvent.action = KeyAction::DOWN; 359 keyEvent.code = KeyCode::KEY_TAB; 360 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 361 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 362 pipeline->eventManager_->isTabJustTriggerOnKeyEvent_ = true; 363 focusHub->currentFocus_ = true; 364 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 365 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT); 366 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB); 367 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 368 } 369 370 /** 371 * @tc.name: FocusHubTestNg0056 372 * @tc.desc: Test the function RequestNextFocus. 373 * @tc.type: FUNC 374 */ 375 HWTEST_F(FocusHubTestNg, FocusHubTestNg0056, TestSize.Level1) 376 { 377 /** 378 * @tc.steps: step1. Create frameNode. 379 */ 380 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 381 AceType::MakeRefPtr<Pattern>()); 382 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 383 AceType::MakeRefPtr<ButtonPattern>()); 384 child->GetOrCreateFocusHub(); 385 frameNode->AddChild(child); 386 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 387 RefPtr<EventHub> eventHub1 = AceType::MakeRefPtr<EventHub>(); 388 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 389 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub1))); 390 std::list<RefPtr<FocusHub>> focusNodes; 391 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 392 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 393 focusHub->focusAlgorithm_.scopeType = ScopeType::PROJECT_AREA; 394 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 395 EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::LEFT)); 396 EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::SHIFT_TAB)); 397 focusHub->focusAlgorithm_.getNextFocusNode = [](FocusStep, const WeakPtr<FocusHub>&, WeakPtr<FocusHub>&) __anonb1b74d190302(FocusStep, const WeakPtr<FocusHub>&, WeakPtr<FocusHub>&) 398 -> bool { return false; }; 399 EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::TAB)); 400 } 401 402 /** 403 * @tc.name: FocusHubTestNg0057 404 * @tc.desc: Test the function GetNearestNodeByProjectArea. 405 * @tc.type: FUNC 406 */ 407 HWTEST_F(FocusHubTestNg, FocusHubTestNg0057, TestSize.Level1) 408 { 409 /** 410 * @tc.steps: step1. Create frameNode. 411 */ 412 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 413 AceType::MakeRefPtr<Pattern>()); 414 auto frameNode2 = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>()); 415 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 416 AceType::MakeRefPtr<ButtonPattern>()); 417 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 418 AceType::MakeRefPtr<ButtonPattern>()); 419 child->GetOrCreateFocusHub(); 420 child2->GetOrCreateFocusHub(); 421 frameNode->AddChild(child); 422 frameNode->AddChild(child2); 423 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 424 RefPtr<EventHub> eventHub2 = AceType::MakeRefPtr<EventHub>(); 425 eventHub->AttachHost(frameNode); 426 eventHub2->AttachHost(frameNode2); 427 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 428 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub2))); 429 focusHub->currentFocus_ = true; 430 std::list<RefPtr<FocusHub>> focusNodes; 431 focusNodes.emplace_back(focusHub2); 432 EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::NONE), nullptr); 433 EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::TAB), nullptr); 434 EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::SHIFT_TAB), nullptr); 435 } 436 437 /** 438 * @tc.name: FocusHubTestNg058 439 * @tc.desc: Test the function HandleFocusByTabIndex. 440 * @tc.type: FUNC 441 */ 442 HWTEST_F(FocusHubTestNg, FocusHubTestNg0058, TestSize.Level1) 443 { 444 /** 445 * @tc.steps1: initialize parameters. 446 */ 447 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 448 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 449 KeyEvent keyEvent; 450 TabIndexNodeList tabIndexNodes; 451 keyEvent.action = KeyAction::DOWN; 452 keyEvent.code = KeyCode::KEY_TAB; 453 focusHub->currentFocus_ = true; 454 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent)); 455 } 456 457 /** 458 * @tc.name: FocusHubTestNg059 459 * @tc.desc: Test the function HandleFocusByTabIndex. 460 * @tc.type: FUNC 461 */ 462 HWTEST_F(FocusHubTestNg, FocusHubTestNg0059, TestSize.Level1) 463 { 464 /** 465 * @tc.steps1: create focusHub and construct allNodes. 466 */ 467 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>()); 468 frameNode->GetOrCreateFocusHub(); 469 auto focusHub = frameNode->GetFocusHub(); 470 frameNode->geometryNode_->SetFrameSize(SizeF(20, 20)); 471 frameNode->geometryNode_->SetFrameOffset(OffsetF(20, 20)); 472 ASSERT_NE(focusHub, nullptr); 473 std::list<RefPtr<FocusHub>> allNodes; 474 475 auto focus1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim<EventHub>(nullptr), FocusType::NODE, true); 476 477 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode2", 102, 478 AceType::MakeRefPtr<ButtonPattern>()); 479 frameNode2->GetOrCreateFocusHub(); 480 auto focusHub2 = frameNode2->GetFocusHub(); 481 frameNode2->geometryNode_->SetFrameOffset(OffsetF(15, 15)); 482 frameNode2->geometryNode_->SetFrameSize(SizeF(30, 30)); 483 484 auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode3", 103, 485 AceType::MakeRefPtr<ButtonPattern>()); 486 frameNode3->GetOrCreateFocusHub(); 487 auto focusHub3 = frameNode3->GetFocusHub(); 488 frameNode3->geometryNode_->SetFrameOffset(OffsetF(20, 20)); 489 frameNode3->geometryNode_->SetFrameSize(SizeF(30, 30)); 490 491 auto frameNode4 = FrameNodeOnTree::CreateFrameNode("frameNode4", 104, 492 AceType::MakeRefPtr<ButtonPattern>()); 493 frameNode4->GetOrCreateFocusHub(); 494 auto focusHub4 = frameNode4->GetFocusHub(); 495 frameNode4->geometryNode_->SetFrameOffset(OffsetF(10, 20)); 496 frameNode4->geometryNode_->SetFrameSize(SizeF(20, 20)); 497 498 auto frameNode5 = FrameNodeOnTree::CreateFrameNode("frameNode5", 105, 499 AceType::MakeRefPtr<ButtonPattern>()); 500 frameNode5->GetOrCreateFocusHub(); 501 auto focusHub5 = frameNode5->GetFocusHub(); 502 frameNode5->geometryNode_->SetFrameOffset(OffsetF(20, 20)); 503 frameNode5->geometryNode_->SetFrameSize(SizeF(30, 30)); 504 505 allNodes.push_back(nullptr); 506 allNodes.push_back(focus1); 507 allNodes.push_back(focusHub); 508 allNodes.push_back(focusHub2); 509 allNodes.push_back(focusHub3); 510 allNodes.push_back(focusHub4); 511 allNodes.push_back(focusHub5); 512 513 auto res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::UP); 514 ASSERT_NE(res, nullptr); 515 res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::DOWN); 516 ASSERT_NE(res, nullptr); 517 res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::LEFT); 518 ASSERT_NE(res, nullptr); 519 res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::RIGHT); 520 ASSERT_NE(res, nullptr); 521 } 522 523 /** 524 * @tc.name: FocusHubTestNg064 525 * @tc.desc: Test the function CollectTabIndexNodes. 526 * @tc.type: FUNC 527 */ 528 HWTEST_F(FocusHubTestNg, FocusHubTestNg0064, TestSize.Level1) 529 { 530 /** 531 * @tc.steps1: create focusHub and construct allNodes. 532 */ 533 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 534 AceType::MakeRefPtr<ButtonPattern>()); 535 frameNode->GetOrCreateFocusHub(); 536 auto focusHub = frameNode->GetFocusHub(); 537 ASSERT_NE(focusHub, nullptr); 538 539 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 540 AceType::MakeRefPtr<ButtonPattern>()); 541 frameNode1->GetOrCreateFocusHub(); 542 auto focusHub1 = frameNode1->GetFocusHub(); 543 544 frameNode->children_.push_back(frameNode1); 545 focusHub->focusable_ = true; 546 focusHub->parentFocusable_ = true; 547 focusHub->focusType_ = FocusType::SCOPE; 548 549 focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 550 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 551 focusHub1->focusable_ = true; 552 focusHub1->parentFocusable_ = true; 553 focusHub1->focusType_ = FocusType::NODE; 554 focusHub1->focusCallbackEvents_->tabIndex_ = 1; 555 556 TabIndexNodeList list; 557 focusHub->CollectTabIndexNodes(list); 558 ASSERT_FALSE(list.empty()); 559 560 focusHub->focusCallbackEvents_->tabIndex_ = 1; 561 focusHub->CollectTabIndexNodes(list); 562 ASSERT_FALSE(list.empty()); 563 } 564 565 /** 566 * @tc.name: FocusHubTestNg065 567 * @tc.desc: Test the function AcceptFocusByRectOfLastFocusFlex. 568 * @tc.type: FUNC 569 */ 570 HWTEST_F(FocusHubTestNg, FocusHubTestNg0065, TestSize.Level1) 571 { 572 /** 573 * @tc.steps1: create focusHub and construct allNodes. 574 */ 575 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 576 AceType::MakeRefPtr<ButtonPattern>()); 577 frameNode->GetOrCreateFocusHub(); 578 auto focusHub = frameNode->GetFocusHub(); 579 ASSERT_NE(focusHub, nullptr); 580 581 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 582 AceType::MakeRefPtr<ButtonPattern>()); 583 frameNode1->GetOrCreateFocusHub(); 584 auto focusHub1 = frameNode1->GetFocusHub(); 585 586 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 587 AceType::MakeRefPtr<ButtonPattern>()); 588 frameNode2->GetOrCreateFocusHub(); 589 auto focusHub2 = frameNode2->GetFocusHub(); 590 591 auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 592 AceType::MakeRefPtr<ButtonPattern>()); 593 frameNode3->GetOrCreateFocusHub(); 594 auto focusHub3 = frameNode3->GetFocusHub(); 595 596 auto frameNode4 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 597 AceType::MakeRefPtr<ButtonPattern>()); 598 frameNode4->GetOrCreateFocusHub(); 599 auto focusHub4 = frameNode4->GetFocusHub(); 600 601 focusHub1->focusable_ = false; 602 frameNode2->geometryNode_ = nullptr; 603 focusHub3->currentFocus_ = true; 604 605 focusHub->focusable_ = true; 606 focusHub->parentFocusable_ = true; 607 focusHub->focusType_ = FocusType::SCOPE; 608 frameNode->children_.push_back(frameNode1); 609 frameNode->children_.push_back(frameNode2); 610 frameNode->children_.push_back(frameNode3); 611 frameNode->children_.push_back(frameNode4); 612 613 auto res = focusHub->AcceptFocusByRectOfLastFocusFlex(RectF(0, 0, -1, -1)); 614 ASSERT_FALSE(res); 615 focusHub->AcceptFocusByRectOfLastFocusFlex(RectF()); 616 focusHub->focusDepend_ = FocusDependence::SELF; 617 focusHub->focusType_ = FocusType::DISABLE; 618 res = focusHub->AcceptFocusByRectOfLastFocusFlex(RectF(0, 0, -1, -1)); 619 ASSERT_FALSE(res); 620 } 621 622 /** 623 * @tc.name: FocusHubTestNg067 624 * @tc.desc: Test the function GetChildFocusNodeByType. 625 * @tc.type: FUNC 626 */ 627 HWTEST_F(FocusHubTestNg, FocusHubTestNg0067, TestSize.Level1) 628 { 629 /** 630 * @tc.steps1: create focusHub and construct allNodes. 631 */ 632 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 633 AceType::MakeRefPtr<ButtonPattern>()); 634 frameNode->GetOrCreateFocusHub(); 635 auto focusHub = frameNode->GetFocusHub(); 636 ASSERT_NE(focusHub, nullptr); 637 638 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 639 AceType::MakeRefPtr<ButtonPattern>()); 640 frameNode1->GetOrCreateFocusHub(); 641 auto focusHub1 = frameNode1->GetFocusHub(); 642 643 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 644 AceType::MakeRefPtr<ButtonPattern>()); 645 frameNode2->GetOrCreateFocusHub(); 646 auto focusHub2 = frameNode2->GetFocusHub(); 647 648 auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 649 AceType::MakeRefPtr<ButtonPattern>()); 650 frameNode3->GetOrCreateFocusHub(); 651 auto focusHub3 = frameNode3->GetFocusHub(); 652 653 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 654 focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 655 focusHub3->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 656 657 focusHub3->focusCallbackEvents_->isDefaultGroupFocus_ = false; 658 focusHub1->focusCallbackEvents_->isDefaultGroupFocus_ = true; 659 660 focusHub->focusType_ = FocusType::SCOPE; 661 frameNode->children_.push_back(frameNode3); 662 frameNode->children_.push_back(frameNode1); 663 664 auto res = focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT); 665 ASSERT_NE(res, nullptr); 666 } 667 668 /** 669 * @tc.name: FocusHubTestNg068 670 * @tc.desc: Test the function GoToFocusByTabNodeIdx. 671 * @tc.type: FUNC 672 */ 673 HWTEST_F(FocusHubTestNg, FocusHubTestNg0068, TestSize.Level1) 674 { 675 /** 676 * @tc.steps1: create focusHub and construct allNodes. 677 */ 678 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 679 AceType::MakeRefPtr<ButtonPattern>()); 680 frameNode->GetOrCreateFocusHub(); 681 auto focusHub = frameNode->GetFocusHub(); 682 ASSERT_NE(focusHub, nullptr); 683 684 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 685 AceType::MakeRefPtr<ButtonPattern>()); 686 frameNode1->GetOrCreateFocusHub(); 687 auto focusHub1 = frameNode1->GetFocusHub(); 688 689 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 690 AceType::MakeRefPtr<ButtonPattern>()); 691 frameNode2->GetOrCreateFocusHub(); 692 auto focusHub2 = frameNode2->GetFocusHub(); 693 694 auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 695 AceType::MakeRefPtr<ButtonPattern>()); 696 frameNode3->GetOrCreateFocusHub(); 697 auto focusHub3 = frameNode3->GetFocusHub(); 698 699 auto frameNode4 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 700 AceType::MakeRefPtr<ButtonPattern>()); 701 frameNode4->GetOrCreateFocusHub(); 702 auto focusHub4 = frameNode4->GetFocusHub(); 703 704 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 705 focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 706 focusHub3->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 707 focusHub4->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 708 709 frameNode4->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode2)); 710 focusHub1->focusType_ = FocusType::SCOPE; 711 focusHub2->focusType_ = FocusType::SCOPE; 712 focusHub3->focusCallbackEvents_->isDefaultGroupFocus_ = true; 713 focusHub4->focusCallbackEvents_->isDefaultGroupFocus_ = true; 714 focusHub2->focusable_ = false; 715 716 frameNode1->children_.push_back(frameNode3); 717 frameNode2->children_.push_back(frameNode4); 718 719 TabIndexNodeList list; 720 list.push_back({1, AceType::WeakClaim(AceType::RawPtr(focusHub1))}); 721 list.push_back({2, AceType::WeakClaim(AceType::RawPtr(focusHub2))}); 722 723 focusHub->focusType_ = FocusType::SCOPE; 724 auto res = focusHub->GoToFocusByTabNodeIdx(list, 0); 725 ASSERT_TRUE(res); 726 res = focusHub->GoToFocusByTabNodeIdx(list, 1); 727 ASSERT_FALSE(res); 728 } 729 730 /** 731 * @tc.name: FocusHubTestNg069 732 * @tc.desc: Test the function CollectTabIndexNodes. 733 * @tc.type: FUNC 734 */ 735 HWTEST_F(FocusHubTestNg, FocusHubTestNg0069, TestSize.Level1) 736 { 737 /** 738 * @tc.steps1: create focusHub and construct allNodes. 739 */ 740 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 741 AceType::MakeRefPtr<ButtonPattern>()); 742 frameNode->GetOrCreateFocusHub(); 743 auto focusHub = frameNode->GetFocusHub(); 744 ASSERT_NE(focusHub, nullptr); 745 746 focusHub->focusable_ = false; 747 focusHub->focusType_ = FocusType::SCOPE; 748 TabIndexNodeList list; 749 focusHub->CollectTabIndexNodes(list); 750 ASSERT_TRUE(list.empty()); 751 } 752 753 /** 754 * @tc.name: FocusHubTestNg070 755 * @tc.desc: Test the function IsFocusableWholePath. 756 * @tc.type: FUNC 757 */ 758 HWTEST_F(FocusHubTestNg, FocusHubTestNg0070, TestSize.Level1) 759 { 760 /** 761 * @tc.steps1: create focusHub and construct allNodes. 762 */ 763 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 764 AceType::MakeRefPtr<ButtonPattern>()); 765 frameNode->GetOrCreateFocusHub(); 766 auto focusHub = frameNode->GetFocusHub(); 767 ASSERT_NE(focusHub, nullptr); 768 769 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 770 AceType::MakeRefPtr<ButtonPattern>()); 771 frameNode1->GetOrCreateFocusHub(); 772 auto focusHub1 = frameNode1->GetFocusHub(); 773 774 focusHub->focusType_ = FocusType::SCOPE; 775 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 776 frameNode->children_.push_back(frameNode1); 777 778 ASSERT_TRUE(focusHub->IsFocusableNode()); 779 ASSERT_TRUE(focusHub->IsFocusableScope()); 780 auto res = focusHub1->IsFocusableWholePath(); 781 ASSERT_TRUE(res); 782 } 783 784 /** 785 * @tc.name: FocusHubTestNg071 786 * @tc.desc: Test the function IsFocusableScopeByTab. 787 * @tc.type: FUNC 788 */ 789 HWTEST_F(FocusHubTestNg, FocusHubTestNg0071, TestSize.Level1) 790 { 791 /** 792 * @tc.steps1: create focusHub and construct allNodes. 793 */ 794 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 795 AceType::MakeRefPtr<ButtonPattern>()); 796 frameNode->GetOrCreateFocusHub(); 797 auto focusHub = frameNode->GetFocusHub(); 798 ASSERT_NE(focusHub, nullptr); 799 800 focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 801 focusHub->focusCallbackEvents_->tabIndex_ = 1; 802 803 auto res = focusHub->IsFocusableScopeByTab(); 804 ASSERT_FALSE(res); 805 } 806 807 /** 808 * @tc.name: FocusHubTestNg072 809 * @tc.desc: Test the function AcceptFocusOfSpecifyChild. 810 * @tc.type: FUNC 811 */ 812 HWTEST_F(FocusHubTestNg, FocusHubTestNg0072, TestSize.Level1) 813 { 814 /** 815 * @tc.steps1: create focusHub and construct allNodes. 816 */ 817 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 818 AceType::MakeRefPtr<ButtonPattern>()); 819 frameNode->GetOrCreateFocusHub(); 820 auto focusHub = frameNode->GetFocusHub(); 821 ASSERT_NE(focusHub, nullptr); 822 823 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 824 AceType::MakeRefPtr<ButtonPattern>()); 825 frameNode1->GetOrCreateFocusHub(); 826 auto focusHub1 = frameNode1->GetFocusHub(); 827 828 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 829 AceType::MakeRefPtr<ButtonPattern>()); 830 frameNode2->GetOrCreateFocusHub(); 831 auto focusHub2 = frameNode2->GetFocusHub(); 832 833 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 834 focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 835 836 focusHub->focusType_ = FocusType::SCOPE; 837 focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB); 838 frameNode->children_.push_back(frameNode1); 839 frameNode->children_.push_back(frameNode2); 840 focusHub1->focusable_ = false; 841 auto res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB); 842 ASSERT_TRUE(res); 843 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB); 844 ASSERT_TRUE(res); 845 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::DOWN); 846 ASSERT_FALSE(res); 847 focusHub2->focusable_ = false; 848 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB); 849 ASSERT_FALSE(res); 850 res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB); 851 ASSERT_FALSE(res); 852 } 853 854 /** 855 * @tc.name: FocusHubTestNg073 856 * @tc.desc: Test the function ClearAllFocusState. 857 * @tc.type: FUNC 858 */ 859 HWTEST_F(FocusHubTestNg, FocusHubTestNg0073, TestSize.Level1) 860 { 861 /** 862 * @tc.steps1: create focusHub and construct allNodes. 863 */ 864 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 865 AceType::MakeRefPtr<ButtonPattern>()); 866 frameNode->GetOrCreateFocusHub(); 867 auto focusHub = frameNode->GetFocusHub(); 868 ASSERT_NE(focusHub, nullptr); 869 870 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 871 AceType::MakeRefPtr<ButtonPattern>()); 872 frameNode1->GetOrCreateFocusHub(); 873 auto focusHub1 = frameNode1->GetFocusHub(); 874 875 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 876 focusHub->ClearAllFocusState(); 877 ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr); 878 879 /** 880 * @tc.steps: step1. Create frameNode. 881 */ 882 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 883 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); 884 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>())); 885 } 886 887 /** 888 * @tc.name: FocusHubTestNg074 889 * @tc.desc: Test the function PaintAllFocusState. 890 * @tc.type: FUNC 891 */ 892 HWTEST_F(FocusHubTestNg, FocusHubTestNg0074, TestSize.Level1) 893 { 894 /** 895 * @tc.steps1: create focusHub and construct allNodes. 896 */ 897 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 898 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); 899 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>())); 900 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 901 AceType::MakeRefPtr<ButtonPattern>()); 902 frameNode->GetOrCreateFocusHub(); 903 auto focusHub = frameNode->GetFocusHub(); 904 ASSERT_NE(focusHub, nullptr); 905 auto context = PipelineContext::GetCurrentContext(); 906 context->isFocusActive_ = true; 907 908 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER; 909 auto res = focusHub->PaintAllFocusState(); 910 ASSERT_TRUE(res); 911 } 912 913 /** 914 * @tc.name: FocusHubTestNg075 915 * @tc.desc: Test the function PaintFocusState. 916 * @tc.type: FUNC 917 */ 918 HWTEST_F(FocusHubTestNg, FocusHubTestNg0075, TestSize.Level1) 919 { 920 /** 921 * @tc.steps1: create focusHub and construct allNodes. 922 */ 923 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 924 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager); 925 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>())); 926 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 927 AceType::MakeRefPtr<ButtonPattern>()); 928 frameNode->GetOrCreateFocusHub(); 929 auto focusHub = frameNode->GetFocusHub(); 930 ASSERT_NE(focusHub, nullptr); 931 auto context = PipelineContext::GetCurrentContext(); 932 context->isFocusActive_ = true; 933 __anonb1b74d190402(RoundRect& rect) 934 auto func = [](RoundRect& rect) { rect.rect_ = RectF(); }; 935 focusHub->getInnerFocusRectFunc_ = func; 936 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION; 937 auto res = focusHub->PaintFocusState(); 938 ASSERT_TRUE(res); 939 } 940 941 /** 942 * @tc.name: FocusHubTestNg076 943 * @tc.desc: Test the function OnFocusScope. 944 * @tc.type: FUNC 945 */ 946 HWTEST_F(FocusHubTestNg, FocusHubTestNg0076, TestSize.Level1) 947 { 948 /** 949 * @tc.steps1: create focusHub and construct allNodes. 950 */ 951 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 952 AceType::MakeRefPtr<ButtonPattern>()); 953 frameNode->GetOrCreateFocusHub(); 954 auto focusHub = frameNode->GetFocusHub(); 955 ASSERT_NE(focusHub, nullptr); 956 957 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 958 AceType::MakeRefPtr<ButtonPattern>()); 959 frameNode1->GetOrCreateFocusHub(); 960 auto focusHub1 = frameNode1->GetFocusHub(); 961 962 focusHub1->focusable_ =false; 963 focusHub->focusType_ = FocusType::SCOPE; 964 frameNode->children_.push_back(frameNode1); 965 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 966 focusHub->OnFocusScope(); 967 ASSERT_FALSE(focusHub1->focusable_); 968 } 969 970 /** 971 * @tc.name: FocusHubTestNg077 972 * @tc.desc: Test the function OnFocus. 973 * @tc.type: FUNC 974 */ 975 HWTEST_F(FocusHubTestNg, FocusHubTestNg0077, TestSize.Level1) 976 { 977 /** 978 * @tc.steps1: create focusHub and construct allNodes. 979 */ 980 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 981 AceType::MakeRefPtr<ButtonPattern>()); 982 frameNode->GetOrCreateFocusHub(); 983 auto focusHub = frameNode->GetFocusHub(); 984 ASSERT_NE(focusHub, nullptr); 985 986 focusHub->focusType_ = FocusType::DISABLE; 987 focusHub->OnFocus(); 988 ASSERT_EQ(focusHub->focusType_, FocusType::DISABLE); 989 } 990 991 /** 992 * @tc.name: FocusHubTestNg078 993 * @tc.desc: Test the function CalculatePosition. 994 * @tc.type: FUNC 995 */ 996 HWTEST_F(FocusHubTestNg, FocusHubTestNg0078, TestSize.Level1) 997 { 998 /** 999 * @tc.steps1: create focusHub and construct allNodes. 1000 */ 1001 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1002 AceType::MakeRefPtr<ButtonPattern>()); 1003 frameNode->GetOrCreateFocusHub(); 1004 auto focusHub = frameNode->GetFocusHub(); 1005 ASSERT_NE(focusHub, nullptr); 1006 1007 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1008 AceType::MakeRefPtr<ButtonPattern>()); 1009 frameNode1->GetOrCreateFocusHub(); 1010 auto focusHub1 = frameNode1->GetFocusHub(); 1011 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1012 frameNode1->geometryNode_ = nullptr; 1013 auto res = focusHub->CalculatePosition(); 1014 ASSERT_FALSE(res); 1015 } 1016 1017 /** 1018 * @tc.name: FocusHubTestNg079 1019 * @tc.desc: Test the function TryRequestFocus. 1020 * @tc.type: FUNC obsolete 1021 */ 1022 HWTEST_F(FocusHubTestNg, FocusHubTestNg0079, TestSize.Level1) 1023 { 1024 /** 1025 * @tc.steps1: create focusHub and construct allNodes. 1026 */ 1027 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1028 AceType::MakeRefPtr<ButtonPattern>()); 1029 frameNode->GetOrCreateFocusHub(); 1030 auto focusHub = frameNode->GetFocusHub(); 1031 ASSERT_NE(focusHub, nullptr); 1032 1033 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1034 AceType::MakeRefPtr<ButtonPattern>()); 1035 frameNode1->GetOrCreateFocusHub(); 1036 auto focusHub1 = frameNode1->GetFocusHub(); 1037 auto res = focusHub->TryRequestFocus(focusHub1, RectF(), FocusStep::LEFT); 1038 ASSERT_TRUE(res); 1039 } 1040 1041 /** 1042 * @tc.name: FocusHubTestNg080 1043 * @tc.desc: Test the function GoToNextFocusLinear. 1044 * @tc.type: FUNC 1045 */ 1046 HWTEST_F(FocusHubTestNg, FocusHubTestNg0080, TestSize.Level1) 1047 { 1048 /** 1049 * @tc.steps1: create focusHub and construct allNodes. 1050 */ 1051 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1052 AceType::MakeRefPtr<ButtonPattern>()); 1053 frameNode->GetOrCreateFocusHub(); 1054 auto focusHub = frameNode->GetFocusHub(); 1055 ASSERT_NE(focusHub, nullptr); 1056 1057 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1058 AceType::MakeRefPtr<ButtonPattern>()); 1059 frameNode1->GetOrCreateFocusHub(); 1060 auto focusHub1 = frameNode1->GetFocusHub(); 1061 1062 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1063 AceType::MakeRefPtr<ButtonPattern>()); 1064 frameNode2->GetOrCreateFocusHub(); 1065 auto focusHub2 = frameNode2->GetFocusHub(); 1066 1067 auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1068 AceType::MakeRefPtr<ButtonPattern>()); 1069 frameNode3->GetOrCreateFocusHub(); 1070 auto focusHub3 = frameNode3->GetFocusHub(); 1071 1072 auto frameNode4 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1073 AceType::MakeRefPtr<ButtonPattern>()); 1074 frameNode4->GetOrCreateFocusHub(); 1075 auto focusHub4 = frameNode4->GetFocusHub(); 1076 1077 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub4)); 1078 frameNode->children_.push_back(frameNode1); 1079 frameNode->children_.push_back(frameNode2); 1080 frameNode->children_.push_back(frameNode3); 1081 frameNode->children_.push_back(frameNode4); 1082 1083 focusHub3->focusable_ = false; 1084 1085 auto res = focusHub->GoToNextFocusLinear(FocusStep::SHIFT_TAB, RectF()); 1086 ASSERT_TRUE(res); 1087 focusHub2->focusable_ = false; 1088 res = focusHub->GoToNextFocusLinear(FocusStep::SHIFT_TAB, RectF()); 1089 ASSERT_TRUE(res); 1090 focusHub1->focusable_ = false; 1091 res = focusHub->GoToNextFocusLinear(FocusStep::SHIFT_TAB, RectF()); 1092 ASSERT_FALSE(res); 1093 focusHub->lastWeakFocusNode_ = AceType::WeakClaim<FocusHub>(nullptr); 1094 focusHub4->focusable_ = false; 1095 res = focusHub->GoToNextFocusLinear(FocusStep::TAB, RectF()); 1096 ASSERT_FALSE(res); 1097 } 1098 1099 /** 1100 * @tc.name: FocusHubTestNg081 1101 * @tc.desc: Test the function SwitchFocus. 1102 * @tc.type: FUNC 1103 */ 1104 HWTEST_F(FocusHubTestNg, FocusHubTestNg0081, TestSize.Level1) 1105 { 1106 /** 1107 * @tc.steps1: create focusHub and construct allNodes. 1108 */ 1109 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1110 AceType::MakeRefPtr<ButtonPattern>()); 1111 frameNode->GetOrCreateFocusHub(); 1112 auto focusHub = frameNode->GetFocusHub(); 1113 ASSERT_NE(focusHub, nullptr); 1114 1115 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1116 AceType::MakeRefPtr<ButtonPattern>()); 1117 frameNode1->GetOrCreateFocusHub(); 1118 auto focusHub1 = frameNode1->GetFocusHub(); 1119 1120 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1121 AceType::MakeRefPtr<ButtonPattern>()); 1122 frameNode2->GetOrCreateFocusHub(); 1123 auto focusHub2 = frameNode2->GetFocusHub(); 1124 1125 focusHub->currentFocus_ = true; 1126 focusHub->focusType_ = FocusType::SCOPE; 1127 frameNode->children_.push_back(frameNode1); 1128 frameNode->children_.push_back(frameNode2); 1129 focusHub->lastWeakFocusNode_ = AceType::WeakClaim<FocusHub>(nullptr); 1130 focusHub->SwitchFocus(focusHub2); 1131 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1132 focusHub1->currentFocus_ = true; 1133 focusHub->SwitchFocus(focusHub2); 1134 ASSERT_FALSE(focusHub1->currentFocus_); 1135 } 1136 1137 /** 1138 * @tc.name: FocusHubTestNg083 1139 * @tc.desc: Test the function FocusToHeadOrTailChild. 1140 * @tc.type: FUNC 1141 */ 1142 HWTEST_F(FocusHubTestNg, FocusHubTestNg0083, TestSize.Level1) 1143 { 1144 /** 1145 * @tc.steps1: create focusHub and construct allNodes. 1146 */ 1147 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1148 AceType::MakeRefPtr<ButtonPattern>()); 1149 frameNode->GetOrCreateFocusHub(); 1150 auto focusHub = frameNode->GetFocusHub(); 1151 ASSERT_NE(focusHub, nullptr); 1152 1153 auto res = focusHub->FocusToHeadOrTailChild(true); 1154 ASSERT_TRUE(res); 1155 } 1156 1157 /** 1158 * @tc.name: FocusHubTestNg0084 1159 * @tc.desc: Test the function OnKeyEventScope. 1160 * @tc.type: FUNC 1161 */ 1162 HWTEST_F(FocusHubTestNg, FocusHubTestNg0084, TestSize.Level1) 1163 { 1164 /** 1165 * @tc.steps: step1. Create frameNode. 1166 */ 1167 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1168 AceType::MakeRefPtr<Pattern>()); 1169 auto frameNode1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1170 AceType::MakeRefPtr<Pattern>()); 1171 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1172 RefPtr<EventHub> eventHub1 = AceType::MakeRefPtr<EventHub>(); 1173 eventHub->AttachHost(frameNode); 1174 eventHub1->AttachHost(frameNode1); 1175 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1176 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub1))); 1177 KeyEvent keyEvent; 1178 std::list<RefPtr<FocusHub>> focusNodes; 1179 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 1180 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 1181 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1182 auto pipeline = PipelineContext::GetCurrentContext(); 1183 focusHub->currentFocus_ = false; 1184 pipeline->isFocusActive_ = true; 1185 keyEvent.action = KeyAction::DOWN; 1186 keyEvent.code = KeyCode::KEY_TAB; 1187 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 1188 pipeline->eventManager_->isTabJustTriggerOnKeyEvent_ = true; 1189 focusHub->currentFocus_ = true; 1190 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT); 1191 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1192 keyEvent.code = KeyCode::TV_CONTROL_UP; 1193 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1194 keyEvent.code = KeyCode::TV_CONTROL_DOWN; 1195 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1196 keyEvent.code = KeyCode::TV_CONTROL_LEFT; 1197 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1198 keyEvent.code = KeyCode::TV_CONTROL_RIGHT; 1199 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1200 keyEvent.code = KeyCode::KEY_MOVE_HOME; 1201 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1202 keyEvent.code = KeyCode::KEY_MOVE_END; 1203 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1204 keyEvent.code = KeyCode::KEY_FOCUS; 1205 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1206 } 1207 1208 /** 1209 * @tc.name: FocusHubTestNg0091 1210 * @tc.desc: Test the function FocusToHeadOrTailChild. 1211 * @tc.type: FUNC 1212 */ 1213 HWTEST_F(FocusHubTestNg, FocusHubTestNg0091, TestSize.Level1) 1214 { 1215 /** 1216 * @tc.steps: step1. Create frameNode. 1217 */ 1218 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1219 AceType::MakeRefPtr<ButtonPattern>()); 1220 frameNode->GetOrCreateFocusHub(); 1221 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1222 eventHub->AttachHost(frameNode); 1223 auto focusHub = frameNode->GetFocusHub(); 1224 ASSERT_NE(focusHub, nullptr); 1225 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1226 AceType::MakeRefPtr<ButtonPattern>()); 1227 frameNode1->GetOrCreateFocusHub(); 1228 auto focusHub1 = frameNode1->GetFocusHub(); 1229 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION; 1230 focusHub->focusType_ = FocusType::SCOPE; 1231 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1232 frameNode->children_.push_back(frameNode1); 1233 ASSERT_TRUE(focusHub->IsFocusableNode()); 1234 ASSERT_TRUE(focusHub->IsFocusableScope()); 1235 focusHub->focusDepend_ = FocusDependence::AUTO; 1236 EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(true)); 1237 focusHub->focusDepend_ = FocusDependence::SELF; 1238 EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(false)); 1239 focusHub->focusDepend_ = FocusDependence::CHILD; 1240 EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(false)); 1241 } 1242 1243 /** 1244 * @tc.name: FocusHubTestNg0093 1245 * @tc.desc: Test the function IsNeedPaintFocusState. 1246 * @tc.type: FUNC 1247 */ 1248 HWTEST_F(FocusHubTestNg, FocusHubTestNg0093, TestSize.Level1) 1249 { 1250 /** 1251 * @tc.steps: step1. Create frameNode. 1252 */ 1253 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1254 AceType::MakeRefPtr<ButtonPattern>()); 1255 frameNode->GetOrCreateFocusHub(); 1256 auto focusHub = frameNode->GetFocusHub(); 1257 ASSERT_NE(focusHub, nullptr); 1258 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1259 AceType::MakeRefPtr<ButtonPattern>()); 1260 frameNode1->GetOrCreateFocusHub(); 1261 auto focusHub1 = frameNode1->GetFocusHub(); 1262 focusHub->focusType_ = FocusType::SCOPE; 1263 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1264 frameNode->children_.push_back(frameNode1); 1265 ASSERT_TRUE(focusHub->IsFocusableNode()); 1266 focusHub->currentFocus_ = true; 1267 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1268 ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr); 1269 EXPECT_TRUE(focusHub->IsNeedPaintFocusState()); 1270 focusHub->focusDepend_ = FocusDependence::SELF; 1271 EXPECT_TRUE(focusHub->IsNeedPaintFocusState()); 1272 focusHub->focusType_ = FocusType::NODE; 1273 EXPECT_TRUE(focusHub->IsNeedPaintFocusState()); 1274 } 1275 1276 /** 1277 * @tc.name: FocusHubTestNg0094 1278 * @tc.desc: Test the function HandleFocusByTabIndex. 1279 * @tc.type: FUNC 1280 */ 1281 HWTEST_F(FocusHubTestNg, FocusHubTestNg0094, TestSize.Level1) 1282 { 1283 /** 1284 * @tc.steps1: initialize parameters. 1285 */ 1286 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1287 AceType::MakeRefPtr<ButtonPattern>()); 1288 frameNode->GetOrCreateFocusHub(); 1289 auto focusHub = frameNode->GetFocusHub(); 1290 ASSERT_NE(focusHub, nullptr); 1291 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1292 AceType::MakeRefPtr<ButtonPattern>()); 1293 frameNode1->GetOrCreateFocusHub(); 1294 auto focusHub1 = frameNode1->GetFocusHub(); 1295 frameNode->children_.push_back(frameNode1); 1296 focusHub->focusable_ = true; 1297 focusHub->parentFocusable_ = true; 1298 focusHub->focusType_ = FocusType::SCOPE; 1299 focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 1300 focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>(); 1301 focusHub1->focusable_ = true; 1302 focusHub1->parentFocusable_ = true; 1303 focusHub1->focusType_ = FocusType::NODE; 1304 focusHub1->focusCallbackEvents_->tabIndex_ = 1; 1305 focusHub1->currentFocus_ = true; 1306 KeyEvent keyEvent; 1307 TabIndexNodeList tabIndexNodes; 1308 keyEvent.action = KeyAction::DOWN; 1309 keyEvent.code = KeyCode::KEY_TAB; 1310 auto pipeline = PipelineContext::GetCurrentContext(); 1311 pipeline->eventManager_->isTabJustTriggerOnKeyEvent_ = false; 1312 auto context = NG::PipelineContext::GetCurrentContextSafely(); 1313 context->isFocusingByTab_ = false; 1314 EXPECT_TRUE(focusHub->HandleFocusByTabIndex(keyEvent)); 1315 } 1316 1317 /** 1318 * @tc.name: FocusHubTestNg0096 1319 * @tc.desc: Test the function OnFocusScope. 1320 * @tc.type: FUNC 1321 */ 1322 HWTEST_F(FocusHubTestNg, FocusHubTestNg0096, TestSize.Level1) 1323 { 1324 /** 1325 * @tc.steps: step1. Create frameNode. 1326 */ 1327 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1328 AceType::MakeRefPtr<Pattern>()); 1329 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1330 AceType::MakeRefPtr<ButtonPattern>()); 1331 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1332 AceType::MakeRefPtr<ButtonPattern>()); 1333 child->GetOrCreateFocusHub(); 1334 child2->GetOrCreateFocusHub(); 1335 frameNode->AddChild(child); 1336 frameNode->AddChild(child2); 1337 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1338 auto eventHub2 = AceType::MakeRefPtr<EventHub>(); 1339 eventHub->AttachHost(frameNode); 1340 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1341 focusHub->currentFocus_ = true; 1342 std::list<RefPtr<FocusHub>> focusNodes; 1343 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes); 1344 EXPECT_EQ(itNewFocusNode, focusNodes.end()); 1345 focusHub->OnFocusScope(true); 1346 frameNode->Clean(false, false); 1347 focusNodes.clear(); 1348 EXPECT_TRUE(focusNodes.empty()); 1349 focusHub->focusDepend_ = FocusDependence::AUTO; 1350 focusHub->OnFocusScope(true); 1351 focusHub->focusDepend_ = FocusDependence::SELF; 1352 focusHub->OnFocusScope(true); 1353 EXPECT_TRUE(focusHub->currentFocus_); 1354 } 1355 1356 /** 1357 * @tc.name: FocusHubTestNg0097 1358 * @tc.desc: Test the function RequestFocusImmediatelyById. 1359 * @tc.type: FUNC 1360 */ 1361 HWTEST_F(FocusHubTestNg, FocusHubTestNg0097, TestSize.Level1) 1362 { 1363 /** 1364 * @tc.steps1: create focusHub and construct allNodes. 1365 */ 1366 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1367 AceType::MakeRefPtr<ButtonPattern>()); 1368 frameNode->GetOrCreateFocusHub(); 1369 auto focusHub = frameNode->GetFocusHub(); 1370 ASSERT_NE(focusHub, nullptr); 1371 auto frameNode1 = FrameNodeOnTree::CreateFrameNode("123", 123, 1372 AceType::MakeRefPtr<ButtonPattern>()); 1373 frameNode1->GetOrCreateFocusHub(); 1374 auto focusHub1 = frameNode1->GetFocusHub(); 1375 frameNode1->propInspectorId_ = "123"; 1376 auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 102, 1377 AceType::MakeRefPtr<ButtonPattern>()); 1378 frameNode2->GetOrCreateFocusHub(); 1379 auto focusHub2 = frameNode2->GetFocusHub(); 1380 frameNode->children_.push_back(frameNode2); 1381 frameNode->children_.push_back(frameNode1); 1382 focusHub->focusType_ = FocusType::SCOPE; 1383 focusHub1->parentFocusable_ = false; 1384 auto res = focusHub->RequestFocusImmediatelyById("123"); 1385 ASSERT_FALSE(res); 1386 } 1387 1388 /** 1389 * @tc.name: FocusHubTestNg0098 1390 * @tc.desc: Test functions OnBlurScope. 1391 * @tc.type: FUNC 1392 */ 1393 HWTEST_F(FocusHubTestNg, FocusHubTestNg0098, TestSize.Level1) 1394 { 1395 /** 1396 * @tc.steps1: initialize parameters. 1397 */ 1398 auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, 101, 1399 AceType::MakeRefPtr<ButtonPattern>()); 1400 frameNode->GetOrCreateFocusHub(); 1401 auto focusHub = frameNode->GetFocusHub(); 1402 ASSERT_NE(focusHub, nullptr); 1403 auto frameNode1 = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, 101, 1404 AceType::MakeRefPtr<ButtonPattern>()); 1405 frameNode1->GetOrCreateFocusHub(); 1406 auto focusHub1 = frameNode1->GetFocusHub(); 1407 focusHub->focusType_ = FocusType::SCOPE; 1408 frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1409 frameNode->children_.push_back(frameNode1); 1410 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1)); 1411 focusHub->OnBlurScope(); 1412 ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr); 1413 } 1414 1415 /** 1416 * @tc.name: FocusHubTestNg0100 1417 * @tc.desc: Test the function IsImplicitFocusableScope. 1418 * @tc.type: FUNC 1419 */ 1420 HWTEST_F(FocusHubTestNg, FocusHubTestNg0100, TestSize.Level1) 1421 { 1422 /** 1423 * @tc.steps1: initialize parameters. 1424 */ 1425 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1426 eventHub->SetEnabled(true); 1427 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1428 1429 /** 1430 * @tc.steps2: Set focusHub to scope type. 1431 * @tc.expected: The default value of focusable_ is false. 1432 */ 1433 focusHub->focusType_ = FocusType::SCOPE; 1434 EXPECT_FALSE(focusHub->IsImplicitFocusableScope()); 1435 1436 /** 1437 * @tc.steps3: Set focusable_ to true implicitly. 1438 * @tc.expected: The value of focusable_ is true. 1439 */ 1440 focusHub->SetFocusable(true, false); 1441 EXPECT_TRUE(focusHub->IsImplicitFocusableScope()); 1442 } 1443 1444 /** 1445 * @tc.name: LostFocusToViewRoot001 1446 * @tc.desc: Test the function LostFocusToViewRoot. 1447 * @tc.type: FUNC 1448 */ 1449 HWTEST_F(FocusHubTestNg, LostFocusToViewRoot001, TestSize.Level1) 1450 { 1451 /** 1452 * @tc.steps1: create focusHub and construct allNodes. 1453 */ 1454 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1455 AceType::MakeRefPtr<ButtonPattern>()); 1456 frameNode->GetOrCreateFocusHub(); 1457 auto focusHub = frameNode->GetFocusHub(); 1458 /** 1459 * @tc.Calling LostFocusToViewRoot to increase coverage 1460 */ 1461 focusHub->LostFocusToViewRoot(); 1462 ASSERT_TRUE(focusHub->currentFocus_ == false); 1463 } 1464 1465 /* 1466 * @tc.name: SetEnabled01 1467 * @tc.desc: Test the function SetEnabled. 1468 * @tc.type: FUNC 1469 */ 1470 HWTEST_F(FocusHubTestNg, SetEnabled001, TestSize.Level1) 1471 { 1472 /** 1473 * @tc.steps1: create focusHub and construct allNodes. 1474 */ 1475 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, 1476 AceType::MakeRefPtr<ButtonPattern>()); 1477 frameNode->GetOrCreateFocusHub(); 1478 auto focusHub = frameNode->GetFocusHub(); 1479 ASSERT_NE(focusHub, nullptr); 1480 1481 focusHub->currentFocus_ = true; 1482 1483 focusHub->SetEnabled(false); 1484 ASSERT_FALSE(focusHub->currentFocus_); 1485 } 1486 1487 /** 1488 * @tc.name: FocusHubTestNg0101 1489 * @tc.desc: Test the function IsSyncRequestFocusable. 1490 * @tc.type: FUNC 1491 */ 1492 HWTEST_F(FocusHubTestNg, FocusHubTestNg0101, TestSize.Level1) 1493 { 1494 /** 1495 * @tc.steps1: initialize parameters. 1496 */ 1497 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1498 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1499 eventHub->SetEnabled(false); 1500 1501 /** 1502 * @tc.steps2: call the function IsSyncRequestFocusable with FocusType::NODE 1503 * @tc.expected: The return value of IsSyncRequestFocusable is false. 1504 */ 1505 focusHub->SetFocusType(FocusType::NODE); 1506 EXPECT_FALSE(focusHub->IsSyncRequestFocusable()); 1507 1508 /** 1509 * @tc.steps3: call the function IsSyncRequestFocusable with FocusType::SCOPE 1510 * @tc.expected: The return value of IsSyncRequestFocusable is false. 1511 */ 1512 focusHub->SetFocusType(FocusType::SCOPE); 1513 EXPECT_FALSE(focusHub->IsSyncRequestFocusable()); 1514 1515 /** 1516 * @tc.steps4: call the function IsSyncRequestFocusable with FocusType::DISABLE 1517 * @tc.expected: The return value of IsSyncRequestFocusable is false. 1518 */ 1519 focusHub->SetFocusType(FocusType::DISABLE); 1520 EXPECT_FALSE(focusHub->IsSyncRequestFocusable()); 1521 } 1522 1523 /** 1524 * @tc.name: FocusHubTestNg0102 1525 * @tc.desc: Test the function ScrollByOffsetToParent. 1526 * @tc.type: FUNC 1527 */ 1528 HWTEST_F(FocusHubTestNg, FocusHubTestNg0102, TestSize.Level1) 1529 { 1530 /** 1531 * @tc.steps1: create focusHub and construct allNodes. 1532 */ 1533 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102, 1534 AceType::MakeRefPtr<ButtonPattern>()); 1535 frameNode->GetOrCreateFocusHub(); 1536 auto focusHub = frameNode->GetFocusHub(); 1537 ASSERT_NE(focusHub, nullptr); 1538 1539 auto textFieldNode = FrameNodeOnTree::CreateFrameNode("frameNode", 103, 1540 AceType::MakeRefPtr<TextFieldPattern>()); 1541 textFieldNode->GetOrCreateFocusHub(); 1542 auto textFieldFocusHub = textFieldNode->GetFocusHub(); 1543 ASSERT_NE(textFieldNode, nullptr); 1544 ASSERT_FALSE(focusHub->ScrollByOffsetToParent(textFieldNode)); 1545 1546 auto listNode = FrameNodeOnTree::CreateFrameNode("frameNode", 104, 1547 AceType::MakeRefPtr<ListPattern>()); 1548 listNode->GetOrCreateFocusHub(); 1549 auto listFocusHub = listNode->GetFocusHub(); 1550 ASSERT_NE(listFocusHub, nullptr); 1551 ASSERT_FALSE(focusHub->ScrollByOffsetToParent(listNode)); 1552 } 1553 1554 1555 /** 1556 * @tc.name: FocusHubTestNg0103 1557 * @tc.desc: Test the function AcceptFocusOfPriorityChild. 1558 * @tc.type: FUNC 1559 */ 1560 HWTEST_F(FocusHubTestNg, FocusHubTestNg0103, TestSize.Level1) 1561 { 1562 /** 1563 * @tc.steps: step1. Create frameNode. 1564 */ 1565 auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 105, 1566 AceType::MakeRefPtr<LinearLayoutPattern>(true)); 1567 auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190502() 1568 106, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1569 auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190602() 1570 107, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1571 child->MountToParent(frameNode); 1572 child2->MountToParent(frameNode); 1573 1574 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 1575 ASSERT_NE(parentFocusHub, nullptr); 1576 parentFocusHub->SetFocusScopeId("scope1", false); 1577 1578 auto child2FocusHub = child2->GetOrCreateFocusHub(); 1579 ASSERT_NE(child2FocusHub, nullptr); 1580 child2FocusHub->SetFocusScopePriority("scope1", 2000); 1581 EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild()); 1582 EXPECT_EQ(parentFocusHub->lastWeakFocusNode_.Upgrade(), child2FocusHub); 1583 } 1584 1585 /** 1586 * @tc.name: FocusHubTestNg0104 1587 * @tc.desc: Test the function AcceptFocusOfPriorityChild. 1588 * @tc.type: FUNC 1589 */ 1590 HWTEST_F(FocusHubTestNg, FocusHubTestNg0104, TestSize.Level1) 1591 { 1592 /** 1593 * @tc.steps: step1. Create frameNode. 1594 */ 1595 auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 108, 1596 AceType::MakeRefPtr<LinearLayoutPattern>(true)); 1597 auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190702() 1598 109, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1599 auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190802() 1600 110, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1601 child->MountToParent(frameNode); 1602 child2->MountToParent(frameNode); 1603 1604 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 1605 ASSERT_NE(parentFocusHub, nullptr); 1606 parentFocusHub->SetFocusScopeId("scope2", true); 1607 1608 auto child2FocusHub = child2->GetOrCreateFocusHub(); 1609 ASSERT_NE(child2FocusHub, nullptr); 1610 child2FocusHub->SetFocusScopePriority("scope2", 2000); 1611 EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild()); 1612 EXPECT_EQ(parentFocusHub->lastWeakFocusNode_.Upgrade(), child2FocusHub); 1613 1614 auto childFocusHub = child->GetOrCreateFocusHub(); 1615 ASSERT_NE(childFocusHub, nullptr); 1616 childFocusHub->SetFocusScopePriority("scope2", 3000); 1617 EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild()); 1618 EXPECT_EQ(parentFocusHub->lastWeakFocusNode_.Upgrade(), childFocusHub); 1619 } 1620 1621 /** 1622 * @tc.name: FocusHubTestNg0105 1623 * @tc.desc: Test the function RequestFocusByPriorityInScope. 1624 * @tc.type: FUNC 1625 */ 1626 HWTEST_F(FocusHubTestNg, FocusHubTestNg0105, TestSize.Level1) 1627 { 1628 /** 1629 * @tc.steps: step1. Create frameNode. 1630 */ 1631 auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 111, 1632 AceType::MakeRefPtr<LinearLayoutPattern>(true)); 1633 auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190902() 1634 112, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1635 auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190a02() 1636 113, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1637 child->MountToParent(frameNode); 1638 child2->MountToParent(frameNode); 1639 1640 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 1641 ASSERT_NE(parentFocusHub, nullptr); 1642 parentFocusHub->SetFocusScopeId("scope3", false); 1643 1644 auto child2FocusHub = child2->GetOrCreateFocusHub(); 1645 ASSERT_NE(child2FocusHub, nullptr); 1646 child2FocusHub->SetFocusScopePriority("scope3", 2000); 1647 EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope()); 1648 EXPECT_TRUE(child2FocusHub->IsCurrentFocus()); 1649 } 1650 1651 /** 1652 * @tc.name: FocusHubTestNg0106 1653 * @tc.desc: Test the function RequestFocusByPriorityInScope. 1654 * @tc.type: FUNC 1655 */ 1656 HWTEST_F(FocusHubTestNg, FocusHubTestNg0106, TestSize.Level1) 1657 { 1658 /** 1659 * @tc.steps: step1. Create frameNode. 1660 */ 1661 auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 114, 1662 AceType::MakeRefPtr<LinearLayoutPattern>(true)); 1663 auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190b02() 1664 115, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1665 auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, __anonb1b74d190c02() 1666 116, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1667 child->MountToParent(frameNode); 1668 child2->MountToParent(frameNode); 1669 1670 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 1671 ASSERT_NE(parentFocusHub, nullptr); 1672 parentFocusHub->SetFocusScopeId("scope4", true); 1673 1674 auto child2FocusHub = child2->GetOrCreateFocusHub(); 1675 ASSERT_NE(child2FocusHub, nullptr); 1676 child2FocusHub->SetFocusScopePriority("scope4", 2000); 1677 EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope()); 1678 EXPECT_TRUE(child2FocusHub->IsCurrentFocus()); 1679 1680 auto childFocusHub = child->GetOrCreateFocusHub(); 1681 ASSERT_NE(childFocusHub, nullptr); 1682 childFocusHub->SetFocusScopePriority("scope4", 3000); 1683 EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope()); 1684 EXPECT_TRUE(childFocusHub->IsCurrentFocus()); 1685 } 1686 1687 /** 1688 * @tc.name: FocusHubTestNg0107 1689 * @tc.desc: Test the function IsInFocusGroup. 1690 * @tc.type: FUNC 1691 */ 1692 HWTEST_F(FocusHubTestNg, FocusHubTestNg0107, TestSize.Level1) 1693 { 1694 /** 1695 * @tc.steps: step1. Create frameNode. 1696 */ 1697 auto frameNode = 1698 FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 117, AceType::MakeRefPtr<LinearLayoutPattern>(true)); 1699 auto child = FrameNodeOnTree::GetOrCreateFrameNode( __anonb1b74d190d02() 1700 V2::BUTTON_ETS_TAG, 118, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1701 auto child2 = FrameNodeOnTree::GetOrCreateFrameNode( __anonb1b74d190e02() 1702 V2::BUTTON_ETS_TAG, 119, []() { return AceType::MakeRefPtr<ButtonPattern>(); }); 1703 child->MountToParent(frameNode); 1704 child2->MountToParent(frameNode); 1705 1706 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 1707 ASSERT_NE(parentFocusHub, nullptr); 1708 parentFocusHub->SetFocusScopeId("scope5", true); 1709 1710 auto child2FocusHub = child2->GetOrCreateFocusHub(); 1711 ASSERT_NE(child2FocusHub, nullptr); 1712 child2FocusHub->SetFocusScopePriority("scope5", 2000); 1713 parentFocusHub->isFocusScope_ = true; 1714 EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope()); 1715 parentFocusHub->isFocusScope_ = false; 1716 EXPECT_FALSE(parentFocusHub->RequestFocusByPriorityInScope()); 1717 EXPECT_TRUE(child2FocusHub->IsCurrentFocus()); 1718 1719 auto pipeline = PipelineContext::GetCurrentContext(); 1720 pipeline->isFocusActive_ = true; 1721 pipeline->eventManager_->isTabJustTriggerOnKeyEvent_ = true; 1722 KeyEvent keyEvent; 1723 keyEvent.action = KeyAction::DOWN; 1724 keyEvent.code = KeyCode::KEY_TAB; 1725 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB); 1726 EXPECT_FALSE(parentFocusHub->HandleEvent(keyEvent)); 1727 } 1728 1729 /** 1730 * @tc.name: FocusHubTestNg0108 1731 * @tc.desc: Test the function HasFocusedChild. 1732 * @tc.type: FUNC 1733 */ 1734 HWTEST_F(FocusHubTestNg, FocusHubTestNg0108, TestSize.Level1) 1735 { 1736 /** 1737 * @tc.steps1: initialize parameters. 1738 */ 1739 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1740 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1741 ASSERT_NE(focusHub, nullptr); 1742 1743 /** 1744 * @tc.steps2: call the function HasFocusedChild with true and FocusType::SCOPE 1745 */ 1746 focusHub->currentFocus_ = true; 1747 focusHub->focusType_ = FocusType::SCOPE; 1748 focusHub->HasFocusedChild(); 1749 1750 1751 /** 1752 * @tc.steps3: call the function HasFocusedChild with true and FocusType::DISABLE 1753 * @tc.expected: The return value of HasFocusedChild is false. 1754 */ 1755 focusHub->focusType_ = FocusType::DISABLE; 1756 ASSERT_FALSE(focusHub->HasFocusedChild()); 1757 1758 /** 1759 * @tc.steps4: call the function HasFocusedChild with false and FocusType::DISABLE 1760 * @tc.expected: The return value of HasFocusedChild is false. 1761 */ 1762 focusHub->currentFocus_ = false; 1763 focusHub->focusType_ = FocusType::DISABLE; 1764 ASSERT_FALSE(focusHub->HasFocusedChild()); 1765 1766 1767 /** 1768 * @tc.steps5: call the function HasFocusedChild with false and FocusType::SCOPE 1769 * @tc.expected: The return value of HasFocusedChild is false. 1770 */ 1771 focusHub->focusType_ = FocusType::SCOPE; 1772 ASSERT_FALSE(focusHub->HasFocusedChild()); 1773 } 1774 1775 /** 1776 * @tc.name: FocusHubTestNg0121 1777 * @tc.desc: Test the function onKeyEventDispatch. 1778 * @tc.type: FUNC 1779 */ 1780 HWTEST_F(FocusHubTestNg, FocusHubTestNg0121, TestSize.Level1) 1781 { 1782 /** 1783 * @tc.steps1: Create frameNode and add button as its children which focus type is enable. 1784 */ 1785 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1786 AceType::MakeRefPtr<Pattern>()); 1787 auto child1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1788 AceType::MakeRefPtr<ButtonPattern>()); 1789 1790 /** 1791 * @tc.steps: step2. Create FocusHub and set keyEvent. 1792 */ 1793 child1->GetOrCreateFocusHub(); 1794 frameNode->AddChild(child1); 1795 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1796 eventHub->AttachHost(frameNode); 1797 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1798 focusHub->SetFocusType(FocusType::SCOPE); 1799 focusHub->currentFocus_ = true; 1800 1801 KeyEvent keyEvent; 1802 keyEvent.action = KeyAction::DOWN; 1803 keyEvent.code = KeyCode::KEY_SPACE; 1804 1805 /** 1806 * @tc.expected: The return value of is false. 1807 * @tc.steps3: Default returns false if onKeyEventDispatch is not bound. 1808 */ 1809 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1810 } 1811 1812 /** 1813 * @tc.name: FocusHubTestNg0122 1814 * @tc.desc: Test the function onKeyEventDispatch. 1815 * @tc.type: FUNC 1816 */ 1817 HWTEST_F(FocusHubTestNg, FocusHubTestNg0122, TestSize.Level1) 1818 { 1819 /** 1820 * @tc.steps1: Create frameNode and add button as its children which focus type is enable. 1821 */ 1822 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1823 AceType::MakeRefPtr<Pattern>()); 1824 auto child1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1825 AceType::MakeRefPtr<ButtonPattern>()); 1826 1827 /** 1828 * @tc.steps: step2. Create FocusHub and set keyEvent. 1829 */ 1830 child1->GetOrCreateFocusHub(); 1831 frameNode->AddChild(child1); 1832 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1833 eventHub->AttachHost(frameNode); 1834 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1835 focusHub->SetFocusType(FocusType::SCOPE); 1836 focusHub->currentFocus_ = true; 1837 1838 KeyEvent keyEvent; 1839 keyEvent.action = KeyAction::DOWN; 1840 keyEvent.code = KeyCode::KEY_SPACE; 1841 1842 /** 1843 * @tc.expected: The return value of onKeyEventDispatch is true. 1844 * @tc.steps3: call the function onKeyEventDispatch with FocusType::SCOPE. 1845 */ __anonb1b74d190f02(KeyEventInfo& info) 1846 auto onKeyEventDispatchCallback = [](KeyEventInfo& info) -> bool { 1847 return true; 1848 }; 1849 focusHub->SetOnKeyEventDispatchCallback(std::move(onKeyEventDispatchCallback)); 1850 EXPECT_TRUE(focusHub->HandleEvent(keyEvent)); 1851 } 1852 1853 /** 1854 * @tc.name: FocusHubTestNg0123 1855 * @tc.desc: Test the function onKeyEventDispatch. 1856 * @tc.type: FUNC 1857 */ 1858 HWTEST_F(FocusHubTestNg, FocusHubTestNg0123, TestSize.Level1) 1859 { 1860 /** 1861 * @tc.steps1: Create frameNode and add button as its children which focus type is enable. 1862 */ 1863 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1864 AceType::MakeRefPtr<Pattern>()); 1865 auto child1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1866 AceType::MakeRefPtr<ButtonPattern>()); 1867 1868 /** 1869 * @tc.steps: step2. Create FocusHub and set keyEvent. 1870 */ 1871 child1->GetOrCreateFocusHub(); 1872 frameNode->AddChild(child1); 1873 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1874 eventHub->AttachHost(frameNode); 1875 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1876 focusHub->SetFocusType(FocusType::SCOPE); 1877 focusHub->currentFocus_ = true; 1878 1879 KeyEvent keyEvent; 1880 keyEvent.action = KeyAction::DOWN; 1881 keyEvent.code = KeyCode::KEY_SPACE; 1882 1883 /** 1884 * @tc.expected: The return value of onKeyEventDispatch is false. 1885 * @tc.steps3: call the function onKeyEventDispatch with FocusType::SCOPE. 1886 */ __anonb1b74d191002(KeyEventInfo& info) 1887 auto onKeyEventDispatchCallback = [](KeyEventInfo& info) -> bool { 1888 return false; 1889 }; 1890 focusHub->SetOnKeyEventDispatchCallback(std::move(onKeyEventDispatchCallback)); 1891 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 1892 } 1893 1894 /** 1895 * @tc.name: FocusHubTestNg0124 1896 * @tc.desc: Test the function dispatchKeyEvent. 1897 * @tc.type: FUNC 1898 */ 1899 HWTEST_F(FocusHubTestNg, FocusHubTestNg0124, TestSize.Level1) 1900 { 1901 /** 1902 * @tc.steps1: Create frameNode and add button as its children which focus type is enable. 1903 */ 1904 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1905 AceType::MakeRefPtr<Pattern>()); 1906 auto child1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1907 AceType::MakeRefPtr<ButtonPattern>()); 1908 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1909 AceType::MakeRefPtr<ButtonPattern>()); 1910 1911 /** 1912 * @tc.steps: step2. Create FocusHub and set keyEvent. 1913 */ 1914 child2->GetOrCreateFocusHub(); 1915 frameNode->AddChild(child1); 1916 frameNode->AddChild(child2); 1917 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1918 eventHub->AttachHost(frameNode); 1919 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1920 focusHub->SetFocusType(FocusType::SCOPE); 1921 RefPtr<EventHub> childEventHub2 = AceType::MakeRefPtr<EventHub>(); 1922 childEventHub2->AttachHost(child2); 1923 auto childFocusHub2 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(childEventHub2))); 1924 childFocusHub2->SetFocusType(FocusType::NODE); 1925 focusHub->currentFocus_ = true; 1926 1927 KeyEvent keyEvent; 1928 keyEvent.action = KeyAction::DOWN; 1929 keyEvent.code = KeyCode::KEY_SPACE; 1930 1931 /** 1932 * @tc.steps: step3. Binds onKeyEventDispatch callback, executes dipatchKeyEvent to dispatch keyevent to child2. 1933 */ __anonb1b74d191102(KeyEventInfo& eventInfo) 1934 auto onKeyEventDispatchCallback = [&childFocusHub2, &keyEvent](KeyEventInfo& eventInfo) -> bool { 1935 childFocusHub2->currentFocus_ = true; 1936 return childFocusHub2->HandleEvent(keyEvent); 1937 }; 1938 focusHub->SetOnKeyEventDispatchCallback(std::move(onKeyEventDispatchCallback)); 1939 1940 /** 1941 * @tc.expected: The return value of child2 onKeyEvent is true. 1942 * @tc.steps: step4. call the function onKeyEventDispatch and dipatchKeyEvent. 1943 */ __anonb1b74d191202(KeyEventInfo& eventInfo) 1944 auto onKeyEventCallback = [](KeyEventInfo& eventInfo) -> bool { return true; }; 1945 childFocusHub2->SetOnKeyCallback(std::move(onKeyEventCallback)); 1946 EXPECT_TRUE(focusHub->HandleEvent(keyEvent)); 1947 } 1948 1949 /** 1950 * @tc.name: FocusHubTestNg0125 1951 * @tc.desc: Test the function dispatchKeyEvent. 1952 * @tc.type: FUNC 1953 */ 1954 HWTEST_F(FocusHubTestNg, FocusHubTestNg0125, TestSize.Level1) 1955 { 1956 /** 1957 * @tc.steps1: Create frameNode and add button as its children which focus type is enable. 1958 */ 1959 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 1960 AceType::MakeRefPtr<Pattern>()); 1961 auto child1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1962 AceType::MakeRefPtr<ButtonPattern>()); 1963 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 1964 AceType::MakeRefPtr<ButtonPattern>()); 1965 1966 /** 1967 * @tc.steps: step2. Create FocusHub and set keyEvent. 1968 */ 1969 child2->GetOrCreateFocusHub(); 1970 frameNode->AddChild(child1); 1971 frameNode->AddChild(child2); 1972 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1973 eventHub->AttachHost(frameNode); 1974 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1975 focusHub->SetFocusType(FocusType::SCOPE); 1976 RefPtr<EventHub> childEventHub2 = AceType::MakeRefPtr<EventHub>(); 1977 childEventHub2->AttachHost(child2); 1978 auto childFocusHub2 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(childEventHub2))); 1979 childFocusHub2->SetFocusType(FocusType::NODE); 1980 focusHub->currentFocus_ = true; 1981 1982 KeyEvent keyEvent; 1983 keyEvent.action = KeyAction::DOWN; 1984 keyEvent.code = KeyCode::KEY_SPACE; 1985 /** 1986 * @tc.steps: step3. Binds onKeyEventDispatch callback, executes dipatchKeyEvent to dispatch keyevent to child2. 1987 */ __anonb1b74d191302(KeyEventInfo& eventInfo) 1988 auto onKeyEventDispatchCallback = [&childFocusHub2, &keyEvent](KeyEventInfo& eventInfo) -> bool { 1989 childFocusHub2->currentFocus_ = true; 1990 return childFocusHub2->HandleEvent(keyEvent); 1991 }; 1992 focusHub->SetOnKeyEventDispatchCallback(std::move(onKeyEventDispatchCallback)); 1993 1994 /** 1995 * @tc.expected: The return value of child2 onKeyEvent is false. 1996 * @tc.steps: step4. call the function onKeyEventDispatch and dipatchKeyEvent. 1997 */ __anonb1b74d191402(KeyEventInfo& eventInfo) 1998 auto onKeyEventCallback = [](KeyEventInfo& eventInfo) -> bool { return false; }; 1999 childFocusHub2->SetOnKeyCallback(std::move(onKeyEventCallback)); 2000 EXPECT_FALSE(focusHub->HandleEvent(keyEvent)); 2001 } 2002 2003 /** 2004 * @tc.name: FocusHubTestNg0126 2005 * @tc.desc: Test the function dispatchKeyEvent. 2006 * @tc.type: FUNC 2007 */ 2008 HWTEST_F(FocusHubTestNg, FocusHubTestNg0126, TestSize.Level1) 2009 { 2010 /** 2011 * @tc.steps1: Create frameNode and add button as its children which focus type is enable. 2012 */ 2013 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 2014 AceType::MakeRefPtr<Pattern>()); 2015 auto child1 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 2016 AceType::MakeRefPtr<ButtonPattern>()); 2017 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1, 2018 AceType::MakeRefPtr<ButtonPattern>()); 2019 2020 /** 2021 * @tc.steps: step2. Create FocusHub and set keyEvent. 2022 */ 2023 child2->GetOrCreateFocusHub(); 2024 frameNode->AddChild(child1); 2025 frameNode->AddChild(child2); 2026 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2027 eventHub->AttachHost(frameNode); 2028 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2029 focusHub->SetFocusType(FocusType::SCOPE); 2030 RefPtr<EventHub> childEventHub2 = AceType::MakeRefPtr<EventHub>(); 2031 childEventHub2->AttachHost(child2); 2032 auto childFocusHub2 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(childEventHub2))); 2033 childFocusHub2->SetFocusType(FocusType::NODE); 2034 focusHub->currentFocus_ = true; 2035 2036 KeyEvent keyEvent; 2037 keyEvent.action = KeyAction::DOWN; 2038 keyEvent.code = KeyCode::KEY_SPACE; 2039 2040 /** 2041 * @tc.steps: step3. Binds onKeyEventDispatch callback, executes dipatchKeyEvent to dispatch keyevent to child2. 2042 */ __anonb1b74d191502(KeyEventInfo& eventInfo) 2043 auto onKeyEventDispatchCallback = [&childFocusHub2, &keyEvent](KeyEventInfo& eventInfo) -> bool { 2044 childFocusHub2->currentFocus_ = true; 2045 return childFocusHub2->HandleEvent(keyEvent); 2046 }; 2047 focusHub->SetOnKeyEventDispatchCallback(std::move(onKeyEventDispatchCallback)); 2048 2049 /** 2050 * @tc.expected: The return value of child2 onKeyEvent SetStopPropagation true. 2051 * @tc.steps: step6. call the function onKeyEventDispatch and dipatchKeyEvent. 2052 */ __anonb1b74d191602(KeyEventInfo& eventInfo) 2053 auto onKeyEventCallback = [](KeyEventInfo& eventInfo) -> bool { 2054 eventInfo.SetStopPropagation(true); 2055 return false; 2056 }; 2057 childFocusHub2->SetOnKeyCallback(std::move(onKeyEventCallback)); 2058 EXPECT_TRUE(focusHub->HandleEvent(keyEvent)); 2059 } 2060 2061 #ifdef SUPPORT_DIGITAL_CROWN 2062 /** 2063 * @tc.name: FocusHubTestNg0999 2064 * @tc.desc: Test the function OnFocusEventNode. 2065 * @tc.type: FUNC 2066 */ 2067 HWTEST_F(FocusHubTestNg, FocusHubTestNg0999, TestSize.Level1) 2068 { 2069 /** 2070 * @tc.steps1: Create frameNode. 2071 */ 2072 auto frameNode = FrameNode::CreateFrameNode("frameNode", 120, AceType::MakeRefPtr<ButtonPattern>()); 2073 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 2074 ASSERT_NE(parentFocusHub, nullptr); 2075 2076 /** 2077 * @tc.steps2: initialize parameters. 2078 */ 2079 auto eventHub = AceType::MakeRefPtr<EventHub>(); 2080 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2081 ASSERT_NE(focusHub, nullptr); 2082 ASSERT_NE(focusHub->GetRootFocusHub(), nullptr); 2083 NonPointerEvent nonPointerEvent; 2084 nonPointerEvent.sourceType = SourceType::CROWN; 2085 FocusEvent focusEvent(nonPointerEvent); 2086 EXPECT_FALSE(focusHub->OnFocusEventNode(focusEvent)); 2087 2088 focusHub->currentFocus_ = true; 2089 auto focus = focusHub->IsCurrentFocus(); 2090 EXPECT_EQ(focus, true); 2091 } 2092 2093 /** 2094 * @tc.name: FocusHubTestNg01000 2095 * @tc.desc: Test the function HandleCrownEvent. 2096 * @tc.type: FUNC 2097 */ 2098 HWTEST_F(FocusHubTestNg, FocusHubTestNg01000, TestSize.Level1) 2099 { 2100 /** 2101 * @tc.steps1: Create frameNode. 2102 */ 2103 auto frameNode = FrameNode::CreateFrameNode("frameNode", 120, AceType::MakeRefPtr<ButtonPattern>()); 2104 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 2105 ASSERT_NE(parentFocusHub, nullptr); 2106 2107 /** 2108 * @tc.steps2: initialize parameters. 2109 */ 2110 auto eventHub = AceType::MakeRefPtr<EventHub>(); 2111 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2112 ASSERT_NE(focusHub, nullptr); 2113 ASSERT_NE(focusHub->GetRootFocusHub(), nullptr); 2114 2115 CrownEvent event; 2116 EXPECT_FALSE(focusHub->HandleCrownEvent(event)); 2117 __anonb1b74d191702(CrownEventInfo& info) 2118 OnCrownCallbackFunc onCrownEventCallback = [](CrownEventInfo& info) {}; 2119 focusHub->SetOnCrownCallback(std::move(onCrownEventCallback)); 2120 2121 EXPECT_FALSE(focusHub->HandleCrownEvent(event)); 2122 2123 focusHub->currentFocus_ = true; 2124 auto focus = focusHub->IsCurrentFocus(); 2125 EXPECT_EQ(focus, true); 2126 } 2127 2128 /** 2129 * @tc.name: FocusHubTestNg01001 2130 * @tc.desc: Test the function ProcessOnCrownEventInternal. 2131 * @tc.type: FUNC 2132 */ 2133 HWTEST_F(FocusHubTestNg, FocusHubTestNg01001, TestSize.Level1) 2134 { 2135 /** 2136 * @tc.steps1: Create frameNode. 2137 */ 2138 auto frameNode = FrameNode::CreateFrameNode("frameNode", 120, AceType::MakeRefPtr<ButtonPattern>()); 2139 auto parentFocusHub = frameNode->GetOrCreateFocusHub(); 2140 ASSERT_NE(parentFocusHub, nullptr); 2141 2142 /** 2143 * @tc.steps2: initialize parameters. 2144 */ 2145 auto eventHub = AceType::MakeRefPtr<EventHub>(); 2146 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2147 ASSERT_NE(focusHub, nullptr); 2148 ASSERT_NE(focusHub->GetRootFocusHub(), nullptr); 2149 2150 CrownEvent event; 2151 EXPECT_FALSE(focusHub->ProcessOnCrownEventInternal(event)); 2152 2153 focusHub->currentFocus_ = true; 2154 auto focus = focusHub->IsCurrentFocus(); 2155 EXPECT_EQ(focus, true); 2156 __anonb1b74d191802(const CrownEvent& info) 2157 OnCrownEventFunc onCrownEventsInternal = [](const CrownEvent& info) -> bool { return true;}; 2158 focusHub->SetOnCrownEventInternal(std::move(onCrownEventsInternal)); 2159 EXPECT_TRUE(focusHub->ProcessOnCrownEventInternal(event)); 2160 } 2161 #endif 2162 2163 /** 2164 * @tc.name: GetRootFocusHub001 2165 * @tc.desc: Test the function GetRootFocusHub. 2166 * @tc.type: FUNC 2167 */ 2168 HWTEST_F(FocusHubTestNg, GetRootFocusHub001, TestSize.Level1) 2169 { 2170 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2171 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2172 ASSERT_NE(focusHub, nullptr); 2173 ASSERT_NE(focusHub->GetRootFocusHub(), nullptr); 2174 } 2175 2176 /** 2177 * @tc.name: SetFocusable001 2178 * @tc.desc: Test the function SetFocusable. 2179 * @tc.type: FUNC 2180 */ 2181 HWTEST_F(FocusHubTestNg, SetFocusable001, TestSize.Level1) 2182 { 2183 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2184 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2185 ASSERT_NE(focusHub, nullptr); 2186 focusHub->focusType_ = FocusType::SCOPE; 2187 focusHub->focusable_ = true; 2188 focusHub->implicitFocusable_ = true; 2189 focusHub->focusDepend_ = FocusDependence::AUTO; 2190 focusHub->SetFocusable(true, true); 2191 focusHub->focusDepend_ = FocusDependence::CHILD; 2192 focusHub->SetFocusable(true, true); 2193 ASSERT_NE(focusHub->focusDepend_, FocusDependence::CHILD); 2194 } 2195 2196 /** 2197 * @tc.name: DumpFocusScopeTree001 2198 * @tc.desc: 2199 * @tc.type: FUNC 2200 */ 2201 HWTEST_F(FocusHubTestNg, DumpFocusScopeTree001, TestSize.Level1) 2202 { 2203 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 2204 AceType::MakeRefPtr<Pattern>()); 2205 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2206 eventHub->AttachHost(frameNode); 2207 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2208 int32_t depth = 1; 2209 focusHub->focusType_ = FocusType::SCOPE; 2210 auto ss = std::make_unique<std::ostringstream>(); 2211 DumpLog::GetInstance().SetDumpFile(std::move(ss)); 2212 DumpLog::GetInstance().description_.push_back("test"); 2213 focusHub->currentFocus_ = false; 2214 focusHub->SetTabStop(true); 2215 focusHub->focusable_ = false; 2216 focusHub->DumpFocusTree(depth); 2217 EXPECT_TRUE(DumpLog::GetInstance().description_.empty()); 2218 } 2219 2220 /** 2221 * @tc.name: DumpFocusNodeTree001 2222 * @tc.desc: 2223 * @tc.type: FUNC 2224 */ 2225 HWTEST_F(FocusHubTestNg, DumpFocusNodeTree001, TestSize.Level1) 2226 { 2227 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, 2228 AceType::MakeRefPtr<Pattern>()); 2229 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2230 eventHub->AttachHost(frameNode); 2231 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2232 int32_t depth = 1; 2233 focusHub->focusType_ = FocusType::NODE; 2234 auto ss = std::make_unique<std::ostringstream>(); 2235 DumpLog::GetInstance().SetDumpFile(std::move(ss)); 2236 DumpLog::GetInstance().description_.push_back("test"); 2237 focusHub->currentFocus_ = false; 2238 focusHub->SetTabStop(true); 2239 focusHub->focusable_ = false; 2240 focusHub->DumpFocusTree(depth); 2241 EXPECT_TRUE(DumpLog::GetInstance().description_.empty()); 2242 } 2243 2244 /** 2245 * @tc.name: HandleFocusNavigation001 2246 * @tc.desc: 2247 * @tc.type: FUNC 2248 */ 2249 HWTEST_F(FocusHubTestNg, HandleFocusNavigation001, TestSize.Level1) 2250 { 2251 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2252 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2253 eventHub->AttachHost(frameNode); 2254 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2255 KeyEvent keyEvent; 2256 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 2257 FocusEvent focusEvent(keyEvent); 2258 auto ret = focusHub->HandleFocusNavigation(focusEvent); 2259 EXPECT_EQ(ret, false); 2260 } 2261 2262 /** 2263 * @tc.name: HandleFocusTravel001 2264 * @tc.desc: 2265 * @tc.type: FUNC 2266 */ 2267 HWTEST_F(FocusHubTestNg, HandleFocusTravel001, TestSize.Level1) 2268 { 2269 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2270 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2271 eventHub->AttachHost(frameNode); 2272 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2273 KeyEvent keyEvent; 2274 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 2275 FocusEvent focusEvent(keyEvent); 2276 focusEvent.intension = FocusIntension::LEFT; 2277 auto ret = focusHub->HandleFocusTravel(focusEvent); 2278 EXPECT_EQ(ret, false); 2279 } 2280 2281 /** 2282 * @tc.name: DumpFocusTree003 2283 * @tc.desc: 2284 * @tc.type: FUNC 2285 */ 2286 HWTEST_F(FocusHubTestNg, DumpFocusTree003, TestSize.Level1) 2287 { 2288 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2289 int32_t depth = 1; 2290 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2291 eventHub->AttachHost(frameNode); 2292 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2293 2294 focusHub->focusType_ = FocusType::SCOPE; 2295 auto stream = std::make_unique<std::ostringstream>(); 2296 DumpLog::GetInstance().SetDumpFile(std::move(stream)); 2297 2298 DumpLog::GetInstance().description_.push_back("test"); 2299 focusHub->currentFocus_ = false; 2300 focusHub->SetTabStop(true); 2301 focusHub->focusable_ = false; 2302 focusHub->DumpFocusTree(depth, true); 2303 EXPECT_NE(DumpLog::GetInstance().description_.empty(), true); 2304 2305 focusHub->focusType_ = FocusType::NODE; 2306 DumpLog::GetInstance().description_.push_back("test"); 2307 focusHub->currentFocus_ = false; 2308 focusHub->SetTabStop(true); 2309 focusHub->focusable_ = false; 2310 focusHub->DumpFocusTree(depth, true); 2311 EXPECT_NE(DumpLog::GetInstance().description_.empty(), true); 2312 } 2313 2314 /** 2315 * @tc.name: LostFocusToTabStop001 2316 * @tc.desc: 2317 * @tc.type: FUNC 2318 */ 2319 HWTEST_F(FocusHubTestNg, LostFocusToTabStop001, TestSize.Level1) 2320 { 2321 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2322 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2323 eventHub->AttachHost(frameNode); 2324 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2325 auto focusNode = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2326 focusNode->SetCurrentFocus(true); 2327 focusHub->LostFocusToTabStop(focusNode); 2328 EXPECT_EQ(focusNode->IsCurrentFocus(), true); 2329 } 2330 2331 /** 2332 * @tc.name: LostFocusToTabStop001 2333 * @tc.desc: 2334 * @tc.type: FUNC 2335 */ 2336 HWTEST_F(FocusHubTestNg, LostFocusToTabStop002, TestSize.Level1) 2337 { 2338 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2339 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2340 eventHub->AttachHost(frameNode); 2341 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2342 auto focusNode = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2343 focusNode->SetCurrentFocus(false); 2344 focusHub->LostFocusToTabStop(focusNode); 2345 EXPECT_EQ(focusNode->IsCurrentFocus(), false); 2346 } 2347 2348 /** 2349 * @tc.name: RequestNextFocusByKey001 2350 * @tc.desc: 2351 * @tc.type: FUNC 2352 */ 2353 HWTEST_F(FocusHubTestNg, RequestNextFocusByKey001, TestSize.Level1) 2354 { 2355 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2356 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2357 eventHub->AttachHost(frameNode); 2358 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2359 focusHub->SetNextFocus(FocusIntension::SHIFT_TAB, std::string("SHIFT_TAB")); 2360 KeyEvent keyEvent; 2361 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 2362 FocusEvent focusEvent1(keyEvent); 2363 focusEvent1.intension = FocusIntension::SHIFT_TAB; 2364 auto ret = focusHub->RequestNextFocusByKey(focusEvent1); 2365 EXPECT_EQ(ret, false); 2366 2367 focusHub->ResetNextFocus(); 2368 focusHub->SetNextFocus(FocusIntension::UP, std::string("UP")); 2369 FocusEvent focusEvent2(keyEvent); 2370 focusEvent2.intension = FocusIntension::UP; 2371 ret = focusHub->RequestNextFocusByKey(focusEvent2); 2372 EXPECT_EQ(ret, false); 2373 2374 focusHub->ResetNextFocus(); 2375 focusHub->SetNextFocus(FocusIntension::DOWN, std::string("DOWN")); 2376 FocusEvent focusEvent3(keyEvent); 2377 focusEvent3.intension = FocusIntension::DOWN; 2378 ret = focusHub->RequestNextFocusByKey(focusEvent3); 2379 EXPECT_EQ(ret, false); 2380 2381 focusHub->ResetNextFocus(); 2382 focusHub->SetNextFocus(FocusIntension::LEFT, std::string("LEFT")); 2383 FocusEvent focusEvent4(keyEvent); 2384 focusEvent4.intension = FocusIntension::LEFT; 2385 ret = focusHub->RequestNextFocusByKey(focusEvent4); 2386 EXPECT_EQ(ret, false); 2387 } 2388 2389 /** 2390 * @tc.name: RequestNextFocusByKey002 2391 * @tc.desc: 2392 * @tc.type: FUNC 2393 */ 2394 HWTEST_F(FocusHubTestNg, RequestNextFocusByKey002, TestSize.Level1) 2395 { 2396 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2397 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2398 eventHub->AttachHost(frameNode); 2399 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2400 focusHub->SetNextFocus(FocusIntension::SHIFT_TAB, std::string("SHIFT_TAB")); 2401 KeyEvent keyEvent; 2402 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 2403 2404 focusHub->ResetNextFocus(); 2405 focusHub->SetNextFocus(FocusIntension::RIGHT, std::string("RIGHT")); 2406 FocusEvent focusEvent1(keyEvent); 2407 focusEvent1.intension = FocusIntension::RIGHT; 2408 auto ret = focusHub->RequestNextFocusByKey(focusEvent1); 2409 EXPECT_EQ(ret, false); 2410 2411 focusHub->ResetNextFocus(); 2412 focusHub->SetNextFocus(FocusIntension::SELECT, std::string("SELECT")); 2413 FocusEvent focusEvent2(keyEvent); 2414 focusEvent2.intension = FocusIntension::SELECT; 2415 ret = focusHub->RequestNextFocusByKey(focusEvent2); 2416 EXPECT_EQ(ret, false); 2417 2418 focusHub->ResetNextFocus(); 2419 focusHub->SetNextFocus(FocusIntension::ESC, std::string("ESC")); 2420 FocusEvent focusEvent3(keyEvent); 2421 focusEvent3.intension = FocusIntension::ESC; 2422 ret = focusHub->RequestNextFocusByKey(focusEvent3); 2423 EXPECT_EQ(ret, false); 2424 2425 focusHub->ResetNextFocus(); 2426 focusHub->SetNextFocus(FocusIntension::HOME, std::string("HOME")); 2427 FocusEvent focusEvent4(keyEvent); 2428 focusEvent4.intension = FocusIntension::HOME; 2429 ret = focusHub->RequestNextFocusByKey(focusEvent4); 2430 EXPECT_EQ(ret, false); 2431 2432 focusHub->ResetNextFocus(); 2433 focusHub->SetNextFocus(FocusIntension::END, std::string("END")); 2434 FocusEvent focusEvent5(keyEvent); 2435 focusEvent5.intension = FocusIntension::END; 2436 ret = focusHub->RequestNextFocusByKey(focusEvent5); 2437 EXPECT_EQ(ret, false); 2438 } 2439 2440 /** 2441 * @tc.name: GetNextFocusByStep001 2442 * @tc.desc: 2443 * @tc.type: FUNC 2444 */ 2445 HWTEST_F(FocusHubTestNg, GetNextFocusByStep001, TestSize.Level1) 2446 { 2447 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2448 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2449 eventHub->AttachHost(frameNode); 2450 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2451 KeyEvent keyEvent; 2452 auto ret = focusHub->GetNextFocusByStep(keyEvent); 2453 EXPECT_EQ(ret, false); 2454 } 2455 2456 /** 2457 * @tc.name: RequestUserNextFocus001 2458 * @tc.desc: 2459 * @tc.type: FUNC 2460 */ 2461 HWTEST_F(FocusHubTestNg, RequestUserNextFocus001, TestSize.Level1) 2462 { 2463 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2464 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2465 eventHub->AttachHost(frameNode); 2466 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2467 KeyEvent keyEvent; 2468 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 2469 FocusEvent focusEvent(keyEvent); 2470 auto ret = focusHub->RequestUserNextFocus(focusEvent); 2471 EXPECT_EQ(ret, false); 2472 2473 focusHub->ResetNextFocus(); 2474 focusHub->SetNextFocus(FocusIntension::END, std::string("END")); 2475 ret = focusHub->RequestUserNextFocus(focusEvent); 2476 EXPECT_EQ(ret, false); 2477 2478 focusHub->ResetNextFocus(); 2479 focusHub->SetNextFocus(FocusIntension::END, std::string("END")); 2480 focusEvent.intension = FocusIntension::END; 2481 ret = focusHub->RequestUserNextFocus(focusEvent); 2482 EXPECT_EQ(ret, false); 2483 } 2484 2485 /** 2486 * @tc.name: RequestNextFocusOfKeyTab001 2487 * @tc.desc: 2488 * @tc.type: FUNC 2489 */ 2490 HWTEST_F(FocusHubTestNg, RequestNextFocusOfKeyTab001, TestSize.Level1) 2491 { 2492 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2493 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2494 eventHub->AttachHost(frameNode); 2495 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2496 KeyEvent keyEvent; 2497 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_HOME); 2498 FocusEvent focusEvent(keyEvent); 2499 focusHub->isGroup_ = true; 2500 EXPECT_EQ(focusHub->IsInFocusGroup(), true); 2501 auto ret = focusHub->RequestNextFocusOfKeyTab(focusEvent); 2502 EXPECT_EQ(ret, false); 2503 2504 focusHub->isGroup_ = false; 2505 EXPECT_EQ(focusHub->IsInFocusGroup(), false); 2506 focusEvent.intension = FocusIntension::TAB; 2507 ret = focusHub->RequestNextFocusOfKeyTab(focusEvent); 2508 EXPECT_EQ(ret, false); 2509 2510 focusHub->isGroup_ = false; 2511 EXPECT_EQ(focusHub->IsInFocusGroup(), false); 2512 focusEvent.intension = FocusIntension::SHIFT_TAB; 2513 ret = focusHub->RequestNextFocusOfKeyTab(focusEvent); 2514 EXPECT_EQ(ret, false); 2515 } 2516 2517 /** 2518 * @tc.name: RequestNextFocusByDefaultAlgorithm001 2519 * @tc.desc: 2520 * @tc.type: FUNC 2521 */ 2522 HWTEST_F(FocusHubTestNg, RequestNextFocusByDefaultAlgorithm001, TestSize.Level1) 2523 { 2524 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2525 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2526 eventHub->AttachHost(frameNode); 2527 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2528 2529 FocusStep moveStep = FocusStep::LEFT; 2530 auto frameOffset = frameNode->GetTransformRelativeOffset(); 2531 auto geometryNode = frameNode->GetGeometryNode(); 2532 RectF frameRect = RectF(frameOffset, geometryNode->GetFrameRect().GetSize()); 2533 2534 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2535 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::VERTICAL; 2536 focusHub->focusAlgorithm_.isVertical = true; 2537 auto ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2538 EXPECT_EQ(ret, false); 2539 2540 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2541 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::UNIVERSAL; 2542 ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2543 EXPECT_EQ(ret, false); 2544 2545 std::list<RefPtr<FocusHub>> focusNodes; 2546 focusHub->FlushChildrenFocusHub(focusNodes); 2547 focusHub->focusAlgorithm_.scopeType = ScopeType::PROJECT_AREA; 2548 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(*(focusNodes.begin()))); 2549 moveStep = FocusStep::SHIFT_TAB; 2550 ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2551 EXPECT_EQ(ret, false); 2552 } 2553 2554 /** 2555 * @tc.name: RequestNextFocusByDefaultAlgorithm002 2556 * @tc.desc: 2557 * @tc.type: FUNC 2558 */ 2559 HWTEST_F(FocusHubTestNg, RequestNextFocusByDefaultAlgorithm002, TestSize.Level1) 2560 { 2561 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2562 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2563 eventHub->AttachHost(frameNode); 2564 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2565 2566 FocusStep moveStep = FocusStep::LEFT; 2567 auto frameOffset = frameNode->GetTransformRelativeOffset(); 2568 auto geometryNode = frameNode->GetGeometryNode(); 2569 RectF frameRect = RectF(frameOffset, geometryNode->GetFrameRect().GetSize()); 2570 2571 std::list<RefPtr<FocusHub>> focusNodes; 2572 focusHub->FlushChildrenFocusHub(focusNodes); 2573 auto node = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2574 focusNodes.push_front(node); 2575 focusHub->focusAlgorithm_.scopeType = ScopeType::PROJECT_AREA; 2576 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(*(focusNodes.begin()))); 2577 EXPECT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr); 2578 2579 auto ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2580 EXPECT_EQ(ret, false); 2581 2582 moveStep = FocusStep::SHIFT_TAB; 2583 ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2584 EXPECT_EQ(ret, false); 2585 } 2586 2587 /** 2588 * @tc.name: RequestNextFocusByDefaultAlgorithm003 2589 * @tc.desc: 2590 * @tc.type: FUNC 2591 */ 2592 HWTEST_F(FocusHubTestNg, RequestNextFocusByDefaultAlgorithm003, TestSize.Level1) 2593 { 2594 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2595 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2596 eventHub->AttachHost(frameNode); 2597 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2598 2599 FocusStep moveStep = FocusStep::LEFT; 2600 auto frameOffset = frameNode->GetTransformRelativeOffset(); 2601 auto geometryNode = frameNode->GetGeometryNode(); 2602 RectF frameRect = RectF(frameOffset, geometryNode->GetFrameRect().GetSize()); 2603 2604 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2605 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::UNIVERSAL; 2606 focusHub->focusAlgorithm_.isVertical = true; 2607 auto ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2608 EXPECT_EQ(ret, false); 2609 2610 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2611 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::UNIVERSAL; 2612 focusHub->focusAlgorithm_.isVertical = false; 2613 ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2614 EXPECT_EQ(ret, false); 2615 2616 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2617 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::VERTICAL; 2618 focusHub->focusAlgorithm_.isVertical = false; 2619 ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2620 EXPECT_EQ(ret, false); 2621 } 2622 2623 /** 2624 * @tc.name: RequestNextFocusByDefaultAlgorithm004 2625 * @tc.desc: 2626 * @tc.type: FUNC 2627 */ 2628 HWTEST_F(FocusHubTestNg, RequestNextFocusByDefaultAlgorithm004, TestSize.Level1) 2629 { 2630 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2631 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2632 eventHub->AttachHost(frameNode); 2633 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2634 2635 FocusStep moveStep = FocusStep::LEFT; 2636 auto frameOffset = frameNode->GetTransformRelativeOffset(); 2637 auto geometryNode = frameNode->GetGeometryNode(); 2638 RectF frameRect = RectF(frameOffset, geometryNode->GetFrameRect().GetSize()); 2639 2640 moveStep = FocusStep::SHIFT_TAB; 2641 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2642 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::VERTICAL; 2643 focusHub->focusAlgorithm_.isVertical = true; 2644 auto ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2645 EXPECT_EQ(ret, false); 2646 2647 moveStep = FocusStep::SHIFT_TAB; 2648 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2649 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::UNIVERSAL; 2650 focusHub->focusAlgorithm_.isVertical = true; 2651 ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2652 EXPECT_EQ(ret, false); 2653 2654 moveStep = FocusStep::SHIFT_TAB; 2655 focusHub->focusAlgorithm_.scopeType = ScopeType::OTHERS; 2656 focusHub->focusAlgorithm_.direction = ScopeFocusDirection::VERTICAL; 2657 focusHub->focusAlgorithm_.isVertical =false; 2658 ret = focusHub->RequestNextFocusByDefaultAlgorithm(moveStep, frameRect); 2659 EXPECT_EQ(ret, false); 2660 } 2661 2662 /** 2663 * @tc.name: LostChildFocusToSelf001 2664 * @tc.desc: 2665 * @tc.type: FUNC 2666 */ 2667 HWTEST_F(FocusHubTestNg, LostChildFocusToSelf001, TestSize.Level1) 2668 { 2669 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2670 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2671 eventHub->AttachHost(frameNode); 2672 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2673 focusHub->SetCurrentFocus(false); 2674 focusHub->LostChildFocusToSelf(); 2675 EXPECT_NE(focusHub->IsCurrentFocus(), true); 2676 } 2677 2678 /** 2679 * @tc.name: RequestNextFocusByCustomAlgorithm001 2680 * @tc.desc: 2681 * @tc.type: FUNC 2682 */ 2683 HWTEST_F(FocusHubTestNg, RequestNextFocusByCustomAlgorithm001, TestSize.Level1) 2684 { 2685 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2686 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2687 eventHub->AttachHost(frameNode); 2688 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2689 2690 FocusStep moveStep = FocusStep::LEFT; 2691 auto frameOffset = frameNode->GetTransformRelativeOffset(); 2692 auto geometryNode = frameNode->GetGeometryNode(); 2693 RectF frameRect = RectF(frameOffset, geometryNode->GetFrameRect().GetSize()); 2694 2695 std::list<RefPtr<FocusHub>> focusNodes; 2696 focusHub->FlushChildrenFocusHub(focusNodes); 2697 auto ret = focusHub->RequestNextFocusByCustomAlgorithm(moveStep, frameRect); 2698 EXPECT_EQ(ret, false); 2699 } 2700 2701 /** 2702 * @tc.name: IsArrowKeyStepOut001 2703 * @tc.desc: 2704 * @tc.type: FUNC 2705 */ 2706 HWTEST_F(FocusHubTestNg, IsArrowKeyStepOut001, TestSize.Level1) 2707 { 2708 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2709 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2710 eventHub->AttachHost(frameNode); 2711 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2712 2713 FocusStep moveStep = FocusStep::LEFT; 2714 focusHub->isGroup_ = true; 2715 focusHub->arrowKeyStepOut_ = false; 2716 auto ret = focusHub->IsArrowKeyStepOut(moveStep); 2717 EXPECT_EQ(ret, true); 2718 2719 focusHub->isGroup_ = false; 2720 ret = focusHub->IsArrowKeyStepOut(moveStep); 2721 EXPECT_EQ(ret, false); 2722 2723 focusHub->arrowKeyStepOut_ = true; 2724 ret = focusHub->IsArrowKeyStepOut(moveStep); 2725 EXPECT_EQ(ret, false); 2726 2727 focusHub->isGroup_ = true; 2728 ret = focusHub->IsArrowKeyStepOut(moveStep); 2729 EXPECT_EQ(ret, false); 2730 } 2731 2732 /** 2733 * @tc.name: IsArrowKeyStepOut002 2734 * @tc.desc: 2735 * @tc.type: FUNC 2736 */ 2737 HWTEST_F(FocusHubTestNg, IsArrowKeyStepOut002, TestSize.Level1) 2738 { 2739 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>()); 2740 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 2741 eventHub->AttachHost(frameNode); 2742 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 2743 2744 FocusStep moveStep = FocusStep::SHIFT_TAB; 2745 focusHub->isGroup_ = true; 2746 focusHub->arrowKeyStepOut_ = false; 2747 auto ret = focusHub->IsArrowKeyStepOut(moveStep); 2748 EXPECT_EQ(ret, false); 2749 2750 focusHub->isGroup_ = false; 2751 ret = focusHub->IsArrowKeyStepOut(moveStep); 2752 EXPECT_EQ(ret, false); 2753 2754 focusHub->arrowKeyStepOut_ = true; 2755 ret = focusHub->IsArrowKeyStepOut(moveStep); 2756 EXPECT_EQ(ret, false); 2757 2758 focusHub->isGroup_ = true; 2759 ret = focusHub->IsArrowKeyStepOut(moveStep); 2760 EXPECT_EQ(ret, false); 2761 } 2762 } // namespace OHOS::Ace::NG