1 /*
2 * Copyright (c) 2024-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
16 #include "tabs_test_ng.h"
17 #include "test/mock/base/mock_task_executor.h"
18
19 #include "core/components_ng/pattern/text/text_layout_property.h"
20
21 namespace OHOS::Ace::NG {
22 class TabBarPatternTestNg : public TabsTestNg {
23 public:
24 static void SetUpTestSuite();
25 static void TearDownTestSuite();
26 float GetTabBarPosition();
27 };
28
SetUpTestSuite()29 void TabBarPatternTestNg::SetUpTestSuite()
30 {
31 TabsTestNg::SetUpTestSuite();
32 MockAnimationManager::Enable(true);
33 const int32_t ticks = 2;
34 MockAnimationManager::GetInstance().SetTicks(ticks);
35 }
36
TearDownTestSuite()37 void TabBarPatternTestNg::TearDownTestSuite()
38 {
39 TabsTestNg::TearDownTestSuite();
40 MockAnimationManager::GetInstance().Reset();
41 MockAnimationManager::Enable(false);
42 }
43
GetTabBarPosition()44 float TabBarPatternTestNg::GetTabBarPosition()
45 {
46 auto renderContext = tabBarNode_->GetRenderContext();
47 auto options = renderContext->GetTransformTranslateValue(TranslateOptions(0.0f, 0.0f, 0.0f));
48 return options.y.ConvertToPx();
49 }
50
51 /**
52 * @tc.name: TabBarPatternUpdateBottomTabBarImageColor001
53 * @tc.desc: test UpdateBottomTabBarImageColor
54 * @tc.type: FUNC
55 */
56 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateBottomTabBarImageColor001, TestSize.Level1)
57 {
58 TabsModelNG model = CreateTabs();
59 CreateTabContents(1);
60 CreateTabsDone(model);
61 std::vector<int32_t> selectedIndexes(1, 1);
62
63 IconStyle iconStyle;
64 iconStyle.unselectedColor = Color::WHITE;
65 tabBarPattern_->SetIconStyle(iconStyle, 0);
66 int32_t maskIndex = 0;
67 for (int i = 0; i <= 1; i++) {
68 tabBarPattern_->UpdateBottomTabBarImageColor(selectedIndexes, maskIndex);
69 maskIndex = 1;
70 }
71 EXPECT_EQ(tabBarPattern_->iconStyles_.size(), 1);
72 }
73
74 /**
75 * @tc.name: TabBarPatternUpdateBottomTabBarImageColor002
76 * @tc.desc: test UpdateBottomTabBarImageColor
77 * @tc.type: FUNC
78 */
79 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateBottomTabBarImageColor002, TestSize.Level1)
80 {
81 TabsModelNG model = CreateTabs();
82 CreateTabContents(1);
83 CreateTabsDone(model);
84 std::vector<int32_t> selectedIndexes(1, 1);
85
86 IconStyle iconStyle;
87 iconStyle.selectedColor = Color::WHITE;
88 tabBarPattern_->SetIconStyle(iconStyle, 0);
89 int32_t maskIndex = 0;
90 for (int i = 0; i <= 1; i++) {
91 tabBarPattern_->UpdateBottomTabBarImageColor(selectedIndexes, maskIndex);
92 maskIndex = 1;
93 }
94 EXPECT_EQ(tabBarPattern_->iconStyles_.size(), 1);
95 }
96 /**
97 * @tc.name: TabBarPatternUpdateBottomTabBarImageColor003
98 * @tc.desc: test UpdateBottomTabBarImageColor
99 * @tc.type: FUNC
100 */
101 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateBottomTabBarImageColor003, TestSize.Level1)
102 {
103 TabsModelNG model = CreateTabs();
104 CreateTabContents(1);
105 CreateTabsDone(model);
106 std::vector<int32_t> selectedIndexes(1, 1);
107
108 IconStyle iconStyle;
109 iconStyle.unselectedColor = Color::WHITE;
110 iconStyle.selectedColor = Color::WHITE;
111 tabBarPattern_->SetIconStyle(iconStyle, 0);
112 int32_t maskIndex = 0;
113 for (int i = 0; i <= 1; i++) {
114 tabBarPattern_->UpdateBottomTabBarImageColor(selectedIndexes, maskIndex);
115 maskIndex = 1;
116 }
117 EXPECT_EQ(tabBarPattern_->iconStyles_.size(), 1);
118 }
119 /**
120 * @tc.name: TabBarPatternUpdateBottomTabBarImageColor004
121 * @tc.desc: test UpdateBottomTabBarImageColor
122 * @tc.type: FUNC
123 */
124 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateBottomTabBarImageColor004, TestSize.Level1)
125 {
126 TabsModelNG model = CreateTabs();
127 CreateTabContents(1);
128 CreateTabsDone(model);
129 std::vector<int32_t> selectedIndexes(1, 1);
130
131 IconStyle iconStyle;
132 tabBarPattern_->SetIconStyle(iconStyle, 0);
133 int32_t maskIndex = 0;
134 for (int i = 0; i <= 1; i++) {
135 tabBarPattern_->UpdateBottomTabBarImageColor(selectedIndexes, maskIndex);
136 maskIndex = 1;
137 }
138 EXPECT_TRUE(frameNode_);
139 }
140
141 /**
142 * @tc.name: TabBarPatternGetBottomTabBarImageSizeAndOffset002
143 * @tc.desc: test GetBottomTabBarImageSizeAndOffset
144 * @tc.type: FUNC
145 */
146 HWTEST_F(TabBarPatternTestNg, TabBarPatternGetBottomTabBarImageSizeAndOffset002, TestSize.Level1)
147 {
148 TabsModelNG model = CreateTabs();
149 CreateTabContents(1);
150 CreateTabsDone(model);
151 std::vector<int32_t> selectedIndexes(1, 1);
152 float selectedImageSize = 1.0f;
153 float unselectedImageSize = 1.1f;
154 OffsetF originalSelectedMaskOffset(1.0f, 1.1f);
155 OffsetF originalUnselectedMaskOffset(0.0f, 1.0f);
156
157 /**
158 * @tc.steps: step2. Test function HandleMouseEvent.
159 * @tc.expected: Related function runs ok.
160 */
161 int32_t maskIndex = 0;
162 for (int i = 0; i <= 1; i++) {
163 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
164 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
165 maskIndex = 1;
166 }
167
168 IconStyle iconStyle;
169 iconStyle.selectedColor = Color::WHITE;
170 tabBarPattern_->SetIconStyle(iconStyle, 0);
171 maskIndex = 0;
172 for (int i = 0; i <= 1; i++) {
173 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
174 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
175 maskIndex = 1;
176 }
177
178 int32_t nodeId = 1;
179 for (int i = 0; i <= 2; i++) {
180 auto frameNode_ = TabsModelNG::GetOrCreateTabsNode(
__anona63b8a510102() 181 V2::TABS_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<TabsPattern>(); });
182 tabBarNode_->AddChild(frameNode_);
183 }
184 maskIndex = 0;
185 for (int i = 0; i <= 1; i++) {
186 for (int j = 0; j <= 1; j++) {
187 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
188 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
189 maskIndex = 1;
190 }
191 tabBarNode_->Clean(false, false);
192 }
193 EXPECT_TRUE(tabBarPattern_);
194 }
195
196 /**
197 * @tc.name: TabBarPatternGetBottomTabBarImageSizeAndOffset003
198 * @tc.desc: test GetBottomTabBarImageSizeAndOffset
199 * @tc.type: FUNC
200 */
201 HWTEST_F(TabBarPatternTestNg, TabBarPatternGetBottomTabBarImageSizeAndOffset003, TestSize.Level1)
202 {
203 TabsModelNG model = CreateTabs();
204 CreateTabContents(1);
205 CreateTabsDone(model);
206 std::vector<int32_t> selectedIndexes(1, 1);
207 float selectedImageSize = 1.0f;
208 float unselectedImageSize = 1.1f;
209 OffsetF originalSelectedMaskOffset(1.0f, 1.1f);
210 OffsetF originalUnselectedMaskOffset(0.0f, 1.0f);
211
212 /**
213 * @tc.steps: step2. Test function HandleMouseEvent.
214 * @tc.expected: Related function runs ok.
215 */
216 int32_t maskIndex = 0;
217 for (int i = 0; i <= 1; i++) {
218 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
219 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
220 maskIndex = 1;
221 }
222
223 IconStyle iconStyle;
224 iconStyle.unselectedColor = Color::WHITE;
225 tabBarPattern_->SetIconStyle(iconStyle, 0);
226 maskIndex = 0;
227 for (int i = 0; i <= 1; i++) {
228 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
229 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
230 maskIndex = 1;
231 }
232
233 int32_t nodeId = 1;
234 for (int i = 0; i <= 2; i++) {
235 auto frameNode_ = TabsModelNG::GetOrCreateTabsNode(
__anona63b8a510202() 236 V2::TABS_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<TabsPattern>(); });
237 tabBarNode_->AddChild(frameNode_);
238 }
239 maskIndex = 0;
240 for (int i = 0; i <= 1; i++) {
241 for (int j = 0; j <= 1; j++) {
242 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
243 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
244 maskIndex = 1;
245 }
246 tabBarNode_->Clean(false, false);
247 }
248 EXPECT_TRUE(frameNode_);
249 }
250
251 /**
252 * @tc.name: TabBarPatternGetBottomTabBarImageSizeAndOffset004
253 * @tc.desc: test GetBottomTabBarImageSizeAndOffset
254 * @tc.type: FUNC
255 */
256 HWTEST_F(TabBarPatternTestNg, TabBarPatternGetBottomTabBarImageSizeAndOffset004, TestSize.Level1)
257 {
258 TabsModelNG model = CreateTabs();
259 CreateTabContents(1);
260 CreateTabsDone(model);
261 std::vector<int32_t> selectedIndexes(1, 1);
262 float selectedImageSize = 1.0f;
263 float unselectedImageSize = 1.1f;
264 OffsetF originalSelectedMaskOffset(1.0f, 1.1f);
265 OffsetF originalUnselectedMaskOffset(0.0f, 1.0f);
266
267 /**
268 * @tc.steps: step2. Test function HandleMouseEvent.
269 * @tc.expected: Related function runs ok.
270 */
271 int32_t maskIndex = 0;
272 for (int i = 0; i <= 1; i++) {
273 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
274 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
275 maskIndex = 1;
276 }
277
278 IconStyle iconStyle;
279 tabBarPattern_->SetIconStyle(iconStyle, 0);
280 maskIndex = 0;
281 for (int i = 0; i <= 1; i++) {
282 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
283 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
284 maskIndex = 1;
285 }
286
287 int32_t nodeId = 1;
288 for (int i = 0; i <= 2; i++) {
289 auto frameNode_ = TabsModelNG::GetOrCreateTabsNode(
__anona63b8a510302() 290 V2::TABS_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<TabsPattern>(); });
291 tabBarNode_->AddChild(frameNode_);
292 }
293 maskIndex = 0;
294 for (int i = 0; i <= 1; i++) {
295 for (int j = 0; j <= 1; j++) {
296 tabBarPattern_->GetBottomTabBarImageSizeAndOffset(selectedIndexes, maskIndex, selectedImageSize,
297 unselectedImageSize, originalSelectedMaskOffset, originalUnselectedMaskOffset);
298 maskIndex = 1;
299 }
300 tabBarNode_->Clean(false, false);
301 }
302 EXPECT_TRUE(frameNode_);
303 }
304
305 /**
306 * @tc.name: TabBarPatternMaskAnimationFinish004
307 * @tc.desc: test MaskAnimationFinish
308 * @tc.type: FUNC
309 */
310 HWTEST_F(TabBarPatternTestNg, TabBarPatternMaskAnimationFinish004, TestSize.Level1)
311 {
312 /**
313 * @tc.steps: step1. build two bottom style tabbar.
314 */
315 TabsModelNG model = CreateTabs();
316 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
317 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
318 CreateTabsDone(model);
319
320 /**
321 * @tc.steps: step2. call MaskAnimationFinish function.
322 * @tc.expected: step2. expect The function is run ok.
323 */
324 IconStyle iconStyle;
325 iconStyle.unselectedColor = Color::WHITE;
326 tabBarPattern_->SetIconStyle(iconStyle, 0);
327 tabBarPattern_->MaskAnimationFinish(tabBarNode_, 0, false);
328 EXPECT_NE(tabBarNode_->GetChildAtIndex(0), nullptr);
329 tabBarPattern_->MaskAnimationFinish(tabBarNode_, 1, true);
330 EXPECT_NE(tabBarNode_->GetChildAtIndex(1), nullptr);
331 EXPECT_EQ(tabBarPattern_->indicator_, 0);
332 }
333
334 /**
335 * @tc.name: TabBarPatternMaskAnimationFinish005
336 * @tc.desc: test MaskAnimationFinish
337 * @tc.type: FUNC
338 */
339 HWTEST_F(TabBarPatternTestNg, TabBarPatternMaskAnimationFinish005, TestSize.Level1)
340 {
341 /**
342 * @tc.steps: step1. build two bottom style tabbar.
343 */
344 TabsModelNG model = CreateTabs();
345 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
346 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
347 CreateTabsDone(model);
348
349 /**
350 * @tc.steps: step2. call MaskAnimationFinish function.
351 * @tc.expected: step2. expect The function is run ok.
352 */
353 IconStyle iconStyle;
354 iconStyle.selectedColor = Color::WHITE;
355 tabBarPattern_->SetIconStyle(iconStyle, 0);
356 tabBarPattern_->MaskAnimationFinish(tabBarNode_, 0, false);
357 EXPECT_NE(tabBarNode_->GetChildAtIndex(0), nullptr);
358 tabBarPattern_->MaskAnimationFinish(tabBarNode_, 1, true);
359 EXPECT_NE(tabBarNode_->GetChildAtIndex(1), nullptr);
360 EXPECT_EQ(tabBarPattern_->indicator_, 0);
361 }
362
363 /**
364 * @tc.name: TabBarPatternMaskAnimationFinish006
365 * @tc.desc: test MaskAnimationFinish
366 * @tc.type: FUNC
367 */
368 HWTEST_F(TabBarPatternTestNg, TabBarPatternMaskAnimationFinish006, TestSize.Level1)
369 {
370 /**
371 * @tc.steps: step1. build two bottom style tabbar.
372 */
373 TabsModelNG model = CreateTabs();
374 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
375 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
376 CreateTabsDone(model);
377
378 /**
379 * @tc.steps: step2. call MaskAnimationFinish function.
380 * @tc.expected: step2. expect The function is run ok.
381 */
382 IconStyle iconStyle;
383 tabBarPattern_->SetIconStyle(iconStyle, 0);
384 tabBarPattern_->MaskAnimationFinish(tabBarNode_, 0, false);
385 EXPECT_NE(tabBarNode_->GetChildAtIndex(0), nullptr);
386 tabBarPattern_->MaskAnimationFinish(tabBarNode_, 1, true);
387 EXPECT_NE(tabBarNode_->GetChildAtIndex(1), nullptr);
388 EXPECT_EQ(tabBarPattern_->indicator_, 0);
389 }
390
391 /**
392 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight003
393 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
394 * @tc.type: FUNC
395 */
396 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight003, TestSize.Level1)
397 {
398 TabsModelNG model = CreateTabs();
399 TabsItemDivider divider;
400 model.SetDivider(divider);
401 CreateTabContents(1);
402 CreateTabsDone(model);
403 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
404 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
405 ASSERT_TRUE(pr.second);
406 /**
407 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
408 * @tc.expected: Related functions run ok.
409 */
410 int32_t index = 0;
411 tabBarPattern_->UpdateTextColorAndFontWeight(index);
412 tabBarPattern_->UpdateImageColor(index);
413
414 IconStyle iconStyle;
415 iconStyle.unselectedColor = Color::WHITE;
416 iconStyle.selectedColor = Color::WHITE;
417 tabBarPattern_->SetIconStyle(iconStyle, 0);
418 LabelStyle labelStyle;
419 labelStyle.unselectedColor = Color::WHITE;
420 labelStyle.selectedColor = Color::WHITE;
421 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
422 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
423 index = 0;
424 tabBarPattern_->UpdateTextColorAndFontWeight(index);
425 tabBarPattern_->UpdateImageColor(index);
426 EXPECT_EQ(tabBarPattern_->iconStyles_.size(), 1);
427 }
428
429 /**
430 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight004
431 * @tc.desc: test UpdateTextColorAndFontWeight
432 * @tc.type: FUNC
433 */
434 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight004, TestSize.Level1)
435 {
436 TabsModelNG model = CreateTabs();
437 TabsItemDivider divider;
438 model.SetDivider(divider);
439 CreateTabContents(1);
440 CreateTabsDone(model);
441 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
442 for (int i = 0; i <= 1; i++) {
443 AceType::DynamicCast<FrameNode>(
444 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
445 ->layoutProperty_ = AceType::MakeRefPtr<TextLayoutProperty>();
446 ASSERT_NE(AceType::DynamicCast<FrameNode>(
447 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
448 ->layoutProperty_,
449 nullptr);
450 }
451
452 /**
453 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight.
454 * @tc.expected: Related function runs ok.
455 */
456 LabelStyle labelStyle;
457 labelStyle.unselectedColor = Color::WHITE;
458 labelStyle.selectedColor = Color::WHITE;
459 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
460 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
461 int32_t index = 0;
462 tabBarPattern_->UpdateTextColorAndFontWeight(index);
463 EXPECT_TRUE(pattern_);
464 }
465
466 /**
467 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight005
468 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
469 * @tc.type: FUNC
470 */
471 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight005, TestSize.Level1)
472 {
473 TabsModelNG model = CreateTabs();
474 TabsItemDivider divider;
475 model.SetDivider(divider);
476 CreateTabContents(1);
477 CreateTabsDone(model);
478 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
479 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
480 ASSERT_TRUE(pr.second);
481 /**
482 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
483 * @tc.expected: Related functions run ok.
484 */
485 int32_t index = 0;
486 tabBarPattern_->UpdateTextColorAndFontWeight(index);
487 tabBarPattern_->UpdateImageColor(index);
488
489 IconStyle iconStyle;
490 iconStyle.selectedColor = Color::WHITE;
491 tabBarPattern_->SetIconStyle(iconStyle, 0);
492 LabelStyle labelStyle;
493 labelStyle.unselectedColor = Color::WHITE;
494 labelStyle.selectedColor = Color::WHITE;
495 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
496 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
497 index = 0;
498 tabBarPattern_->UpdateTextColorAndFontWeight(index);
499 tabBarPattern_->UpdateImageColor(index);
500 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
501 }
502
503 /**
504 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight006
505 * @tc.desc: test UpdateTextColorAndFontWeight
506 * @tc.type: FUNC
507 */
508 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight006, TestSize.Level1)
509 {
510 TabsModelNG model = CreateTabs();
511 TabsItemDivider divider;
512 model.SetDivider(divider);
513 CreateTabContents(1);
514 CreateTabsDone(model);
515 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
516 for (int i = 0; i <= 1; i++) {
517 AceType::DynamicCast<FrameNode>(
518 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
519 ->layoutProperty_ = AceType::MakeRefPtr<TextLayoutProperty>();
520 ASSERT_NE(AceType::DynamicCast<FrameNode>(
521 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
522 ->layoutProperty_,
523 nullptr);
524 }
525
526 /**
527 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight.
528 * @tc.expected: Related function runs ok.
529 */
530 LabelStyle labelStyle;
531 labelStyle.selectedColor = Color::WHITE;
532 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
533 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
534 int32_t index = 0;
535 tabBarPattern_->UpdateTextColorAndFontWeight(index);
536 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
537 }
538
539 /**
540 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight007
541 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
542 * @tc.type: FUNC
543 */
544 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight007, TestSize.Level1)
545 {
546 TabsModelNG model = CreateTabs();
547 TabsItemDivider divider;
548 model.SetDivider(divider);
549 CreateTabContents(1);
550 CreateTabsDone(model);
551 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
552 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
553 ASSERT_TRUE(pr.second);
554 /**
555 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
556 * @tc.expected: Related functions run ok.
557 */
558 int32_t index = 0;
559 tabBarPattern_->UpdateTextColorAndFontWeight(index);
560 tabBarPattern_->UpdateImageColor(index);
561
562 IconStyle iconStyle;
563 iconStyle.unselectedColor = Color::WHITE;
564 tabBarPattern_->SetIconStyle(iconStyle, 0);
565 LabelStyle labelStyle;
566 labelStyle.unselectedColor = Color::WHITE;
567 labelStyle.selectedColor = Color::WHITE;
568 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
569 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
570 index = 0;
571 tabBarPattern_->UpdateTextColorAndFontWeight(index);
572 tabBarPattern_->UpdateImageColor(index);
573 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
574 }
575
576 /**
577 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight008
578 * @tc.desc: test UpdateTextColorAndFontWeight
579 * @tc.type: FUNC
580 */
581 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight008, TestSize.Level1)
582 {
583 TabsModelNG model = CreateTabs();
584 TabsItemDivider divider;
585 model.SetDivider(divider);
586 CreateTabContents(1);
587 CreateTabsDone(model);
588 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
589 for (int i = 0; i <= 1; i++) {
590 AceType::DynamicCast<FrameNode>(
591 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
592 ->layoutProperty_ = AceType::MakeRefPtr<TextLayoutProperty>();
593 ASSERT_NE(AceType::DynamicCast<FrameNode>(
594 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
595 ->layoutProperty_,
596 nullptr);
597 }
598
599 /**
600 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight.
601 * @tc.expected: Related function runs ok.
602 */
603 LabelStyle labelStyle;
604 labelStyle.unselectedColor = Color::WHITE;
605 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
606 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
607 int32_t index = 0;
608 tabBarPattern_->UpdateTextColorAndFontWeight(index);
609 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
610 }
611
612 /**
613 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight009
614 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
615 * @tc.type: FUNC
616 */
617 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight009, TestSize.Level1)
618 {
619 TabsModelNG model = CreateTabs();
620 TabsItemDivider divider;
621 model.SetDivider(divider);
622 CreateTabContents(1);
623 CreateTabsDone(model);
624 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
625 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
626 ASSERT_TRUE(pr.second);
627 /**
628 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
629 * @tc.expected: Related functions run ok.
630 */
631 int32_t index = 0;
632 tabBarPattern_->UpdateTextColorAndFontWeight(index);
633 tabBarPattern_->UpdateImageColor(index);
634
635 IconStyle iconStyle;
636 tabBarPattern_->SetIconStyle(iconStyle, 0);
637 LabelStyle labelStyle;
638 labelStyle.unselectedColor = Color::WHITE;
639 labelStyle.selectedColor = Color::WHITE;
640 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
641 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
642 index = 0;
643 tabBarPattern_->UpdateTextColorAndFontWeight(index);
644 tabBarPattern_->UpdateImageColor(index);
645 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
646 }
647
648 /**
649 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight010
650 * @tc.desc: test UpdateTextColorAndFontWeight
651 * @tc.type: FUNC
652 */
653 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight010, TestSize.Level1)
654 {
655 TabsModelNG model = CreateTabs();
656 TabsItemDivider divider;
657 model.SetDivider(divider);
658 CreateTabContents(1);
659 CreateTabsDone(model);
660 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
661 for (int i = 0; i <= 1; i++) {
662 AceType::DynamicCast<FrameNode>(
663 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
664 ->layoutProperty_ = AceType::MakeRefPtr<TextLayoutProperty>();
665 ASSERT_NE(AceType::DynamicCast<FrameNode>(
666 AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(i))->GetChildren().back())
667 ->layoutProperty_,
668 nullptr);
669 }
670
671 /**
672 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight.
673 * @tc.expected: Related function runs ok.
674 */
675 LabelStyle labelStyle;
676 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
677 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
678 int32_t index = 0;
679 tabBarPattern_->UpdateTextColorAndFontWeight(index);
680 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
681 }
682
683 /**
684 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight011
685 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
686 * @tc.type: FUNC
687 */
688 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight011, TestSize.Level1)
689 {
690 TabsModelNG model = CreateTabs();
691 TabsItemDivider divider;
692 model.SetDivider(divider);
693 CreateTabContents(1);
694 CreateTabsDone(model);
695 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
696 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
697 ASSERT_TRUE(pr.second);
698 /**
699 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
700 * @tc.expected: Related functions run ok.
701 */
702 int32_t index = 0;
703 tabBarPattern_->UpdateTextColorAndFontWeight(index);
704 tabBarPattern_->UpdateImageColor(index);
705
706 IconStyle iconStyle;
707 iconStyle.unselectedColor = Color::WHITE;
708 iconStyle.selectedColor = Color::WHITE;
709 tabBarPattern_->SetIconStyle(iconStyle, 0);
710 LabelStyle labelStyle;
711 labelStyle.selectedColor = Color::WHITE;
712 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
713 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
714 index = 0;
715 tabBarPattern_->UpdateTextColorAndFontWeight(index);
716 tabBarPattern_->UpdateImageColor(index);
717 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
718 }
719
720 /**
721 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight012
722 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
723 * @tc.type: FUNC
724 */
725 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight012, TestSize.Level1)
726 {
727 TabsModelNG model = CreateTabs();
728 TabsItemDivider divider;
729 model.SetDivider(divider);
730 CreateTabContents(1);
731 CreateTabsDone(model);
732 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
733 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
734 ASSERT_TRUE(pr.second);
735 /**
736 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
737 * @tc.expected: Related functions run ok.
738 */
739 int32_t index = 0;
740 tabBarPattern_->UpdateTextColorAndFontWeight(index);
741 tabBarPattern_->UpdateImageColor(index);
742
743 IconStyle iconStyle;
744 iconStyle.unselectedColor = Color::WHITE;
745 tabBarPattern_->SetIconStyle(iconStyle, 0);
746 LabelStyle labelStyle;
747 labelStyle.selectedColor = Color::WHITE;
748 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
749 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
750 index = 0;
751 tabBarPattern_->UpdateTextColorAndFontWeight(index);
752 tabBarPattern_->UpdateImageColor(index);
753 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
754 }
755
756 /**
757 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight013
758 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
759 * @tc.type: FUNC
760 */
761 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight013, TestSize.Level1)
762 {
763 TabsModelNG model = CreateTabs();
764 TabsItemDivider divider;
765 model.SetDivider(divider);
766 CreateTabContents(1);
767 CreateTabsDone(model);
768 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
769 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
770 ASSERT_TRUE(pr.second);
771 /**
772 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
773 * @tc.expected: Related functions run ok.
774 */
775 int32_t index = 0;
776 tabBarPattern_->UpdateTextColorAndFontWeight(index);
777 tabBarPattern_->UpdateImageColor(index);
778
779 IconStyle iconStyle;
780 iconStyle.selectedColor = Color::WHITE;
781 tabBarPattern_->SetIconStyle(iconStyle, 0);
782 LabelStyle labelStyle;
783 labelStyle.selectedColor = Color::WHITE;
784 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
785 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
786 index = 0;
787 tabBarPattern_->UpdateTextColorAndFontWeight(index);
788 tabBarPattern_->UpdateImageColor(index);
789 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
790 }
791
792 /**
793 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight014
794 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
795 * @tc.type: FUNC
796 */
797 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight014, TestSize.Level1)
798 {
799 TabsModelNG model = CreateTabs();
800 TabsItemDivider divider;
801 model.SetDivider(divider);
802 CreateTabContents(1);
803 CreateTabsDone(model);
804 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
805 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
806 ASSERT_TRUE(pr.second);
807 /**
808 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
809 * @tc.expected: Related functions run ok.
810 */
811 int32_t index = 0;
812 tabBarPattern_->UpdateTextColorAndFontWeight(index);
813 tabBarPattern_->UpdateImageColor(index);
814
815 IconStyle iconStyle;
816 tabBarPattern_->SetIconStyle(iconStyle, 0);
817 LabelStyle labelStyle;
818 labelStyle.selectedColor = Color::WHITE;
819 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
820 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
821 index = 0;
822 tabBarPattern_->UpdateTextColorAndFontWeight(index);
823 tabBarPattern_->UpdateImageColor(index);
824 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
825 }
826
827 /**
828 * @tc.name: TabBarPatternUpdateImageColor002
829 * @tc.desc: test UpdateImageColor
830 * @tc.type: FUNC
831 */
832 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateImageColor002, TestSize.Level1)
833 {
834 /**
835 * @tc.steps: step1. build two bottom style tabbar.
836 */
837 TabsModelNG model = CreateTabs();
838 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
839 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
840 CreateTabsDone(model);
841
842 /**
843 * @tc.steps: step2. call UpdateImageColor function.
844 * @tc.expected: step2. expect The function is run ok.
845 */
846 IconStyle iconStyle;
847 iconStyle.unselectedColor = Color::WHITE;
848 iconStyle.selectedColor = Color::WHITE;
849 tabBarPattern_->SetIconStyle(iconStyle, 0);
850 tabBarPattern_->UpdateImageColor(0);
851 EXPECT_NE(tabBarNode_->GetChildAtIndex(0), nullptr);
852 tabBarPattern_->UpdateImageColor(1);
853 EXPECT_NE(tabBarNode_->GetChildAtIndex(1), nullptr);
854 EXPECT_EQ(tabBarPattern_->indicator_, 0);
855 tabBarPattern_->SetMaskAnimationByCreate(false);
856 EXPECT_EQ(tabBarPattern_->IsMaskAnimationByCreate(), false);
857 }
858
859 /**
860 * @tc.name: TabBarPatternUpdateImageColor003
861 * @tc.desc: test UpdateImageColor
862 * @tc.type: FUNC
863 */
864 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateImageColor003, TestSize.Level1)
865 {
866 /**
867 * @tc.steps: step1. build two bottom style tabbar.
868 */
869 TabsModelNG model = CreateTabs();
870 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
871 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
872 CreateTabsDone(model);
873
874 /**
875 * @tc.steps: step2. call UpdateImageColor function.
876 * @tc.expected: step2. expect The function is run ok.
877 */
878 IconStyle iconStyle;
879 iconStyle.unselectedColor = Color::WHITE;
880 tabBarPattern_->SetIconStyle(iconStyle, 0);
881 tabBarPattern_->UpdateImageColor(0);
882 EXPECT_NE(tabBarNode_->GetChildAtIndex(0), nullptr);
883 tabBarPattern_->UpdateImageColor(1);
884 EXPECT_NE(tabBarNode_->GetChildAtIndex(1), nullptr);
885 EXPECT_EQ(tabBarPattern_->indicator_, 0);
886 tabBarPattern_->SetMaskAnimationByCreate(false);
887 EXPECT_EQ(tabBarPattern_->IsMaskAnimationByCreate(), false);
888 }
889
890 /**
891 * @tc.name: TabBarPatternUpdateImageColor004
892 * @tc.desc: test UpdateImageColor
893 * @tc.type: FUNC
894 */
895 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateImageColor004, TestSize.Level1)
896 {
897 /**
898 * @tc.steps: step1. build two bottom style tabbar.
899 */
900 TabsModelNG model = CreateTabs();
901 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
902 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
903 CreateTabsDone(model);
904
905 /**
906 * @tc.steps: step2. call UpdateImageColor function.
907 * @tc.expected: step2. expect The function is run ok.
908 */
909 IconStyle iconStyle;
910 iconStyle.selectedColor = Color::WHITE;
911 tabBarPattern_->SetIconStyle(iconStyle, 0);
912 tabBarPattern_->UpdateImageColor(0);
913 EXPECT_NE(tabBarNode_->GetChildAtIndex(0), nullptr);
914 tabBarPattern_->UpdateImageColor(1);
915 EXPECT_NE(tabBarNode_->GetChildAtIndex(1), nullptr);
916 EXPECT_EQ(tabBarPattern_->indicator_, 0);
917 tabBarPattern_->SetMaskAnimationByCreate(false);
918 EXPECT_EQ(tabBarPattern_->IsMaskAnimationByCreate(), false);
919 }
920
921 /**
922 * @tc.name: TabBarPatternUpdateImageColor005
923 * @tc.desc: test UpdateImageColor
924 * @tc.type: FUNC
925 */
926 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateImageColor005, TestSize.Level1)
927 {
928 /**
929 * @tc.steps: step1. build two bottom style tabbar.
930 */
931 TabsModelNG model = CreateTabs();
932 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
933 CreateTabContentTabBarStyle(TabBarStyle::BOTTOMTABBATSTYLE);
934 CreateTabsDone(model);
935
936 /**
937 * @tc.steps: step2. call UpdateImageColor function.
938 * @tc.expected: step2. expect The function is run ok.
939 */
940 IconStyle iconStyle;
941 tabBarPattern_->SetIconStyle(iconStyle, 0);
942 tabBarPattern_->UpdateImageColor(0);
943 EXPECT_NE(tabBarNode_->GetChildAtIndex(0), nullptr);
944 tabBarPattern_->UpdateImageColor(1);
945 EXPECT_NE(tabBarNode_->GetChildAtIndex(1), nullptr);
946 EXPECT_EQ(tabBarPattern_->indicator_, 0);
947 tabBarPattern_->SetMaskAnimationByCreate(false);
948 EXPECT_EQ(tabBarPattern_->IsMaskAnimationByCreate(), false);
949 }
950
951 /**
952 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight015
953 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
954 * @tc.type: FUNC
955 */
956 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight015, TestSize.Level1)
957 {
958 TabsModelNG model = CreateTabs();
959 TabsItemDivider divider;
960 model.SetDivider(divider);
961 CreateTabContents(1);
962 CreateTabsDone(model);
963 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
964 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
965 ASSERT_TRUE(pr.second);
966 /**
967 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
968 * @tc.expected: Related functions run ok.
969 */
970 int32_t index = 0;
971 tabBarPattern_->UpdateTextColorAndFontWeight(index);
972 tabBarPattern_->UpdateImageColor(index);
973
974 IconStyle iconStyle;
975 iconStyle.unselectedColor = Color::WHITE;
976 iconStyle.selectedColor = Color::WHITE;
977 tabBarPattern_->SetIconStyle(iconStyle, 0);
978 LabelStyle labelStyle;
979 labelStyle.unselectedColor = Color::WHITE;
980 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
981 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
982 index = 0;
983 tabBarPattern_->UpdateTextColorAndFontWeight(index);
984 tabBarPattern_->UpdateImageColor(index);
985 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
986 }
987
988 /**
989 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight016
990 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
991 * @tc.type: FUNC
992 */
993 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight016, TestSize.Level1)
994 {
995 TabsModelNG model = CreateTabs();
996 TabsItemDivider divider;
997 model.SetDivider(divider);
998 CreateTabContents(1);
999 CreateTabsDone(model);
1000 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
1001 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
1002 ASSERT_TRUE(pr.second);
1003 /**
1004 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
1005 * @tc.expected: Related functions run ok.
1006 */
1007 int32_t index = 0;
1008 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1009 tabBarPattern_->UpdateImageColor(index);
1010
1011 IconStyle iconStyle;
1012 iconStyle.unselectedColor = Color::WHITE;
1013 tabBarPattern_->SetIconStyle(iconStyle, 0);
1014 LabelStyle labelStyle;
1015 labelStyle.unselectedColor = Color::WHITE;
1016 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
1017 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
1018 index = 0;
1019 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1020 tabBarPattern_->UpdateImageColor(index);
1021 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
1022 }
1023
1024 /**
1025 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight017
1026 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
1027 * @tc.type: FUNC
1028 */
1029 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight017, TestSize.Level1)
1030 {
1031 TabsModelNG model = CreateTabs();
1032 TabsItemDivider divider;
1033 model.SetDivider(divider);
1034 CreateTabContents(1);
1035 CreateTabsDone(model);
1036 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
1037 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
1038 ASSERT_TRUE(pr.second);
1039 /**
1040 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
1041 * @tc.expected: Related functions run ok.
1042 */
1043 int32_t index = 0;
1044 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1045 tabBarPattern_->UpdateImageColor(index);
1046
1047 IconStyle iconStyle;
1048 iconStyle.selectedColor = Color::WHITE;
1049 tabBarPattern_->SetIconStyle(iconStyle, 0);
1050 LabelStyle labelStyle;
1051 labelStyle.unselectedColor = Color::WHITE;
1052 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
1053 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
1054 index = 0;
1055 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1056 tabBarPattern_->UpdateImageColor(index);
1057 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
1058 }
1059
1060 /**
1061 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight018
1062 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
1063 * @tc.type: FUNC
1064 */
1065 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight018, TestSize.Level1)
1066 {
1067 TabsModelNG model = CreateTabs();
1068 TabsItemDivider divider;
1069 model.SetDivider(divider);
1070 CreateTabContents(1);
1071 CreateTabsDone(model);
1072 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
1073 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
1074 ASSERT_TRUE(pr.second);
1075 /**
1076 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
1077 * @tc.expected: Related functions run ok.
1078 */
1079 int32_t index = 0;
1080 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1081 tabBarPattern_->UpdateImageColor(index);
1082
1083 IconStyle iconStyle;
1084 tabBarPattern_->SetIconStyle(iconStyle, 0);
1085 LabelStyle labelStyle;
1086 labelStyle.unselectedColor = Color::WHITE;
1087 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
1088 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
1089 index = 0;
1090 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1091 tabBarPattern_->UpdateImageColor(index);
1092 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
1093 }
1094
1095 /**
1096 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight019
1097 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
1098 * @tc.type: FUNC
1099 */
1100 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight019, TestSize.Level1)
1101 {
1102 TabsModelNG model = CreateTabs();
1103 TabsItemDivider divider;
1104 model.SetDivider(divider);
1105 CreateTabContents(1);
1106 CreateTabsDone(model);
1107 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
1108 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
1109 ASSERT_TRUE(pr.second);
1110 /**
1111 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
1112 * @tc.expected: Related functions run ok.
1113 */
1114 int32_t index = 0;
1115 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1116 tabBarPattern_->UpdateImageColor(index);
1117
1118 IconStyle iconStyle;
1119 iconStyle.unselectedColor = Color::WHITE;
1120 iconStyle.selectedColor = Color::WHITE;
1121 tabBarPattern_->SetIconStyle(iconStyle, 0);
1122 LabelStyle labelStyle;
1123 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
1124 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
1125 index = 0;
1126 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1127 tabBarPattern_->UpdateImageColor(index);
1128 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
1129 }
1130
1131 /**
1132 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight020
1133 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
1134 * @tc.type: FUNC
1135 */
1136 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight020, TestSize.Level1)
1137 {
1138 TabsModelNG model = CreateTabs();
1139 TabsItemDivider divider;
1140 model.SetDivider(divider);
1141 CreateTabContents(1);
1142 CreateTabsDone(model);
1143 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
1144 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
1145 ASSERT_TRUE(pr.second);
1146 /**
1147 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
1148 * @tc.expected: Related functions run ok.
1149 */
1150 int32_t index = 0;
1151 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1152 tabBarPattern_->UpdateImageColor(index);
1153
1154 IconStyle iconStyle;
1155 iconStyle.unselectedColor = Color::WHITE;
1156 tabBarPattern_->SetIconStyle(iconStyle, 0);
1157 LabelStyle labelStyle;
1158 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
1159 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
1160 index = 0;
1161 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1162 tabBarPattern_->UpdateImageColor(index);
1163 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
1164 }
1165
1166 /**
1167 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight021
1168 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight021, TestSize.Level1)
1172 {
1173 TabsModelNG model = CreateTabs();
1174 TabsItemDivider divider;
1175 model.SetDivider(divider);
1176 CreateTabContents(1);
1177 CreateTabsDone(model);
1178 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
1179 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
1180 ASSERT_TRUE(pr.second);
1181 /**
1182 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
1183 * @tc.expected: Related functions run ok.
1184 */
1185 int32_t index = 0;
1186 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1187 tabBarPattern_->UpdateImageColor(index);
1188
1189 IconStyle iconStyle;
1190 iconStyle.selectedColor = Color::WHITE;
1191 tabBarPattern_->SetIconStyle(iconStyle, 0);
1192 LabelStyle labelStyle;
1193 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
1194 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
1195 index = 0;
1196 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1197 tabBarPattern_->UpdateImageColor(index);
1198 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
1199 }
1200
1201 /**
1202 * @tc.name: TabBarPatternUpdateTextColorAndFontWeight022
1203 * @tc.desc: test UpdateTextColorAndFontWeight and UpdateImageColor
1204 * @tc.type: FUNC
1205 */
1206 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTextColorAndFontWeight022, TestSize.Level1)
1207 {
1208 TabsModelNG model = CreateTabs();
1209 TabsItemDivider divider;
1210 model.SetDivider(divider);
1211 CreateTabContents(1);
1212 CreateTabsDone(model);
1213 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
1214 auto pr = tabBarPattern_->tabBarType_.emplace(std::make_pair(1, TabBarParamType::CUSTOM_BUILDER));
1215 ASSERT_TRUE(pr.second);
1216 /**
1217 * @tc.steps: step2. Test function UpdateTextColorAndFontWeight and UpdateImageColor.
1218 * @tc.expected: Related functions run ok.
1219 */
1220 int32_t index = 0;
1221 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1222 tabBarPattern_->UpdateImageColor(index);
1223
1224 IconStyle iconStyle;
1225 tabBarPattern_->SetIconStyle(iconStyle, 0);
1226 LabelStyle labelStyle;
1227 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
1228 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
1229 index = 0;
1230 tabBarPattern_->UpdateTextColorAndFontWeight(index);
1231 tabBarPattern_->UpdateImageColor(index);
1232 EXPECT_EQ(tabBarPattern_->labelStyles_.size(), 1);
1233 }
1234
1235 /**
1236 * @tc.name: TabBarPatternPlayMaskAnimation002
1237 * @tc.desc: test PlayMaskAnimation
1238 * @tc.type: FUNC
1239 */
1240 HWTEST_F(TabBarPatternTestNg, TabBarPatternPlayMaskAnimation002, TestSize.Level1)
1241 {
1242 TabsModelNG model = CreateTabs();
1243 CreateTabContents(TABCONTENT_NUMBER);
1244 CreateTabsDone(model);
1245
1246 /**
1247 * @tc.steps: step2. Test function PlayMaskAnimation.
1248 * @tc.expected: Related function runs ok.
1249 */
1250 float selectedImageSize = 0.1f;
1251 OffsetF originalSelectedMaskOffset(0.1f, 0.2f);
1252 int32_t selectedIndex = 1;
1253 float unselectedImageSize = 0.2f;
1254 OffsetF originalUnselectedMaskOffset(0.1f, 0.2f);
1255 int32_t unselectedIndex = 1;
1256 IconStyle iconStyle;
1257 iconStyle.unselectedColor = Color::WHITE;
1258 iconStyle.selectedColor = Color::WHITE;
1259 tabBarPattern_->SetIconStyle(iconStyle, 0);
1260 tabBarPattern_->PlayMaskAnimation(selectedImageSize, originalSelectedMaskOffset, selectedIndex, unselectedImageSize,
1261 originalUnselectedMaskOffset, unselectedIndex);
1262 EXPECT_EQ(tabBarPattern_->iconStyles_.size(), 4);
1263 }
1264
1265 /**
1266 * @tc.name: TabBarPatternPlayMaskAnimation003
1267 * @tc.desc: test PlayMaskAnimation
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(TabBarPatternTestNg, TabBarPatternPlayMaskAnimation003, TestSize.Level1)
1271 {
1272 TabsModelNG model = CreateTabs();
1273 CreateTabContents(TABCONTENT_NUMBER);
1274 CreateTabsDone(model);
1275
1276 /**
1277 * @tc.steps: step2. Test function PlayMaskAnimation.
1278 * @tc.expected: Related function runs ok.
1279 */
1280 float selectedImageSize = 0.1f;
1281 OffsetF originalSelectedMaskOffset(0.1f, 0.2f);
1282 int32_t selectedIndex = 1;
1283 float unselectedImageSize = 0.2f;
1284 OffsetF originalUnselectedMaskOffset(0.1f, 0.2f);
1285 int32_t unselectedIndex = 1;
1286 IconStyle iconStyle;
1287 iconStyle.unselectedColor = Color::WHITE;
1288 tabBarPattern_->SetIconStyle(iconStyle, 0);
1289 tabBarPattern_->PlayMaskAnimation(selectedImageSize, originalSelectedMaskOffset, selectedIndex, unselectedImageSize,
1290 originalUnselectedMaskOffset, unselectedIndex);
1291 EXPECT_TRUE(tabBarPattern_);
1292 }
1293
1294 /**
1295 * @tc.name: TabBarPatternPlayMaskAnimation004
1296 * @tc.desc: test PlayMaskAnimation
1297 * @tc.type: FUNC
1298 */
1299 HWTEST_F(TabBarPatternTestNg, TabBarPatternPlayMaskAnimation004, TestSize.Level1)
1300 {
1301 TabsModelNG model = CreateTabs();
1302 CreateTabContents(TABCONTENT_NUMBER);
1303 CreateTabsDone(model);
1304
1305 /**
1306 * @tc.steps: step2. Test function PlayMaskAnimation.
1307 * @tc.expected: Related function runs ok.
1308 */
1309 float selectedImageSize = 0.1f;
1310 OffsetF originalSelectedMaskOffset(0.1f, 0.2f);
1311 int32_t selectedIndex = 1;
1312 float unselectedImageSize = 0.2f;
1313 OffsetF originalUnselectedMaskOffset(0.1f, 0.2f);
1314 int32_t unselectedIndex = 1;
1315 IconStyle iconStyle;
1316 iconStyle.selectedColor = Color::WHITE;
1317 tabBarPattern_->SetIconStyle(iconStyle, 0);
1318 tabBarPattern_->PlayMaskAnimation(selectedImageSize, originalSelectedMaskOffset, selectedIndex, unselectedImageSize,
1319 originalUnselectedMaskOffset, unselectedIndex);
1320 EXPECT_EQ(tabBarPattern_->iconStyles_.size(), 4);
1321 }
1322
1323 /**
1324 * @tc.name: TabBarPatternPlayMaskAnimation005
1325 * @tc.desc: test PlayMaskAnimation
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(TabBarPatternTestNg, TabBarPatternPlayMaskAnimation005, TestSize.Level1)
1329 {
1330 TabsModelNG model = CreateTabs();
1331 CreateTabContents(TABCONTENT_NUMBER);
1332 CreateTabsDone(model);
1333
1334 /**
1335 * @tc.steps: step2. Test function PlayMaskAnimation.
1336 * @tc.expected: Related function runs ok.
1337 */
1338 float selectedImageSize = 0.1f;
1339 OffsetF originalSelectedMaskOffset(0.1f, 0.2f);
1340 int32_t selectedIndex = 1;
1341 float unselectedImageSize = 0.2f;
1342 OffsetF originalUnselectedMaskOffset(0.1f, 0.2f);
1343 int32_t unselectedIndex = 1;
1344 IconStyle iconStyle;
1345 tabBarPattern_->SetIconStyle(iconStyle, 0);
1346 tabBarPattern_->PlayMaskAnimation(selectedImageSize, originalSelectedMaskOffset, selectedIndex, unselectedImageSize,
1347 originalUnselectedMaskOffset, unselectedIndex);
1348 EXPECT_EQ(tabBarPattern_->iconStyles_.size(), 4);
1349 }
1350
1351 /**
1352 * @tc.name: TabBarPatternStartShowTabBarTest001
1353 * @tc.desc: test StartShowTabBar
1354 * @tc.type: FUNC
1355 */
1356 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartShowTabBarTest001, TestSize.Level1)
1357 {
1358 TabsModelNG model = CreateTabs(BarPosition::END);
1359 CreateTabContents(TABCONTENT_NUMBER);
1360 CreateTabsDone(model);
1361 MockPaintRect(tabBarNode_);
1362
1363 /**
1364 * @tc.steps: step2. default translate is 0, test function StartShowTabBar.
1365 * @tc.expected: Related function runs ok.
1366 */
1367 tabBarPattern_->StartShowTabBar();
1368 MockAnimationManager::GetInstance().Tick();
1369 EXPECT_FALSE(tabBarPattern_->isTabBarShowing_);
1370 MockAnimationManager::GetInstance().Tick();
1371
1372 /**
1373 * @tc.steps: step3. Set translate to a value greater than 0, test function StartShowTabBar.
1374 * @tc.expected: Related function runs ok.
1375 */
1376 auto renderContext = tabBarNode_->GetRenderContext();
1377 renderContext->UpdateTransformTranslate(TranslateOptions(0.0f, 10.0f, 0.0f));
1378 tabBarPattern_->StartShowTabBar();
1379 MockAnimationManager::GetInstance().Tick();
1380 EXPECT_TRUE(tabBarPattern_->isTabBarShowing_);
1381 EXPECT_LT(GetTabBarPosition(), 10.0f);
1382 tabBarPattern_->StartShowTabBar();
1383 MockAnimationManager::GetInstance().Tick();
1384 EXPECT_FALSE(tabBarPattern_->isTabBarShowing_);
1385 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1386 }
1387
1388 /**
1389 * @tc.name: TabBarPatternStartShowTabBarTest002
1390 * @tc.desc: test StartShowTabBar
1391 * @tc.type: FUNC
1392 */
1393 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartShowTabBarTest002, TestSize.Level1)
1394 {
1395 TabsModelNG model = CreateTabs(BarPosition::END);
1396 CreateTabContents(TABCONTENT_NUMBER);
1397 CreateTabsDone(model);
1398 MockPaintRect(tabBarNode_);
1399
1400 /**
1401 * @tc.steps: step2. start hide tab bar, test function StartShowTabBar.
1402 * @tc.expected: Related function runs ok.
1403 */
1404 tabBarPattern_->StartHideTabBar();
1405 MockAnimationManager::GetInstance().Tick();
1406 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1407 EXPECT_GT(GetTabBarPosition(), 0.0f);
1408 tabBarPattern_->StartShowTabBar();
1409 MockAnimationManager::GetInstance().Tick();
1410 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1411 EXPECT_TRUE(tabBarPattern_->isTabBarShowing_);
1412 auto renderContext = tabBarNode_->GetRenderContext();
1413 auto size = renderContext->GetPaintRectWithoutTransform().Height();
1414 EXPECT_LT(GetTabBarPosition(), size);
1415 MockAnimationManager::GetInstance().Tick();
1416 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1417 EXPECT_FALSE(tabBarPattern_->isTabBarShowing_);
1418 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1419 }
1420
1421 /**
1422 * @tc.name: TabBarPatternStartHideTabBarTest001
1423 * @tc.desc: test StartHideTabBar
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartHideTabBarTest001, TestSize.Level1)
1427 {
1428 TabsModelNG model = CreateTabs();
1429 CreateTabContents(TABCONTENT_NUMBER);
1430 CreateTabsDone(model);
1431 MockPaintRect(tabBarNode_);
1432
1433 /**
1434 * @tc.steps: step2. default translate is 0, test function StartHideTabBar.
1435 * @tc.expected: Related function runs ok.
1436 */
1437 tabBarPattern_->StartHideTabBar();
1438 MockAnimationManager::GetInstance().Tick();
1439 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1440 EXPECT_LT(GetTabBarPosition(), 0.0f);
1441 tabBarPattern_->StartHideTabBar();
1442 MockAnimationManager::GetInstance().Tick();
1443 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1444 auto renderContext = tabBarNode_->GetRenderContext();
1445 auto size = renderContext->GetPaintRectWithoutTransform().Height();
1446 EXPECT_EQ(GetTabBarPosition(), -size);
1447
1448 /**
1449 * @tc.steps: step3. Translate equals tab bar size, test function StartHideTabBar.
1450 * @tc.expected: Related function runs ok.
1451 */
1452 tabBarPattern_->StartHideTabBar();
1453 MockAnimationManager::GetInstance().Tick();
1454 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1455 MockAnimationManager::GetInstance().Tick();
1456 }
1457
1458 /**
1459 * @tc.name: TabBarPatternStartHideTabBarTest002
1460 * @tc.desc: test StartHideTabBar
1461 * @tc.type: FUNC
1462 */
1463 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartHideTabBarTest002, TestSize.Level1)
1464 {
1465 TabsModelNG model = CreateTabs(BarPosition::END);
1466 CreateTabContents(TABCONTENT_NUMBER);
1467 CreateTabsDone(model);
1468 MockPaintRect(tabBarNode_);
1469
1470 /**
1471 * @tc.steps: step2. default translate is 0, test function StartHideTabBar.
1472 * @tc.expected: Related function runs ok.
1473 */
1474 tabBarPattern_->StartHideTabBar();
1475 MockAnimationManager::GetInstance().Tick();
1476 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1477 EXPECT_GT(GetTabBarPosition(), 0.0f);
1478 tabBarPattern_->StartHideTabBar();
1479 MockAnimationManager::GetInstance().Tick();
1480 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1481 auto renderContext = tabBarNode_->GetRenderContext();
1482 auto size = renderContext->GetPaintRectWithoutTransform().Height();
1483 EXPECT_EQ(GetTabBarPosition(), size);
1484 }
1485
1486 /**
1487 * @tc.name: TabBarPatternStopHideTabBarTest001
1488 * @tc.desc: test StopHideTabBar
1489 * @tc.type: FUNC
1490 */
1491 HWTEST_F(TabBarPatternTestNg, TabBarPatternStopHideTabBarTest001, TestSize.Level1)
1492 {
1493 TabsModelNG model = CreateTabs(BarPosition::END);
1494 CreateTabContents(TABCONTENT_NUMBER);
1495 CreateTabsDone(model);
1496 MockPaintRect(tabBarNode_);
1497
1498 /**
1499 * @tc.steps: step2.Not start hide tab bar, test function StopHideTabBar.
1500 * @tc.expected: Related function runs ok.
1501 */
1502 tabBarPattern_->StopHideTabBar();
1503 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1504
1505 /**
1506 * @tc.steps: step3. Start hide tab bar, test function StopHideTabBar.
1507 * @tc.expected: Related function runs ok.
1508 */
1509 tabBarPattern_->StartHideTabBar();
1510 MockAnimationManager::GetInstance().Tick();
1511 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1512 EXPECT_GT(GetTabBarPosition(), 0.0f);
1513 tabBarPattern_->StopHideTabBar();
1514 MockAnimationManager::GetInstance().Tick();
1515 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1516 auto renderContext = tabBarNode_->GetRenderContext();
1517 auto size = renderContext->GetPaintRectWithoutTransform().Height();
1518 EXPECT_LT(GetTabBarPosition(), size);
1519 }
1520
1521 /**
1522 * @tc.name: TabBarPatternUpdateTabBarOffsetTest001
1523 * @tc.desc: test UpdateTabBarOffset
1524 * @tc.type: FUNC
1525 */
1526 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTabBarOffsetTest001, TestSize.Level1)
1527 {
1528 TabsModelNG model = CreateTabs();
1529 CreateTabContents(TABCONTENT_NUMBER);
1530 CreateTabsDone(model);
1531 MockPaintRect(tabBarNode_);
1532
1533 /**
1534 * @tc.steps: step2.Set offset to 10.0f, test function UpdateTabBarOffset.
1535 * @tc.expected: Related function runs ok.
1536 */
1537 auto offset1 = 10.0f;
1538 tabBarPattern_->UpdateTabBarHiddenOffset(offset1);
1539 auto renderContext = tabBarNode_->GetRenderContext();
1540 auto opacity = renderContext->GetOpacityValue(1.0f);
1541 auto size = renderContext->GetPaintRectWithoutTransform().Height();
1542 EXPECT_EQ(GetTabBarPosition(), -offset1);
1543 EXPECT_EQ(opacity, 1.0f - offset1 / size);
1544
1545 /**
1546 * @tc.steps: step3.Set offset to 26.0_vp, test function UpdateTabBarOffset.
1547 * @tc.expected: Related function runs ok.
1548 */
1549 auto offset2 = Dimension(26.0f, DimensionUnit::VP).ConvertToPx();
1550 tabBarPattern_->UpdateTabBarHiddenOffset(offset2);
1551 MockAnimationManager::GetInstance().Tick();
1552 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1553 EXPECT_LT(GetTabBarPosition(), -(offset1 + offset2));
1554 tabBarPattern_->UpdateTabBarHiddenOffset(offset2);
1555 MockAnimationManager::GetInstance().Tick();
1556 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1557 opacity = renderContext->GetOpacityValue(1.0f);
1558 EXPECT_EQ(GetTabBarPosition(), -size);
1559 EXPECT_EQ(opacity, 0.0f);
1560
1561 /**
1562 * @tc.steps: step4.Set offset to -10.0f, test function UpdateTabBarOffset.
1563 * @tc.expected: Related function runs ok.
1564 */
1565 tabBarPattern_->UpdateTabBarHiddenOffset(-offset1);
1566 opacity = renderContext->GetOpacityValue(1.0f);
1567 EXPECT_EQ(GetTabBarPosition(), -size + offset1);
1568 EXPECT_EQ(opacity, offset1 / size);
1569
1570 /**
1571 * @tc.steps: step5.Set offset to -26.0_vp, test function UpdateTabBarOffset.
1572 * @tc.expected: Related function runs ok.
1573 */
1574 tabBarPattern_->UpdateTabBarHiddenOffset(-offset2);
1575 MockAnimationManager::GetInstance().Tick();
1576 EXPECT_TRUE(tabBarPattern_->isTabBarShowing_);
1577 EXPECT_GT(GetTabBarPosition(), -size + (offset1 + offset2));
1578 tabBarPattern_->UpdateTabBarHiddenOffset(offset2);
1579 MockAnimationManager::GetInstance().Tick();
1580 EXPECT_FALSE(tabBarPattern_->isTabBarShowing_);
1581 opacity = renderContext->GetOpacityValue(1.0f);
1582 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1583 EXPECT_EQ(opacity, 1.0f);
1584 }
1585
1586 /**
1587 * @tc.name: TabBarPatternUpdateTabBarOffsetTest002
1588 * @tc.desc: test UpdateTabBarOffset
1589 * @tc.type: FUNC
1590 */
1591 HWTEST_F(TabBarPatternTestNg, TabBarPatternUpdateTabBarOffsetTest002, TestSize.Level1)
1592 {
1593 TabsModelNG model = CreateTabs(BarPosition::END);
1594 CreateTabContents(TABCONTENT_NUMBER);
1595 CreateTabsDone(model);
1596 MockPaintRect(tabBarNode_);
1597
1598 /**
1599 * @tc.steps: step2.Set offset to 10.0f, test function UpdateTabBarOffset.
1600 * @tc.expected: Related function runs ok.
1601 */
1602 auto offset1 = 10.0f;
1603 tabBarPattern_->UpdateTabBarHiddenOffset(offset1);
1604 auto renderContext = tabBarNode_->GetRenderContext();
1605 auto size = renderContext->GetPaintRectWithoutTransform().Height();
1606 EXPECT_EQ(GetTabBarPosition(), offset1);
1607
1608 /**
1609 * @tc.steps: step3.Set offset to 26.0_vp, test function UpdateTabBarOffset.
1610 * @tc.expected: Related function runs ok.
1611 */
1612 auto offset2 = Dimension(26.0f, DimensionUnit::VP).ConvertToPx();
1613 tabBarPattern_->UpdateTabBarHiddenOffset(offset2);
1614 MockAnimationManager::GetInstance().Tick();
1615 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1616 EXPECT_GT(GetTabBarPosition(), offset1 + offset2);
1617 tabBarPattern_->UpdateTabBarHiddenOffset(offset2);
1618 MockAnimationManager::GetInstance().Tick();
1619 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1620 EXPECT_EQ(GetTabBarPosition(), size);
1621
1622 /**
1623 * @tc.steps: step4.Set offset to -10.0f, test function UpdateTabBarOffset.
1624 * @tc.expected: Related function runs ok.
1625 */
1626 tabBarPattern_->UpdateTabBarHiddenOffset(-offset1);
1627 EXPECT_EQ(GetTabBarPosition(), size - offset1);
1628
1629 /**
1630 * @tc.steps: step5.Set offset to -26.0_vp, test function UpdateTabBarOffset.
1631 * @tc.expected: Related function runs ok.
1632 */
1633 tabBarPattern_->UpdateTabBarHiddenOffset(-offset2);
1634 MockAnimationManager::GetInstance().Tick();
1635 EXPECT_TRUE(tabBarPattern_->isTabBarShowing_);
1636 EXPECT_LT(GetTabBarPosition(), size - (offset1 + offset2));
1637 tabBarPattern_->UpdateTabBarHiddenOffset(offset2);
1638 MockAnimationManager::GetInstance().Tick();
1639 EXPECT_FALSE(tabBarPattern_->isTabBarShowing_);
1640 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1641 }
1642
1643 /**
1644 * @tc.name: TabBarPatternSetTabBarTranslateAndOpacityTest001
1645 * @tc.desc: test SetTabBarTranslate and SetTabBarOpacity
1646 * @tc.type: FUNC
1647 */
1648 HWTEST_F(TabBarPatternTestNg, TabBarPatternSetTabBarTranslateAndOpacityTest001, TestSize.Level1)
1649 {
1650 TabsModelNG model = CreateTabs(BarPosition::END);
1651 CreateTabContents(TABCONTENT_NUMBER);
1652 CreateTabsDone(model);
1653
1654 /**
1655 * @tc.steps: step2.Set translate and opacity, test function SetTabBarTranslate and SetTabBarOpacity.
1656 * @tc.expected: Related function runs ok.
1657 */
1658 auto options = TranslateOptions(10.f, 10.f, 1.0f);
1659 tabBarPattern_->SetTabBarTranslate(options);
1660 auto opacity = 0.5f;
1661 tabBarPattern_->SetTabBarOpacity(opacity);
1662 auto renderContext = tabBarNode_->GetRenderContext();
1663 EXPECT_EQ(options, renderContext->GetTransformTranslateValue(TranslateOptions(0.0f, 0.0f, 0.0f)));
1664 EXPECT_EQ(opacity, renderContext->GetOpacityValue(1.0f));
1665 }
1666
1667 /**
1668 * @tc.name: SetTabBarTranslate001
1669 * @tc.desc: test SetTabBarTranslate
1670 * @tc.type: FUNC
1671 */
1672 HWTEST_F(TabBarPatternTestNg, SetTabBarTranslate001, TestSize.Level1)
1673 {
1674 /**
1675 * @tc.steps: step1. build tabbar.
1676 */
1677 TabsModelNG model = CreateTabs(BarPosition::END);
1678 CreateTabContents(TABCONTENT_NUMBER);
1679 CreateTabsDone(model);
1680
1681 /**
1682 * @tc.steps: step2.Set translate, test function SetTabBarTranslate.
1683 * @tc.expected: userDefinedTranslateY_ is 10.
1684 */
1685 auto options = TranslateOptions(0.0f, 10.f, 0.0f);
1686 tabBarPattern_->SetTabBarTranslate(options, true);
1687 EXPECT_EQ(tabBarPattern_->userDefinedTranslateY_, 10.f);
1688 }
1689
1690 /**
1691 * @tc.name: StartShowTabBar001
1692 * @tc.desc: test StartShowTabBar
1693 * @tc.type: FUNC
1694 */
1695 HWTEST_F(TabBarPatternTestNg, StartShowTabBar001, TestSize.Level1)
1696 {
1697 /**
1698 * @tc.steps: step1. build tabbar.
1699 */
1700 TabsModelNG model = CreateTabs(BarPosition::END);
1701 CreateTabContents(TABCONTENT_NUMBER);
1702 CreateTabsDone(model);
1703 MockPaintRect(tabBarNode_);
1704
1705 /**
1706 * @tc.steps: step2. Test function StartShowTabBar.
1707 * @tc.expected: Related function runs ok.
1708 */
1709 auto renderContext = tabBarNode_->GetRenderContext();
1710 renderContext->UpdateTransformTranslate(TranslateOptions(0.0f, 1.0f, 0.0f));
1711 tabBarPattern_->isTabBarHiding_ = false;
1712 tabBarPattern_->tabBarState_ = TabBarState::HIDE;
1713 tabBarPattern_->StartShowTabBar(2000);
1714 MockAnimationManager::GetInstance().Tick();
1715 EXPECT_FALSE(tabBarPattern_->isTabBarShowing_);
1716 EXPECT_LT(GetTabBarPosition(), 10.0f);
1717 }
1718
1719 /**
1720 * @tc.name: StartShowTabBar002
1721 * @tc.desc: test StartShowTabBar
1722 * @tc.type: FUNC
1723 */
1724 HWTEST_F(TabBarPatternTestNg, StartShowTabBar002, TestSize.Level1)
1725 {
1726 /**
1727 * @tc.steps: step1. build tabbar.
1728 */
1729 TabsModelNG model = CreateTabs(BarPosition::END);
1730 CreateTabContents(TABCONTENT_NUMBER);
1731 CreateTabsDone(model);
1732 MockPaintRect(tabBarNode_);
1733
1734 /**
1735 * @tc.steps: step2. Test function StartShowTabBar.
1736 * @tc.expected: Related function runs ok.
1737 */
1738 auto renderContext = tabBarNode_->GetRenderContext();
1739 renderContext->UpdateTransformTranslate(TranslateOptions(0.0f, 100.0f, 0.0f));
1740 tabBarPattern_->isTabBarHiding_ = false;
1741 tabBarPattern_->tabBarState_ = TabBarState::SHOW;
1742 tabBarPattern_->StartShowTabBar(2000);
1743 MockAnimationManager::GetInstance().Tick();
1744 EXPECT_FALSE(tabBarPattern_->isTabBarShowing_);
1745 EXPECT_GT(GetTabBarPosition(), 10.0f);
1746 }
1747
1748 /**
1749 * @tc.name: StartShowTabBar003
1750 * @tc.desc: test StartShowTabBar
1751 * @tc.type: FUNC
1752 */
1753 HWTEST_F(TabBarPatternTestNg, StartShowTabBar003, TestSize.Level1)
1754 {
1755 /**
1756 * @tc.steps: step1. build tabbar.
1757 */
1758 TabsModelNG model = CreateTabs(BarPosition::END);
1759 CreateTabContents(TABCONTENT_NUMBER);
1760 CreateTabsDone(model);
1761 MockPaintRect(tabBarNode_);
1762
1763 /**
1764 * @tc.steps: step2. Test function StartShowTabBar.
1765 * @tc.expected: Related function runs ok.
1766 */
1767 auto renderContext = tabBarNode_->GetRenderContext();
1768 renderContext->UpdateTransformTranslate(TranslateOptions(0.0f, 1.0f, 0.0f));
1769 tabBarPattern_->isTabBarHiding_ = false;
1770 tabBarPattern_->tabBarState_ = TabBarState::SHOW;
1771 tabBarPattern_->StartShowTabBar(2000);
1772 MockAnimationManager::GetInstance().Tick();
1773 EXPECT_TRUE(tabBarPattern_->isTabBarShowing_);
1774 EXPECT_LT(GetTabBarPosition(), 10.0f);
1775 }
1776
1777 /**
1778 * @tc.name: CancelShowTabBar
1779 * @tc.desc: test StartShowTabBar
1780 * @tc.type: FUNC
1781 */
1782 HWTEST_F(TabBarPatternTestNg, CancelShowTabBar, TestSize.Level1)
1783 {
1784 /**
1785 * @tc.steps: step1. build tabbar.
1786 */
1787 TabsModelNG model = CreateTabs(BarPosition::END);
1788 CreateTabContents(TABCONTENT_NUMBER);
1789 CreateTabsDone(model);
1790 MockPaintRect(tabBarNode_);
1791
1792 /**
1793 * @tc.steps: step2. Test function StartShowTabBar.
1794 * @tc.expected: Related function runs ok.
1795 */
1796 bool taskExecuted = false;
__anona63b8a510402() 1797 tabBarPattern_->showTabBarTask_.Reset([&taskExecuted]() { taskExecuted = true; });
1798 tabBarPattern_->CancelShowTabBar();
1799 EXPECT_FALSE(tabBarPattern_->showTabBarTask_);
1800 }
1801
1802 /**
1803 * @tc.name: TabBarPatternStartHideTabBarTest003
1804 * @tc.desc: test StartHideTabBar
1805 * @tc.type: FUNC
1806 */
1807 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartHideTabBarTest003, TestSize.Level1)
1808 {
1809 /**
1810 * @tc.steps: step1. build tabbar.
1811 */
1812 TabsModelNG model = CreateTabs(BarPosition::END);
1813 CreateTabContents(TABCONTENT_NUMBER);
1814 CreateTabsDone(model);
1815 MockPaintRect(tabBarNode_);
1816
1817 /**
1818 * @tc.steps: step2. Test function StartHideTabBar.
1819 * @tc.expected: Related function runs ok.
1820 */
1821 tabBarPattern_->axis_ = Axis::HORIZONTAL;
1822 tabBarPattern_->StartHideTabBar();
1823 MockAnimationManager::GetInstance().Tick();
1824 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1825 EXPECT_GT(GetTabBarPosition(), 0.0f);
1826 }
1827
1828 /**
1829 * @tc.name: TabBarPatternStartHideTabBarTest004
1830 * @tc.desc: test StartHideTabBar
1831 * @tc.type: FUNC
1832 */
1833 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartHideTabBarTest004, TestSize.Level1)
1834 {
1835 /**
1836 * @tc.steps: step1. build tabbar.
1837 */
1838 TabsModelNG model = CreateTabs(BarPosition::END);
1839 CreateTabContents(TABCONTENT_NUMBER);
1840 CreateTabsDone(model);
1841 MockPaintRect(tabBarNode_);
1842
1843 /**
1844 * @tc.steps: step2. Test function StartHideTabBar.
1845 * @tc.expected: Related function runs ok.
1846 */
1847 tabBarPattern_->axis_ = Axis::VERTICAL;
1848 tabBarPattern_->StartHideTabBar();
1849 MockAnimationManager::GetInstance().Tick();
1850 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1851 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1852 }
1853
1854 /**
1855 * @tc.name: TabBarPatternStartHideTabBarTest005
1856 * @tc.desc: test StartHideTabBar
1857 * @tc.type: FUNC
1858 */
1859 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartHideTabBarTest005, TestSize.Level1)
1860 {
1861 /**
1862 * @tc.steps: step1. build tabbar.
1863 */
1864 TabsModelNG model = CreateTabs(BarPosition::END);
1865 CreateTabContents(TABCONTENT_NUMBER);
1866 CreateTabsDone(model);
1867 MockPaintRect(tabBarNode_);
1868
1869 /**
1870 * @tc.steps: step2. Test function StartHideTabBar.
1871 * @tc.expected: Related function runs ok.
1872 */
1873 tabBarPattern_->axis_ = Axis::VERTICAL;
1874 tabBarPattern_->StartHideTabBar();
1875 MockAnimationManager::GetInstance().Tick();
1876 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1877 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1878 }
1879
1880 /**
1881 * @tc.name: TabBarPatternStartHideTabBarTest006
1882 * @tc.desc: test StartHideTabBar
1883 * @tc.type: FUNC
1884 */
1885 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartHideTabBarTest006, TestSize.Level1)
1886 {
1887 /**
1888 * @tc.steps: step1. build tabbar.
1889 */
1890 TabsModelNG model = CreateTabs(BarPosition::END);
1891 CreateTabContents(TABCONTENT_NUMBER);
1892 CreateTabsDone(model);
1893 MockPaintRect(tabBarNode_);
1894
1895 /**
1896 * @tc.steps: step2. Test function StartHideTabBar.
1897 * @tc.expected: Related function runs ok.
1898 */
1899 tabBarPattern_->axis_ = Axis::HORIZONTAL;
1900 tabBarPattern_->showTabBarTask_.Reset(nullptr);
1901 tabBarPattern_->isTabBarShowing_ = true;
1902 tabBarPattern_->StartHideTabBar();
1903 MockAnimationManager::GetInstance().Tick();
1904 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1905 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1906 }
1907
1908 /**
1909 * @tc.name: TabBarPatternStartHideTabBarTest007
1910 * @tc.desc: test StartHideTabBar
1911 * @tc.type: FUNC
1912 */
1913 HWTEST_F(TabBarPatternTestNg, TabBarPatternStartHideTabBarTest007, TestSize.Level1)
1914 {
1915 /**
1916 * @tc.steps: step1. build tabbar.
1917 */
1918 TabsModelNG model = CreateTabs(BarPosition::END);
1919 CreateTabContents(TABCONTENT_NUMBER);
1920 CreateTabsDone(model);
1921 MockPaintRect(tabBarNode_);
1922
1923 /**
1924 * @tc.steps: step2. Test function StartHideTabBar.
1925 * @tc.expected: Related function runs ok.
1926 */
1927 tabBarPattern_->axis_ = Axis::HORIZONTAL;
1928 tabBarPattern_->showTabBarTask_.Reset(nullptr);
1929 tabBarPattern_->isTabBarShowing_ = false;
1930 tabBarPattern_->isTabBarHiding_ = true;
1931 tabBarPattern_->StartHideTabBar();
1932 MockAnimationManager::GetInstance().Tick();
1933 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1934 EXPECT_EQ(GetTabBarPosition(), 0.0f);
1935 }
1936
1937 /**
1938 * @tc.name: StopHideTabBarTest001
1939 * @tc.desc: test StopHideTabBar
1940 * @tc.type: FUNC
1941 */
1942 HWTEST_F(TabBarPatternTestNg, StopHideTabBarTest001, TestSize.Level1)
1943 {
1944 /**
1945 * @tc.steps: step1. build tabbar.
1946 */
1947 TabsModelNG model = CreateTabs(BarPosition::END);
1948 CreateTabContents(TABCONTENT_NUMBER);
1949 CreateTabsDone(model);
1950 MockPaintRect(tabBarNode_);
1951
1952 /**
1953 * @tc.steps: step2.Not start hide tab bar, test function StopHideTabBar.
1954 * @tc.expected: Related function runs ok.
1955 */
1956 tabBarPattern_->StopHideTabBar();
1957 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1958
1959 /**
1960 * @tc.steps: step3. Start hide tab bar, test function StopHideTabBar.
1961 * @tc.expected: Related function runs ok.
1962 */
1963 tabBarPattern_->StartHideTabBar();
1964 MockAnimationManager::GetInstance().Tick();
1965 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
1966 EXPECT_GT(GetTabBarPosition(), 0.0f);
1967 tabBarPattern_->axis_ = Axis::HORIZONTAL;
1968 tabBarPattern_->StopHideTabBar();
1969 MockAnimationManager::GetInstance().Tick();
1970 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1971 auto renderContext = tabBarNode_->GetRenderContext();
1972 auto size = renderContext->GetPaintRectWithoutTransform().Height();
1973 EXPECT_LT(GetTabBarPosition(), size);
1974 }
1975
1976 /**
1977 * @tc.name: StopHideTabBarTest002
1978 * @tc.desc: test StopHideTabBar
1979 * @tc.type: FUNC
1980 */
1981 HWTEST_F(TabBarPatternTestNg, StopHideTabBarTest002, TestSize.Level1)
1982 {
1983 /**
1984 * @tc.steps: step1. build tabbar.
1985 */
1986 TabsModelNG model = CreateTabs(BarPosition::END);
1987 CreateTabContents(TABCONTENT_NUMBER);
1988 CreateTabsDone(model);
1989 MockPaintRect(tabBarNode_);
1990
1991 /**
1992 * @tc.steps: step2.Not start hide tab bar, test function StopHideTabBar.
1993 * @tc.expected: Related function runs ok.
1994 */
1995 tabBarPattern_->StopHideTabBar();
1996 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
1997
1998 /**
1999 * @tc.steps: step3. Start hide tab bar, test function StopHideTabBar.
2000 * @tc.expected: Related function runs ok.
2001 */
2002 tabBarPattern_->StartHideTabBar();
2003 MockAnimationManager::GetInstance().Tick();
2004 EXPECT_TRUE(tabBarPattern_->isTabBarHiding_);
2005 EXPECT_GT(GetTabBarPosition(), 0.0f);
2006 tabBarPattern_->axis_ = Axis::VERTICAL;
2007 tabBarPattern_->StopHideTabBar();
2008 MockAnimationManager::GetInstance().Tick();
2009 EXPECT_FALSE(tabBarPattern_->isTabBarHiding_);
2010 auto renderContext = tabBarNode_->GetRenderContext();
2011 auto size = renderContext->GetPaintRectWithoutTransform().Height();
2012 EXPECT_EQ(GetTabBarPosition(), size);
2013 }
2014
2015 /**
2016 * @tc.name: UpdateTabBarOffsetTest001
2017 * @tc.desc: test UpdateTabBarOffset
2018 * @tc.type: FUNC
2019 */
2020 HWTEST_F(TabBarPatternTestNg, UpdateTabBarOffsetTest001, TestSize.Level1)
2021 {
2022 /**
2023 * @tc.steps: step1. build tabbar.
2024 */
2025 TabsModelNG model = CreateTabs();
2026 CreateTabContents(TABCONTENT_NUMBER);
2027 CreateTabsDone(model);
2028 MockPaintRect(tabBarNode_);
2029
2030 /**
2031 * @tc.steps: Test function UpdateTabBarOffset.
2032 * @tc.expected: Related function runs ok.
2033 */
2034 auto offset1 = 10.0f;
2035 tabBarPattern_->axis_ = Axis::HORIZONTAL;
2036 tabBarPattern_->UpdateTabBarHiddenOffset(offset1);
2037 auto renderContext = tabBarNode_->GetRenderContext();
2038 auto opacity = renderContext->GetOpacityValue(1.0f);
2039 auto size = renderContext->GetPaintRectWithoutTransform().Height();
2040 EXPECT_EQ(GetTabBarPosition(), -offset1);
2041 EXPECT_EQ(opacity, 1.0f - offset1 / size);
2042 }
2043
2044 /**
2045 * @tc.name: UpdateTabBarOffsetTest002
2046 * @tc.desc: test UpdateTabBarOffset
2047 * @tc.type: FUNC
2048 */
2049 HWTEST_F(TabBarPatternTestNg, UpdateTabBarOffsetTest002, TestSize.Level1)
2050 {
2051 /**
2052 * @tc.steps: step1. build tabbar.
2053 */
2054 TabsModelNG model = CreateTabs();
2055 CreateTabContents(TABCONTENT_NUMBER);
2056 CreateTabsDone(model);
2057 MockPaintRect(tabBarNode_);
2058
2059 /**
2060 * @tc.steps: step2.Test function UpdateTabBarOffset.
2061 * @tc.expected: Related function runs ok.
2062 */
2063 auto offset1 = 10.0f;
2064 tabBarPattern_->axis_ = Axis::VERTICAL;
2065 tabBarPattern_->showTabBarTask_.Reset(nullptr);
2066 tabBarPattern_->UpdateTabBarHiddenOffset(offset1);
2067 auto renderContext = tabBarNode_->GetRenderContext();
2068 auto opacity = renderContext->GetOpacityValue(1.0f);
2069 auto size = renderContext->GetPaintRectWithoutTransform().Height();
2070 EXPECT_NE(GetTabBarPosition(), -offset1);
2071 EXPECT_NE(opacity, 1.0f - offset1 / size);
2072 }
2073
2074 /**
2075 * @tc.name: UpdateTabBarOffsetTest003
2076 * @tc.desc: test UpdateTabBarOffset
2077 * @tc.type: FUNC
2078 */
2079 HWTEST_F(TabBarPatternTestNg, UpdateTabBarOffsetTest003, TestSize.Level1)
2080 {
2081 /**
2082 * @tc.steps: step1. build tabbar.
2083 */
2084 TabsModelNG model = CreateTabs();
2085 CreateTabContents(TABCONTENT_NUMBER);
2086 CreateTabsDone(model);
2087 MockPaintRect(tabBarNode_);
2088
2089 /**
2090 * @tc.steps: step2.Test function UpdateTabBarOffset.
2091 * @tc.expected: Related function runs ok.
2092 */
2093 auto offset1 = 10.0f;
2094 tabBarPattern_->axis_ = Axis::HORIZONTAL;
2095 bool taskExecuted = false;
__anona63b8a510502() 2096 tabBarPattern_->showTabBarTask_.Reset([&taskExecuted]() { taskExecuted = true; });
2097 tabBarPattern_->UpdateTabBarHiddenOffset(offset1);
2098 auto renderContext = tabBarNode_->GetRenderContext();
2099 auto opacity = renderContext->GetOpacityValue(1.0f);
2100 auto size = renderContext->GetPaintRectWithoutTransform().Height();
2101 EXPECT_NE(GetTabBarPosition(), -offset1);
2102 EXPECT_NE(opacity, 1.0f - offset1 / size);
2103 }
2104
2105 /**
2106 * @tc.name: UpdateTabBarOffsetTest004
2107 * @tc.desc: test UpdateTabBarOffset
2108 * @tc.type: FUNC
2109 */
2110 HWTEST_F(TabBarPatternTestNg, UpdateTabBarOffsetTest004, TestSize.Level1)
2111 {
2112 /**
2113 * @tc.steps: step1. build tabbar.
2114 */
2115 TabsModelNG model = CreateTabs();
2116 CreateTabContents(TABCONTENT_NUMBER);
2117 CreateTabsDone(model);
2118 MockPaintRectSmallSize(tabBarNode_);
2119
2120 /**
2121 * @tc.steps: step2.Test function UpdateTabBarOffset.
2122 * @tc.expected: Related function runs ok.
2123 */
2124 auto offset1 = 10.0f;
2125 tabBarPattern_->axis_ = Axis::HORIZONTAL;
2126 tabBarPattern_->showTabBarTask_.Reset(nullptr);
2127 tabBarPattern_->isTabBarShowing_ = false;
2128 tabBarPattern_->isTabBarHiding_ = false;
2129 tabBarPattern_->UpdateTabBarHiddenOffset(offset1);
2130 auto renderContext = tabBarNode_->GetRenderContext();
2131 auto opacity = renderContext->GetOpacityValue(1.0f);
2132 auto size = renderContext->GetPaintRectWithoutTransform().Height();
2133 EXPECT_NE(GetTabBarPosition(), -offset1);
2134 EXPECT_NE(opacity, 20.0f - offset1 / size);
2135 }
2136
2137 /**
2138 * @tc.name: HandleMoveAway001
2139 * @tc.desc: test HandleMoveAway
2140 * @tc.type: FUNC
2141 */
2142 HWTEST_F(TabBarPatternTestNg, HandleMoveAway001, TestSize.Level1)
2143 {
2144 /**
2145 * @tc.steps: step1. build tabbar.
2146 */
2147 TabsModelNG model = CreateTabs();
2148 CreateTabContents(TABCONTENT_NUMBER);
2149 CreateTabsDone(model);
2150 MockPaintRect(tabBarNode_);
2151
2152 /**
2153 * @tc.steps: step2.Test function HandleMoveAway.
2154 * @tc.expected: Related function runs ok.
2155 */
2156 auto index = 10.0f;
2157 tabBarPattern_->tabBarStyle_ = TabBarStyle::BOTTOMTABBATSTYLE;
2158 tabBarPattern_->isTabBarFocusActive_ = false;
2159 tabBarPattern_->focusIndicator_ = 20.0f;
2160 tabBarPattern_->HandleMoveAway(index);
2161 EXPECT_EQ(GetTabBarPosition(), 0);
2162 }
2163
2164 /**
2165 * @tc.name: HandleMoveAway002
2166 * @tc.desc: test HandleMoveAway
2167 * @tc.type: FUNC
2168 */
2169 HWTEST_F(TabBarPatternTestNg, HandleMoveAway002, TestSize.Level1)
2170 {
2171 /**
2172 * @tc.steps: step1. build tabbar.
2173 */
2174 TabsModelNG model = CreateTabs();
2175 CreateTabContents(TABCONTENT_NUMBER);
2176 CreateTabsDone(model);
2177 MockPaintRect(tabBarNode_);
2178
2179 /**
2180 * @tc.steps: step2.Test function HandleMoveAway.
2181 * @tc.expected: Related function runs ok.
2182 */
2183 auto index = 10.0f;
2184 tabBarPattern_->tabBarStyle_ = TabBarStyle::SUBTABBATSTYLE;
2185 tabBarPattern_->isTabBarFocusActive_ = false;
2186 tabBarPattern_->focusIndicator_ = 20.0f;
2187 tabBarPattern_->HandleMoveAway(index);
2188 EXPECT_EQ(GetTabBarPosition(), 0);
2189 }
2190
2191 /**
2192 * @tc.name: HandleMoveAway003
2193 * @tc.desc: test HandleMoveAway
2194 * @tc.type: FUNC
2195 */
2196 HWTEST_F(TabBarPatternTestNg, HandleMoveAway003, TestSize.Level1)
2197 {
2198 /**
2199 * @tc.steps: step1. build tabbar.
2200 */
2201 TabsModelNG model = CreateTabs();
2202 CreateTabContents(TABCONTENT_NUMBER);
2203 CreateTabsDone(model);
2204 MockPaintRect(tabBarNode_);
2205
2206 /**
2207 * @tc.steps: step2.Test function HandleMoveAway.
2208 * @tc.expected: Related function runs ok.
2209 */
2210 auto index = 10.0f;
2211 tabBarPattern_->tabBarStyle_ = TabBarStyle::SUBTABBATSTYLE;
2212 tabBarPattern_->isTabBarFocusActive_ = true;
2213 tabBarPattern_->focusIndicator_ = 20.0f;
2214 tabBarPattern_->HandleMoveAway(index);
2215 EXPECT_EQ(GetTabBarPosition(), 0);
2216 }
2217
2218 /**
2219 * @tc.name: HandleMoveAway004
2220 * @tc.desc: test HandleMoveAway
2221 * @tc.type: FUNC
2222 */
2223 HWTEST_F(TabBarPatternTestNg, HandleMoveAway004, TestSize.Level1)
2224 {
2225 /**
2226 * @tc.steps: step1. build tabbar.
2227 */
2228 TabsModelNG model = CreateTabs();
2229 CreateTabContents(TABCONTENT_NUMBER);
2230 CreateTabsDone(model);
2231 MockPaintRect(tabBarNode_);
2232
2233 /**
2234 * @tc.steps: step2.Test function HandleMoveAway.
2235 * @tc.expected: Related function runs ok.
2236 */
2237 auto index = 10.0f;
2238 tabBarPattern_->tabBarStyle_ = TabBarStyle::SUBTABBATSTYLE;
2239 tabBarPattern_->isTabBarFocusActive_ = true;
2240 tabBarPattern_->focusIndicator_ = 10.0f;
2241 tabBarPattern_->HandleMoveAway(index);
2242 EXPECT_EQ(GetTabBarPosition(), 0);
2243 }
2244
2245 /**
2246 * @tc.name: GetNextFocusNode001
2247 * @tc.desc: test GetNextFocusNode
2248 * @tc.type: FUNC
2249 */
2250 HWTEST_F(TabBarPatternTestNg, GetNextFocusNode001, TestSize.Level1)
2251 {
2252 /**
2253 * @tc.steps: step1. build tabbar.
2254 */
2255 TabsModelNG model = CreateTabs();
2256 CreateTabContents(TABCONTENT_NUMBER);
2257 CreateTabsDone(model);
2258 MockPaintRect(tabBarNode_);
2259
2260 /**
2261 * @tc.steps: step2.Test function GetNextFocusNode.
2262 * @tc.expected: Related function runs ok.
2263 */
2264 auto step = FocusStep::RIGHT;
2265 tabBarPattern_->tabBarStyle_ = TabBarStyle::SUBTABBATSTYLE;
2266 tabBarPattern_->isTabBarFocusActive_ = true;
2267 tabBarPattern_->focusIndicator_ = 10.0f;
2268 tabBarPattern_->GetNextFocusNode(step);
2269 EXPECT_EQ(tabBarPattern_->focusIndicator_, 10.0f);
2270 }
2271
2272 /**
2273 * @tc.name: IndicatorOffsetTest001
2274 * @tc.desc: test currentIndicatorOffset
2275 * @tc.type: FUNC
2276 */
2277 HWTEST_F(TabBarPatternTestNg, IndicatorOffsetTest001, TestSize.Level1)
2278 {
2279 TabsModelNG model = CreateTabs();
2280 for (int32_t index = 0; index < TABCONTENT_NUMBER; index++) {
2281 TabContentModelNG tabContentModel = CreateTabContent();
2282 tabContentModel.SetTabBarStyle(TabBarStyle::SUBTABBATSTYLE);
2283 tabContentModel.SetTabBar("text", std::nullopt, std::nullopt, nullptr, false);
2284 ViewStackProcessor::GetInstance()->Pop();
2285 ViewStackProcessor::GetInstance()->StopGetAccessRecording();
2286 }
2287 CreateTabsDone(model);
2288
2289 /**
2290 * @tc.steps: step2.Set tabBarMode to scrollable and axis to horizontal, init child item width.
2291 */
2292 tabBarLayoutProperty_->UpdateTabBarMode(TabBarMode::SCROLLABLE);
2293 tabBarLayoutProperty_->UpdateAxis(Axis::HORIZONTAL);
2294 auto itemWidth = 300.0f;
2295 for (int32_t index = 0; index < TABCONTENT_NUMBER; index++) {
2296 auto child = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(index));
2297 ViewAbstract::SetWidth(AceType::RawPtr(child), CalcLength(itemWidth));
2298 }
2299
2300 /**
2301 * @tc.steps: step3.FlushUITask, check visibleItemPosition_ and currentIndicatorOffset_.
2302 */
2303 FlushUITasks(tabBarNode_);
2304 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->first, 0);
2305 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->second.startPos, 0.0f);
2306 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->second.endPos, 300.0f);
2307 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->first, 2);
2308 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->second.startPos, 600.0f);
2309 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->second.endPos, 900.0f);
2310 EXPECT_EQ(tabBarPattern_->currentIndicatorOffset_, 150.0f);
2311
2312 /**
2313 * @tc.steps: step4.Click to 1, check visibleItemPosition_ and currentIndicatorOffset_.
2314 */
2315 HandleClick(1);
2316 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->first, 0);
2317 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->second.startPos, -90.0f);
2318 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->second.endPos, 210.0f);
2319 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->first, 2);
2320 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->second.startPos, 510.0f);
2321 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->second.endPos, 810.0f);
2322 EXPECT_EQ(tabBarPattern_->currentIndicatorOffset_, 360.0f);
2323
2324 /**
2325 * @tc.steps: step5.Click to 2, check visibleItemPosition_ and currentIndicatorOffset_.
2326 */
2327 MockAnimationManager::Enable(true);
2328 MockAnimationManager::GetInstance().SetTicks(2);
2329 HandleClick(2);
2330 MockAnimationManager::GetInstance().Tick();
2331 EXPECT_EQ(tabBarPattern_->currentIndicatorOffset_, 360.0f);
2332 MockAnimationManager::GetInstance().Tick();
2333 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->first, 1);
2334 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->second.startPos, -90.0f);
2335 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.begin()->second.endPos, 210.0f);
2336 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->first, 3);
2337 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->second.startPos, 510.0f);
2338 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.rbegin()->second.endPos, 810.0f);
2339 EXPECT_EQ(tabBarPattern_->currentIndicatorOffset_, 360.0f);
2340 }
2341 /**
2342 * @tc.name: AddTabBarItemCallBack
2343 * @tc.desc: test AddTabBarItemCallBack
2344 * @tc.type: FUNC
2345 */
2346 HWTEST_F(TabBarPatternTestNg, AddTabBarItemCallBack, TestSize.Level1)
2347 {
2348 TabsModelNG model = CreateTabs();
2349 CreateTabContents(TABCONTENT_NUMBER);
2350 CreateTabsDone(model);
2351 MockPaintRect(tabBarNode_);
2352 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
2353 EXPECT_NE(tabBarItemNode, nullptr);
2354 auto columnProperty = tabBarItemNode->GetAccessibilityProperty<AccessibilityProperty>();
2355 EXPECT_NE(columnProperty, nullptr);
2356 tabBarPattern_->AddTabBarItemCallBack(tabBarItemNode);
2357
2358 auto columnNode =
2359 FrameNode::GetOrCreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anona63b8a510602() 2360 []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
2361 EXPECT_NE(columnNode, nullptr);
2362 auto columnProperty1 = columnNode->GetAccessibilityProperty<AccessibilityProperty>();
2363 EXPECT_NE(columnProperty1, nullptr);
2364 tabBarPattern_->AddTabBarItemCallBack(columnNode);
2365 }
2366 /**
2367 * @tc.name: GetOverScrollInfo
2368 * @tc.desc: test GetOverScrollInfo
2369 * @tc.type: FUNC
2370 */
2371 HWTEST_F(TabBarPatternTestNg, GetOverScrollInfo, TestSize.Level1)
2372 {
2373 TabsModelNG model = CreateTabs();
2374 CreateTabContents(TABCONTENT_NUMBER);
2375 CreateTabsDone(model);
2376 MockPaintRect(tabBarNode_);
2377
2378 tabBarPattern_->visibleItemPosition_.clear();
2379 EXPECT_EQ(tabBarPattern_->visibleItemPosition_.empty(), true);
2380 auto result = tabBarPattern_->GetOverScrollInfo(tabBarPattern_->GetContentSize());
2381 EXPECT_EQ(result.first, 0.0f);
2382 EXPECT_EQ(result.second, 0.0f);
2383 }
2384 /**
2385 * @tc.name: HandleMouseEvent
2386 * @tc.desc: test HandleMouseEvent
2387 * @tc.type: FUNC
2388 */
2389 HWTEST_F(TabBarPatternTestNg, HandleMouseEvent, TestSize.Level1)
2390 {
2391 TabsModelNG model = CreateTabs();
2392 CreateTabContents(TABCONTENT_NUMBER);
2393 CreateTabsDone(model);
2394 MockPaintRect(tabBarNode_);
2395
2396 int32_t nodeId = 1;
2397 for (int i = 0; i <= 2; i++) {
2398 auto frameNode_ = TabsModelNG::GetOrCreateTabsNode(
__anona63b8a510702() 2399 V2::TABS_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<TabsPattern>(); });
2400 tabBarNode_->AddChild(frameNode_);
2401 }
2402 MouseInfo mouseInfo;
2403 mouseInfo.SetAction(MouseAction::WINDOW_LEAVE);
2404 tabBarPattern_->hoverIndex_.emplace(1);
2405 tabBarPattern_->HandleMouseEvent(mouseInfo);
2406 EXPECT_EQ(tabBarPattern_->indicator_, 0);
2407 }
2408 /**
2409 * @tc.name: ResetOnForceMeasure001
2410 * @tc.desc: test ResetOnForceMeasure
2411 * @tc.type: FUNC
2412 */
2413 HWTEST_F(TabBarPatternTestNg, ResetOnForceMeasure001, TestSize.Level1)
2414 {
2415 TabsModelNG model = CreateTabs();
2416 CreateTabContents(TABCONTENT_NUMBER);
2417 CreateTabsDone(model);
2418 MockPaintRect(tabBarNode_);
2419
2420 tabBarPattern_->ResetOnForceMeasure(5);
2421 tabBarPattern_->ResetOnForceMeasure(6);
2422 EXPECT_EQ(tabBarPattern_->jumpIndex_, 6);
2423
2424 tabBarPattern_->indicatorStyles_.clear();
2425 IndicatorStyle indicatorStyle1;
2426 tabBarPattern_->indicatorStyles_ = { indicatorStyle1 };
2427 indicatorStyle1.color = Color::BLACK;
2428 tabBarPattern_->selectedModes_.clear();
2429 tabBarPattern_->ResetOnForceMeasure(0);
2430 EXPECT_EQ(tabBarPattern_->jumpIndex_, 0);
2431
2432 tabBarPattern_->visibleItemPosition_.clear();
2433 tabBarPattern_->visibleItemPosition_[0] = { 5, 0.0f };
2434 tabBarPattern_->ResetOnForceMeasure(6);
2435 EXPECT_EQ(tabBarPattern_->jumpIndex_, 6);
2436 }
2437 /**
2438 * @tc.name: ResetOnForceMeasure002
2439 * @tc.desc: test HandleBottomTabBarChange
2440 * @tc.type: FUNC
2441 */
2442 HWTEST_F(TabBarPatternTestNg, ResetOnForceMeasure002, TestSize.Level1)
2443 {
2444 TabsModelNG model = CreateTabs();
2445 CreateTabContents(TABCONTENT_NUMBER);
2446 CreateTabsDone(model);
2447 MockPaintRect(tabBarNode_);
2448
2449 tabBarPattern_->tabBarStyles_.clear();
2450 tabBarPattern_->ResetOnForceMeasure(6);
2451
2452 LabelStyle labelStyle;
2453 labelStyle.fontWeight = FontWeight::NORMAL;
2454 tabBarPattern_->tabBarStyles_ = { TabBarStyle::SUBTABBATSTYLE };
2455 auto tabBarItemNode = AceType::DynamicCast<FrameNode>(tabBarNode_->GetChildAtIndex(0));
2456 tabBarPattern_->SetLabelStyle(tabBarItemNode->GetId(), labelStyle);
2457 tabBarPattern_->ResetOnForceMeasure(6);
2458 EXPECT_EQ(tabBarPattern_->jumpIndex_, 6);
2459 }
2460 /**
2461 * @tc.name: UpdateBackBlurStyle
2462 * @tc.desc: test UpdateBackBlurStyle
2463 * @tc.type: FUNC
2464 */
2465 HWTEST_F(TabBarPatternTestNg, UpdateBackBlurStyle, TestSize.Level1)
2466 {
2467 TabsModelNG model = CreateTabs();
2468 CreateTabContents(TABCONTENT_NUMBER);
2469 CreateTabsDone(model);
2470 MockPaintRect(tabBarNode_);
2471
2472 auto container = Container::Current();
2473 container->SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_TWENTY));
2474 auto pipeline = frameNode_->GetContext();
2475 EXPECT_NE(pipeline, nullptr);
2476 auto tabTheme = pipeline->GetTheme<TabTheme>();
2477 tabBarPattern_->UpdateBackBlurStyle(tabTheme);
2478
2479 tabTheme->bottomTabBackgroundBlurStyle_=11;
2480 auto defaultBlurStyle = static_cast<BlurStyle>(tabTheme->GetBottomTabBackgroundBlurStyle());
2481 EXPECT_NE(defaultBlurStyle, BlurStyle::NO_MATERIAL);
2482 auto renderContext = tabBarNode_->GetRenderContext();
2483 renderContext ->UpdateBackBlurStyle(std::nullopt);
2484 renderContext ->UpdateBackBlurRadius(Dimension());
2485 renderContext ->UpdateBackgroundEffect(std::nullopt);
2486 tabBarPattern_->UpdateBackBlurStyle(tabTheme);
2487
2488 tabTheme->bottomTabBackgroundBlurStyle_=0;
2489 tabBarPattern_->UpdateBackBlurStyle(tabTheme);
2490
2491 tabTheme->bottomTabBackgroundBlurStyle_=11;
2492 model.SetBarOverlap(AceType::RawPtr(frameNode_), true);
2493 EXPECT_EQ(renderContext->GetBackBlurStyle().has_value(), true);
2494 tabBarPattern_->UpdateBackBlurStyle(tabTheme);
2495
2496 tabTheme->bottomTabBackgroundBlurStyle_=11;
2497 renderContext->UpdateBackBlurStyle(std::nullopt);
2498 auto radius = Dimension(10.0f);
2499 renderContext->UpdateBackBlurRadius(radius);
2500 EXPECT_EQ(renderContext->GetBackBlurRadius().has_value(), false);
2501 tabBarPattern_->UpdateBackBlurStyle(tabTheme);
2502
2503 tabTheme->bottomTabBackgroundBlurStyle_=11;
2504 renderContext->UpdateBackBlurStyle(std::nullopt);
2505 renderContext->UpdateBackBlurRadius(Dimension());
2506 EffectOption effectOption;
2507 effectOption.policy = BlurStyleActivePolicy::FOLLOWS_WINDOW_ACTIVE_STATE;
2508 renderContext->UpdateBackgroundEffect(effectOption);
2509 EXPECT_EQ(renderContext->GetBackgroundEffect().has_value(), true);
2510 tabBarPattern_->UpdateBackBlurStyle(tabTheme);
2511 }
2512 /**
2513 * @tc.name: UpdatePaintIndicator
2514 * @tc.desc: test UpdatePaintIndicator
2515 * @tc.type: FUNC
2516 */
2517 HWTEST_F(TabBarPatternTestNg, UpdatePaintIndicator, TestSize.Level1)
2518 {
2519 TabsModelNG model = CreateTabs();
2520 CreateTabContents(TABCONTENT_NUMBER);
2521 CreateTabsDone(model);
2522 MockPaintRect(tabBarNode_);
2523
2524 tabBarPattern_->visibleItemPosition_.clear();
2525 tabBarPattern_->visibleItemPosition_[0] = { -1.0f, 1.0f };
2526 tabBarPattern_->visibleItemPosition_[1] = { 1.0f, 2.0f };
2527 tabBarPattern_->visibleItemPosition_[2] = { 1.0f, 2.0f };
2528 tabBarPattern_->UpdatePaintIndicator(2, true);
2529 EXPECT_NE(tabBarPattern_->visibleItemPosition_.find(2), tabBarPattern_->visibleItemPosition_.end());
2530
2531
2532 tabBarPattern_->isTouchingSwiper_ = true;
2533 tabBarPattern_->tabBarStyles_.clear();
2534 tabBarPattern_->tabBarStyles_ = { TabBarStyle::BOTTOMTABBATSTYLE };
2535 tabBarPattern_->UpdatePaintIndicator(0, true);
2536 EXPECT_NE(tabBarPattern_->tabBarStyles_[0], TabBarStyle::SUBTABBATSTYLE);
2537 }
2538 /**
2539 * @tc.name: OnDirtyLayoutWrapperSwap
2540 * @tc.desc: test OnDirtyLayoutWrapperSwap
2541 * @tc.type: FUNC
2542 */
2543 HWTEST_F(TabBarPatternTestNg, OnDirtyLayoutWrapperSwap, TestSize.Level1)
2544 {
2545 TabsModelNG model = CreateTabs();
2546 CreateTabContents(TABCONTENT_NUMBER);
2547 CreateTabsDone(model);
2548
2549 DirtySwapConfig config;
2550 config.skipMeasure = true;
2551 config.skipLayout = true;
2552 auto layoutWrapper =
2553 AceType::MakeRefPtr<LayoutWrapperNode>(tabBarNode_, tabBarNode_->GetGeometryNode(), tabBarLayoutProperty_);
2554 EXPECT_EQ(tabBarPattern_->OnDirtyLayoutWrapperSwap(layoutWrapper, config), false);
2555 }
2556 /**
2557 * @tc.name: HandleClick
2558 * @tc.desc: test HandleClick
2559 * @tc.type: FUNC
2560 */
2561 HWTEST_F(TabBarPatternTestNg, HandleClick, TestSize.Level1)
2562 {
2563 TabsModelNG model = CreateTabs();
2564 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2565 model.SetIsVertical(false);
2566 CreateTabContents(TABCONTENT_NUMBER);
2567 CreateTabsDone(model);
2568
2569 auto scrollable = tabBarPattern_->scrollableEvent_->GetScrollable();
2570 scrollable->GetSpringProperty();
2571 scrollable->state_ = Scrollable::AnimationState::SPRING;
2572 EXPECT_NE(tabBarPattern_->scrollableEvent_->GetScrollable(), nullptr);
2573 EXPECT_NE(tabBarPattern_->IsOutOfBoundary(), true);
2574 HandleClick(1); // click second tabBarItem
2575
2576 tabBarPattern_->visibleItemPosition_.clear();
2577 tabBarPattern_->visibleItemPosition_[0] = { -1.0f, 1.0f };
2578 tabBarPattern_->visibleItemPosition_[1] = { 1.0f, 2.0f };
2579 HandleClick(5);
2580
2581 tabBarPattern_->tabBarStyles_.clear();
2582 tabBarPattern_->tabBarStyles_ = { TabBarStyle::BOTTOMTABBATSTYLE };
2583 HandleClick(5);
2584 }
2585 /**
2586 * @tc.name: HandleBottomTabBarChange001
2587 * @tc.desc: test HandleBottomTabBarChange
2588 * @tc.type: FUNC
2589 */
2590 HWTEST_F(TabBarPatternTestNg, HandleBottomTabBarChange001, TestSize.Level1)
2591 {
2592 TabsModelNG model = CreateTabs();
2593 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2594 model.SetIsVertical(false);
2595 CreateTabContents(TABCONTENT_NUMBER);
2596 CreateTabsDone(model);
2597
2598 tabBarPattern_->tabBarStyles_.clear();
2599 tabBarPattern_->tabBarStyles_ = { TabBarStyle::BOTTOMTABBATSTYLE };
2600 tabBarPattern_->HandleBottomTabBarChange(-1);
2601 EXPECT_NE(tabBarPattern_->indicator_, -1);
2602 }
2603 /**
2604 * @tc.name: HandleBottomTabBarChange002
2605 * @tc.desc: test HandleBottomTabBarChange
2606 * @tc.type: FUNC
2607 */
2608 HWTEST_F(TabBarPatternTestNg, HandleBottomTabBarChange002, TestSize.Level1)
2609 {
2610 TabsModelNG model = CreateTabs();
2611 IconStyle iconStyle;
2612 iconStyle.selectedColor = Color::WHITE;
2613 iconStyle.unselectedColor = Color::BLACK;
2614 tabBarPattern_->SetIconStyle(iconStyle, 0);
2615 auto tabContentModel = CreateTabContent();
2616 tabContentModel.SetTabBar("test", IMAGE_SRC_URL, std::nullopt, nullptr, true);
2617 ViewStackProcessor::GetInstance()->Pop();
2618 ViewStackProcessor::GetInstance()->StopGetAccessRecording();
2619
2620 auto tabContentModel2 = CreateTabContent();
2621 tabContentModel2.SetTabBar("", IMAGE_SRC_URL, std::nullopt, nullptr, true);
2622 ViewStackProcessor::GetInstance()->Pop();
2623 ViewStackProcessor::GetInstance()->StopGetAccessRecording();
2624 CreateTabsDone(model);
2625
2626 tabBarPattern_->tabBarStyles_.clear();
2627 tabBarPattern_->tabBarStyles_ = { TabBarStyle::BOTTOMTABBATSTYLE, TabBarStyle::SUBTABBATSTYLE };
2628
2629 tabBarPattern_->indicator_ = 1;
2630 tabBarPattern_->ResetOnForceMeasure(1);
2631 tabBarPattern_->HandleBottomTabBarChange(0);
2632 EXPECT_EQ(tabBarPattern_->indicator_, 1);
2633
2634 tabBarPattern_->tabBarStyles_.clear();
2635 tabBarPattern_->tabBarStyles_ = { TabBarStyle::SUBTABBATSTYLE, TabBarStyle::BOTTOMTABBATSTYLE };
2636
2637 tabBarPattern_->indicator_ = 1;
2638 tabBarPattern_->ResetOnForceMeasure(1);
2639 tabBarPattern_->HandleBottomTabBarChange(0);
2640 EXPECT_EQ(tabBarPattern_->indicator_, 1);
2641 }
2642 /**
2643 * @tc.name: HandleBottomTabBarChange003
2644 * @tc.desc: test HandleBottomTabBarChange
2645 * @tc.type: FUNC
2646 */
2647 HWTEST_F(TabBarPatternTestNg, HandleBottomTabBarChange003, TestSize.Level1)
2648 {
2649 TabsModelNG model = CreateTabs();
2650 IconStyle iconStyle;
2651 iconStyle.selectedColor = Color::WHITE;
2652 iconStyle.unselectedColor = Color::BLACK;
2653 tabBarPattern_->SetIconStyle(iconStyle, 0);
2654 auto tabContentModel = CreateTabContent();
2655 tabContentModel.SetTabBar("test", IMAGE_SRC_URL, std::nullopt, nullptr, true);
2656 ViewStackProcessor::GetInstance()->Pop();
2657 ViewStackProcessor::GetInstance()->StopGetAccessRecording();
2658
2659 auto tabContentModel2 = CreateTabContent();
2660 tabContentModel2.SetTabBar("", IMAGE_SRC_URL, std::nullopt, nullptr, true);
2661 ViewStackProcessor::GetInstance()->Pop();
2662 ViewStackProcessor::GetInstance()->StopGetAccessRecording();
2663 CreateTabsDone(model);
2664
2665 tabBarPattern_->tabBarStyles_.clear();
2666 tabBarPattern_->tabBarStyles_ = { TabBarStyle::SUBTABBATSTYLE, TabBarStyle::BOTTOMTABBATSTYLE,
2667 TabBarStyle::BOTTOMTABBATSTYLE };
2668
2669 tabBarPattern_->indicator_ = 1;
2670 tabBarPattern_->ResetOnForceMeasure(1);
2671 tabBarPattern_->HandleBottomTabBarChange(2);
2672 EXPECT_EQ(tabBarPattern_->indicator_, 1);
2673 }
2674 /**
2675 * @tc.name: PlayPressAnimation
2676 * @tc.desc: test PlayPressAnimation
2677 * @tc.type: FUNC
2678 */
2679 HWTEST_F(TabBarPatternTestNg, PlayPressAnimation, TestSize.Level1)
2680 {
2681 TabsModelNG model = CreateTabs();
2682 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2683 model.SetIsVertical(false);
2684 CreateTabContents(TABCONTENT_NUMBER);
2685 CreateTabsDone(model);
2686
2687 frameNode_->GetContext()->SetMinPlatformVersion(static_cast<int32_t>(PlatformVersion::VERSION_TWENTY));
2688 tabBarPattern_->tabBarStyle_ = TabBarStyle::BOTTOMTABBATSTYLE;
2689 EXPECT_EQ(Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_TWELVE), true);
2690 tabBarPattern_->PlayPressAnimation(0, Color::BLACK, AnimationType::PRESS);
2691
2692 tabBarPattern_->PlayPressAnimation(0, Color::BLACK, AnimationType::HOVER);
2693
2694 tabBarPattern_->tabBarStyles_.clear();
2695 tabBarPattern_->tabBarStyles_ = { TabBarStyle::SUBTABBATSTYLE, TabBarStyle::BOTTOMTABBATSTYLE,
2696 TabBarStyle::BOTTOMTABBATSTYLE };
2697 tabBarPattern_->selectedModes_ = { SelectedMode::BOARD };
2698 tabBarPattern_->PlayPressAnimation(1, Color::BLACK, AnimationType::HOVER);
2699 EXPECT_EQ(tabBarPattern_->tabBarStyles_.size(), 3);
2700
2701 tabBarPattern_->selectedModes_ = { SelectedMode::BOARD, SelectedMode::INDICATOR };
2702 IndicatorStyle indicatorStyle;
2703 indicatorStyle.color = Color::BLACK;
2704 tabBarPattern_->indicatorStyles_ = { indicatorStyle };
2705 tabBarPattern_->PlayPressAnimation(1, Color::BLACK, AnimationType::HOVER);
2706 EXPECT_EQ(tabBarPattern_->indicatorStyles_.size(), 1);
2707 }
2708 /**
2709 * @tc.name: UpdateSubTabBoard
2710 * @tc.desc: test UpdateSubTabBoard
2711 * @tc.type: FUNC
2712 */
2713 HWTEST_F(TabBarPatternTestNg, UpdateSubTabBoard, TestSize.Level1)
2714 {
2715 TabsModelNG model = CreateTabs();
2716 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2717 model.SetIsVertical(false);
2718 CreateTabContents(TABCONTENT_NUMBER);
2719 CreateTabsDone(model);
2720
2721 tabBarPattern_->indicatorStyles_.clear();
2722 tabBarPattern_->selectedModes_ = { SelectedMode::BOARD };
2723 tabBarPattern_->UpdateSubTabBoard(1);
2724 EXPECT_EQ(tabBarPattern_->selectedModes_.size(), 1);
2725
2726 tabBarPattern_->visibleItemPosition_.clear();
2727 tabBarPattern_->visibleItemPosition_[0] = { -1.0f, 1.0f };
2728 tabBarPattern_->visibleItemPosition_[1] = { 1.0f, 2.0f };
2729 tabBarPattern_->tabBarStyles_.clear();
2730 tabBarPattern_->tabBarStyles_ = { TabBarStyle::SUBTABBATSTYLE };
2731 IndicatorStyle indicatorStyle;
2732 indicatorStyle.color = Color::BLACK;
2733 tabBarPattern_->indicatorStyles_ = { indicatorStyle };
2734 tabBarPattern_->UpdateSubTabBoard(0);
2735 EXPECT_EQ(tabBarPattern_->indicatorStyles_.size(), 1);
2736 }
2737 /**
2738 * @tc.name: CalculateTargetOffset
2739 * @tc.desc: test CalculateTargetOffset
2740 * @tc.type: FUNC
2741 */
2742 HWTEST_F(TabBarPatternTestNg, CalculateTargetOffset, TestSize.Level1)
2743 {
2744 TabsModelNG model = CreateTabs();
2745 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2746 model.SetIsVertical(false);
2747 CreateTabContents(TABCONTENT_NUMBER);
2748 CreateTabsDone(model);
2749
2750 tabBarPattern_->visibleItemPosition_.clear();
2751 tabBarPattern_->visibleItemPosition_[0] = { -1.0f, 1.0f };
2752 tabBarPattern_->visibleItemPosition_[1] = { 1.0f, 2.0f };
2753 tabBarPattern_->CalculateTargetOffset(0);
2754 EXPECT_NE(tabBarPattern_->visibleItemPosition_.find(0), tabBarPattern_->visibleItemPosition_.end());
2755
2756 tabBarPattern_->visibleItemPosition_.clear();
2757 tabBarPattern_->scrollMargin_ = 365.0f;
2758 tabBarPattern_->CalculateTargetOffset(1);
2759 auto backChildrenMainSize = tabBarPattern_->CalculateBackChildrenMainSize(1);
2760 auto space = tabBarPattern_->GetSpace(1);
2761 EXPECT_EQ(LessOrEqual(backChildrenMainSize, space), false);
2762 }
2763 /**
2764 * @tc.name: GetIndicatorStyle
2765 * @tc.desc: test GetIndicatorStyle
2766 * @tc.type: FUNC
2767 */
2768 HWTEST_F(TabBarPatternTestNg, GetIndicatorStyle, TestSize.Level1)
2769 {
2770 TabsModelNG model = CreateTabs();
2771 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2772 model.SetIsVertical(false);
2773 CreateTabContents(TABCONTENT_NUMBER);
2774 CreateTabsDone(model);
2775
2776 tabBarPattern_->axis_ = Axis::HORIZONTAL;
2777 tabBarPattern_->isTouchingSwiper_ = true;
2778 tabBarPattern_->indicator_ = 0;
2779 tabBarPattern_->swiperStartIndex_ = 1;
2780 IndicatorStyle indicatorStyle;
2781 indicatorStyle.color = Color::BLACK;
2782 tabBarPattern_->indicatorStyles_ = { indicatorStyle };
2783 auto firstRect = tabBarLayoutProperty_->GetIndicatorRect(0);
2784 tabBarPattern_->tabBarStyles_ = { TabBarStyle::NOSTYLE, TabBarStyle::SUBTABBATSTYLE };
2785 tabBarPattern_->selectedModes_ = { SelectedMode::BOARD, SelectedMode::INDICATOR };
2786 IndicatorStyle indicator;
2787 OffsetF indicatorOffset;
2788 EXPECT_EQ(tabBarPattern_->IsValidIndex(tabBarPattern_->swiperStartIndex_), true);
2789 EXPECT_EQ(tabBarLayoutProperty_->GetIndicatorValue(0), 0);
2790 tabBarPattern_->GetIndicatorStyle(indicator, indicatorOffset, firstRect);
2791
2792 IndicatorStyle indicatorStyle1;
2793 indicatorStyle1.color = Color::BLACK;
2794 IndicatorStyle indicatorStyle2;
2795 indicatorStyle1.color = Color::BLACK;
2796 tabBarPattern_->indicatorStyles_ = { indicatorStyle, indicatorStyle1, indicatorStyle2 };
2797 tabBarPattern_->GetIndicatorStyle(indicator, indicatorOffset, firstRect);
2798 EXPECT_EQ(tabBarPattern_->indicatorStyles_.size() >= 2, true);
2799 }
2800 /**
2801 * @tc.name: OnRestoreInfo
2802 * @tc.desc: test OnRestoreInfo
2803 * @tc.type: FUNC
2804 */
2805 HWTEST_F(TabBarPatternTestNg, OnRestoreInfo, TestSize.Level1)
2806 {
2807 TabsModelNG model = CreateTabs();
2808 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2809 model.SetIsVertical(false);
2810 CreateTabContents(TABCONTENT_NUMBER);
2811 CreateTabsDone(model);
2812
2813 std::string restoreInfo_ = R"({"Index":2})";
2814 auto info = JsonUtil::ParseJsonString(restoreInfo_);
2815 tabBarPattern_->indicator_ = 2;
2816 tabBarPattern_->tabBarStyles_ = { TabBarStyle::NOSTYLE, TabBarStyle::SUBTABBATSTYLE };
2817 EXPECT_EQ(tabBarPattern_->tabBarStyles_.size(), 2);
2818 tabBarPattern_->OnRestoreInfo(restoreInfo_);
2819
2820 tabBarPattern_->tabBarStyles_ = { TabBarStyle::NOSTYLE, TabBarStyle::SUBTABBATSTYLE,
2821 TabBarStyle::BOTTOMTABBATSTYLE };
2822 pattern_->SetAnimateMode(TabAnimateMode::NO_ANIMATION);
2823 tabBarPattern_->OnRestoreInfo(restoreInfo_);
2824 EXPECT_EQ(tabBarPattern_->GetAnimationDuration().has_value(), true);
2825 }
2826 /**
2827 * @tc.name: FromJson
2828 * @tc.desc: test FromJson
2829 * @tc.type: FUNC
2830 */
2831 HWTEST_F(TabBarPatternTestNg, FromJson, TestSize.Level1)
2832 {
2833 TabsModelNG model = CreateTabs();
2834 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2835 model.SetIsVertical(false);
2836 CreateTabContents(TABCONTENT_NUMBER);
2837 CreateTabsDone(model);
2838
2839 InspectorFilter filter;
2840 IndicatorStyle style1;
2841 style1.height = Dimension(12);
2842 IndicatorStyle style2;
2843 style2.height = Dimension(16);
2844 tabBarPattern_->selectedModes_ = { SelectedMode::INDICATOR, SelectedMode::BOARD };
2845 tabBarPattern_->indicatorStyles_ = { style1, style2 };
2846 tabBarPattern_->tabBarStyles_ = { TabBarStyle::NOSTYLE, TabBarStyle::SUBTABBATSTYLE };
2847
2848 auto json = JsonUtil::Create(true);
2849 tabBarPattern_->ToJsonValue(json, filter);
2850 tabBarPattern_->FromJson(json);
2851 auto tabBarStyles = JsonUtil::ParseJsonString(json->GetString("tabBarStyles"));
2852 EXPECT_EQ(tabBarStyles->GetArraySize(), 2);
2853 }
2854 /**
2855 * @tc.name: ApplyTurnPageRateToIndicator
2856 * @tc.desc: test ApplyTurnPageRateToIndicator
2857 * @tc.type: FUNC
2858 */
2859 HWTEST_F(TabBarPatternTestNg, ApplyTurnPageRateToIndicator, TestSize.Level1)
2860 {
2861 TabsModelNG model = CreateTabs();
2862 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2863 model.SetIsVertical(false);
2864 CreateTabContentTabBarStyle(TabBarStyle::SUBTABBATSTYLE);
2865 CreateTabContentTabBarStyle(TabBarStyle::SUBTABBATSTYLE);
2866 CreateTabContents(TABCONTENT_NUMBER);
2867 CreateTabsDone(model);
2868
2869 tabBarPattern_->ApplyTurnPageRateToIndicator(0.9f);
2870
2871 tabBarPattern_->turnPageRate_ = 0.5f;
2872 EXPECT_EQ(tabBarPattern_->turnPageRate_ <= 0.673f, true);
2873 tabBarPattern_->ApplyTurnPageRateToIndicator(0.9f);
2874
2875 tabBarPattern_->turnPageRate_ = 0.9f;
2876 tabBarPattern_->ApplyTurnPageRateToIndicator(0.3f);
2877
2878 tabBarPattern_->isRTL_ = true;
2879 tabBarPattern_->ApplyTurnPageRateToIndicator(0.3f);
2880 EXPECT_EQ(tabBarPattern_->currentIndicatorOffset_, 360);
2881 }
2882 /**
2883 * @tc.name: HandleBottomTabBarAnimation
2884 * @tc.desc: test HandleBottomTabBarAnimation
2885 * @tc.type: FUNC
2886 */
2887 HWTEST_F(TabBarPatternTestNg, HandleBottomTabBarAnimation, TestSize.Level1)
2888 {
2889 TabsModelNG model = CreateTabs();
2890 model.SetTabBarMode(TabBarMode::SCROLLABLE);
2891 model.SetIsVertical(false);
2892 CreateTabContents(TABCONTENT_NUMBER);
2893 CreateTabsDone(model);
2894
2895 tabBarPattern_->tabBarStyles_ = { TabBarStyle::NOSTYLE };
2896 tabBarPattern_->indicator_ = 1;
2897 tabBarPattern_->HandleBottomTabBarAnimation(1);
2898 EXPECT_EQ(tabBarPattern_->indicator_, tabBarPattern_->tabBarStyles_.size());
2899
2900 tabBarPattern_->indicator_ = 0;
2901 tabBarPattern_->HandleBottomTabBarAnimation(1);
2902
2903 tabBarPattern_->indicator_ = -1;
2904 tabBarPattern_->HandleBottomTabBarAnimation(1);
2905
2906 tabBarPattern_->indicator_ = 0;
2907 tabBarPattern_->HandleBottomTabBarAnimation(-1);
2908
2909 tabBarPattern_->tabBarStyles_ = { TabBarStyle::BOTTOMTABBATSTYLE, TabBarStyle::NOSTYLE };
2910 tabBarPattern_->indicator_ = 1;
2911 tabBarPattern_->HandleBottomTabBarAnimation(1);
2912 EXPECT_NE(tabBarPattern_->tabBarStyles_[1], TabBarStyle::BOTTOMTABBATSTYLE);
2913 }
2914 } // namespace OHOS::Ace::NG
2915