1 /*
2 * Copyright (c) 2022-2023 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
16 #include <type_traits>
17 #include "gtest/gtest.h"
18
19 #define private public
20 #define protected public
21
22 #include "test/mock/core/common/mock_theme_manager.h"
23 #include "test/mock/core/pipeline/mock_pipeline_context.h"
24 #include "test/mock/core/render/mock_render_context.h"
25 #include "test/mock/core/rosen/mock_canvas.h"
26 #include "test/mock/core/rosen/testing_canvas.h"
27
28 #include "core/components/common/layout/constants.h"
29 #include "core/components/common/layout/grid_system_manager.h"
30 #include "core/components/common/properties/shadow_config.h"
31 #include "core/components/container_modal/container_modal_constants.h"
32 #include "core/components/select/select_theme.h"
33 #include "core/components/theme/shadow_theme.h"
34 #include "core/components_ng/base/view_stack_processor.h"
35 #include "core/components_ng/pattern/image/image_layout_property.h"
36 #include "core/components_ng/pattern/image/image_pattern.h"
37 #include "core/components_ng/pattern/menu/menu_item/menu_item_model_ng.h"
38 #include "core/components_ng/pattern/menu/menu_item/menu_item_pattern.h"
39 #include "core/components_ng/pattern/menu/menu_item_group/menu_item_group_pattern.h"
40 #include "core/components_ng/pattern/menu/menu_item_group/menu_item_group_view.h"
41 #include "core/components_ng/pattern/menu/menu_model_ng.h"
42 #include "core/components_ng/pattern/menu/menu_pattern.h"
43 #include "core/components_ng/pattern/menu/menu_theme.h"
44 #include "core/components_ng/pattern/menu/menu_view.h"
45 #include "core/components_ng/pattern/menu/multi_menu_layout_algorithm.h"
46 #include "core/components_ng/pattern/menu/preview/menu_preview_layout_algorithm.h"
47 #include "core/components_ng/pattern/menu/preview/menu_preview_pattern.h"
48 #include "core/components_ng/pattern/menu/sub_menu_layout_algorithm.h"
49 #include "core/components_ng/pattern/menu/wrapper/menu_wrapper_pattern.h"
50 #include "core/components_ng/pattern/pattern.h"
51 #include "core/components_ng/pattern/root/root_pattern.h"
52 #include "core/components_ng/pattern/scroll/scroll_pattern.h"
53 #include "core/components_ng/pattern/text/text_layout_property.h"
54 #include "core/components_ng/pattern/text/text_pattern.h"
55 #include "core/components_ng/property/border_property.h"
56 #include "core/components_ng/property/measure_property.h"
57 #include "core/components_ng/syntax/lazy_for_each_model.h"
58 #include "core/components_ng/syntax/lazy_layout_wrapper_builder.h"
59 #include "core/event/touch_event.h"
60
61 using namespace testing;
62 using namespace testing::ext;
63 using namespace OHOS::Ace::Framework;
64
65 namespace OHOS::Ace::NG {
66 namespace {
67 const InspectorFilter filter;
68 constexpr int32_t TARGET_ID = 3;
69 constexpr MenuType TYPE = MenuType::MENU;
70 const std::string EMPTY_TEXT = "";
71 const std::string TEXT_TAG = "text";
72 const std::string MENU_TAG = "menu";
73 const std::string MENU_ITEM_TEXT = "menuItem";
74 const std::string MENU_ITEM_GROUP_TEXT = "menuItemGroup";
75 const std::string MENU_TOUCH_EVENT_TYPE = "1";
76 const DirtySwapConfig configDirtySwap = { false, false, false, false, true, false };
77 const std::string IMAGE_SRC_URL = "file://data/data/com.example.test/res/example.svg";
78
79 constexpr float FULL_SCREEN_WIDTH = 720.0f;
80 constexpr float FULL_SCREEN_HEIGHT = 1136.0f;
81 constexpr float POSITION_OFFSET = 100.0f;
82 constexpr float TARGET_SIZE_WIDTH = 100.0f;
83 constexpr float TARGET_SIZE_HEIGHT = 100.0f;
84
85 constexpr float OFFSET_FIRST = 20.0f;
86 constexpr float OFFSET_SECOND = 5.0f;
87 constexpr float OFFSET_FORTH = 300.0f;
88 const SizeF FULL_SCREEN_SIZE(FULL_SCREEN_WIDTH, FULL_SCREEN_HEIGHT);
89 constexpr float GREATER_WINDOW_MENU_HEIGHT = 1190.0f;
90 constexpr double DIP_SCALE = 1.5;
91 const std::vector<std::string> FONT_FAMILY_VALUE = {"cursive"};
92 constexpr double CONST_DOUBLE_ZREO = 0.0;
93 constexpr float PAN_MAX_VELOCITY = 2000.0f;
94 const std::vector<SelectParam> CREATE_VALUE = { { "content1", "icon1" }, { "content2", "" },
95 { "", "icon3" }, { "", "" } };
96 const std::vector<SelectParam> CREATE_VALUE_NEW = { { "content1_new", "" }, { "", "icon4_new" },
97 { "", "" }, { "", "icon4_new" } };
98 const V2::ItemDivider ITEM_DIVIDER = { Dimension(5.f), Dimension(10), Dimension(20), Color(0x000000) };
99 constexpr double MENU_OFFSET_X = 10.0;
100 constexpr double MENU_OFFSET_Y = 10.0;
101 constexpr float MENU_SIZE_WIDTH = 100.0f;
102 constexpr float MENU_SIZE_HEIGHT = 50.0f;
103 constexpr double CONST_NEAR_ZREO = 0.0001;
104 constexpr double CONST_LESS_NEAR_ZREO = 0.00001;
105 constexpr float PAN_GREATER_MAX_VELOCITY = 2100.0f;
106 } // namespace
107 class MenuPattern1TestNg : public testing::Test {
108 public:
109 static void SetUpTestCase();
110 static void TearDownTestCase();
111 void SetUp() override;
112 void TearDown() override;
113 void InitMenuPattern1TestNg();
114 void InitMenuItemTestNg();
115 PaintWrapper* GetPaintWrapper(RefPtr<MenuPaintProperty> paintProperty);
116 RefPtr<FrameNode> GetPreviewMenuWrapper(
117 SizeF itemSize = SizeF(0.0f, 0.0f), std::optional<MenuPreviewAnimationOptions> scaleOptions = std::nullopt);
118 RefPtr<FrameNode> menuFrameNode_;
119 RefPtr<MenuAccessibilityProperty> menuAccessibilityProperty_;
120 RefPtr<FrameNode> menuItemFrameNode_;
121 RefPtr<MenuItemPattern> menuItemPattern_;
122 RefPtr<MenuItemAccessibilityProperty> menuItemAccessibilityProperty_;
123 };
124
SetUpTestCase()125 void MenuPattern1TestNg::SetUpTestCase() {}
126
TearDownTestCase()127 void MenuPattern1TestNg::TearDownTestCase() {}
128
SetUp()129 void MenuPattern1TestNg::SetUp()
130 {
131 MockPipelineContext::SetUp();
132 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
133 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
134 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>()));
135 }
136
TearDown()137 void MenuPattern1TestNg::TearDown()
138 {
139 MockPipelineContext::TearDown();
140 menuFrameNode_ = nullptr;
141 menuAccessibilityProperty_ = nullptr;
142 menuItemFrameNode_ = nullptr;
143 menuItemPattern_ = nullptr;
144 menuItemAccessibilityProperty_ = nullptr;
145 SystemProperties::SetDeviceType(DeviceType::PHONE);
146 ScreenSystemManager::GetInstance().dipScale_ = 1.0;
147 SystemProperties::orientation_ = DeviceOrientation::PORTRAIT;
148 }
149
InitMenuPattern1TestNg()150 void MenuPattern1TestNg::InitMenuPattern1TestNg()
151 {
152 menuFrameNode_ = FrameNode::GetOrCreateFrameNode(V2::MENU_TAG, ViewStackProcessor::GetInstance()->ClaimNodeId(),
153 []() { return AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE); });
154 ASSERT_NE(menuFrameNode_, nullptr);
155
156 menuAccessibilityProperty_ = menuFrameNode_->GetAccessibilityProperty<MenuAccessibilityProperty>();
157 ASSERT_NE(menuAccessibilityProperty_, nullptr);
158 }
159
InitMenuItemTestNg()160 void MenuPattern1TestNg::InitMenuItemTestNg()
161 {
162 menuItemFrameNode_ = FrameNode::GetOrCreateFrameNode(V2::MENU_ITEM_ETS_TAG,
163 ViewStackProcessor::GetInstance()->ClaimNodeId(), []() { return AceType::MakeRefPtr<MenuItemPattern>(); });
164 ASSERT_NE(menuItemFrameNode_, nullptr);
165
166 menuItemPattern_ = menuItemFrameNode_->GetPattern<MenuItemPattern>();
167 ASSERT_NE(menuItemPattern_, nullptr);
168
169 menuItemAccessibilityProperty_ = menuItemFrameNode_->GetAccessibilityProperty<MenuItemAccessibilityProperty>();
170 ASSERT_NE(menuItemAccessibilityProperty_, nullptr);
171 }
172
GetPaintWrapper(RefPtr<MenuPaintProperty> paintProperty)173 PaintWrapper* MenuPattern1TestNg::GetPaintWrapper(RefPtr<MenuPaintProperty> paintProperty)
174 {
175 WeakPtr<RenderContext> renderContext;
176 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
177 PaintWrapper* paintWrapper = new PaintWrapper(renderContext, geometryNode, paintProperty);
178 return paintWrapper;
179 }
180
GetPreviewMenuWrapper(SizeF itemSize,std::optional<MenuPreviewAnimationOptions> scaleOptions)181 RefPtr<FrameNode> MenuPattern1TestNg::GetPreviewMenuWrapper(
182 SizeF itemSize, std::optional<MenuPreviewAnimationOptions> scaleOptions)
183 {
184 auto rootNode = FrameNode::CreateFrameNode(
185 V2::ROOT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<RootPattern>());
186 CHECK_NULL_RETURN(rootNode, nullptr);
187 auto targetNode = FrameNode::CreateFrameNode(
188 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
189 CHECK_NULL_RETURN(targetNode, nullptr);
190 auto textNode = FrameNode::CreateFrameNode(
191 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
192 CHECK_NULL_RETURN(textNode, nullptr);
193 if (!(LessOrEqual(itemSize.Width(), 0.0) || LessOrEqual(itemSize.Height(), 0.0))) {
194 auto itemGeometryNode = textNode->GetGeometryNode();
195 CHECK_NULL_RETURN(itemGeometryNode, nullptr);
196 itemGeometryNode->SetFrameSize(itemSize);
197 }
198 targetNode->MountToParent(rootNode);
199 MenuParam menuParam;
200 menuParam.type = MenuType::CONTEXT_MENU;
201 menuParam.previewMode = MenuPreviewMode::CUSTOM;
202 if (scaleOptions != std::nullopt) {
203 menuParam.previewAnimationOptions = scaleOptions.value();
204 }
205 auto customNode = FrameNode::CreateFrameNode(
206 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
207 CHECK_NULL_RETURN(customNode, nullptr);
208 auto customGeometryNode = customNode->GetGeometryNode();
209 CHECK_NULL_RETURN(customGeometryNode, nullptr);
210 customGeometryNode->SetFrameSize(SizeF(TARGET_SIZE_WIDTH, TARGET_SIZE_HEIGHT));
211 auto menuWrapperNode =
212 MenuView::Create(textNode, targetNode->GetId(), V2::TEXT_ETS_TAG, menuParam, true, customNode);
213 return menuWrapperNode;
214 }
215
216 /**
217 * @tc.name: MenuPatternTestNg001
218 * @tc.desc: Verify RegisterOnTouch.
219 * @tc.type: FUNC
220 */
221 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg001, TestSize.Level1)
222 {
223 RefPtr<MenuPattern> menuPattern = AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE);
224 std::string type = "1";
225 TouchEventInfo info(type);
226 menuPattern->RegisterOnTouch();
227 EXPECT_TRUE(info.GetTouches().empty());
228 }
229
230 /**
231 * @tc.name: MenuPatternTestNg002
232 * @tc.desc: Verify RegisterOnTouch.
233 * @tc.type: FUNC
234 */
235 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg002, TestSize.Level1)
236 {
237 RefPtr<MenuPattern> menuPattern = AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE);
238 std::string type = "1";
239 TouchType touchType = TouchType::UP;
240 TouchEventInfo info(type);
241 TouchLocationInfo locationInfo(TARGET_ID);
242 Offset globalLocation(1, 1);
243 locationInfo.SetTouchType(touchType);
244 auto touchLocationInfo = locationInfo.SetGlobalLocation(globalLocation);
245 info.touches_.emplace_back(touchLocationInfo);
246 menuPattern->RegisterOnTouch();
247 EXPECT_FALSE(info.GetTouches().empty());
248 EXPECT_TRUE(info.GetTouches().front().GetTouchType() == TouchType::UP);
249 }
250
251 /**
252 * @tc.name: MenuPatternTestNg003
253 * @tc.desc: Verify RegisterOnTouch.
254 * @tc.type: FUNC
255 */
256 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg003, TestSize.Level1)
257 {
258 RefPtr<MenuPattern> menuPattern = AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE);
259 std::string type = "1";
260 TouchType touchType = TouchType::UP;
261 TouchEventInfo info(type);
262 TouchLocationInfo locationInfo(TARGET_ID);
263 Offset globalLocation(1, 1);
264 locationInfo.SetTouchType(touchType);
265 auto touchLocationInfo = locationInfo.SetGlobalLocation(globalLocation);
266 info.touches_.emplace_back(touchLocationInfo);
267 menuPattern->type_ = MenuType::CONTEXT_MENU;
268 menuPattern->RegisterOnTouch();
269 EXPECT_FALSE(info.GetTouches().empty());
270 EXPECT_TRUE(info.GetTouches().front().GetTouchType() == TouchType::UP);
271 }
272
273 /**
274 * @tc.name: MenuPatternTestNg004
275 * @tc.desc: Verify RegisterOnTouch.
276 * @tc.type: FUNC
277 */
278 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg004, TestSize.Level1)
279 {
280 RefPtr<MenuPattern> menuPattern = AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE);
281 std::string type = "1";
282 TouchEventInfo info(type);
283 TouchLocationInfo locationInfo(TARGET_ID);
284 Offset globalLocation(1, 1);
285 auto touchLocationInfo = locationInfo.SetGlobalLocation(globalLocation);
286 info.touches_.emplace_back(touchLocationInfo);
287 menuPattern->RegisterOnTouch();
288 EXPECT_FALSE(info.GetTouches().empty());
289 EXPECT_TRUE(info.GetTouches().front().GetTouchType() == TouchType::UNKNOWN);
290 }
291
292 /**
293 * @tc.name: MenuPatternTestNg005
294 * @tc.desc: Verify RegisterOnTouch.
295 * @tc.type: FUNC
296 */
297 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg005, TestSize.Level1)
298 {
299 RefPtr<MenuPattern> menuPattern = AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE);
300 std::string type = "1";
301 TouchEventInfo info(type);
302 TouchType touchType = TouchType::UP;
303 TouchLocationInfo locationInfo(TARGET_ID);
304 locationInfo.SetTouchType(touchType);
305 menuPattern->RegisterOnTouch();
306 EXPECT_TRUE(info.GetTouches().empty());
307 EXPECT_FALSE(info.GetTouches().front().GetTouchType() == TouchType::UP);
308 }
309
310 /**
311 * @tc.name: MenuPatternTestNg006
312 * @tc.desc: Verify UpdateMenuItemChildren.
313 * @tc.type: FUNC
314 */
315 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg006, TestSize.Level1)
316 {
317 MenuModelNG MneuModelInstance;
318 MneuModelInstance.Create();
319 MneuModelInstance.SetFontSize(Dimension(25.0));
320 MneuModelInstance.SetFontColor(Color::RED);
321 MneuModelInstance.SetFontWeight(FontWeight::BOLD);
322 MneuModelInstance.SetFontStyle(Ace::FontStyle::ITALIC);
323
324 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
325 ASSERT_NE(menuNode, nullptr);
326 auto menuPattern = menuNode->GetPattern<MenuPattern>();
327 ASSERT_NE(menuPattern, nullptr);
328 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
329 ASSERT_NE(layoutProperty, nullptr);
330
331 // call UpdateMenuItemChildren
332 menuPattern->OnModifyDone();
333
334 ASSERT_TRUE(layoutProperty->GetFontSize().has_value());
335 EXPECT_EQ(layoutProperty->GetFontSize().value(), Dimension(25.0));
336 ASSERT_TRUE(layoutProperty->GetFontWeight().has_value());
337 EXPECT_EQ(layoutProperty->GetFontWeight().value(), FontWeight::BOLD);
338 ASSERT_TRUE(layoutProperty->GetFontColor().has_value());
339 EXPECT_EQ(layoutProperty->GetFontColor().value(), Color::RED);
340 ASSERT_TRUE(layoutProperty->GetItalicFontStyle().has_value());
341 EXPECT_EQ(layoutProperty->GetItalicFontStyle().value(), Ace::FontStyle::ITALIC);
342 }
343
344 /**
345 * @tc.name: MenuPatternTestNg007
346 * @tc.desc: Verify UpdateMenuItemChildren.
347 * @tc.type: FUNC
348 */
349 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg007, TestSize.Level1)
350 {
351 MenuModelNG MneuModelInstance;
352 MenuItemModelNG MneuItemModelInstance;
353 MneuModelInstance.Create();
354 MneuModelInstance.SetFontSize(Dimension(25.0));
355 MneuModelInstance.SetFontColor(Color::RED);
356 MneuModelInstance.SetFontWeight(FontWeight::BOLD);
357
358 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
359 ASSERT_NE(menuNode, nullptr);
360 auto menuPattern = menuNode->GetPattern<MenuPattern>();
361 ASSERT_NE(menuPattern, nullptr);
362 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
363 ASSERT_NE(layoutProperty, nullptr);
364
365 MenuItemProperties itemOption;
366 itemOption.content = "content";
367 itemOption.labelInfo = "label";
368 MneuItemModelInstance.Create(itemOption);
369 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
370 ASSERT_NE(itemNode, nullptr);
371 auto itemPattern = itemNode->GetPattern<MenuItemPattern>();
372 ASSERT_NE(itemPattern, nullptr);
373 itemPattern->OnModifyDone();
374 itemNode->MountToParent(menuNode);
375 itemNode->OnMountToParentDone();
376
377 // call UpdateMenuItemChildren
378 menuPattern->OnModifyDone();
379
380 auto contentNode = itemPattern->GetContentNode();
381 ASSERT_NE(contentNode, nullptr);
382 auto textProperty = contentNode->GetLayoutProperty<TextLayoutProperty>();
383 ASSERT_NE(textProperty, nullptr);
384 ASSERT_TRUE(textProperty->GetFontSize().has_value());
385 EXPECT_EQ(textProperty->GetFontSize().value(), Dimension(25.0));
386 ASSERT_TRUE(textProperty->GetFontWeight().has_value());
387 EXPECT_EQ(textProperty->GetFontWeight().value(), FontWeight::BOLD);
388 ASSERT_TRUE(textProperty->GetTextColor().has_value());
389 EXPECT_EQ(textProperty->GetTextColor().value(), Color::RED);
390
391 auto labelNode = itemPattern->GetLabelNode();
392 ASSERT_NE(labelNode, nullptr);
393 auto labelProperty = labelNode->GetLayoutProperty<TextLayoutProperty>();
394 ASSERT_NE(labelProperty, nullptr);
395 ASSERT_TRUE(labelProperty->GetFontSize().has_value());
396 EXPECT_EQ(labelProperty->GetFontSize().value(), Dimension(25.0));
397 ASSERT_TRUE(labelProperty->GetFontWeight().has_value());
398 EXPECT_EQ(labelProperty->GetFontWeight().value(), FontWeight::BOLD);
399 ASSERT_TRUE(labelProperty->GetTextColor().has_value());
400 EXPECT_EQ(labelProperty->GetTextColor().value(), Color::RED);
401 }
402
403 /**
404 * @tc.name: MenuPatternTestNg008
405 * @tc.desc: Verify UpdateMenuItemChildren.
406 * @tc.type: FUNC
407 */
408 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg008, TestSize.Level1)
409 {
410 MenuModelNG MneuModelInstance;
411 MenuItemModelNG MneuItemModelInstance;
412 MneuModelInstance.Create();
413 MneuModelInstance.SetFontSize(Dimension(25.0));
414 MneuModelInstance.SetFontColor(Color::RED);
415 MneuModelInstance.SetFontWeight(FontWeight::BOLD);
416
417 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
418 ASSERT_NE(menuNode, nullptr);
419 auto menuPattern = menuNode->GetPattern<MenuPattern>();
420 ASSERT_NE(menuPattern, nullptr);
421 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
422 ASSERT_NE(layoutProperty, nullptr);
423
424 MenuItemProperties itemOption;
425 itemOption.content = "content";
426 itemOption.labelInfo = "label";
427 MneuItemModelInstance.Create(itemOption);
428 MneuItemModelInstance.SetFontSize(Dimension(35.0));
429 MneuItemModelInstance.SetFontColor(Color::BLUE);
430 MneuItemModelInstance.SetFontWeight(FontWeight::LIGHTER);
431 MneuItemModelInstance.SetLabelFontSize(Dimension(40.0));
432 MneuItemModelInstance.SetLabelFontColor(Color::GRAY);
433 MneuItemModelInstance.SetLabelFontWeight(FontWeight::LIGHTER);
434 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
435 ASSERT_NE(itemNode, nullptr);
436 auto itemPattern = itemNode->GetPattern<MenuItemPattern>();
437 ASSERT_NE(itemPattern, nullptr);
438 itemPattern->OnModifyDone();
439 itemNode->MountToParent(menuNode);
440 itemNode->OnMountToParentDone();
441
442 // call UpdateMenuItemChildren
443 menuPattern->OnModifyDone();
444
445 auto contentNode = itemPattern->GetContentNode();
446 ASSERT_NE(contentNode, nullptr);
447 auto textProperty = contentNode->GetLayoutProperty<TextLayoutProperty>();
448 ASSERT_NE(textProperty, nullptr);
449
450 auto labelNode = itemPattern->GetLabelNode();
451 ASSERT_NE(labelNode, nullptr);
452 auto labelProperty = labelNode->GetLayoutProperty<TextLayoutProperty>();
453 ASSERT_NE(labelProperty, nullptr);
454 }
455
456 /**
457 * @tc.name: MenuPatternTestNg009
458 * @tc.desc: Verify UpdateMenuItemChildren.
459 * @tc.type: FUNC
460 */
461 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg009, TestSize.Level1)
462 {
463 MenuModelNG MneuModelInstance;
464 MenuItemModelNG MneuItemModelInstance;
465 MneuModelInstance.Create();
466 MneuModelInstance.SetFontSize(Dimension(25.0));
467 MneuModelInstance.SetFontColor(Color::RED);
468 MneuModelInstance.SetFontWeight(FontWeight::BOLD);
469
470 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
471 ASSERT_NE(menuNode, nullptr);
472 auto menuPattern = menuNode->GetPattern<MenuPattern>();
473 ASSERT_NE(menuPattern, nullptr);
474 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
475 ASSERT_NE(layoutProperty, nullptr);
476
477 MenuItemGroupView::Create();
478 auto groupNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
479 MenuItemGroupView::Create();
480 auto groupNode2 = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
481 ASSERT_NE(groupNode, nullptr);
482 auto groupPattern = groupNode->GetPattern<MenuItemGroupPattern>();
483
484 MenuItemProperties itemOption;
485 itemOption.content = "content";
486 itemOption.labelInfo = "label";
487 MneuItemModelInstance.Create(itemOption);
488 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
489 ASSERT_NE(itemNode, nullptr);
490 auto itemPattern = itemNode->GetPattern<MenuItemPattern>();
491 ASSERT_NE(itemPattern, nullptr);
492 itemPattern->OnModifyDone();
493 itemNode->MountToParent(groupNode);
494 itemNode->OnMountToParentDone();
495 groupPattern->OnModifyDone();
496 groupNode->MountToParent(menuNode);
497 groupNode->OnMountToParentDone();
498 groupNode2->MountToParent(menuNode);
499 groupNode2->OnMountToParentDone();
500
501 // call UpdateMenuItemChildren
502 menuPattern->OnModifyDone();
503
504 auto contentNode = itemPattern->GetContentNode();
505 ASSERT_NE(contentNode, nullptr);
506 auto textProperty = contentNode->GetLayoutProperty<TextLayoutProperty>();
507 ASSERT_NE(textProperty, nullptr);
508 ASSERT_TRUE(textProperty->GetFontSize().has_value());
509 EXPECT_EQ(textProperty->GetFontSize().value(), Dimension(25.0));
510 ASSERT_TRUE(textProperty->GetFontWeight().has_value());
511 EXPECT_EQ(textProperty->GetFontWeight().value(), FontWeight::BOLD);
512 ASSERT_TRUE(textProperty->GetTextColor().has_value());
513 EXPECT_EQ(textProperty->GetTextColor().value(), Color::RED);
514
515 auto labelNode = itemPattern->GetLabelNode();
516 ASSERT_NE(labelNode, nullptr);
517 auto labelProperty = labelNode->GetLayoutProperty<TextLayoutProperty>();
518 ASSERT_NE(labelProperty, nullptr);
519 ASSERT_TRUE(labelProperty->GetFontSize().has_value());
520 EXPECT_EQ(labelProperty->GetFontSize().value(), Dimension(25.0));
521 ASSERT_TRUE(labelProperty->GetFontWeight().has_value());
522 EXPECT_EQ(labelProperty->GetFontWeight().value(), FontWeight::BOLD);
523 ASSERT_TRUE(labelProperty->GetTextColor().has_value());
524 EXPECT_EQ(labelProperty->GetTextColor().value(), Color::RED);
525 }
526
527 /**
528 * @tc.name: MenuPatternTestNg010
529 * @tc.desc: Verify UpdateMenuItemChildren.
530 * @tc.type: FUNC
531 */
532 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg010, TestSize.Level1)
533 {
534 MenuModelNG MneuModelInstance;
535 MenuItemModelNG MneuItemModelInstance;
536 MneuModelInstance.Create();
537 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
538 ASSERT_NE(menuNode, nullptr);
539 auto menuPattern = menuNode->GetPattern<MenuPattern>();
540 ASSERT_NE(menuPattern, nullptr);
541 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
542 ASSERT_NE(layoutProperty, nullptr);
543
544 MenuItemGroupView::Create();
545 auto groupNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
546 ASSERT_NE(groupNode, nullptr);
547 auto groupPattern = groupNode->GetPattern<MenuItemGroupPattern>();
548
549 MenuItemProperties itemOption;
550 itemOption.content = "content";
551 MneuItemModelInstance.Create(itemOption);
552 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
553 ASSERT_NE(itemNode, nullptr);
554 auto itemPattern = itemNode->GetPattern<MenuItemPattern>();
555 ASSERT_NE(itemPattern, nullptr);
556 itemPattern->OnModifyDone();
557 itemNode->MountToParent(groupNode);
558 itemNode->OnMountToParentDone();
559 auto textNode = FrameNode::CreateFrameNode(
560 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
561 auto textPattern = textNode->GetPattern<TextPattern>();
562 textPattern->OnModifyDone();
563 textNode->MountToParent(groupNode);
564 textNode->OnMountToParentDone();
565 groupPattern->OnModifyDone();
566 groupNode->MountToParent(menuNode);
567 groupNode->OnMountToParentDone();
568
569 // call UpdateMenuItemChildren
570 menuPattern->OnModifyDone();
571
572 auto contentNode = itemPattern->GetContentNode();
573 ASSERT_NE(contentNode, nullptr);
574 auto textProperty = contentNode->GetLayoutProperty<TextLayoutProperty>();
575 ASSERT_NE(textProperty, nullptr);
576
577 auto labelNode = itemPattern->GetLabelNode();
578 ASSERT_EQ(labelNode, nullptr);
579 }
580
581 /**
582 * @tc.name: MenuPatternTestNg011
583 * @tc.desc: Verify UpdateMenuItemChildren.
584 * @tc.type: FUNC
585 */
586 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg011, TestSize.Level1)
587 {
588 MenuModelNG MneuModelInstance;
589 MenuItemModelNG MneuItemModelInstance;
590 MneuModelInstance.Create();
591 MneuModelInstance.SetFontSize(Dimension(25.0));
592 MneuModelInstance.SetFontColor(Color::RED);
593 MneuModelInstance.SetFontWeight(FontWeight::BOLD);
594 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
595 ASSERT_NE(menuNode, nullptr);
596 auto menuPattern = menuNode->GetPattern<MenuPattern>();
597 ASSERT_NE(menuPattern, nullptr);
598 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
599 ASSERT_NE(layoutProperty, nullptr);
600
601 MenuItemProperties itemOption;
602 itemOption.content = "content";
603 MneuItemModelInstance.Create(itemOption);
604 MneuItemModelInstance.SetFontStyle(Ace::FontStyle::ITALIC);
605 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
606 ASSERT_NE(itemNode, nullptr);
607 auto itemPattern = itemNode->GetPattern<MenuItemPattern>();
608 ASSERT_NE(itemPattern, nullptr);
609 itemPattern->OnModifyDone();
610 itemNode->MountToParent(menuNode);
611 itemNode->OnMountToParentDone();
612
613 // call UpdateMenuItemChildren
614 menuPattern->OnModifyDone();
615 itemPattern->OnModifyDone();
616 auto labelNode = itemPattern->GetLabelNode();
617 ASSERT_EQ(labelNode, nullptr);
618 }
619
620 /**
621 * @tc.name: MenuPatternTestNg012
622 * @tc.desc: Verify UpdateSelectParam.
623 * @tc.type: FUNC
624 */
625 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg012, TestSize.Level1)
626 {
627 auto wrapperNode = MenuView::Create(CREATE_VALUE, TARGET_ID, EMPTY_TEXT);
628 ASSERT_NE(wrapperNode, nullptr);
629 auto menuNode = AceType::DynamicCast<FrameNode>(wrapperNode->GetChildAtIndex(0));
630 ASSERT_NE(menuNode, nullptr);
631
632 auto menuPattern = menuNode->GetPattern<MenuPattern>();
633 ASSERT_NE(menuPattern, nullptr);
634 ASSERT_EQ(menuPattern->GetOptions().size(), 4);
635 const auto& children = menuPattern->GetOptions();
636 auto childIt = children.begin();
637 for (size_t i = 0; i < children.size(); i++, childIt++) {
638 const auto& childNode = AceType::DynamicCast<FrameNode>(*childIt);
639 ASSERT_NE(childNode, nullptr);
640 auto optionPattern = childNode->GetPattern<OptionPattern>();
641 ASSERT_NE(optionPattern, nullptr);
642 ASSERT_NE(optionPattern->text_, nullptr);
643 auto textProps = optionPattern->text_->GetLayoutProperty<TextLayoutProperty>();
644 ASSERT_NE(textProps, nullptr);
645 auto param = CREATE_VALUE.at(i);
646 EXPECT_EQ(textProps->GetContent().value_or(""), param.text);
647 if (param.icon.empty()) {
648 ASSERT_EQ(optionPattern->icon_, nullptr);
649 } else {
650 ASSERT_NE(optionPattern->icon_, nullptr);
651 auto imageProps = optionPattern->icon_->GetLayoutProperty<ImageLayoutProperty>();
652 ASSERT_NE(imageProps, nullptr);
653 auto imageSrcInfo = imageProps->GetImageSourceInfo();
654 ASSERT_TRUE(imageSrcInfo.has_value());
655 ASSERT_EQ(imageSrcInfo->GetSrc(), param.icon);
656 }
657 }
658 std::vector<SelectParam> params;
659 params.clear();
660 menuPattern->UpdateSelectParam(params);
661 ASSERT_EQ(menuPattern->GetOptions().size(), 0);
662 }
663
664 /**
665 * @tc.name: MenuPatternTestNg013
666 * @tc.desc: Verify UpdateSelectParam.
667 * @tc.type: FUNC
668 */
669 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg013, TestSize.Level1)
670 {
671 std::vector<SelectParam> params;
672 auto wrapperNode = MenuView::Create(params, TARGET_ID, EMPTY_TEXT);
673 ASSERT_NE(wrapperNode, nullptr);
674 auto menuNode = AceType::DynamicCast<FrameNode>(wrapperNode->GetChildAtIndex(0));
675 ASSERT_NE(menuNode, nullptr);
676 ASSERT_EQ(menuNode->GetChildren().size(), 1);
677
678 auto menuPattern = menuNode->GetPattern<MenuPattern>();
679 ASSERT_NE(menuPattern, nullptr);
680 menuPattern->UpdateSelectParam(CREATE_VALUE);
681
682 ASSERT_EQ(menuPattern->GetOptions().size(), 4);
683 const auto& children = menuPattern->GetOptions();
684 auto childIt = children.begin();
685 for (size_t i = 0; i < children.size(); i++, childIt++) {
686 const auto& childNode = AceType::DynamicCast<FrameNode>(*childIt);
687 ASSERT_NE(childNode, nullptr);
688 auto optionPattern = childNode->GetPattern<OptionPattern>();
689 ASSERT_NE(optionPattern, nullptr);
690 ASSERT_NE(optionPattern->text_, nullptr);
691 auto textProps = optionPattern->text_->GetLayoutProperty<TextLayoutProperty>();
692 ASSERT_NE(textProps, nullptr);
693 auto param = CREATE_VALUE.at(i);
694 EXPECT_EQ(textProps->GetContent().value_or(""), param.text);
695 if (param.icon.empty()) {
696 ASSERT_EQ(optionPattern->icon_, nullptr);
697 } else {
698 ASSERT_NE(optionPattern->icon_, nullptr);
699 auto imageProps = optionPattern->icon_->GetLayoutProperty<ImageLayoutProperty>();
700 ASSERT_NE(imageProps, nullptr);
701 auto imageSrcInfo = imageProps->GetImageSourceInfo();
702 ASSERT_TRUE(imageSrcInfo.has_value());
703 ASSERT_EQ(imageSrcInfo->GetSrc(), param.icon);
704 }
705 }
706 }
707
708 /**
709 * @tc.name: MenuPatternTestNg014
710 * @tc.desc: Verify UpdateSelectParam.
711 * @tc.type: FUNC
712 */
713 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg014, TestSize.Level1)
714 {
715 std::vector<SelectParam> params;
716 auto wrapperNode = MenuView::Create(params, TARGET_ID, EMPTY_TEXT);
717 ASSERT_NE(wrapperNode, nullptr);
718 auto menuNode = AceType::DynamicCast<FrameNode>(wrapperNode->GetChildAtIndex(0));
719 ASSERT_NE(menuNode, nullptr);
720 auto menuPattern = menuNode->GetPattern<MenuPattern>();
721 ASSERT_NE(menuPattern, nullptr);
722 ASSERT_EQ(menuPattern->GetOptions().size(), 0);
723
724 menuPattern->UpdateSelectParam(params);
725 ASSERT_EQ(menuPattern->GetOptions().size(), 0);
726 }
727
728 /**
729 * @tc.name: MenuPatternTestNg015
730 * @tc.desc: Verify UpdateSelectParam.
731 * @tc.type: FUNC
732 */
733 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg015, TestSize.Level1)
734 {
735 auto wrapperNode = MenuView::Create(CREATE_VALUE, TARGET_ID, EMPTY_TEXT);
736 ASSERT_NE(wrapperNode, nullptr);
737 auto menuNode = AceType::DynamicCast<FrameNode>(wrapperNode->GetChildAtIndex(0));
738 ASSERT_NE(menuNode, nullptr);
739
740 auto menuPattern = menuNode->GetPattern<MenuPattern>();
741 ASSERT_NE(menuPattern, nullptr);
742 ASSERT_EQ(menuPattern->GetOptions().size(), 4);
743
744 menuPattern->UpdateSelectParam(CREATE_VALUE_NEW);
745 ASSERT_EQ(menuPattern->GetOptions().size(), 4);
746
747 const auto& children = menuPattern->GetOptions();
748 auto childIt = children.begin();
749 for (size_t i = 0; i < children.size(); i++, childIt++) {
750 const auto& childNode = AceType::DynamicCast<FrameNode>(*childIt);
751 ASSERT_NE(childNode, nullptr);
752 auto optionPattern = childNode->GetPattern<OptionPattern>();
753 ASSERT_NE(optionPattern, nullptr);
754 ASSERT_NE(optionPattern->text_, nullptr);
755 auto textProps = optionPattern->text_->GetLayoutProperty<TextLayoutProperty>();
756 ASSERT_NE(textProps, nullptr);
757 auto param = CREATE_VALUE_NEW.at(i);
758 EXPECT_EQ(textProps->GetContent().value_or(""), param.text);
759 if (param.icon.empty()) {
760 ASSERT_EQ(optionPattern->icon_, nullptr);
761 } else {
762 ASSERT_NE(optionPattern->icon_, nullptr);
763 auto imageProps = optionPattern->icon_->GetLayoutProperty<ImageLayoutProperty>();
764 ASSERT_NE(imageProps, nullptr);
765 auto imageSrcInfo = imageProps->GetImageSourceInfo();
766 ASSERT_TRUE(imageSrcInfo.has_value());
767 ASSERT_EQ(imageSrcInfo->GetSrc(), param.icon);
768 }
769 }
770 }
771
772 /**
773 * @tc.name: MenuPatternTestNg016
774 * @tc.desc: Verify UpdateSelectParam.
775 * @tc.type: FUNC
776 */
777 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg016, TestSize.Level1)
778 {
779 auto wrapperNode = MenuView::Create(CREATE_VALUE, TARGET_ID, EMPTY_TEXT);
780 ASSERT_NE(wrapperNode, nullptr);
781 auto menuNode = AceType::DynamicCast<FrameNode>(wrapperNode->GetChildAtIndex(0));
782 ASSERT_NE(menuNode, nullptr);
783
784 auto menuPattern = menuNode->GetPattern<MenuPattern>();
785 ASSERT_NE(menuPattern, nullptr);
786 ASSERT_EQ(menuPattern->GetOptions().size(), 4);
787
788 std::vector<SelectParam> params;
789 params.push_back({ "content1_new", "" });
790 params.push_back({ "content2_new", "icon2_new" });
791 params.push_back({ "", "" });
792 menuPattern->UpdateSelectParam(params);
793 ASSERT_EQ(menuPattern->GetOptions().size(), 3);
794
795 const auto& children = menuPattern->GetOptions();
796 auto childIt = children.begin();
797 for (size_t i = 0; i < children.size(); i++, childIt++) {
798 const auto& childNode = AceType::DynamicCast<FrameNode>(*childIt);
799 ASSERT_NE(childNode, nullptr);
800 auto optionPattern = childNode->GetPattern<OptionPattern>();
801 ASSERT_NE(optionPattern, nullptr);
802 ASSERT_NE(optionPattern->text_, nullptr);
803 auto textProps = optionPattern->text_->GetLayoutProperty<TextLayoutProperty>();
804 ASSERT_NE(textProps, nullptr);
805 auto param = params.at(i);
806 EXPECT_EQ(textProps->GetContent().value_or(""), param.text);
807 if (param.icon.empty()) {
808 ASSERT_EQ(optionPattern->icon_, nullptr);
809 } else {
810 ASSERT_NE(optionPattern->icon_, nullptr);
811 auto imageProps = optionPattern->icon_->GetLayoutProperty<ImageLayoutProperty>();
812 ASSERT_NE(imageProps, nullptr);
813 auto imageSrcInfo = imageProps->GetImageSourceInfo();
814 ASSERT_TRUE(imageSrcInfo.has_value());
815 ASSERT_EQ(imageSrcInfo->GetSrc(), param.icon);
816 }
817 }
818 }
819
820 /**
821 * @tc.name: MenuPatternTestNg017
822 * @tc.desc: Verify UpdateSelectParam.
823 * @tc.type: FUNC
824 */
825 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg017, TestSize.Level1)
826 {
827 std::vector<SelectParam> params;
828 params.push_back({ "content1", "icon1" });
829 params.push_back({ "content2", "" });
830 params.push_back({ "", "icon3" });
831 auto wrapperNode = MenuView::Create(params, TARGET_ID, EMPTY_TEXT);
832 ASSERT_NE(wrapperNode, nullptr);
833 auto menuNode = AceType::DynamicCast<FrameNode>(wrapperNode->GetChildAtIndex(0));
834 ASSERT_NE(menuNode, nullptr);
835
836 auto menuPattern = menuNode->GetPattern<MenuPattern>();
837 ASSERT_NE(menuPattern, nullptr);
838 ASSERT_EQ(menuPattern->GetOptions().size(), 3);
839
840
841 menuPattern->UpdateSelectParam(CREATE_VALUE_NEW);
842 ASSERT_EQ(menuPattern->GetOptions().size(), 4);
843
844 const auto& children = menuPattern->GetOptions();
845 auto childIt = children.begin();
846 for (size_t i = 0; i < children.size(); i++, childIt++) {
847 const auto& childNode = AceType::DynamicCast<FrameNode>(*childIt);
848 ASSERT_NE(childNode, nullptr);
849 auto optionPattern = childNode->GetPattern<OptionPattern>();
850 ASSERT_NE(optionPattern, nullptr);
851 ASSERT_NE(optionPattern->text_, nullptr);
852 auto textProps = optionPattern->text_->GetLayoutProperty<TextLayoutProperty>();
853 ASSERT_NE(textProps, nullptr);
854 auto param = CREATE_VALUE_NEW.at(i);
855 EXPECT_EQ(textProps->GetContent().value_or(""), param.text);
856 if (param.icon.empty()) {
857 ASSERT_EQ(optionPattern->icon_, nullptr);
858 } else {
859 ASSERT_NE(optionPattern->icon_, nullptr);
860 auto imageProps = optionPattern->icon_->GetLayoutProperty<ImageLayoutProperty>();
861 ASSERT_NE(imageProps, nullptr);
862 auto imageSrcInfo = imageProps->GetImageSourceInfo();
863 ASSERT_TRUE(imageSrcInfo.has_value());
864 ASSERT_EQ(imageSrcInfo->GetSrc(), param.icon);
865 }
866 }
867 }
868
869 /**
870 * @tc.name: MenuPatternTestNg018
871 * @tc.desc: Verify UpdateMenuItemChildren.
872 * @tc.type: FUNC
873 */
874 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg018, TestSize.Level1)
875 {
876 MenuModelNG MneuModelInstance;
877 MneuModelInstance.Create();
878 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
879 ASSERT_NE(menuNode, nullptr);
880 auto menuPattern = menuNode->GetPattern<MenuPattern>();
881 ASSERT_NE(menuPattern, nullptr);
882
883 ASSERT_EQ(menuPattern->GetOptions().size(), 0);
884 std::vector<SelectParam> params;
885 params.push_back({ "content1", "icon1" });
886 menuPattern->UpdateSelectParam(params);
887 ASSERT_EQ(menuPattern->GetOptions().size(), 0);
888 }
889
890 /**
891 * @tc.name: MenuPatternTestNg019
892 * @tc.desc: Test MultiMenu and outer Menu container.
893 */
894 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg019, TestSize.Level1)
895 {
896 MockPipelineContext::GetCurrent()->SetMinPlatformVersion(static_cast<int32_t>(PlatformVersion::VERSION_ELEVEN));
897 MenuModelNG model;
898 model.Create();
899 auto multiMenu = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
900 auto menuWrapper = MenuView::Create(multiMenu, -1, EMPTY_TEXT);
901 ASSERT_NE(menuWrapper, nullptr);
902 auto outerMenu = AceType::DynamicCast<FrameNode>(menuWrapper->GetFirstChild());
903 ASSERT_NE(outerMenu, nullptr);
904
905 // backgroundColor should be reset
906 ASSERT_EQ(outerMenu->GetRenderContext()->GetBackgroundColorValue(), Color::TRANSPARENT);
907
908 // padding should be moved to inner multi menu
909 auto scroll = AceType::DynamicCast<FrameNode>(outerMenu->GetFirstChild());
910 ASSERT_NE(scroll, nullptr);
911 auto&& padding = scroll->GetLayoutProperty()->GetPaddingProperty();
912 // should have empty padding
913 ASSERT_EQ(padding->ToString(), PaddingProperty().ToString());
914
915 multiMenu->GetPattern()->BeforeCreateLayoutWrapper();
916 // inner multi menu should have backgroundColor and padding set up
917 ASSERT_NE(multiMenu->GetLayoutProperty()->GetPaddingProperty()->ToString(), PaddingProperty().ToString());
918 ASSERT_NE(multiMenu->GetRenderContext()->GetBackgroundColor(), Color::TRANSPARENT);
919 // inner menu should have no shadow
920 ASSERT_EQ(multiMenu->GetRenderContext()->GetBackShadow(), ShadowConfig::NoneShadow);
921
922 // MultiMenu should have its own layout algorithm
923 auto layoutAlgorithm = multiMenu->GetPattern<MenuPattern>()->CreateLayoutAlgorithm();
924 ASSERT_NE(AceType::DynamicCast<MultiMenuLayoutAlgorithm>(layoutAlgorithm), nullptr);
925 }
926
927 /**
928 * @tc.name: MenuPatternTestNg020
929 * @tc.desc: Verify UpdateMenuItemChildren.
930 * @tc.type: FUNC
931 */
932 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg020, TestSize.Level1)
933 {
934 /**
935 * @tc.steps: step1. create MenuModelNG and MenuItemModelNG object and set FontStyle properties of MenuModelNG.
936 */
937 MenuModelNG MneuModelInstance;
938 MenuItemModelNG MneuItemModelInstance;
939 MneuModelInstance.Create();
940 MneuModelInstance.SetFontStyle(Ace::FontStyle::ITALIC);
941
942 /**
943 * @tc.steps: step2. get the frameNode, MenuPattern and MenuLayoutProperty.
944 * @tc.expected: step2. check whether the objects is available.
945 */
946 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
947 ASSERT_NE(menuNode, nullptr);
948 auto menuPattern = menuNode->GetPattern<MenuPattern>();
949 ASSERT_NE(menuPattern, nullptr);
950 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
951 ASSERT_NE(layoutProperty, nullptr);
952
953 /**
954 * @tc.steps: step3. not set FontStyle properties of MenuModelNG.
955 */
956 MenuItemProperties itemOption;
957 itemOption.content = "content";
958 itemOption.labelInfo = "label";
959 MneuItemModelInstance.Create(itemOption);
960 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
961 ASSERT_NE(itemNode, nullptr);
962 auto itemPattern = itemNode->GetPattern<MenuItemPattern>();
963 ASSERT_NE(itemPattern, nullptr);
964 itemPattern->OnModifyDone();
965 itemNode->MountToParent(menuNode);
966 itemNode->OnMountToParentDone();
967
968 /**
969 * @tc.steps: step4. call OnModifyDone of MenuPattern to call UpdateMenuItemChildren
970 */
971 menuPattern->OnModifyDone();
972
973 /**
974 * @tc.steps: step5. get the FontStyle properties of menuItemLayoutProperty.
975 * @tc.expected: step5. check whether the FontStyle properties is is correct.
976 */
977 auto contentNode = itemPattern->GetContentNode();
978 ASSERT_NE(contentNode, nullptr);
979 auto textProperty = contentNode->GetLayoutProperty<TextLayoutProperty>();
980 ASSERT_NE(textProperty, nullptr);
981 ASSERT_TRUE(textProperty->GetItalicFontStyle().has_value());
982 EXPECT_EQ(textProperty->GetItalicFontStyle().value(), Ace::FontStyle::ITALIC);
983 }
984
985 /**
986 * @tc.name: MenuPatternTest021
987 * @tc.desc: Verify RegisterOnTouch.
988 * @tc.type: FUNC
989 */
990 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg021, TestSize.Level1)
991 {
992 MenuPattern* menuPattern = new MenuPattern(TARGET_ID, "", TYPE);
993 const std::string tag = "tag";
994 int32_t nodeId = 1;
995 RefPtr<Pattern> pattern = AceType::MakeRefPtr<Pattern>();
996 bool isRoot = false;
997 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
998 RefPtr<FrameNode> frameNode = AceType::MakeRefPtr<FrameNode>(tag, nodeId, pattern, isRoot);
999 const RefPtr<LayoutWrapperNode> layoutWrapper;
1000 std::string type = "1";
1001 TouchEventInfo info(type);
1002 TouchType touchType = TouchType::UP;
1003 TouchLocationInfo locationInfo(TARGET_ID);
1004 Offset globalLocation(1, 1);
1005 locationInfo.SetTouchType(touchType);
1006 auto touchLocationInfo = locationInfo.SetGlobalLocation(globalLocation);
1007 info.touches_.emplace_back(touchLocationInfo);
1008 menuPattern->OnTouchEvent(info);
1009 menuPattern->RegisterOnTouch();
1010 KeyEvent keyEvent(KeyCode::KEY_ESCAPE, KeyAction::UP);
1011 EXPECT_FALSE(menuPattern->IsMultiMenu());
1012 EXPECT_FALSE(menuPattern->OnKeyEvent(keyEvent));
1013 menuPattern->HideMenu();
1014 menuPattern->HideSubMenu();
1015 EXPECT_FALSE(menuPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, configDirtySwap));
1016 menuPattern->type_ = MenuType::SUB_MENU;
1017 EXPECT_FALSE(menuPattern->OnKeyEvent(keyEvent));
1018 menuPattern->HideMenu();
1019 menuPattern->HideSubMenu();
1020 menuPattern->RemoveParentHoverStyle();
1021 delete menuPattern;
1022 menuPattern = nullptr;
1023 }
1024
1025 /**
1026 * @tc.name: MenuPatternTestNg022
1027 * @tc.desc: Verify OnTouchEvent.
1028 * @tc.type: FUNC
1029 */
1030 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg022, TestSize.Level1)
1031 {
1032 /**
1033 * @tc.steps: step1. multi menu touch event
1034 * @tc.expected: menu type is multi
1035 */
1036 auto multiMenuPattern = AceType::MakeRefPtr<MenuPattern>(-1, "", MenuType::MULTI_MENU);
1037 TouchEventInfo multiMenuTouchEventInfo(MENU_TOUCH_EVENT_TYPE);
1038 multiMenuPattern->OnTouchEvent(multiMenuTouchEventInfo);
1039 EXPECT_TRUE(multiMenuPattern->IsMultiMenu());
1040 /**
1041 * @tc.steps: step2. select menu touch event
1042 * @tc.expected: menu options nums as expected
1043 */
1044 std::vector<SelectParam> selectParams;
1045 selectParams.push_back({ "content", "icon" });
1046 auto selectWrapperNode = MenuView::Create(selectParams, TARGET_ID, EMPTY_TEXT);
1047 ASSERT_NE(selectWrapperNode, nullptr);
1048 auto selectMenuNode = AceType::DynamicCast<FrameNode>(selectWrapperNode->GetChildAtIndex(0));
1049 ASSERT_NE(selectMenuNode, nullptr);
1050 TouchEventInfo selectMenuEventInfo(MENU_TOUCH_EVENT_TYPE);
1051 auto selectMenuPattern = selectMenuNode->GetPattern<MenuPattern>();
1052 ASSERT_NE(selectMenuPattern, nullptr);
1053 selectMenuPattern->OnTouchEvent(selectMenuEventInfo);
1054 ASSERT_EQ(selectMenuPattern->GetOptions().size(), 1);
1055 /**
1056 * @tc.steps: step3. contextMenu touch event
1057 * @tc.expected: menu type is context
1058 */
1059 auto contextMenuPattern = AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", MenuType::CONTEXT_MENU);
1060 // excute touch down event
1061 TouchEventInfo contextMenuTouchDownEventInfo(MENU_TOUCH_EVENT_TYPE);
1062 TouchLocationInfo downLocationInfo(TARGET_ID);
1063 Offset touchDownGlobalLocation(1, 1);
1064 downLocationInfo.SetTouchType(TouchType::DOWN);
1065 auto touchDownLocationInfo = downLocationInfo.SetGlobalLocation(touchDownGlobalLocation);
1066 contextMenuTouchDownEventInfo.touches_.emplace_back(touchDownLocationInfo);
1067 contextMenuPattern->OnTouchEvent(contextMenuTouchDownEventInfo);
1068 // execute touch up event
1069 TouchEventInfo contextMenuTouchUpEventInfo(MENU_TOUCH_EVENT_TYPE);
1070 TouchLocationInfo upLocationInfo(TARGET_ID);
1071 Offset touchUpGlobalLocation(3, 3);
1072 upLocationInfo.SetTouchType(TouchType::UP);
1073 auto touchUpLocationInfo = upLocationInfo.SetGlobalLocation(touchUpGlobalLocation);
1074 contextMenuTouchUpEventInfo.touches_.emplace_back(touchUpLocationInfo);
1075 contextMenuPattern->OnTouchEvent(contextMenuTouchUpEventInfo);
1076 EXPECT_TRUE(contextMenuPattern->IsContextMenu());
1077 }
1078
1079 /**
1080 * @tc.name: MenuPatternTestNg023
1081 * @tc.desc: Verify OnKeyEvent.
1082 * @tc.type: FUNC
1083 */
1084 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg023, TestSize.Level1)
1085 {
1086 /**
1087 * @tc.steps: step1. create menu wrapper
1088 * @tc.expected: wrapper node is not null and has 1 child
1089 */
1090 std::vector<SelectParam> selectParams;
1091 selectParams.push_back({ "MenuItem1", "Icon1" });
1092 auto menuWrapperNode = MenuView::Create(std::move(selectParams), 1, EMPTY_TEXT);
1093 ASSERT_NE(menuWrapperNode, nullptr);
1094 EXPECT_EQ(menuWrapperNode->GetChildren().size(), 1);
1095 /**
1096 * @tc.steps: step2. execute OnKeyEvent
1097 * @tc.expected: result as expected
1098 */
1099 auto menuNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(0));
1100 ASSERT_NE(menuNode, nullptr);
1101 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1102 menuPattern->type_ = MenuType::SUB_MENU;
1103 KeyEvent escapeKeyEvent(KeyCode::KEY_ESCAPE, KeyAction::DOWN);
1104 EXPECT_TRUE(menuPattern->OnKeyEvent(escapeKeyEvent));
1105 KeyEvent upKeyEvent(KeyCode::KEY_PLUS, KeyAction::DOWN);
1106 EXPECT_FALSE(menuPattern->OnKeyEvent(upKeyEvent));
1107 }
1108
1109 /**
1110 * @tc.name: MenuPatternTestNg024
1111 * @tc.desc: Verify RemoveParentHoverStyle.
1112 * @tc.type: FUNC
1113 */
1114 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg024, TestSize.Level1)
1115 {
1116 /**
1117 * @tc.steps: step1. create menuItem and menu
1118 * @tc.expected: menuItem not null
1119 */
1120 auto menuPattern = AceType::MakeRefPtr<MenuPattern>(-1, "", MenuType::MENU);
1121 auto menuItemPattern = AceType::MakeRefPtr<MenuItemPattern>();
1122 auto menuItem = AceType::MakeRefPtr<FrameNode>("", -1, menuItemPattern);
1123 ASSERT_NE(menuItem, nullptr);
1124 /**
1125 * @tc.steps: step2. execute RemoveParentHoverStyle
1126 * @tc.expected: item IsSubMenuShowed as expected
1127 */
1128 menuPattern->SetParentMenuItem(menuItem);
1129 menuPattern->RemoveParentHoverStyle();
1130 auto itemPattern = menuItem->GetPattern<MenuItemPattern>();
1131 EXPECT_FALSE(itemPattern->IsSubMenuShowed());
1132 menuPattern->type_ = MenuType::SUB_MENU;
1133 menuPattern->RemoveParentHoverStyle();
1134 EXPECT_FALSE(itemPattern->IsSubMenuShowed());
1135 }
1136
1137 /**
1138 * @tc.name: MenuPatternTestNg025
1139 * @tc.desc: Verify MenuPattern::HideStackExpandMenu.
1140 * @tc.type: FUNC
1141 */
1142 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg025, TestSize.Level1)
1143 {
1144 /**
1145 * @tc.steps: step1. Create MENU_ETS_TAG child and mount to a menuwrapper;
1146 * @tc.expected: menu is not sub menu.
1147 */
1148 auto wrapperNode =
1149 FrameNode::CreateFrameNode(V2::MENU_WRAPPER_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1150 auto mainMenu = FrameNode::CreateFrameNode(
1151 V2::SELECT_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1152 auto menuNode =
1153 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 3, AceType::MakeRefPtr<MenuPattern>(2, "", MenuType::MENU));
1154 menuNode->GetGeometryNode()->SetFrameSize(SizeF(MENU_SIZE_WIDTH, MENU_SIZE_HEIGHT));
1155 menuNode->GetGeometryNode()->SetFrameOffset(OffsetF(MENU_OFFSET_X, MENU_OFFSET_Y));
1156 mainMenu->MountToParent(wrapperNode);
1157 menuNode->MountToParent(mainMenu);
1158 auto wrapperPattern = wrapperNode->GetPattern<MenuWrapperPattern>();
1159 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1160 ASSERT_NE(wrapperPattern, nullptr);
1161 ASSERT_NE(menuPattern, nullptr);
1162 menuPattern->type_ = MenuType::CONTEXT_MENU;
1163 auto layoutProps = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
1164 layoutProps->UpdateExpandingMode(SubMenuExpandingMode::STACK);
1165 menuPattern->HideStackExpandMenu(OffsetF(0.0f, 0.0f));
1166 EXPECT_FALSE(menuPattern->IsSubMenu());
1167 /**
1168 * @tc.steps: step1+. make menu change sub menu.
1169 */
1170 menuPattern->type_ = MenuType::SUB_MENU;
1171 menuPattern->HideStackExpandMenu(OffsetF(0.0f, 0.0f));
1172 EXPECT_TRUE(menuPattern->IsSubMenu());
1173 /**
1174 * @tc.steps: step1+. make menu change sub menu.
1175 */
1176 bool testResult = menuPattern->HideStackExpandMenu(OffsetF(0.0f, 0.0f));
1177 EXPECT_FALSE(testResult);
1178 }
1179
1180 /**
1181 * @tc.name: MenuPatternTestNg026
1182 * @tc.desc: Verify HideSubMenu.
1183 * @tc.type: FUNC
1184 */
1185 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg026, TestSize.Level1)
1186 {
1187 /**
1188 * @tc.steps: step1. create menu wrapper
1189 * @tc.expected: wrapper node is not null and has 1 child
1190 */
1191 std::vector<SelectParam> selectParams;
1192 selectParams.push_back({ "MenuItem1", "Icon1" });
1193 auto menuWrapperNode = MenuView::Create(std::move(selectParams), 1, EMPTY_TEXT);
1194 ASSERT_NE(menuWrapperNode, nullptr);
1195 EXPECT_EQ(menuWrapperNode->GetChildren().size(), 1);
1196 /**
1197 * @tc.steps: step2. execute HideSubMenu
1198 * @tc.expected: result as expected
1199 */
1200 auto menuNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(0));
1201 ASSERT_NE(menuNode, nullptr);
1202 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1203 auto menuItemPattern = AceType::MakeRefPtr<MenuItemPattern>();
1204 auto menuItem = AceType::MakeRefPtr<FrameNode>("", -1, menuItemPattern);
1205 menuPattern->SetParentMenuItem(menuItem);
1206 menuPattern->type_ = MenuType::SUB_MENU;
1207 menuPattern->SetShowedSubMenu(menuNode);
1208 menuPattern->HideSubMenu();
1209 auto itemPattern = menuItem->GetPattern<MenuItemPattern>();
1210 EXPECT_FALSE(itemPattern->IsSubMenuShowed());
1211 ASSERT_EQ(menuPattern->GetShowedSubMenu(), nullptr);
1212 }
1213
1214 /**
1215 * @tc.name: MenuPatternTestNg027
1216 * @tc.desc: Verify GetMenuWrapper,GetMainMenuPattern.
1217 * @tc.type: FUNC
1218 */
1219 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg027, TestSize.Level1)
1220 {
1221 /**
1222 * @tc.steps: step1. create menu wrapper and menu
1223 * @tc.expected: wrapper node is not null and has 1 child
1224 */
1225 std::vector<SelectParam> selectParams;
1226 selectParams.push_back({ "MenuItem1", "Icon1" });
1227 auto menuWrapperNode = MenuView::Create(std::move(selectParams), 1, EMPTY_TEXT);
1228 ASSERT_NE(menuWrapperNode, nullptr);
1229 EXPECT_EQ(menuWrapperNode->GetChildren().size(), 1);
1230 auto menuNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(0));
1231 ASSERT_NE(menuNode, nullptr);
1232 /**
1233 * @tc.steps: step2. create child to menu, execute GetMenuWrapper,GetMainMenuPattern,GetInnerMenuCount
1234 * @tc.expected: result as expected
1235 */
1236 auto multiMenu =
1237 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 1, AceType::MakeRefPtr<MenuPattern>(1, "", MenuType::MULTI_MENU));
1238 multiMenu->MountToParent(menuNode);
1239 auto multiPattern = multiMenu->GetPattern<MenuPattern>();
1240 ASSERT_NE(multiPattern, nullptr);
1241 ASSERT_NE(multiPattern->GetMenuWrapper(), nullptr);
1242 ASSERT_NE(multiPattern->GetMainMenuPattern(), nullptr);
1243 EXPECT_EQ(multiPattern->GetInnerMenuCount(), 0);
1244 /**
1245 * @tc.steps: step3. create cascade node
1246 * @tc.expected: wrapper node relate to child node pattern is null
1247 */
1248 auto singleMenu =
1249 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 1, AceType::MakeRefPtr<MenuPattern>(1, "", MenuType::MULTI_MENU));
1250 auto singleParentMenu =
1251 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(2, "", MenuType::MENU));
1252 singleMenu->MountToParent(singleParentMenu);
1253 auto singleMenuPattern = singleMenu->GetPattern<MenuPattern>();
1254 ASSERT_EQ(singleMenuPattern->GetMenuWrapper(), nullptr);
1255 }
1256
1257 /**
1258 * @tc.name: MenuPatternTestNg028
1259 * @tc.desc: Verify some condition in api 11.
1260 * @tc.type: FUNC
1261 */
1262 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg028, TestSize.Level1)
1263 {
1264 /**
1265 * @tc.steps: step1. set current api 11, create menu wrapper and menu
1266 * @tc.expected: menu blurStyle meet expectations
1267 */
1268 MockPipelineContext::GetCurrent()->SetMinPlatformVersion(static_cast<int32_t>(PlatformVersion::VERSION_ELEVEN));
1269 std::vector<SelectParam> selectParams;
1270 selectParams.push_back({ "MenuItem1", "Icon1" });
1271 auto menuWrapperNode = MenuView::Create(std::move(selectParams), 1, EMPTY_TEXT);
1272 auto menuNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(0));
1273 ASSERT_NE(menuNode, nullptr);
1274 auto renderContext = menuNode->GetRenderContext();
1275 ASSERT_NE(renderContext, nullptr);
1276 /**
1277 * @tc.steps: step2. create option pattern.
1278 * @tc.expected: option bg color meet expectations
1279 */
1280 auto optionPattern = AceType::MakeRefPtr<OptionPattern>(0);
1281 EXPECT_EQ(optionPattern->GetBgColor(), Color::TRANSPARENT);
1282 }
1283
1284 /**
1285 * @tc.name: MenuPatternTestNg029
1286 * @tc.desc: Verify UpdateFontStyle.menuProperty has FontFamily.
1287 * @tc.type: FUNC
1288 */
1289 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg029, TestSize.Level1)
1290 {
1291 /**
1292 * @tc.steps: step1. create MenuModelNG and MenuItemModelNG object and set FontStyle properties of MenuModelNG.
1293 */
1294 MenuModelNG MneuModelInstance;
1295 MenuItemModelNG MneuItemModelInstance;
1296 MneuModelInstance.Create();
1297 MneuModelInstance.SetFontStyle(Ace::FontStyle::ITALIC);
1298
1299 /**
1300 * @tc.steps: step2. get the frameNode, MenuPattern and MenuLayoutProperty.
1301 * @tc.expected: step2. check whether the objects is available.
1302 */
1303 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1304 ASSERT_NE(menuNode, nullptr);
1305 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1306 ASSERT_NE(menuPattern, nullptr);
1307 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
1308 ASSERT_NE(layoutProperty, nullptr);
1309
1310 /**
1311 * @tc.steps: step3. not set FontStyle properties of MenuModelNG.
1312 */
1313 MenuItemProperties itemOption;
1314 itemOption.content = "content";
1315 itemOption.labelInfo = "label";
1316 MneuItemModelInstance.Create(itemOption);
1317 auto itemNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1318 ASSERT_NE(itemNode, nullptr);
1319 auto itemPattern = itemNode->GetPattern<MenuItemPattern>();
1320 ASSERT_NE(itemPattern, nullptr);
1321 auto menuItemLayoutProperty = itemNode->GetLayoutProperty<MenuItemLayoutProperty>();
1322 ASSERT_NE(menuItemLayoutProperty, nullptr);
1323 itemPattern->OnModifyDone();
1324 itemNode->MountToParent(menuNode);
1325 itemNode->OnMountToParentDone();
1326 menuPattern->OnModifyDone();
1327
1328 /**
1329 * @tc.steps: step4. call OnModifyDone of MenuPattern to call UpdateMenuItemChildren
1330 */
1331 menuItemLayoutProperty->UpdateLabelItalicFontStyle(Ace::FontStyle::ITALIC);
1332 layoutProperty->UpdateFontFamily(FONT_FAMILY_VALUE);
1333 menuPattern->OnModifyDone();
1334
1335 /**
1336 * @tc.steps: step5. get the FontStyle properties of menuItemLayoutProperty.
1337 * @tc.expected: step5. check whether the FontStyle properties is is correct.
1338 */
1339 auto contentNode = itemPattern->GetContentNode();
1340 ASSERT_NE(contentNode, nullptr);
1341 auto textProperty = contentNode->GetLayoutProperty<TextLayoutProperty>();
1342 ASSERT_NE(textProperty, nullptr);
1343 ASSERT_TRUE(textProperty->GetItalicFontStyle().has_value());
1344 EXPECT_EQ(textProperty->GetItalicFontStyle().value(), Ace::FontStyle::ITALIC);
1345 }
1346 /**
1347 * @tc.name: MenuPatternTestNg030
1348 * @tc.desc: Verify OnTouchEvent.Extend.
1349 * @tc.type: FUNC
1350 */
1351 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg030, TestSize.Level1)
1352 {
1353 /**
1354 * @tc.steps: step1. multi menu touch event,IsMultiMenu,is ture.
1355 * @tc.expected: menu type is multi
1356 */
1357 auto multiMenuPattern = AceType::MakeRefPtr<MenuPattern>(-1, "", MenuType::MULTI_MENU);
1358 TouchEventInfo multiMenuTouchEventInfo(MENU_TOUCH_EVENT_TYPE);
1359 multiMenuPattern->SetType(MenuType::DESKTOP_MENU);
1360 multiMenuPattern->OnTouchEvent(multiMenuTouchEventInfo);
1361 EXPECT_FALSE(multiMenuPattern->IsMultiMenu());
1362 /**
1363 * @tc.steps: step2. select menu touch event,IsDesktopMenu is true
1364 * @tc.expected: menu options nums as expected
1365 */
1366 multiMenuPattern->SetType(MenuType::DESKTOP_MENU);
1367 multiMenuPattern->OnTouchEvent(multiMenuTouchEventInfo);
1368 EXPECT_TRUE(multiMenuPattern->IsDesktopMenu());
1369 /**
1370 * @tc.steps: step3. contextMenu touch event
1371 * @tc.expected: menu type is context
1372 */
1373 multiMenuPattern->type_ = MenuType::SELECT_OVERLAY_CUSTOM_MENU;
1374 multiMenuPattern->OnTouchEvent(multiMenuTouchEventInfo);
1375 EXPECT_TRUE(multiMenuPattern->IsSelectOverlayCustomMenu());
1376 }
1377 /**
1378 * @tc.name: MenuPatternTestNg031
1379 * @tc.desc: Verify HideMenu(Menu).menunode is SELECT.
1380 * @tc.type: FUNC
1381 */
1382 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg031, TestSize.Level1)
1383 {
1384 /**
1385 * @tc.steps: step1. Create wrapper and child menu
1386 * @tc.expected: wrapper pattern not null
1387 */
1388 auto wrapperNode =
1389 FrameNode::CreateFrameNode(V2::MENU_WRAPPER_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1390 auto mainMenu = FrameNode::CreateFrameNode(
1391 V2::SELECT_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1392 mainMenu->MountToParent(wrapperNode);
1393 auto wrapperPattern = wrapperNode->GetPattern<MenuWrapperPattern>();
1394 auto menuPattern = mainMenu->GetPattern<MenuPattern>();
1395 ASSERT_NE(wrapperPattern, nullptr);
1396 menuPattern->type_ = MenuType::CONTEXT_MENU;
1397
1398 menuPattern->HideMenu();
1399 EXPECT_EQ(wrapperNode->GetChildren().size(), 1);
1400 }
1401 /**
1402 * @tc.name: MenuPatternTestNg032
1403 * @tc.desc: Verify HideMenu(Menu).wrappernode is SELECT_OVERLAY.
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg032, TestSize.Level1)
1407 {
1408 /**
1409 * @tc.steps: step1. Create wrapper and child menu
1410 * @tc.expected: wrapper pattern not null
1411 */
1412 auto wrapperNode =
1413 FrameNode::CreateFrameNode(V2::SELECT_OVERLAY_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1414 auto mainMenu =
1415 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1416 mainMenu->MountToParent(wrapperNode);
1417 auto wrapperPattern = wrapperNode->GetPattern<MenuWrapperPattern>();
1418 auto menuPattern = mainMenu->GetPattern<MenuPattern>();
1419 ASSERT_NE(wrapperPattern, nullptr);
1420 menuPattern->type_ = MenuType::CONTEXT_MENU;
1421
1422 menuPattern->HideMenu();
1423 EXPECT_EQ(wrapperNode->GetChildren().size(), 1);
1424 }
1425 /**
1426 * @tc.name: MenuPatternTestNg033
1427 * @tc.desc: Verify GetTransformCenter().
1428 * @tc.type: FUNC
1429 */
1430 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg033, TestSize.Level1)
1431 {
1432 /**
1433 * @tc.steps: step1. Create wrapper and child menu
1434 * @tc.expected: wrapper pattern not null
1435 */
1436 auto menuWrapperNode = GetPreviewMenuWrapper();
1437 ASSERT_NE(menuWrapperNode, nullptr);
1438 auto menuNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(0));
1439 ASSERT_NE(menuNode, nullptr);
1440 auto menuAlgorithmWrapper = menuNode->GetLayoutAlgorithm();
1441 auto menuGeometryNode = menuNode->GetGeometryNode();
1442 ASSERT_NE(menuGeometryNode, nullptr);
1443 menuGeometryNode->SetFrameSize(SizeF(TARGET_SIZE_WIDTH, OFFSET_FORTH));
1444 ASSERT_NE(menuAlgorithmWrapper, nullptr);
1445 auto menuAlgorithm = AceType::DynamicCast<MenuLayoutAlgorithm>(menuAlgorithmWrapper->GetLayoutAlgorithm());
1446 ASSERT_NE(menuAlgorithm, nullptr);
1447 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1448 ASSERT_NE(menuPattern, nullptr);
1449
1450 menuAlgorithm->placement_ = Placement::BOTTOM_LEFT;
1451 auto offset = menuPattern->GetTransformCenter();
1452 menuAlgorithm->placement_ = Placement::RIGHT_TOP;
1453 offset = menuPattern->GetTransformCenter();
1454 EXPECT_EQ(offset, Offset(CONST_DOUBLE_ZREO, CONST_DOUBLE_ZREO));
1455
1456 menuAlgorithm->placement_ = Placement::BOTTOM_RIGHT;
1457 offset = menuPattern->GetTransformCenter();
1458 menuAlgorithm->placement_ = Placement::LEFT_TOP;
1459 offset = menuPattern->GetTransformCenter();
1460 EXPECT_EQ(offset, Offset(TARGET_SIZE_WIDTH, CONST_DOUBLE_ZREO));
1461
1462 menuAlgorithm->placement_ = Placement::TOP_LEFT;
1463 offset = menuPattern->GetTransformCenter();
1464 menuAlgorithm->placement_ = Placement::RIGHT_BOTTOM;
1465 offset = menuPattern->GetTransformCenter();
1466 EXPECT_EQ(offset, Offset(CONST_DOUBLE_ZREO, OFFSET_FORTH));
1467
1468 menuAlgorithm->placement_ = Placement::TOP_RIGHT;
1469 offset = menuPattern->GetTransformCenter();
1470 menuAlgorithm->placement_ = Placement::LEFT_BOTTOM;
1471 offset = menuPattern->GetTransformCenter();
1472 EXPECT_EQ(offset, Offset(TARGET_SIZE_WIDTH, OFFSET_FORTH));
1473
1474 menuAlgorithm->placement_ = Placement::BOTTOM;
1475 offset = menuPattern->GetTransformCenter();
1476 EXPECT_EQ(offset, Offset(TARGET_SIZE_WIDTH / 2, CONST_DOUBLE_ZREO));
1477 menuAlgorithm->placement_ = Placement::LEFT;
1478 offset = menuPattern->GetTransformCenter();
1479 EXPECT_EQ(offset, Offset(TARGET_SIZE_WIDTH, OFFSET_FORTH / 2));
1480 menuAlgorithm->placement_ = Placement::TOP;
1481 offset = menuPattern->GetTransformCenter();
1482 EXPECT_EQ(offset, Offset(TARGET_SIZE_WIDTH / 2, OFFSET_FORTH));
1483 menuAlgorithm->placement_ = Placement::RIGHT;
1484 offset = menuPattern->GetTransformCenter();
1485 EXPECT_EQ(offset, Offset(CONST_DOUBLE_ZREO, OFFSET_FORTH / 2));
1486 menuAlgorithm->placement_ = Placement::NONE;
1487 offset = menuPattern->GetTransformCenter();
1488 EXPECT_EQ(offset, Offset(CONST_DOUBLE_ZREO, CONST_DOUBLE_ZREO));
1489 }
1490 /**
1491 * @tc.name: MenuPatternTestNg034
1492 * @tc.desc: Test Layout with preview content
1493 * @tc.type: FUNC
1494 */
1495 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg034, TestSize.Level1)
1496 {
1497 /**
1498 * @tc.steps: step1. create menu node, preview node and menuLayoutAlgorithm, then set the initial properties
1499 * @tc.expected: menu node, preview node and menuLayoutAlgorithm are not null
1500 */
1501 ScreenSystemManager::GetInstance().dipScale_ = DIP_SCALE;
1502 ScreenSystemManager::GetInstance().screenWidth_ = FULL_SCREEN_WIDTH;
1503 auto context = PipelineBase::GetCurrentContext();
1504 if (context) {
1505 context->dipScale_ = DIP_SCALE;
1506 }
1507
1508 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1509 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1510 RefPtr<MenuTheme> menuTheme = AceType::MakeRefPtr<MenuTheme>();
1511 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(menuTheme));
1512
1513 auto menuWrapperNode = GetPreviewMenuWrapper();
1514 ASSERT_NE(menuWrapperNode, nullptr);
1515 auto menuNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(0));
1516 ASSERT_NE(menuNode, nullptr);
1517 auto menuAlgorithmWrapper = menuNode->GetLayoutAlgorithm();
1518 auto menuGeometryNode = menuNode->GetGeometryNode();
1519 ASSERT_NE(menuGeometryNode, nullptr);
1520 menuGeometryNode->SetFrameSize(SizeF(TARGET_SIZE_WIDTH, GREATER_WINDOW_MENU_HEIGHT));
1521 auto previewNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(1));
1522 auto previewGeometryNode = previewNode->GetGeometryNode();
1523 ASSERT_NE(previewGeometryNode, nullptr);
1524 previewGeometryNode->SetFrameSize(SizeF(TARGET_SIZE_WIDTH, TARGET_SIZE_HEIGHT));
1525 ASSERT_NE(menuAlgorithmWrapper, nullptr);
1526 auto menuAlgorithm = AceType::DynamicCast<MenuLayoutAlgorithm>(menuAlgorithmWrapper->GetLayoutAlgorithm());
1527 ASSERT_NE(menuAlgorithm, nullptr);
1528 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1529 ASSERT_NE(menuPattern, nullptr);
1530 menuPattern->ShowPreviewMenuAnimation();
1531 EXPECT_FALSE(menuPattern->isFirstShow_);
1532
1533 menuPattern->isFirstShow_ = true;
1534 menuPattern->ShowPreviewMenuAnimation();
1535 EXPECT_EQ(menuPattern->previewMode_, MenuPreviewMode::CUSTOM);
1536 }
1537 /**
1538 * @tc.name: MenuPatternTest035
1539 * @tc.desc: Verify RegisterOnTouch.
1540 * @tc.type: FUNC
1541 */
1542 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg035, TestSize.Level1)
1543 {
1544 ScreenSystemManager::GetInstance().dipScale_ = DIP_SCALE;
1545 ScreenSystemManager::GetInstance().screenWidth_ = FULL_SCREEN_WIDTH;
1546 auto context = PipelineBase::GetCurrentContext();
1547 if (context) {
1548 context->dipScale_ = DIP_SCALE;
1549 }
1550 auto menuWrapperNode = GetPreviewMenuWrapper();
1551 ASSERT_NE(menuWrapperNode, nullptr);
1552 auto menuNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(0));
1553 ASSERT_NE(menuNode, nullptr);
1554 auto menuAlgorithmWrapper = menuNode->GetLayoutAlgorithm();
1555 auto menuGeometryNode = menuNode->GetGeometryNode();
1556 ASSERT_NE(menuGeometryNode, nullptr);
1557 menuGeometryNode->SetFrameSize(SizeF(TARGET_SIZE_WIDTH, GREATER_WINDOW_MENU_HEIGHT));
1558 auto previewNode = AceType::DynamicCast<FrameNode>(menuWrapperNode->GetChildAtIndex(1));
1559 auto previewGeometryNode = previewNode->GetGeometryNode();
1560 ASSERT_NE(previewGeometryNode, nullptr);
1561 previewGeometryNode->SetFrameSize(SizeF(TARGET_SIZE_WIDTH, TARGET_SIZE_HEIGHT));
1562 ASSERT_NE(menuAlgorithmWrapper, nullptr);
1563 auto menuAlgorithm = AceType::DynamicCast<MenuLayoutAlgorithm>(menuAlgorithmWrapper->GetLayoutAlgorithm());
1564 ASSERT_NE(menuAlgorithm, nullptr);
1565 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1566 ASSERT_NE(menuPattern, nullptr);
1567
1568 menuPattern->type_ = MenuType::SUB_MENU;
1569 menuWrapperNode->skipMeasureContent_ = false;
1570 EXPECT_FALSE(menuPattern->OnDirtyLayoutWrapperSwap(menuWrapperNode, configDirtySwap));
1571 }
1572 /**
1573 * @tc.name: MenuPatternTestNg036
1574 * @tc.desc: Verify HandleDragEnd
1575 * @tc.type: FUNC
1576 */
1577 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg036, TestSize.Level1)
1578 {
1579 /**
1580 * @tc.steps: step1. Create wrapper and child menu
1581 * @tc.expected: wrapper pattern not null
1582 */
1583 auto wrapperNode =
1584 FrameNode::CreateFrameNode(V2::SELECT_OVERLAY_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1585 auto mainMenu =
1586 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1587 mainMenu->MountToParent(wrapperNode);
1588 auto wrapperPattern = wrapperNode->GetPattern<MenuWrapperPattern>();
1589 auto menuPattern = mainMenu->GetPattern<MenuPattern>();
1590 ASSERT_NE(wrapperPattern, nullptr);
1591 menuPattern->type_ = MenuType::CONTEXT_MENU;
1592
1593 menuPattern->HandleDragEnd(OFFSET_FIRST, OFFSET_SECOND, POSITION_OFFSET);
1594 EXPECT_TRUE(LessOrEqual(POSITION_OFFSET, PAN_MAX_VELOCITY));
1595
1596 menuPattern->HandleDragEnd(OFFSET_SECOND, OFFSET_FIRST, PAN_GREATER_MAX_VELOCITY);
1597 EXPECT_TRUE(LessOrEqual(CONST_DOUBLE_ZREO, 0.0f));
1598 }
1599 /**
1600 * @tc.name: MenuPatternTestNg037
1601 * @tc.desc: Verify HandleScrollDragEnd
1602 * @tc.type: FUNC
1603 */
1604 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg037, TestSize.Level1)
1605 {
1606 /**
1607 * @tc.steps: step1. Create wrapper and child menu
1608 * @tc.expected: wrapper pattern not null
1609 */
1610 auto wrapperNode =
1611 FrameNode::CreateFrameNode(V2::SELECT_OVERLAY_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1612 auto mainMenu =
1613 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1614 mainMenu->MountToParent(wrapperNode);
1615 auto wrapperPattern = wrapperNode->GetPattern<MenuWrapperPattern>();
1616 auto menuPattern = mainMenu->GetPattern<MenuPattern>();
1617 ASSERT_NE(wrapperPattern, nullptr);
1618 menuPattern->type_ = MenuType::CONTEXT_MENU;
1619
1620 menuPattern->HandleScrollDragEnd(OFFSET_FIRST, OFFSET_SECOND, POSITION_OFFSET);
1621 EXPECT_TRUE(LessOrEqual(POSITION_OFFSET, PAN_MAX_VELOCITY));
1622
1623 menuPattern->HandleScrollDragEnd(CONST_LESS_NEAR_ZREO, CONST_NEAR_ZREO, PAN_GREATER_MAX_VELOCITY);
1624 EXPECT_FALSE(!NearZero(CONST_DOUBLE_ZREO));
1625 }
1626 /**
1627 * @tc.name: MenuModelNGTestNg001
1628 * @tc.desc: Verify MenuModelNG::SetFontColor & SetFontSize
1629 * @tc.type: FUNC
1630 */
1631 HWTEST_F(MenuPattern1TestNg, MenuModelNGTestNg001, TestSize.Level1)
1632 {
1633 /**
1634 * @tc.steps: step1. Init MenuModelNG
1635 */
1636 MenuModelNG myMenuModelNG;
1637 myMenuModelNG.Create();
1638 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1639 ASSERT_NE(frameNode, nullptr);
1640 MenuModelNG myMenuModelNGEx;
1641 myMenuModelNGEx.Create();
1642 auto frameNodeEx = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1643 ASSERT_NE(frameNode, nullptr);
1644 auto menuPattern = frameNode->GetPattern<MenuPattern>();
1645 ASSERT_NE(menuPattern, nullptr);
1646 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
1647 ASSERT_NE(layoutProperty, nullptr);
1648 /**
1649 * @tc.steps: step2. test SetFontColor
1650 */
1651 myMenuModelNGEx.SetFontColor(AceType::RawPtr(frameNodeEx), Color(-1));
1652 myMenuModelNG.SetFontColor(AceType::RawPtr(frameNode), Color::RED);
1653 EXPECT_EQ(layoutProperty->GetFontColor(), Color::RED);
1654 /**
1655 * @tc.steps: step3. test SetFontSize
1656 */
1657 myMenuModelNGEx.SetFontSize(AceType::RawPtr(frameNode), Dimension(0.0));
1658 myMenuModelNG.SetFontSize(AceType::RawPtr(frameNode), Dimension(25.0));
1659 EXPECT_EQ(layoutProperty->GetFontSize(), Dimension(25.0));
1660 }
1661
1662 /**
1663 * @tc.name: MenuPatternTestNg038
1664 * @tc.desc: Verify MenuPattern::GetForEachMenuItem
1665 * @tc.type: FUNC
1666 */
1667 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg038, TestSize.Level1)
1668 {
1669 /**
1670 * @tc.steps: step1. Create JS_SYNTAX_ITEM_ETS_TAG parent and next is false;
1671 * @tc.expected: wrapper pattern not null.
1672 */
1673 RefPtr<FrameNode> menuNode =
1674 FrameNode::GetOrCreateFrameNode(V2::MENU_TAG, ViewStackProcessor::GetInstance()->ClaimNodeId(),
__anonf878b6990402() 1675 []() { return AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE); });
1676 auto parentNode =
1677 FrameNode::CreateFrameNode(V2::JS_SYNTAX_ITEM_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1678 auto mainMenu =
1679 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1680 parentNode->MountToParent(menuNode);
1681 mainMenu->MountToParent(parentNode);
1682 auto menuPattern = mainMenu->GetPattern<MenuPattern>();
1683 menuPattern->type_ = MenuType::CONTEXT_MENU;
1684 auto testNode = menuPattern->GetForEachMenuItem(parentNode, false);
1685 auto forEachNode = AceType::DynamicCast<UINode>(parentNode->GetParent());
1686 auto& children = forEachNode->GetChildren();
1687 ASSERT_NE(forEachNode, nullptr);
1688 auto syntIndex = forEachNode->GetChildIndex(parentNode);
1689 EXPECT_TRUE((syntIndex >= static_cast<int32_t>(children.size() - 1)));
1690 EXPECT_EQ(testNode, nullptr);
1691 /**
1692 * @tc.steps: step1+. Create JS_SYNTAX_ITEM_ETS_TAG parent next is true;
1693 */
1694 testNode = menuPattern->GetForEachMenuItem(parentNode, true);
1695 EXPECT_EQ(testNode, nullptr);
1696 /**
1697 * @tc.steps: step1-. add a child node to parentNode;
1698 */
1699 auto parentNodeEx =
1700 FrameNode::CreateFrameNode(V2::JS_SYNTAX_ITEM_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1701 parentNodeEx->MountToParent(menuNode);
1702 menuPattern = mainMenu->GetPattern<MenuPattern>();
1703 menuPattern->type_ = MenuType::CONTEXT_MENU;
1704 testNode = menuPattern->GetForEachMenuItem(parentNodeEx, true);
1705 EXPECT_EQ(testNode, nullptr);
1706 testNode = menuPattern->GetForEachMenuItem(parentNodeEx, false);
1707 ASSERT_NE(testNode, nullptr);
1708 EXPECT_EQ(testNode->GetTag(), "Menu");
1709 /**
1710 * @tc.steps: step2. Create JS_FOR_EACH_ETS_TAG parent.
1711 * @tc.expected: wrapper pattern not null.
1712 */
1713 auto foreachNode =
1714 FrameNode::CreateFrameNode(V2::JS_FOR_EACH_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1715 auto MenuNode2 =
1716 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1717 MenuNode2->MountToParent(foreachNode);
1718 auto menuPatternEx = MenuNode2->GetPattern<MenuPattern>();
1719 menuPatternEx->type_ = MenuType::CONTEXT_MENU;
1720 testNode = menuPatternEx->GetForEachMenuItem(foreachNode, false);
1721 EXPECT_EQ(testNode, nullptr);
1722 /**
1723 * @tc.steps: step3. Create other parent.
1724 * @tc.expected: wrapper pattern not null
1725 */
1726 auto otherNode =
1727 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1728 auto otherPattern = otherNode->GetPattern<MenuPattern>();
1729 testNode = otherPattern->GetForEachMenuItem(otherNode, false);
1730 EXPECT_EQ(testNode, nullptr);
1731 }
1732
1733 /**
1734 * @tc.name: MenuPatternTestNg039
1735 * @tc.desc: Verify MenuPattern::OnItemPressed
1736 * @tc.type: FUNC
1737 */
1738 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg039, TestSize.Level1)
1739 {
1740 /**
1741 * @tc.steps: step1. Create JS_SYNTAX_ITEM_ETS_TAG parent index > 0;
1742 */
1743 auto menuitemgroupNode = FrameNode::CreateFrameNode(
1744 V2::MENU_ITEM_GROUP_ETS_TAG, 1, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1745 auto menuitemgroupPattern = menuitemgroupNode->GetPattern<MenuPattern>();
1746 menuitemgroupPattern->OnItemPressed(menuitemgroupNode, 0, false);
1747 /**
1748 * @tc.steps: step2. Create JS_SYNTAX_ITEM_ETS_TAG parent and index < 0;
1749 * @tc.expected: wrapper pattern not null.
1750 */
1751 RefPtr<FrameNode> menuNode =
1752 FrameNode::GetOrCreateFrameNode(V2::MENU_TAG, ViewStackProcessor::GetInstance()->ClaimNodeId(),
__anonf878b6990502() 1753 []() { return AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE); });
1754 auto parentNode =
1755 FrameNode::CreateFrameNode(V2::JS_SYNTAX_ITEM_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1756 auto mainMenu =
1757 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1758 parentNode->MountToParent(menuNode);
1759 mainMenu->MountToParent(parentNode);
1760 auto menuPattern = mainMenu->GetPattern<MenuPattern>();
1761 menuPattern->type_ = MenuType::CONTEXT_MENU;
1762 menuPattern->OnItemPressed(parentNode, 0, false);
1763 EXPECT_EQ(parentNode->GetTag(), V2::JS_SYNTAX_ITEM_ETS_TAG);
1764 /**
1765 * @tc.steps: step2+. Create JS_SYNTAX_ITEM_ETS_TAG parent index > 0;
1766 */
1767 menuPattern->OnItemPressed(parentNode, 1, false);
1768 EXPECT_EQ(parentNode->GetTag(), V2::JS_SYNTAX_ITEM_ETS_TAG);
1769 /**
1770 * @tc.steps: step3. Create JS_FOR_EACH_ETS_TAG parent index > 0;
1771 */
1772 auto foreachNode =
1773 FrameNode::CreateFrameNode(V2::JS_FOR_EACH_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1774 auto MenuNode2 =
1775 FrameNode::CreateFrameNode(V2::MENU_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1776 auto foreachchildNode =
1777 FrameNode::CreateFrameNode(V2::JS_FOR_EACH_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1778 MenuNode2->MountToParent(foreachNode);
1779 foreachchildNode->MountToParent(foreachNode);
1780 auto menuPatternEx = MenuNode2->GetPattern<MenuPattern>();
1781 menuPatternEx->type_ = MenuType::CONTEXT_MENU;
1782 menuPatternEx->OnItemPressed(foreachNode, -1, false);
1783 EXPECT_EQ(parentNode->GetTag(), V2::JS_SYNTAX_ITEM_ETS_TAG);
1784 }
1785
1786 /**
1787 * @tc.name: MenuPatternTestNg040
1788 * @tc.desc: Verify MenuPattern::OnItemPressed
1789 * @tc.type: FUNC
1790 */
1791 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg040, TestSize.Level1)
1792 {
1793 /**
1794 * @tc.steps: step1. Create JS_FOR_EACH_ETS_TAG parent index < 0;
1795 */
1796 auto foreachNode = FrameNode::GetOrCreateFrameNode(V2::MENU_TAG, ViewStackProcessor::GetInstance()->ClaimNodeId(),
__anonf878b6990602() 1797 []() { return AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE); });
1798 auto parent = FrameNode::CreateFrameNode(
1799 V2::JS_SYNTAX_ITEM_ETS_TAG, 2, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1800 auto nextNode = FrameNode::CreateFrameNode(V2::JS_FOR_EACH_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1801 auto nextNodeEx =
1802 FrameNode::CreateFrameNode(V2::JS_FOR_EACH_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1803 parent->MountToParent(foreachNode);
1804 nextNode->MountToParent(parent);
1805 nextNodeEx->MountToParent(parent);
1806 auto menuPattern = parent->GetPattern<MenuPattern>();
1807 menuPattern->type_ = MenuType::CONTEXT_MENU;
1808 menuPattern->OnItemPressed(parent, -1, false);
1809 EXPECT_EQ(parent->GetTag(), V2::JS_SYNTAX_ITEM_ETS_TAG);
1810 }
1811
1812 /**
1813 * @tc.name: MenuPatternTestNg040
1814 * @tc.desc: Verify MenuPattern::GetOutsideForEachMenuItem
1815 * @tc.type: FUNC
1816 */
1817 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg041, TestSize.Level1)
1818 {
1819 /**
1820 * @tc.steps: step1. Create node child one and next is false;
1821 * @tc.expected: wrapper pattern not null.
1822 */
1823 RefPtr<FrameNode> parentForEachNode =
1824 FrameNode::GetOrCreateFrameNode(V2::MENU_TAG, ViewStackProcessor::GetInstance()->ClaimNodeId(),
__anonf878b6990702() 1825 []() { return AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE); });
1826 auto forEachNode =
1827 FrameNode::CreateFrameNode(V2::JS_SYNTAX_ITEM_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1828 forEachNode->MountToParent(parentForEachNode);
1829 auto menuPattern = parentForEachNode->GetPattern<MenuPattern>();
1830 menuPattern->type_ = MenuType::CONTEXT_MENU;
1831 auto testNode = menuPattern->GetOutsideForEachMenuItem(forEachNode, false);
1832 EXPECT_EQ(testNode, nullptr);
1833 /**
1834 * @tc.steps: step1+. Create JS_SYNTAX_ITEM_ETS_TAG parent next is true;
1835 */
1836 menuPattern->GetOutsideForEachMenuItem(forEachNode, true);
1837 EXPECT_EQ(testNode, nullptr);
1838 /**
1839 * @tc.steps: step2. Create node child two and next is false;
1840 */
1841 auto forEachNodeEx =
1842 FrameNode::CreateFrameNode(V2::JS_SYNTAX_ITEM_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1843 forEachNodeEx->MountToParent(parentForEachNode);
1844 menuPattern = parentForEachNode->GetPattern<MenuPattern>();
1845 menuPattern->type_ = MenuType::CONTEXT_MENU;
1846 menuPattern->GetOutsideForEachMenuItem(forEachNode, false);
1847 EXPECT_EQ(testNode, nullptr);
1848 /**
1849 * @tc.steps: step1+. Create JS_SYNTAX_ITEM_ETS_TAG parent next is true;
1850 */
1851 menuPattern->GetOutsideForEachMenuItem(forEachNode, true);
1852 EXPECT_EQ(testNode, nullptr);
1853 }
1854 /**
1855 * @tc.name: MenuPatternTestNg042
1856 * @tc.desc: Verify MenuPattern::GetMenuItemInfo
1857 * @tc.type: FUNC
1858 */
1859 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg042, TestSize.Level1)
1860 {
1861 /**
1862 * @tc.steps: step1. Create menuitem childnode and isNeedRestoreNodeId if false;
1863 */
1864 RefPtr<FrameNode> menuNode =
1865 FrameNode::GetOrCreateFrameNode(V2::MENU_TAG, ViewStackProcessor::GetInstance()->ClaimNodeId(),
__anonf878b6990802() 1866 []() { return AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE); });
1867 auto child = FrameNode::CreateFrameNode(V2::MENU_ITEM_ETS_TAG, 1, AceType::MakeRefPtr<MenuItemPattern>());
1868 child->MountToParent(menuNode);
1869 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1870 menuPattern->type_ = MenuType::CONTEXT_MENU;
1871 auto menuItemPattern = child->GetPattern<MenuItemPattern>();
1872 auto testInfo = menuPattern->GetMenuItemInfo(child, false);
1873 EXPECT_FALSE(testInfo.isFindTargetId);
1874 menuItemPattern->SetClickMenuItemId(child->GetId());
1875 testInfo = menuPattern->GetMenuItemInfo(child, false);
1876 EXPECT_TRUE(testInfo.isFindTargetId);
1877 testInfo = menuPattern->GetMenuItemInfo(child, true);
1878 EXPECT_TRUE(testInfo.isFindTargetId);
1879
1880 testInfo = menuPattern->GetMenuItemInfo(menuNode, false);
1881 EXPECT_FALSE(testInfo.isFindTargetId);
1882 }
1883 /**
1884 * @tc.name: MenuPatternTestNg043
1885 * @tc.desc: Verify MenuPattern::GetInnerMenuOffset
1886 * @tc.type: FUNC
1887 */
1888 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg043, TestSize.Level1)
1889 {
1890 /**
1891 * @tc.steps: step1. Create menuitem childnode and isNeedRestoreNodeId if false;
1892 */
1893 RefPtr<FrameNode> menuNode =
1894 FrameNode::GetOrCreateFrameNode(V2::MENU_TAG, ViewStackProcessor::GetInstance()->ClaimNodeId(),
__anonf878b6990902() 1895 []() { return AceType::MakeRefPtr<MenuPattern>(TARGET_ID, "", TYPE); });
1896 auto child = FrameNode::CreateFrameNode(V2::MENU_ITEM_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1897 child->MountToParent(menuNode);
1898 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1899 menuPattern->type_ = MenuType::CONTEXT_MENU;
1900 auto menuItemPattern = child->GetPattern<MenuItemPattern>();
1901 auto testInfo = menuPattern->GetInnerMenuOffset(child, false);
1902 EXPECT_FALSE(testInfo.isFindTargetId);
1903 /**
1904 * @tc.steps: step1+. test GetInnerMenuOffset and isNeedRestoreNodeId if true;
1905 */
1906 testInfo = menuPattern->GetInnerMenuOffset(child, true);
1907 EXPECT_FALSE(testInfo.isFindTargetId);
1908 /**
1909 * @tc.steps: step2. Create menuitemgroup node and isNeedRestoreNodeId if false;
1910 */
1911 auto menuitemgroupNode = FrameNode::CreateFrameNode(
1912 V2::MENU_ITEM_GROUP_ETS_TAG, 1, AceType::MakeRefPtr<MenuPattern>(1, TEXT_TAG, MenuType::MENU));
1913 auto itemchildOne =
1914 FrameNode::CreateFrameNode(V2::MENU_ITEM_ETS_TAG, 2, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1915 auto itemchildTwo =
1916 FrameNode::CreateFrameNode(V2::MENU_ITEM_ETS_TAG, 3, AceType::MakeRefPtr<MenuWrapperPattern>(1));
1917 itemchildOne->MountToParent(menuitemgroupNode);
1918 itemchildTwo->MountToParent(menuitemgroupNode);
1919 menuPattern = menuNode->GetPattern<MenuPattern>();
1920 testInfo = menuPattern->GetInnerMenuOffset(menuitemgroupNode, false);
1921 EXPECT_FALSE(testInfo.isFindTargetId);
1922 /**
1923 * @tc.steps: step2. Create menuitemgroup node and isNeedRestoreNodeId if true;
1924 */
1925 testInfo = menuPattern->GetInnerMenuOffset(menuitemgroupNode, true);
1926 EXPECT_EQ(testInfo.originOffset, OffsetF(0.0, 0.0));
1927 EXPECT_FALSE(testInfo.isFindTargetId);
1928 }
1929
1930 /**
1931 * @tc.name: MenuPatternTestNg044
1932 * @tc.desc: Verify MneuModelInstance methods.
1933 * @tc.type: FUNC
1934 */
1935 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg044, TestSize.Level1)
1936 {
1937 MenuModelNG MneuModelInstance;
1938 MneuModelInstance.Create();
1939 MneuModelInstance.SetFontSize(Dimension(25.0));
1940 MneuModelInstance.SetFontColor(Color::RED);
1941 MneuModelInstance.SetFontWeight(FontWeight::BOLD);
1942 MneuModelInstance.SetFontStyle(Ace::FontStyle::ITALIC);
1943 MneuModelInstance.SetBorderRadius(Dimension(2));
1944 MneuModelInstance.SetWidth(Dimension(10));
1945 std::vector<std::string> myFamilies = {"Smith"};
1946 MneuModelInstance.SetFontFamily(myFamilies);
1947 MneuModelInstance.SetBorderRadius(Dimension(1), Dimension(2), Dimension(3), Dimension(4));
1948 MneuModelInstance.SetItemDivider(ITEM_DIVIDER);
1949 MneuModelInstance.SetItemGroupDivider(ITEM_DIVIDER);
1950 MneuModelInstance.SetExpandingMode(SubMenuExpandingMode::STACK);
1951
1952 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1953 ASSERT_NE(menuNode, nullptr);
1954 auto menuPattern = menuNode->GetPattern<MenuPattern>();
1955 ASSERT_NE(menuPattern, nullptr);
1956 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
1957 ASSERT_NE(layoutProperty, nullptr);
1958
1959 // call UpdateMenuItemChildren
1960 menuPattern->OnModifyDone();
1961
1962 MneuModelInstance.ResetFontFamily();
1963 MneuModelInstance.ResetBorderRadius();
1964
1965 ASSERT_TRUE(layoutProperty->GetFontSize().has_value());
1966 EXPECT_EQ(layoutProperty->GetFontSize().value(), Dimension(25.0));
1967 ASSERT_TRUE(layoutProperty->GetFontWeight().has_value());
1968 EXPECT_EQ(layoutProperty->GetFontWeight().value(), FontWeight::BOLD);
1969 ASSERT_TRUE(layoutProperty->GetFontColor().has_value());
1970 EXPECT_EQ(layoutProperty->GetFontColor().value(), Color::RED);
1971 ASSERT_TRUE(layoutProperty->GetItalicFontStyle().has_value());
1972 EXPECT_EQ(layoutProperty->GetItalicFontStyle().value(), Ace::FontStyle::ITALIC);
1973 }
1974
1975 /**
1976 * @tc.name: MenuPatternTestNg045
1977 * @tc.desc: Verify MneuModelInstance methods with frameNode.
1978 * @tc.type: FUNC
1979 */
1980 HWTEST_F(MenuPattern1TestNg, MenuPatternTestNg045, TestSize.Level1)
1981 {
1982 MenuModelNG MneuModelInstance;
1983 MneuModelInstance.Create();
1984
1985 auto menuNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish());
1986 ASSERT_NE(menuNode, nullptr);
1987 FrameNode *frameNode = menuNode.GetRawPtr();
1988 CHECK_NULL_VOID(frameNode);
1989 MneuModelInstance.SetFontSize(frameNode, Dimension(25.0));
1990 MneuModelInstance.SetFontWeight(frameNode, FontWeight::BOLD);
1991 MneuModelInstance.SetFontColor(frameNode, Color::RED);
1992 MneuModelInstance.SetFontStyle(frameNode, Ace::FontStyle::ITALIC);
1993 MneuModelInstance.SetBorderRadius(frameNode, Dimension(2));
1994 MneuModelInstance.SetWidth(frameNode, Dimension(10));
1995 std::vector<std::string> myFamilies = {"Smith"};
1996 MneuModelInstance.SetFontFamily(frameNode, myFamilies);
1997 MneuModelInstance.SetBorderRadius(frameNode, Dimension(1), Dimension(2), Dimension(3), Dimension(4));
1998 MneuModelInstance.SetItemDivider(frameNode, ITEM_DIVIDER);
1999 MneuModelInstance.SetItemGroupDivider(frameNode, ITEM_DIVIDER);
2000 MneuModelInstance.ResetBorderRadius(frameNode);
2001
2002 auto menuPattern = menuNode->GetPattern<MenuPattern>();
2003 ASSERT_NE(menuPattern, nullptr);
2004 auto layoutProperty = menuPattern->GetLayoutProperty<MenuLayoutProperty>();
2005 ASSERT_NE(layoutProperty, nullptr);
2006
2007 // call UpdateMenuItemChildren
2008 menuPattern->OnModifyDone();
2009
2010 ASSERT_TRUE(layoutProperty->GetFontSize().has_value());
2011 EXPECT_EQ(layoutProperty->GetFontSize().value(), Dimension(25.0));
2012 ASSERT_TRUE(layoutProperty->GetFontWeight().has_value());
2013 EXPECT_EQ(layoutProperty->GetFontWeight().value(), FontWeight::BOLD);
2014 ASSERT_TRUE(layoutProperty->GetFontColor().has_value());
2015 EXPECT_EQ(layoutProperty->GetFontColor().value(), Color::RED);
2016 ASSERT_TRUE(layoutProperty->GetItalicFontStyle().has_value());
2017 EXPECT_EQ(layoutProperty->GetItalicFontStyle().value(), Ace::FontStyle::ITALIC);
2018
2019 MneuModelInstance.SetFontColor(frameNode, std::nullopt);
2020 ASSERT_FALSE(layoutProperty->GetFontColor().has_value());
2021 MneuModelInstance.SetFontSize(frameNode, Dimension(0.0));
2022 ASSERT_FALSE(layoutProperty->GetFontSize().has_value());
2023 }
2024 } // namespace OHOS::Ace::NG
2025
