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(
__anon165da7af0102() 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(
__anon165da7af0202() 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(
__anon165da7af0302() 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 } // namespace OHOS::Ace::NG
1667