1 /*
2 * Copyright (c) 2025 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/base/view_abstract_test_ng.h"
16 #include "core/components/select/select_theme.h"
17 #include "test/mock/core/render/mock_render_context.h"
18 #include "core/components_ng/base/view_stack_processor.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS::Ace::NG {
24 const std::string NODE_TAG("node");
SetUpTestSuite()25 void ViewAbstractTestNg::SetUpTestSuite()
26 {
27 MockPipelineContext::SetUp();
28 MockContainer::SetUp();
29 MockContainer::Current()->pipelineContext_ = PipelineBase::GetCurrentContext();
30 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
31 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
32 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>());
33 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<PopupTheme>()));
34 }
35
TearDownTestSuite()36 void ViewAbstractTestNg::TearDownTestSuite()
37 {
38 MockContainer::Current()->pipelineContext_ = nullptr;
39 MockPipelineContext::TearDown();
40 }
41
42 /**
43 * @tc.name: SetChainWeight001
44 * @tc.desc: Test SetNeedFocus of View_Abstract
45 * @tc.type: FUNC
46 */
47 HWTEST_F(ViewAbstractTestNg, SetChainWeight001, TestSize.Level1)
48 {
49 auto state = static_cast<VisualState>(INDEX);
50 ViewStackProcessor::GetInstance()->SetVisualState(state);
51 ViewStackProcessor::GetInstance()->ClearStack();
52 NG::ChainWeightPair value = {3.14f, 2.71f };
53 ViewAbstract::SetChainWeight(value);
54 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
55 EXPECT_FALSE(result);
56
57 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
58 ViewAbstract::SetChainWeight(value);
59 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
60 EXPECT_TRUE(result);
61 }
62
63 /**
64 * @tc.name: SetSafeAreaPadding001
65 * @tc.desc: Test SetNeedFocus of View_Abstract
66 * @tc.type: FUNC
67 */
68 HWTEST_F(ViewAbstractTestNg, SetSafeAreaPadding001, TestSize.Level1)
69 {
70 auto state = static_cast<VisualState>(INDEX);
71 ViewStackProcessor::GetInstance()->SetVisualState(state);
72 ViewStackProcessor::GetInstance()->ClearStack();
73 PaddingProperty value;
74 ViewAbstract::SetSafeAreaPadding(value);
75 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
76 EXPECT_FALSE(result);
77
78 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
79 ViewAbstract::SetSafeAreaPadding(value);
80 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
81 EXPECT_TRUE(result);
82 }
83
84 /**
85 * @tc.name: SetSafeAreaPadding002
86 * @tc.desc: Test SetNeedFocus of View_Abstract
87 * @tc.type: FUNC
88 */
89 HWTEST_F(ViewAbstractTestNg, SetSafeAreaPadding002, TestSize.Level1)
90 {
91 auto state = static_cast<VisualState>(INDEX);
92 ViewStackProcessor::GetInstance()->SetVisualState(state);
93 ViewStackProcessor::GetInstance()->ClearStack();
94 ViewAbstract::SetSafeAreaPadding(NG::CalcLength(WIDTH));
95 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
96 EXPECT_FALSE(result);
97
98 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
99 ViewAbstract::SetSafeAreaPadding(NG::CalcLength(WIDTH));
100 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
101 EXPECT_TRUE(result);
102 }
103
104 /**
105 * @tc.name: ResetSafeAreaPadding001
106 * @tc.desc: Test SetNeedFocus of View_Abstract
107 * @tc.type: FUNC
108 */
109 HWTEST_F(ViewAbstractTestNg, ResetSafeAreaPadding001, TestSize.Level1)
110 {
111 auto state = static_cast<VisualState>(INDEX);
112 ViewStackProcessor::GetInstance()->SetVisualState(state);
113 ViewStackProcessor::GetInstance()->ClearStack();
114 ViewAbstract::ResetSafeAreaPadding();
115 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
116 EXPECT_FALSE(result);
117
118 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
119 ViewAbstract::ResetSafeAreaPadding();
120 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
121 EXPECT_TRUE(result);
122 }
123
124 /**
125 * @tc.name: SetPositionEdges001
126 * @tc.desc: Test SetNeedFocus of View_Abstract
127 * @tc.type: FUNC
128 */
129 HWTEST_F(ViewAbstractTestNg, SetPositionEdges001, TestSize.Level1)
130 {
131 EdgesParam value;
132 CalcDimension top(30, DimensionUnit::VP);
133 CalcDimension left(20, DimensionUnit::VP);
134 value.SetTop(top);
135 value.SetLeft(left);
136 ViewAbstract::SetPositionEdges(value);
137
138 auto state = static_cast<VisualState>(INDEX);
139 ViewStackProcessor::GetInstance()->SetVisualState(state);
140 ViewStackProcessor::GetInstance()->ClearStack();
141 ViewAbstract::SetPositionEdges(value);
142 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
143 EXPECT_FALSE(result);
144 }
145
146 /**
147 * @tc.name: SetOffset001
148 * @tc.desc: Test SetNeedFocus of View_Abstract
149 * @tc.type: FUNC
150 */
151 HWTEST_F(ViewAbstractTestNg, SetOffset001, TestSize.Level1)
152 {
153 auto state = static_cast<VisualState>(INDEX);
154 ViewStackProcessor::GetInstance()->SetVisualState(state);
155 ViewStackProcessor::GetInstance()->ClearStack();
156 OffsetT<Dimension> values = { WIDTH, HEIGHT };
157 ViewAbstract::SetOffset(values);
158 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
159 EXPECT_FALSE(result);
160
161 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
162 ViewAbstract::SetOffset(values);
163 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
164 EXPECT_TRUE(result);
165 }
166
167 /**
168 * @tc.name: ResetPosition002
169 * @tc.desc: Test SetNeedFocus of View_Abstract
170 * @tc.type: FUNC
171 */
172 HWTEST_F(ViewAbstractTestNg, ResetPosition002, TestSize.Level1)
173 {
174 auto state = static_cast<VisualState>(INDEX);
175 ViewStackProcessor::GetInstance()->SetVisualState(state);
176 ViewStackProcessor::GetInstance()->ClearStack();
177 ViewAbstract::ResetPosition();
178 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
179 EXPECT_FALSE(result);
180
181 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
182 auto pipe = MockPipelineContext::GetCurrent();
183 const auto root = FrameNode::CreateFrameNode(TAG_CHILD, 0, AceType::MakeRefPtr<RootPattern>(), true);
184 auto child = FrameNode::CreateFrameNode(TAG_CHILD, 3, AceType::MakeRefPtr<RootPattern>(), true);
185 auto child2 = FrameNode::CreateFrameNode(TAG_CHILD, 4, AceType::MakeRefPtr<Pattern>(), true);
186 root->context_ = AceType::RawPtr(pipe);
187 child->context_ = AceType::RawPtr(pipe);
188 child2->context_ = AceType::RawPtr(pipe);
189
190 child->SetParent(child2, false);
191 ViewStackProcessor::GetInstance()->Push(child);
192 child->IncRefCount();
193 ViewAbstract::ResetPosition();
194 EXPECT_NE(child->GetRenderContext(), nullptr);
195 }
196
197 /**
198 * @tc.name: ResetPosition003
199 * @tc.desc: Test SetNeedFocus of View_Abstract
200 * @tc.type: FUNC
201 */
202 HWTEST_F(ViewAbstractTestNg, ResetPosition003, TestSize.Level1)
203 {
204 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
205 auto pipe = MockPipelineContext::GetCurrent();
206 auto parent = FrameNode::CreateFrameNode("parent", 2, AceType::MakeRefPtr<Pattern>());
207 parent->tag_ = V2::COLUMN_ETS_TAG;
208
209 auto child = FrameNode::CreateFrameNode(TAG_CHILD, 3, AceType::MakeRefPtr<RootPattern>(), true);
210 child->SetParent(parent);
211 parent->context_ = AceType::RawPtr(pipe);
212 child->context_ = AceType::RawPtr(pipe);
213 ViewStackProcessor::GetInstance()->Push(child);
214 ViewAbstract::ResetPosition();
215 EXPECT_FALSE(ViewStackProcessor::GetInstance()->visualState_.has_value());
216 }
217 /**
218 * @tc.name: ResetPosition004
219 * @tc.desc: Test SetNeedFocus of View_Abstract
220 * @tc.type: FUNC
221 */
222 HWTEST_F(ViewAbstractTestNg, ResetPosition004, TestSize.Level1)
223 {
224 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
225 auto pipe = MockPipelineContext::GetCurrent();
226 auto parent = FrameNode::CreateFrameNode("parent", 2, AceType::MakeRefPtr<Pattern>());
227 parent->tag_ = V2::ROW_ETS_TAG;
228
229 auto child = FrameNode::CreateFrameNode(TAG_CHILD, 3, AceType::MakeRefPtr<RootPattern>(), true);
230 child->SetParent(parent);
231 parent->context_ = AceType::RawPtr(pipe);
232 child->context_ = AceType::RawPtr(pipe);
233 ViewStackProcessor::GetInstance()->Push(child);
234 ViewAbstract::ResetPosition();
235 EXPECT_FALSE(ViewStackProcessor::GetInstance()->visualState_.has_value());
236 }
237
238 /**
239 * @tc.name: ResetPosition005
240 * @tc.desc: Test SetNeedFocus of View_Abstract
241 * @tc.type: FUNC
242 */
243 HWTEST_F(ViewAbstractTestNg, ResetPosition005, TestSize.Level1)
244 {
245 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
246 auto pipe = MockPipelineContext::GetCurrent();
247 auto parent = FrameNode::CreateFrameNode("parent", 2, AceType::MakeRefPtr<Pattern>());
248 parent->tag_ = V2::FLEX_ETS_TAG;
249
250 auto child = FrameNode::CreateFrameNode(TAG_CHILD, 3, AceType::MakeRefPtr<RootPattern>(), true);
251 child->SetParent(parent);
252 parent->context_ = AceType::RawPtr(pipe);
253 child->context_ = AceType::RawPtr(pipe);
254 ViewStackProcessor::GetInstance()->Push(child);
255 ViewAbstract::ResetPosition();
256 EXPECT_FALSE(ViewStackProcessor::GetInstance()->visualState_.has_value());
257 }
258
259 /**
260 * @tc.name: GetCurOverlayManager001
261 * @tc.desc: Test SetNeedFocus of View_Abstract
262 * @tc.type: FUNC
263 */
264 HWTEST_F(ViewAbstractTestNg, GetCurOverlayManager001, TestSize.Level1)
265 {
266 RefPtr<UINode> node = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
267 auto result = ViewAbstract::GetCurOverlayManager(node);
268 EXPECT_EQ(result, 1);
269 }
270
271 /**
272 * @tc.name: UpdatePopup001
273 * @tc.desc: Test SetNeedFocus of View_Abstract
274 * @tc.type: FUNC
275 */
276 HWTEST_F(ViewAbstractTestNg, UpdatePopup001, TestSize.Level1)
277 {
278 RefPtr<PopupParam> param = nullptr;
279 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
280 auto result = ViewAbstract::UpdatePopup(param, customNode);
281 EXPECT_EQ(result, ERROR_CODE_INTERNAL_ERROR);
282 }
283
284 /**
285 * @tc.name: UpdatePopup002
286 * @tc.desc: Test SetNeedFocus of View_Abstract
287 * @tc.type: FUNC
288 */
289 HWTEST_F(ViewAbstractTestNg, UpdatePopup002, TestSize.Level1)
290 {
291 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
292 RefPtr<UINode> customNode = nullptr;
293 auto result = ViewAbstract::UpdatePopup(param, customNode);
294 EXPECT_EQ(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
295 }
296
297 /**
298 * @tc.name: UpdatePopup003
299 * @tc.desc: Test SetNeedFocus of View_Abstract
300 * @tc.type: FUNC
301 */
302 HWTEST_F(ViewAbstractTestNg, UpdatePopup003, TestSize.Level1)
303 {
304 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
305 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
306 param->SetTargetId("-1");
307 auto result = ViewAbstract::UpdatePopup(param, customNode);
308 EXPECT_NE(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
309 }
310
311 /**
312 * @tc.name: UpdatePopup004
313 * @tc.desc: Test SetNeedFocus of View_Abstract
314 * @tc.type: FUNC
315 */
316 HWTEST_F(ViewAbstractTestNg, UpdatePopup004, TestSize.Level1)
317 {
318 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
319 auto param = AceType::MakeRefPtr<PopupParam>();
320 param->SetTargetId("");
321 auto result = ViewAbstract::UpdatePopup(param, customNode);
322 EXPECT_EQ(result, ERROR_CODE_INTERNAL_ERROR);
323
324 param->SetTargetId("50");
325 result = ViewAbstract::UpdatePopup(param, customNode);
326 EXPECT_EQ(result, ERROR_CODE_INTERNAL_ERROR);
327 }
328
329 /**
330 * @tc.name: UpdatePopup005
331 * @tc.desc: Test SetNeedFocus of View_Abstract
332 * @tc.type: FUNC
333 */
334 HWTEST_F(ViewAbstractTestNg, UpdatePopup005, TestSize.Level1)
335 {
336 auto pipelineContext = PipelineContext::GetCurrentContext();
337 auto param = AceType::MakeRefPtr<PopupParam>();
338 auto contentNode =
339 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon188316920102() 340 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
341 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon188316920202() 342 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
343 ViewStackProcessor::GetInstance()->Push(targetNode);
344 targetNode->onMainTree_ = true;
345 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
346 auto stageNode = FrameNode::CreateFrameNode(
347 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
348 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
349 stageNode->MountToParent(rootNode);
350 targetNode->MountToParent(stageNode);
351 rootNode->MarkDirtyNode();
352 param->SetIsShow(true);
353 param->SetUseCustomComponent(true);
354 param->SetShowInSubWindow(false);
355 param->SetTargetId(std::to_string(targetNode->GetId()));
356 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
357 auto context = contentNode->GetContextWithCheck();
358 ASSERT_NE(context, nullptr);
359 auto overlayManager = context->GetOverlayManager();
360 ASSERT_NE(overlayManager, nullptr);
361 overlayManager->popupMap_[targetNode->GetId()].isCurrentOnShow = true;
362 overlayManager->popupMap_.clear();
363 param->SetIsPartialUpdate(true);
364 int32_t result = ViewAbstract::UpdatePopup(param, contentNode);
365 EXPECT_EQ(result, ERROR_CODE_INTERNAL_ERROR);
366 }
367
368 /**
369 * @tc.name: UpdatePopup006
370 * @tc.desc: Test SetNeedFocus of View_Abstract
371 * @tc.type: FUNC
372 */
373 HWTEST_F(ViewAbstractTestNg, UpdatePopup006, TestSize.Level1)
374 {
375 auto pipelineContext = PipelineContext::GetCurrentContext();
376 auto param = AceType::MakeRefPtr<PopupParam>();
377 auto contentNode =
378 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anon188316920302() 379 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
380 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon188316920402() 381 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
382 ViewStackProcessor::GetInstance()->Push(targetNode);
383 targetNode->onMainTree_ = true;
384 targetNode->AttachToMainTree(false, AceType::RawPtr(pipelineContext));
385 auto stageNode = FrameNode::CreateFrameNode(
386 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<StagePattern>());
387 auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, 1, AceType::MakeRefPtr<RootPattern>());
388 stageNode->MountToParent(rootNode);
389 targetNode->MountToParent(stageNode);
390 rootNode->MarkDirtyNode();
391 param->SetIsShow(true);
392 param->SetUseCustomComponent(true);
393 param->SetShowInSubWindow(false);
394 param->SetTargetId(std::to_string(targetNode->GetId()));
395 EXPECT_EQ(ViewAbstract::OpenPopup(param, contentNode), ERROR_CODE_NO_ERROR);
396 auto context = contentNode->GetContextWithCheck();
397 ASSERT_NE(context, nullptr);
398 auto overlayManager = context->GetOverlayManager();
399 ASSERT_NE(overlayManager, nullptr);
400 overlayManager->popupMap_[targetNode->GetId()].isCurrentOnShow = false;
401 param->SetIsPartialUpdate(true);
402 int32_t result = ViewAbstract::UpdatePopup(param, contentNode);
403 EXPECT_EQ(result, ERROR_CODE_INTERNAL_ERROR);
404 }
405
406 /**
407 * @tc.name: ClosePopup001
408 * @tc.desc: Test SetNeedFocus of View_Abstract
409 * @tc.type: FUNC
410 */
411 HWTEST_F(ViewAbstractTestNg, ClosePopup001, TestSize.Level1)
412 {
413 auto result = ViewAbstract::ClosePopup(nullptr);
414 EXPECT_EQ(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
415 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
416 RefPtr<PopupParam> param = nullptr;
417 result = ViewAbstract::ClosePopup(customNode);
418 EXPECT_NE(result, ERROR_CODE_INTERNAL_ERROR);
419 }
420
421 /**
422 * @tc.name: ClosePopup002
423 * @tc.desc: Test SetNeedFocus of View_Abstract
424 * @tc.type: FUNC
425 */
426 HWTEST_F(ViewAbstractTestNg, ClosePopup002, TestSize.Level1)
427 {
428 RefPtr<PopupParam> param = AceType::MakeRefPtr<PopupParam>();
429 RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
430 param->SetTargetId("-1");
431 auto result = ViewAbstract::ClosePopup(customNode);
432
433 param->SetTargetId("");
434 result = ViewAbstract::ClosePopup(customNode);
435
436 param->SetTargetId("50");
437 result = ViewAbstract::ClosePopup(customNode);
438 EXPECT_NE(result, ERROR_CODE_INTERNAL_ERROR);
439 }
440
441 /**
442 * @tc.name: DismissDialog001
443 * @tc.desc: Test SetNeedFocus of View_Abstract
444 * @tc.type: FUNC
445 */
446 HWTEST_F(ViewAbstractTestNg, DismissDialog001, TestSize.Level1)
447 {
448 auto context = PipelineContext::GetCurrentContext();
449 auto overlayManager = context->GetOverlayManager();
450 auto rootNode = overlayManager->GetRootNode().Upgrade();
451 DialogProperties dialogProperties;
452
453 auto overlay = AceType::DynamicCast<FrameNode>(rootNode->GetLastChild());
454 ASSERT_NE(overlay, nullptr);
455 auto dialog = overlayManager->ShowDialog(dialogProperties, nullptr, false);
456 auto dialogMapSize = overlayManager->dialogMap_.size();
457 ViewAbstract::DismissDialog();
458 EXPECT_NE(overlayManager->dialogMap_.size(), dialogMapSize - 1);
459 }
460
461 /**
462 * @tc.name: OpenMenu001
463 * @tc.desc: Test SetNeedFocus of View_Abstract
464 * @tc.type: FUNC
465 */
466 HWTEST_F(ViewAbstractTestNg, OpenMenu001, TestSize.Level1)
467 {
468 MenuParam menuParam;
469 int32_t targetId = 0;
470 int32_t result = ViewAbstract::OpenMenu(menuParam, nullptr, targetId);
471 EXPECT_EQ(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
472
473 RefPtr<NG::UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
474 targetId = 999;
475 result = ViewAbstract::OpenMenu(menuParam, customNode, targetId);
476 EXPECT_NE(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
477 }
478
479 /**
480 * @tc.name: OpenMenu002
481 * @tc.desc: Test SetNeedFocus of View_Abstract
482 * @tc.type: FUNC
483 */
484 HWTEST_F(ViewAbstractTestNg, OpenMenu002, TestSize.Level1)
485 {
486 MenuParam menuParam;
487 RefPtr<NG::UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
488 auto frameNode = FrameNode::CreateFrameNode("frameNode", 1, AceType::MakeRefPtr<Pattern>(), true);
489 auto targetNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon188316920502() 490 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
491
492 auto element = ElementRegister::GetInstance()->AddReferenced(1, frameNode);
493 EXPECT_FALSE(element);
494 auto result = ViewAbstract::OpenMenu(menuParam, customNode, 1);
495
496 frameNode->onMainTree_ = false;
497 result = ViewAbstract::OpenMenu(menuParam, customNode, 1);
498 EXPECT_NE(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
499 frameNode->onMainTree_ = true;
500 result = ViewAbstract::OpenMenu(menuParam, customNode, 1);
501 EXPECT_NE(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
502 }
503
504 /**
505 * @tc.name: UpdateMenu001
506 * @tc.desc: Test SetNeedFocus of View_Abstract
507 * @tc.type: FUNC
508 */
509 HWTEST_F(ViewAbstractTestNg, UpdateMenu001, TestSize.Level1)
510 {
511 MenuParam menuParam;
512 int32_t result = ViewAbstract::UpdateMenu(menuParam, nullptr);
513 EXPECT_EQ(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
514
515 RefPtr<NG::UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
516 result = ViewAbstract::UpdateMenu(menuParam, customNode);
517 EXPECT_NE(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
518 }
519
520 /**
521 * @tc.name: CloseMenu001
522 * @tc.desc: Test SetNeedFocus of View_Abstract
523 * @tc.type: FUNC
524 */
525 HWTEST_F(ViewAbstractTestNg, CloseMenu001, TestSize.Level1)
526 {
527 int32_t result = ViewAbstract::CloseMenu(nullptr);
528 EXPECT_EQ(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
529
530 RefPtr<NG::UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
531 result = ViewAbstract::CloseMenu(customNode);
532 EXPECT_NE(result, ERROR_CODE_DIALOG_CONTENT_ERROR);
533 }
534
535 /**
536 * @tc.name: SetInspectorId001
537 * @tc.desc: Test SetNeedFocus of View_Abstract
538 * @tc.type: FUNC
539 */
540 HWTEST_F(ViewAbstractTestNg, SetInspectorId001, TestSize.Level1)
541 {
542 ViewStackProcessor::GetInstance()->ClearStack();
543 std::string inspectorId = "test";
544 ViewAbstract::SetInspectorId(inspectorId);
545 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
546 EXPECT_TRUE(result);
547
548 auto node = FrameNode::CreateFrameNode("TestNode", 1, AceType::MakeRefPtr<Pattern>());
549 ViewStackProcessor::GetInstance()->Push(node);
550 ViewAbstract::SetInspectorId("test1");
551 }
552
553 /**
554 * @tc.name: CleanTransition001
555 * @tc.desc: Test SetNeedFocus of View_Abstract
556 * @tc.type: FUNC
557 */
558 HWTEST_F(ViewAbstractTestNg, CleanTransition001, TestSize.Level1)
559 {
560 auto state = static_cast<VisualState>(INDEX);
561 ViewStackProcessor::GetInstance()->SetVisualState(state);
562 ViewStackProcessor::GetInstance()->ClearStack();
563 ViewAbstract::CleanTransition();
564 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
565 EXPECT_FALSE(result);
566
567 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
568 ViewAbstract::CleanTransition();
569 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
570 EXPECT_TRUE(result);
571 }
572
573 /**
574 * @tc.name: CleanTransition002
575 * @tc.desc: Test SetNeedFocus of View_Abstract
576 * @tc.type: FUNC
577 */
578 HWTEST_F(ViewAbstractTestNg, CleanTransition002, TestSize.Level1)
579 {
580 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
581 auto result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
582 auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), true);
583 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
584 ViewStackProcessor::GetInstance()->Push(frameNode);
585 ViewAbstract::CleanTransition();
586 EXPECT_TRUE(result);
587 }
588
589 /**
590 * @tc.name: SetNodeBackdropBlur001
591 * @tc.desc: Test SetNeedFocus of View_Abstract
592 * @tc.type: FUNC
593 */
594 HWTEST_F(ViewAbstractTestNg, SetNodeBackdropBlur001, TestSize.Level1)
595 {
596 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
597 ASSERT_NE(itemNode, nullptr);
598 FrameNode *frameNode = Referenced::RawPtr(itemNode);
599 CHECK_NULL_VOID(frameNode);
600 Dimension radius;
601 BlurOption blurOption;
602 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
603 ViewAbstract::SetNodeBackdropBlur(frameNode, radius, blurOption);
604 EXPECT_NE(itemNode, nullptr);
605 }
606
607 /**
608 * @tc.name: SetBackdropBlur001
609 * @tc.desc: Test SetNeedFocus of View_Abstract
610 * @tc.type: FUNC
611 */
612 HWTEST_F(ViewAbstractTestNg, SetBackdropBlur001, TestSize.Level1)
613 {
614 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
615 FrameNode *frameNode = Referenced::RawPtr(itemNode);
616 CHECK_NULL_VOID(frameNode);
617 Dimension radius;
618 BlurOption blurOption;
619 SysOptions sysOptions;
620 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
621 ViewAbstract::SetBackdropBlur(frameNode, radius, blurOption, sysOptions);
622 EXPECT_NE(itemNode, nullptr);
623 }
624
625 /**
626 * @tc.name: SetOverlayComponentContent001
627 * @tc.desc: Test SetNeedFocus of View_Abstract
628 * @tc.type: FUNC
629 */
630 HWTEST_F(ViewAbstractTestNg, SetOverlayComponentContent001, TestSize.Level1)
631 {
632 auto state = static_cast<VisualState>(INDEX);
633 ViewStackProcessor::GetInstance()->SetVisualState(state);
634 ViewStackProcessor::GetInstance()->ClearStack();
635 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
636 EXPECT_FALSE(result);
637 RefPtr<NG::FrameNode> contentNode = AceType::MakeRefPtr<FrameNode>("content", 1, AceType::MakeRefPtr<Pattern>());
638 std::optional<Alignment> align;
639 std::optional<Dimension> offsetX;
640 std::optional<Dimension> offsetY;
641 ViewAbstract::SetOverlayComponentContent(contentNode, align, offsetX, offsetY);
642
643 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
644 ViewAbstract::SetOverlayComponentContent(contentNode, align, offsetX, offsetY);
645 EXPECT_FALSE(result);
646 }
647
648 /**
649 * @tc.name: AddOverlayToFrameNode001
650 * @tc.desc: Test SetNeedFocus of View_Abstract
651 * @tc.type: FUNC
652 */
653 HWTEST_F(ViewAbstractTestNg, AddOverlayToFrameNode001, TestSize.Level1)
654 {
655 RefPtr<NG::FrameNode> contentNode = AceType::MakeRefPtr<FrameNode>("content", 1, AceType::MakeRefPtr<Pattern>());
656 std::optional<Alignment> align;
657 std::optional<Dimension> offsetX;
658 std::optional<Dimension> offsetY;
659 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
660 ViewAbstract::AddOverlayToFrameNode(contentNode, align, offsetX, offsetY);
661 ASSERT_NE(contentNode, nullptr);
662 }
663
664 /**
665 * @tc.name: AddOverlayToFrameNode002
666 * @tc.desc: Test SetNeedFocus of View_Abstract
667 * @tc.type: FUNC
668 */
669 HWTEST_F(ViewAbstractTestNg, AddOverlayToFrameNode002, TestSize.Level1)
670 {
671 auto state = static_cast<VisualState>(INDEX);
672 ViewStackProcessor::GetInstance()->SetVisualState(state);
673 ViewStackProcessor::GetInstance()->ClearStack();
674 ViewAbstract::CleanTransition();
675 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
676 RefPtr<NG::FrameNode> contentNode = AceType::MakeRefPtr<FrameNode>("content", 1, AceType::MakeRefPtr<Pattern>());
677 ASSERT_NE(contentNode, nullptr);
678 std::optional<Alignment> align;
679 std::optional<Dimension> offsetX;
680 std::optional<Dimension> offsetY;
681 ViewAbstract::AddOverlayToFrameNode(contentNode, align, offsetX, offsetY);
682 EXPECT_FALSE(result);
683 }
684
685 /**
686 * @tc.name: SetOverlayBuilder001
687 * @tc.desc: Test SetNeedFocus of View_Abstract
688 * @tc.type: FUNC
689 */
690 HWTEST_F(ViewAbstractTestNg, SetOverlayBuilder001, TestSize.Level1)
691 {
692 auto state = static_cast<VisualState>(INDEX);
693 ViewStackProcessor::GetInstance()->SetVisualState(state);
694 ViewStackProcessor::GetInstance()->ClearStack();
695 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
696 std::optional<Alignment> align;
697 std::optional<Dimension> offsetX;
698 std::optional<Dimension> offsetY;
699 ViewAbstract::SetOverlayBuilder(nullptr, align, offsetX, offsetY);
700 EXPECT_FALSE(result);
701
702 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
703 ViewAbstract::SetOverlayBuilder(nullptr, align, offsetX, offsetY);
704 EXPECT_FALSE(result);
705 }
706
707 /**
708 * @tc.name: SetClipEdge001
709 * @tc.desc: Test SetNeedFocus of View_Abstract
710 * @tc.type: FUNC
711 */
712 HWTEST_F(ViewAbstractTestNg, SetClipEdge001, TestSize.Level1)
713 {
714 bool isClip = true;
715 ViewAbstract::SetClipEdge(nullptr, isClip);
716 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode();
717 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne);
718 ASSERT_NE(frameNode, nullptr);
719 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode);
720 isClip = false;
721 ViewAbstract::SetClipEdge(AceType::RawPtr(node), isClip);
722 EXPECT_NE(node, nullptr);
723 }
724
725 /**
726 * @tc.name: SetClipShape001
727 * @tc.desc: Test SetNeedFocus of View_Abstract
728 * @tc.type: FUNC
729 */
730 HWTEST_F(ViewAbstractTestNg, SetClipShape001, TestSize.Level1)
731 {
732 RefPtr<BasicShape> basicShape = AceType::MakeRefPtr<BasicShape>();
733 auto state = static_cast<VisualState>(INDEX);
734 ViewStackProcessor::GetInstance()->SetVisualState(state);
735 ViewStackProcessor::GetInstance()->ClearStack();
736 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
737
738 ViewAbstract::SetClipShape(basicShape);
739 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
740 ViewAbstract::SetClipShape(basicShape);
741 EXPECT_FALSE(result);
742 }
743
744 /**
745 * @tc.name: SetClipShape002
746 * @tc.desc: Test SetNeedFocus of View_Abstract
747 * @tc.type: FUNC
748 */
749 HWTEST_F(ViewAbstractTestNg, SetClipShape002, TestSize.Level1)
750 {
751 RefPtr<BasicShape> basicShape = AceType::MakeRefPtr<BasicShape>();
752 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
753 auto result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
754 auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), true);
755 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
756 ViewStackProcessor::GetInstance()->Push(frameNode);
757 ViewAbstract::SetClipShape(basicShape);
758 EXPECT_TRUE(result);
759 }
760
761 /**
762 * @tc.name: SetAttractionEffect001
763 * @tc.desc: Test SetNeedFocus of View_Abstract
764 * @tc.type: FUNC
765 */
766 HWTEST_F(ViewAbstractTestNg, SetAttractionEffect001, TestSize.Level1)
767 {
768 AttractionEffect effect;
769 auto state = static_cast<VisualState>(INDEX);
770 ViewStackProcessor::GetInstance()->SetVisualState(state);
771 ViewStackProcessor::GetInstance()->ClearStack();
772 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
773
774 ViewAbstract::SetAttractionEffect(effect);
775 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
776 ViewAbstract::SetAttractionEffect(effect);
777 EXPECT_FALSE(result);
778 }
779
780 /**
781 * @tc.name: SetLightIlluminated001
782 * @tc.desc: Test SetNeedFocus of View_Abstract
783 * @tc.type: FUNC
784 */
785 HWTEST_F(ViewAbstractTestNg, SetLightIlluminated001, TestSize.Level1)
786 {
787 uint32_t value = 100;
788 auto state = static_cast<VisualState>(INDEX);
789 ViewStackProcessor::GetInstance()->SetVisualState(state);
790 ViewStackProcessor::GetInstance()->ClearStack();
791 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
792
793 ViewAbstract::SetLightIlluminated(value);
794 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
795 ViewAbstract::SetLightIlluminated(value);
796 EXPECT_FALSE(result);
797 }
798
799 /**
800 * @tc.name: SetPrivacySensitive001
801 * @tc.desc: Test SetNeedFocus of View_Abstract
802 * @tc.type: FUNC
803 */
804 HWTEST_F(ViewAbstractTestNg, SetPrivacySensitive001, TestSize.Level1)
805 {
806 bool flag = true;
807 auto state = static_cast<VisualState>(INDEX);
808 ViewStackProcessor::GetInstance()->SetVisualState(state);
809 ViewStackProcessor::GetInstance()->ClearStack();
810 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
811
812 ViewAbstract::SetPrivacySensitive(flag);
813 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
814 ViewAbstract::SetPrivacySensitive(flag);
815 EXPECT_FALSE(result);
816 }
817
818 /**
819 * @tc.name: SetMask001
820 * @tc.desc: Test SetNeedFocus of View_Abstract
821 * @tc.type: FUNC
822 */
823 HWTEST_F(ViewAbstractTestNg, SetMask001, TestSize.Level1)
824 {
825 auto progressNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
826 FrameNode* frameNode = Referenced::RawPtr(progressNode);
827 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
828 RefPtr<BasicShape> basicShape = AceType::MakeRefPtr<BasicShape>();
829 ViewAbstract::SetMask(frameNode, basicShape);
830 EXPECT_NE(frameNode->renderContext_, nullptr);
831 }
832
833 /**
834 * @tc.name: SetProgressMask001
835 * @tc.desc: Test SetNeedFocus of View_Abstract
836 * @tc.type: FUNC
837 */
838 HWTEST_F(ViewAbstractTestNg, SetProgressMask001, TestSize.Level1)
839 {
840 auto progressNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
841 FrameNode* frameNode = Referenced::RawPtr(progressNode);
842 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
843 RefPtr<ProgressMaskProperty> progress;
844 ViewAbstract::SetProgressMask(frameNode, progress);
845 EXPECT_NE(frameNode->renderContext_, nullptr);
846 }
847
848 /**
849 * @tc.name: SetForegroundEffect001
850 * @tc.desc: Test SetNeedFocus of View_Abstract
851 * @tc.type: FUNC
852 */
853 HWTEST_F(ViewAbstractTestNg, SetForegroundEffect001, TestSize.Level1)
854 {
855 auto progressNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
856 FrameNode* frameNode = Referenced::RawPtr(progressNode);
857 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
858 float radius = 10.0f;
859 SysOptions sysOptions;
860 ViewAbstract::SetForegroundEffect(frameNode, radius, sysOptions);
861 EXPECT_NE(frameNode->renderContext_, nullptr);
862 }
863
864 /**
865 * @tc.name: CleanTransit001
866 * @tc.desc: Test SetNeedFocus of View_Abstract
867 * @tc.type: FUNC
868 */
869 HWTEST_F(ViewAbstractTestNg, CleanTransit001, TestSize.Level1)
870 {
871 auto progressNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
872 FrameNode* frameNode = Referenced::RawPtr(progressNode);
873 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
874 ViewAbstract::CleanTransition(frameNode);
875 EXPECT_NE(frameNode->renderContext_, nullptr);
876 }
877
878 /**
879 * @tc.name: SetOverlayBuilder002
880 * @tc.desc: Test SetNeedFocus of View_Abstract
881 * @tc.type: FUNC
882 */
883 HWTEST_F(ViewAbstractTestNg, SetOverlayBuilder002, TestSize.Level1)
884 {
__anon188316920602() 885 std::function<void()> buildFunc = []() {};
886 std::optional<Alignment> align;
887 std::optional<Dimension> offsetX;
888 std::optional<Dimension> offsetY;
889 auto state = static_cast<VisualState>(INDEX);
890 ViewStackProcessor::GetInstance()->SetVisualState(state);
891 ViewStackProcessor::GetInstance()->ClearStack();
892 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess();
893
894 ViewAbstract::SetOverlayBuilder(std::move(buildFunc), align, offsetX, offsetY);
895 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt;
896 ViewAbstract::SetOverlayBuilder(std::move(buildFunc), align, offsetX, offsetY);
897 EXPECT_FALSE(result);
898 }
899
900 /**
901 * @tc.name: SetDraggable001
902 * @tc.desc: Test SetNeedFocus of View_Abstract
903 * @tc.type: FUNC
904 */
905 HWTEST_F(ViewAbstractTestNg, SetDraggable001, TestSize.Level1)
906 {
907 auto progressNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
908 FrameNode* frameNode = Referenced::RawPtr(progressNode);
909 frameNode->renderContext_ = AceType::MakeRefPtr<MockRenderContext>();
910 bool draggable = true;
911
912 ViewAbstract::SetDraggable(frameNode, draggable);
913 draggable = false;
914 ViewAbstract::SetDraggable(frameNode, draggable);
915 EXPECT_NE(frameNode->renderContext_, nullptr);
916 }
917 } // namespace OHOS::Ace::NG