1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstddef>
17 #include <optional>
18 #include <string>
19 #include <utility>
20
21 #include "gtest/gtest.h"
22
23 #define private public
24 #define protected public
25 #include "base/geometry/axis.h"
26 #include "base/geometry/dimension.h"
27 #include "base/geometry/ng/size_t.h"
28 #include "base/geometry/offset.h"
29 #include "base/json/json_util.h"
30 #include "base/memory/ace_type.h"
31 #include "core/components/calendar/calendar_data_adapter.h"
32 #include "core/components/common/layout/constants.h"
33 #include "core/components/common/properties/color.h"
34 #include "core/components_ng/base/frame_node.h"
35 #include "core/components_ng/base/view_stack_processor.h"
36 #include "core/components_ng/pattern/calendar/calendar_month_pattern.h"
37 #include "core/components_ng/pattern/calendar/calendar_paint_method.h"
38 #include "core/components_ng/pattern/calendar/calendar_paint_property.h"
39 #include "core/components_ng/pattern/calendar/calendar_pattern.h"
40 #include "core/components_ng/pattern/calendar/calendar_model_ng.h"
41 #include "core/components_ng/pattern/swiper/swiper_layout_property.h"
42 #include "core/components_ng/pattern/swiper/swiper_paint_property.h"
43 #include "core/components_ng/pattern/swiper/swiper_pattern.h"
44 #include "core/components_ng/render/drawing_mock.h"
45 #include "test/mock/core/rosen/mock_canvas.h"
46 #include "test/mock/core/common/mock_theme_manager.h"
47 #include "core/components_v2/inspector/inspector_constants.h"
48 #include "core/pipeline/base/element_register.h"
49 #include "test/mock/core/pipeline/mock_pipeline_context.h"
50 #include "core/pipeline_ng/ui_task_scheduler.h"
51 #undef private
52 #undef protected
53
54 using namespace testing;
55 using namespace testing::ext;
56 namespace OHOS::Ace::NG {
57 struct TestProperty {};
58 namespace {
59 const InspectorFilter filter;
60 const Color COLOR_VALUE = Color(0xffbbffff);
61 const Dimension SIZE_VALUE = 1.2_px;
62
63 const int32_t DAY_VALUE = 1;
64 const int32_t MONTH_VALUE = 1;
65 const int32_t YEAR_VALUE = 1;
66 const int32_t INDEX_VALUE = 1;
67 const int32_t JUMP_YEAR = 2023;
68 const int32_t JUMP_MONTH = 3;
69 const int32_t JUMP_DAY_FIRST = 3;
70 const int32_t JUMP_DAY_SECOND = 13;
71 const int32_t JUMP_DAY_THIRD = 23;
72 const int32_t DEFAULT_FOCUS_RADIUS = 15;
73 const int32_t WEEKS_COUNT_FIVE = 5;
74 const int32_t WEEKS_COUNT_SIX = 6;
75 const int32_t FIRST_DAY_INDEX_VALUE = 1;
76 const std::string LUNAR_MONTH_VALUE = "五月";
77 const std::string LUNAR_DAY_VALUE = "初五";
78 const std::string DAY_MARK = "MARK";
79 const std::string DAY_MARK_VALUE = "MARK_VALUE";
80 const std::string OFF_DAYS_VALUE = "OFF_DAYS";
81 const double OFFSET_X = 6.0;
82 const double OFFSET_Y = 8.0;
83 const float VALID_LENGTH = 10;
84 const std::string WORK_DAY_MARK = "work";
85 const std::string OFF_DAY_MARK = "off";
86
87 // Day width and Height.
88 const Dimension DAY_HEIGHT = 48.0_vp;
89 const Dimension DAY_WIDTH = 48.0_vp;
90
91 // GregorianDay YAxis Offset and Height.
92 const Dimension GREGORIAN_DAY_HEIGHT = 20.0_vp;
93 const Dimension GREGORIAN_DAY_OFFSET = 4.0_vp;
94
95 // Lunar YAxis Offset and Height.
96 const Dimension LUNAR_DAY_HEIGHT = 10.0_vp;
97 const Dimension LUNAR_DAY_OFFSET = 2.0_vp;
98 } // namespace
99
100 class CalendarTestNg : public testing::Test {
101 public:
102 static void SetUpTestCase();
103 static void TearDownTestCase();
104
105 protected:
106 static RefPtr<FrameNode> CreateCalendarNode(TestProperty& testProperty);
107 };
108
SetUpTestCase()109 void CalendarTestNg::SetUpTestCase()
110 {
111 MockPipelineContext::SetUp();
112 }
113
TearDownTestCase()114 void CalendarTestNg::TearDownTestCase()
115 {
116 MockPipelineContext::TearDown();
117 }
118
CreateCalendarNode(TestProperty & testProperty)119 RefPtr<FrameNode> CalendarTestNg::CreateCalendarNode(TestProperty& testProperty)
120 {
121 return nullptr;
122 }
123
124 /**
125 * @tc.name: CalendarModelNGTest001
126 * @tc.desc: Create Calendar.
127 * @tc.type: FUNC
128 */
129 HWTEST_F(CalendarTestNg, CalendarModelNGTest001, TestSize.Level1)
130 {
131 /**
132 * @tc.steps: step1. Create Calendar
133 * case: property are all unset
134 * @tc.expected: step1. Create Calendar successfully
135 */
136 CalendarModelData calendarData;
137 CalendarModelNG calendarModelNG;
138 calendarModelNG.Create(calendarData);
139 CurrentDayStyleData dayStyle;
140 calendarModelNG.SetCurrentDayStyle(dayStyle, dayStyle);
141 NonCurrentDayStyleData nonCurrentDayStyle;
142 calendarModelNG.SetNonCurrentDayStyle(nonCurrentDayStyle);
143 TodayStyleData todayStyle;
144 calendarModelNG.SetTodayStyle(todayStyle);
145 WeekStyleData weekStyle;
146 calendarModelNG.SetWeekStyle(weekStyle);
147 WorkStateStyleData workStateStyle;
148 calendarModelNG.SetWorkStateStyle(workStateStyle);
149
150 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
151 EXPECT_EQ(element->GetTag(), V2::CALENDAR_ETS_TAG);
152 auto frameNode1 = AceType::DynamicCast<FrameNode>(element);
153 auto calendarPattern = frameNode1->GetPattern<CalendarPattern>();
154 EXPECT_TRUE(calendarPattern);
155 EXPECT_FALSE(calendarPattern->calendarControllerNg_);
156
157 /**
158 * @tc.steps: step2. Create Calendar
159 * case: properties are all set
160 * @tc.expected: step2. Create Calendar successfully & properties are set successfully
161 */
162 // properties related with color are all set to COLOR_VALUE, related with size are all set to SIZE_VALUE
163 dayStyle.dayColor = std::make_optional(COLOR_VALUE);
164 dayStyle.lunarColor = std::make_optional(COLOR_VALUE);
165 dayStyle.markLunarColor = std::make_optional(COLOR_VALUE);
166 dayStyle.dayFontSize = std::make_optional(SIZE_VALUE);
167 dayStyle.lunarDayFontSize = std::make_optional(SIZE_VALUE);
168 dayStyle.dayHeight = std::make_optional(SIZE_VALUE);
169 dayStyle.dayWidth = std::make_optional(SIZE_VALUE);
170 dayStyle.gregorianCalendarHeight = std::make_optional(SIZE_VALUE);
171 dayStyle.lunarHeight = std::make_optional(SIZE_VALUE);
172 dayStyle.dayYAxisOffset = std::make_optional(SIZE_VALUE);
173 dayStyle.lunarDayYAxisOffset = std::make_optional(SIZE_VALUE);
174 dayStyle.underscoreXAxisOffset = std::make_optional(SIZE_VALUE);
175 dayStyle.underscoreYAxisOffset = std::make_optional(SIZE_VALUE);
176 dayStyle.scheduleMarkerXAxisOffset = std::make_optional(SIZE_VALUE);
177 dayStyle.scheduleMarkerYAxisOffset = std::make_optional(SIZE_VALUE);
178 dayStyle.colSpace = std::make_optional(SIZE_VALUE);
179 dayStyle.dailyFiveRowSpace = std::make_optional(SIZE_VALUE);
180 dayStyle.dailySixRowSpace = std::make_optional(SIZE_VALUE);
181 dayStyle.underscoreWidth = std::make_optional(SIZE_VALUE);
182 dayStyle.underscoreLength = std::make_optional(SIZE_VALUE);
183 dayStyle.scheduleMarkerRadius = std::make_optional(SIZE_VALUE);
184 dayStyle.boundaryRowOffset = std::make_optional(SIZE_VALUE);
185 dayStyle.boundaryColOffset = std::make_optional(SIZE_VALUE);
186 dayStyle.touchCircleStrokeWidth = std::make_optional(SIZE_VALUE);
187
188 nonCurrentDayStyle.nonCurrentMonthDayColor = std::make_optional(COLOR_VALUE);
189 nonCurrentDayStyle.nonCurrentMonthLunarColor = std::make_optional(COLOR_VALUE);
190 nonCurrentDayStyle.nonCurrentMonthWorkDayMarkColor = std::make_optional(COLOR_VALUE);
191 nonCurrentDayStyle.nonCurrentMonthOffDayMarkColor = std::make_optional(COLOR_VALUE);
192
193 todayStyle.focusedDayColor = std::make_optional(COLOR_VALUE);
194 todayStyle.focusedLunarColor = std::make_optional(COLOR_VALUE);
195 todayStyle.focusedAreaBackgroundColor = std::make_optional(COLOR_VALUE);
196 todayStyle.focusedAreaRadius = std::make_optional(SIZE_VALUE);
197
198 weekStyle.weekColor = std::make_optional(COLOR_VALUE);
199 weekStyle.weekendDayColor = std::make_optional(COLOR_VALUE);
200 weekStyle.weekendLunarColor = std::make_optional(COLOR_VALUE);
201 weekStyle.weekFontSize = std::make_optional(SIZE_VALUE);
202 weekStyle.weekHeight = std::make_optional(SIZE_VALUE);
203 weekStyle.weekWidth = std::make_optional(SIZE_VALUE);
204 weekStyle.weekAndDayRowSpace = std::make_optional(SIZE_VALUE);
205
206 workStateStyle.workDayMarkColor = std::make_optional(COLOR_VALUE);
207 workStateStyle.offDayMarkColor = std::make_optional(COLOR_VALUE);
208 workStateStyle.workDayMarkSize = std::make_optional(SIZE_VALUE);
209 workStateStyle.offDayMarkSize = std::make_optional(SIZE_VALUE);
210 workStateStyle.workStateWidth = std::make_optional(SIZE_VALUE);
211 workStateStyle.workStateHorizontalMovingDistance = std::make_optional(SIZE_VALUE);
212 workStateStyle.workStateVerticalMovingDistance = std::make_optional(SIZE_VALUE);
213
214 // case: controller is not null
215 auto calendarControllerNg = AceType::MakeRefPtr<CalendarControllerNg>();
216 calendarData.controller = calendarControllerNg;
217 calendarModelNG.Create(calendarData);
218 calendarModelNG.SetCurrentDayStyle(dayStyle, dayStyle);
219 calendarModelNG.SetNonCurrentDayStyle(nonCurrentDayStyle);
220 calendarModelNG.SetTodayStyle(todayStyle);
221 calendarModelNG.SetWeekStyle(weekStyle);
222 calendarModelNG.SetWorkStateStyle(workStateStyle);
223 element = ViewStackProcessor::GetInstance()->Finish();
224
225 EXPECT_EQ(element->GetTag(), V2::CALENDAR_ETS_TAG);
226 auto frameNode = AceType::DynamicCast<FrameNode>(element);
227 ASSERT_TRUE(frameNode);
228 calendarPattern = frameNode->GetPattern<CalendarPattern>();
229 EXPECT_TRUE(calendarPattern);
230 EXPECT_TRUE(calendarPattern->calendarControllerNg_);
231 auto swiperNode = frameNode->GetChildren().front();
232 ASSERT_TRUE(swiperNode);
233 auto calendarFrameNode = AceType::DynamicCast<FrameNode>(swiperNode->GetChildren().front());
234 ASSERT_TRUE(calendarFrameNode);
235 auto calendarPaintProperty = calendarFrameNode->GetPaintProperty<CalendarPaintProperty>();
236
237 // CurrentDayStyle
238 EXPECT_EQ(calendarPaintProperty->GetDayColorValue(Color::RED), COLOR_VALUE);
239 EXPECT_EQ(calendarPaintProperty->GetLunarColorValue(Color::RED), COLOR_VALUE);
240 EXPECT_EQ(calendarPaintProperty->GetMarkLunarColorValue(Color::RED), COLOR_VALUE);
241 EXPECT_EQ(calendarPaintProperty->GetDayFontSizeValue(1.0_px), SIZE_VALUE);
242 EXPECT_EQ(calendarPaintProperty->GetLunarDayFontSizeValue(1.0_px), SIZE_VALUE);
243 EXPECT_EQ(calendarPaintProperty->GetDayHeightValue(1.0_px), SIZE_VALUE);
244 EXPECT_EQ(calendarPaintProperty->GetDayWidthValue(1.0_px), SIZE_VALUE);
245 EXPECT_EQ(calendarPaintProperty->GetGregorianCalendarHeightValue(1.0_px), SIZE_VALUE);
246 EXPECT_EQ(calendarPaintProperty->GetDayYAxisOffsetValue(1.0_px), SIZE_VALUE);
247 EXPECT_EQ(calendarPaintProperty->GetLunarDayYAxisOffsetValue(1.0_px), SIZE_VALUE);
248 EXPECT_EQ(calendarPaintProperty->GetUnderscoreXAxisOffsetValue(1.0_px), SIZE_VALUE);
249 EXPECT_EQ(calendarPaintProperty->GetUnderscoreYAxisOffsetValue(1.0_px), SIZE_VALUE);
250 EXPECT_EQ(calendarPaintProperty->GetScheduleMarkerXAxisOffsetValue(1.0_px), SIZE_VALUE);
251 EXPECT_EQ(calendarPaintProperty->GetScheduleMarkerYAxisOffsetValue(1.0_px), SIZE_VALUE);
252 EXPECT_EQ(calendarPaintProperty->GetColSpaceValue(1.0_px), SIZE_VALUE);
253 EXPECT_EQ(calendarPaintProperty->GetDailyFiveRowSpaceValue(1.0_px), SIZE_VALUE);
254 EXPECT_EQ(calendarPaintProperty->GetDailySixRowSpaceValue(1.0_px), SIZE_VALUE);
255 EXPECT_EQ(calendarPaintProperty->GetLunarHeightValue(1.0_px), SIZE_VALUE);
256 EXPECT_EQ(calendarPaintProperty->GetUnderscoreWidthValue(1.0_px), SIZE_VALUE);
257 EXPECT_EQ(calendarPaintProperty->GetUnderscoreLengthValue(1.0_px), SIZE_VALUE);
258 EXPECT_EQ(calendarPaintProperty->GetScheduleMarkerRadiusValue(1.0_px), SIZE_VALUE);
259 EXPECT_EQ(calendarPaintProperty->GetBoundaryRowOffsetValue(1.0_px), SIZE_VALUE);
260 EXPECT_EQ(calendarPaintProperty->GetBoundaryColOffsetValue(1.0_px), SIZE_VALUE);
261
262 // NonCurrentDayStyle
263 EXPECT_EQ(calendarPaintProperty->GetNonCurrentMonthDayColorValue(Color::RED), COLOR_VALUE);
264 EXPECT_EQ(calendarPaintProperty->GetNonCurrentMonthLunarColorValue(Color::RED), COLOR_VALUE);
265 EXPECT_EQ(calendarPaintProperty->GetNonCurrentMonthWorkDayMarkColorValue(Color::RED), COLOR_VALUE);
266 EXPECT_EQ(calendarPaintProperty->GetNonCurrentMonthOffDayMarkColorValue(Color::RED), COLOR_VALUE);
267
268 // TodayStyle
269 EXPECT_EQ(calendarPaintProperty->GetFocusedDayColorValue(Color::RED), COLOR_VALUE);
270 EXPECT_EQ(calendarPaintProperty->GetFocusedLunarColorValue(Color::RED), COLOR_VALUE);
271 EXPECT_EQ(calendarPaintProperty->GetFocusedAreaBackgroundColorValue(Color::RED), COLOR_VALUE);
272 EXPECT_EQ(calendarPaintProperty->GetFocusedAreaRadiusValue(1.0_px), SIZE_VALUE);
273
274 // WeekStyle
275 EXPECT_EQ(calendarPaintProperty->GetWeekColorValue(Color::RED), COLOR_VALUE);
276 EXPECT_EQ(calendarPaintProperty->GetWeekendDayColorValue(Color::RED), COLOR_VALUE);
277 EXPECT_EQ(calendarPaintProperty->GetWeekendLunarColorValue(Color::RED), COLOR_VALUE);
278 EXPECT_EQ(calendarPaintProperty->GetWeekFontSizeValue(1.0_px), SIZE_VALUE);
279 EXPECT_EQ(calendarPaintProperty->GetWeekHeightValue(1.0_px), SIZE_VALUE);
280 EXPECT_EQ(calendarPaintProperty->GetWeekWidthValue(1.0_px), SIZE_VALUE);
281 EXPECT_EQ(calendarPaintProperty->GetWeekAndDayRowSpaceValue(1.0_px), SIZE_VALUE);
282
283 // WorkStateStyle
284 EXPECT_EQ(calendarPaintProperty->GetWorkDayMarkColorValue(Color::RED), COLOR_VALUE);
285 EXPECT_EQ(calendarPaintProperty->GetOffDayMarkColorValue(Color::RED), COLOR_VALUE);
286 EXPECT_EQ(calendarPaintProperty->GetWorkDayMarkSizeValue(1.0_px), SIZE_VALUE);
287 EXPECT_EQ(calendarPaintProperty->GetOffDayMarkSizeValue(1.0_px), SIZE_VALUE);
288 EXPECT_EQ(calendarPaintProperty->GetWorkStateWidthValue(1.0_px), SIZE_VALUE);
289 EXPECT_EQ(calendarPaintProperty->GetWorkStateHorizontalMovingDistanceValue(1.0_px), SIZE_VALUE);
290 EXPECT_EQ(calendarPaintProperty->GetWorkStateVerticalMovingDistanceValue(1.0_px), SIZE_VALUE);
291 }
292
293 HWTEST_F(CalendarTestNg, CalendarModelNGTest002, TestSize.Level1)
294 {
295 auto* stack = ViewStackProcessor::GetInstance();
296 RefPtr<CalendarPattern> initPattern = AceType::MakeRefPtr<CalendarPattern>();
297 RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("testNode", 1, initPattern);
298 stack->Push(frameNode);
299 ObtainedMonth obtainedMonth;
300 obtainedMonth.year = YEAR_VALUE;
301 obtainedMonth.month = MONTH_VALUE;
302 obtainedMonth.firstDayIndex = FIRST_DAY_INDEX_VALUE;
303 CalendarModelNG calendarModelNG;
304 calendarModelNG.SetCurrentData(obtainedMonth);
305 calendarModelNG.SetPreData(obtainedMonth);
306 calendarModelNG.SetNextData(obtainedMonth);
307
308 CalendarDay calendarDay;
309 calendarDay.index = INDEX_VALUE;
310 calendarDay.day = DAY_VALUE;
311 calendarDay.weekend = true;
312 calendarDay.today = false;
313 calendarDay.focused = false;
314 calendarDay.touched = true;
315 calendarDay.isFirstOfLunar = false;
316 calendarDay.hasSchedule = true;
317 calendarDay.markLunarDay = false;
318 calendarDay.lunarMonth = LUNAR_MONTH_VALUE;
319 calendarDay.lunarDay = LUNAR_DAY_VALUE;
320 calendarDay.dayMark = DAY_MARK;
321 calendarDay.dayMarkValue = DAY_MARK_VALUE;
322 CalendarMonth calendarMonth;
323 calendarMonth.year = YEAR_VALUE;
324 calendarMonth.month = MONTH_VALUE;
325 calendarDay.month = calendarMonth;
326 calendarModelNG.SetCalendarDay(calendarDay);
327 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNode()->GetPattern<CalendarPattern>();
328
329 EXPECT_EQ(pattern->GetCurrentMonthData().year, YEAR_VALUE);
330 EXPECT_EQ(pattern->GetCurrentMonthData().month, MONTH_VALUE);
331 EXPECT_EQ(pattern->GetCurrentMonthData().firstDayIndex, FIRST_DAY_INDEX_VALUE);
332 EXPECT_EQ(pattern->GetPreMonthData().year, YEAR_VALUE);
333 EXPECT_EQ(pattern->GetPreMonthData().month, MONTH_VALUE);
334 EXPECT_EQ(pattern->GetPreMonthData().firstDayIndex, FIRST_DAY_INDEX_VALUE);
335 EXPECT_EQ(pattern->GetNextMonthData().year, YEAR_VALUE);
336 EXPECT_EQ(pattern->GetNextMonthData().month, MONTH_VALUE);
337 EXPECT_EQ(pattern->GetNextMonthData().firstDayIndex, FIRST_DAY_INDEX_VALUE);
338
339 EXPECT_EQ(pattern->GetCalendarDay().index, INDEX_VALUE);
340 EXPECT_EQ(pattern->GetCalendarDay().day, DAY_VALUE);
341 EXPECT_TRUE(pattern->GetCalendarDay().weekend);
342 EXPECT_FALSE(pattern->GetCalendarDay().today);
343 EXPECT_FALSE(pattern->GetCalendarDay().focused);
344 EXPECT_TRUE(pattern->GetCalendarDay().touched);
345 EXPECT_FALSE(pattern->GetCalendarDay().isFirstOfLunar);
346 EXPECT_TRUE(pattern->GetCalendarDay().hasSchedule);
347 EXPECT_FALSE(pattern->GetCalendarDay().markLunarDay);
348 EXPECT_EQ(pattern->GetCalendarDay().lunarMonth, LUNAR_MONTH_VALUE);
349 EXPECT_EQ(pattern->GetCalendarDay().lunarDay, LUNAR_DAY_VALUE);
350 EXPECT_EQ(pattern->GetCalendarDay().dayMark, DAY_MARK);
351 EXPECT_EQ(pattern->GetCalendarDay().dayMarkValue, DAY_MARK_VALUE);
352 EXPECT_EQ(pattern->GetCalendarDay().month.year, YEAR_VALUE);
353 EXPECT_EQ(pattern->GetCalendarDay().month.month, MONTH_VALUE);
354 }
355
356 HWTEST_F(CalendarTestNg, CalendarModelNGTest003, TestSize.Level1)
357 {
358 CalendarModelData calendarData;
359 CalendarModelNG calendarModelNG;
360 calendarModelNG.Create(calendarData);
361 calendarModelNG.SetShowLunar(false);
362 calendarModelNG.SetShowHoliday(false);
363 calendarModelNG.SetNeedSlide(true);
364 calendarModelNG.SetStartOfWeek(static_cast<int32_t>(Week::Sun));
365 calendarModelNG.SetOffDays(OFF_DAYS_VALUE);
366 calendarModelNG.SetDirection(static_cast<int32_t>(Axis::HORIZONTAL));
367
368 auto* stack = ViewStackProcessor::GetInstance();
369 auto swiperNode = stack->GetMainFrameNode()->GetFirstChild();
370 auto swiperFrameNode = AceType::DynamicCast<FrameNode>(swiperNode);
371 auto swiperPaintProperty = swiperFrameNode->GetPaintProperty<SwiperPaintProperty>();
372 auto swiperLayoutProperty = swiperFrameNode->GetLayoutProperty<SwiperLayoutProperty>();
373 auto calendarFrameNode = AceType::DynamicCast<FrameNode>(swiperNode->GetFirstChild());
374 auto calendarPaintProperty = calendarFrameNode->GetPaintProperty<CalendarPaintProperty>();
375
376 EXPECT_FALSE(calendarPaintProperty->GetShowLunarValue());
377 EXPECT_FALSE(calendarPaintProperty->GetShowHolidayValue());
378 EXPECT_FALSE(swiperLayoutProperty->GetDisableSwipeValue());
379 EXPECT_EQ(calendarPaintProperty->GetStartOfWeekValue(), Week::Sun);
380 EXPECT_EQ(calendarPaintProperty->GetOffDaysValue(), OFF_DAYS_VALUE);
381 EXPECT_EQ(swiperLayoutProperty->GetDirectionValue(), Axis::HORIZONTAL);
382 }
383
384 /**
385 * @tc.name: CalendarTest004
386 * @tc.desc: Create calendar, and invoke its JumpTo function to calculate the date.
387 * @tc.type: FUNC
388 */
389 HWTEST_F(CalendarTestNg, CalendarTest004, TestSize.Level1)
390 {
391 /**
392 * @tc.steps: step1. Create Calendar
393 * @tc.expected: step1. Create Calendar successfully.
394 */
395 auto* stack = ViewStackProcessor::GetInstance();
396 RefPtr<CalendarPattern> calendar = AceType::MakeRefPtr<CalendarPattern>();
397 RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("testNode", 1, calendar);
398 stack->Push(frameNode);
399 ObtainedMonth obtainedMonth;
400 obtainedMonth.year = JUMP_YEAR;
401 obtainedMonth.month = JUMP_MONTH;
402 obtainedMonth.firstDayIndex = FIRST_DAY_INDEX_VALUE;
403
404 // Add 31 days.
405 std::vector<CalendarDay> days;
406 for (int32_t i = 0; i < 31; i++) {
407 CalendarDay day;
408 day.index = i;
409 day.month.year = JUMP_YEAR;
410 day.month.month = JUMP_MONTH;
411 day.day = i + 1;
412 if (i == 1) {
413 day.focused = true;
414 }
415 days.emplace_back(std::move(day));
416 }
417 obtainedMonth.days = days;
418 CalendarModelNG calendarModelNG;
419 calendarModelNG.SetCurrentData(obtainedMonth);
420 calendarModelNG.SetPreData(obtainedMonth);
421 calendarModelNG.SetNextData(obtainedMonth);
422
423 CalendarDay calendarDay;
424 calendarDay.index = INDEX_VALUE;
425 calendarDay.day = DAY_VALUE;
426 calendarDay.today = false;
427 calendarDay.focused = true;
428 calendarDay.touched = true;
429
430 /**
431 * @tc.steps: step2. Jump to destination from 1 to 3.
432 * @tc.expected: step2. Jumped successfully, the focused changed from 1 to 3.
433 */
434 CalendarMonth calendarMonth;
435 calendarMonth.year = JUMP_YEAR;
436 calendarMonth.month = JUMP_MONTH;
437 calendarDay.month = calendarMonth;
438 calendarModelNG.SetCalendarDay(calendarDay);
439
440 auto pattern = ViewStackProcessor::GetInstance()->GetMainFrameNode()->GetPattern<CalendarPattern>();
441 pattern->FireGoToRequestData(JUMP_YEAR, JUMP_MONTH, JUMP_DAY_FIRST);
442 pattern->JumpTo(pattern->currentMonth_);
443 EXPECT_EQ(pattern->currentMonth_.days[JUMP_DAY_FIRST - 1].focused, true);
444
445 /**
446 * @tc.steps: step3. Jump to destination from 3 to 13.
447 * @tc.expected: step3. Jumped successfully, the focused changed from 3 to 13.
448 */
449 pattern->FireGoToRequestData(JUMP_YEAR, JUMP_MONTH, JUMP_DAY_SECOND);
450 pattern->JumpTo(pattern->currentMonth_);
451 EXPECT_EQ(pattern->currentMonth_.days[JUMP_DAY_SECOND - 1].focused, true);
452
453 /**
454 * @tc.steps: step4. Jump to destination from 13 to 23.
455 * @tc.expected: step4. Jumped successfully, the focused changed from 13 to 23.
456 */
457 pattern->FireGoToRequestData(JUMP_YEAR, JUMP_MONTH, JUMP_DAY_THIRD);
458 pattern->JumpTo(pattern->currentMonth_);
459 EXPECT_EQ(pattern->currentMonth_.days[JUMP_DAY_THIRD - 1].focused, true);
460
461 /**
462 * @tc.steps: step5. Jump to destination from 23 to 3.
463 * @tc.expected: step5. Jumped successfully, the focused changed from 23 to 3.
464 */
465 pattern->FireGoToRequestData(JUMP_YEAR, JUMP_MONTH, JUMP_DAY_FIRST);
466 pattern->JumpTo(pattern->currentMonth_);
467 EXPECT_EQ(pattern->currentMonth_.days[JUMP_DAY_FIRST - 1].focused, true);
468 }
469
470 /**
471 * @tc.name: CalendarTest005
472 * @tc.desc: Create calendar, and check the 6 rows (42 days).
473 * @tc.type: FUNC
474 */
475 HWTEST_F(CalendarTestNg, CalendarTest005, TestSize.Level1)
476 {
477 /**
478 * @tc.steps: step1. Create Calendar
479 * @tc.expected: step1. Create Calendar successfully.
480 */
481 auto* stack = ViewStackProcessor::GetInstance();
482 RefPtr<CalendarPattern> calendar = AceType::MakeRefPtr<CalendarPattern>();
483 RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("testNode", 1, calendar);
484 stack->Push(frameNode);
485 ObtainedMonth obtainedMonth;
486 obtainedMonth.year = JUMP_YEAR;
487 obtainedMonth.month = JUMP_MONTH;
488 obtainedMonth.firstDayIndex = FIRST_DAY_INDEX_VALUE;
489
490 // Add 42 days totally.
491 // Add 31 days in March.
492 std::vector<CalendarDay> days;
493 for (int32_t i = 0; i < 31; i++) {
494 CalendarDay day;
495 day.index = i;
496 day.month.year = JUMP_YEAR;
497 day.month.month = JUMP_MONTH;
498 day.day = i + 1;
499 if (i == 1) {
500 day.focused = true;
501 }
502 days.emplace_back(std::move(day));
503 }
504
505 // Add 11 days in April.
506 for (int32_t i = 31; i < 42; i++) {
507 CalendarDay day;
508 day.index = i;
509 day.month.year = JUMP_YEAR;
510 day.month.month = JUMP_MONTH + 1;
511 day.day = i - 30;
512 days.emplace_back(std::move(day));
513 }
514
515 obtainedMonth.days = days;
516 CalendarModelNG calendarModelNG;
517 calendarModelNG.SetCurrentData(obtainedMonth);
518 calendarModelNG.SetPreData(obtainedMonth);
519 calendarModelNG.SetNextData(obtainedMonth);
520
521 CalendarDay calendarDay;
522 calendarDay.index = INDEX_VALUE;
523 calendarDay.day = DAY_VALUE;
524 calendarDay.today = false;
525 calendarDay.focused = true;
526 calendarDay.touched = true;
527
528 /**
529 * @tc.steps: step2. Set 42 days in a month.
530 * @tc.expected: step2. The rows of month is 6.
531 */
532 CalendarMonth calendarMonth;
533 calendarMonth.year = JUMP_YEAR;
534 calendarMonth.month = JUMP_MONTH;
535 calendarDay.month = calendarMonth;
536 calendarModelNG.SetCalendarDay(calendarDay);
537
538 auto paintMethod = AceType::MakeRefPtr<CalendarPaintMethod>(obtainedMonth, calendarDay);
539 Testing::MockCanvas rsCanvas;
540 paintMethod->DrawWeekAndDates(rsCanvas, Offset(0, 0));
541 EXPECT_EQ(paintMethod->rowCount_, WEEKS_COUNT_SIX);
542 }
543
544 /**
545 * @tc.name: CalendarTest006
546 * @tc.desc: Create calendar, and check the 5 rows (35 days).
547 * @tc.type: FUNC
548 */
549 HWTEST_F(CalendarTestNg, CalendarTest006, TestSize.Level1)
550 {
551 /**
552 * @tc.steps: step1. Create Calendar
553 * @tc.expected: step1. Create Calendar successfully.
554 */
555 auto* stack = ViewStackProcessor::GetInstance();
556 RefPtr<CalendarPattern> calendar = AceType::MakeRefPtr<CalendarPattern>();
557 RefPtr<FrameNode> frameNode = FrameNode::CreateFrameNode("testNode", 1, calendar);
558 stack->Push(frameNode);
559 ObtainedMonth obtainedMonth;
560 obtainedMonth.year = JUMP_YEAR;
561 obtainedMonth.month = JUMP_MONTH;
562 obtainedMonth.firstDayIndex = FIRST_DAY_INDEX_VALUE;
563
564 // Add 35 days totally.
565 // Add 31 days in March.
566 std::vector<CalendarDay> days;
567 for (int32_t i = 0; i < 31; i++) {
568 CalendarDay day;
569 day.index = i;
570 day.month.year = JUMP_YEAR;
571 day.month.month = JUMP_MONTH;
572 day.day = i + 1;
573 if (i == 1) {
574 day.focused = true;
575 }
576 days.emplace_back(std::move(day));
577 }
578
579 // Add 4 days in April.
580 for (int32_t i = 31; i < 35; i++) {
581 CalendarDay day;
582 day.index = i;
583 day.month.year = JUMP_YEAR;
584 day.month.month = JUMP_MONTH + 1;
585 day.day = i - 30;
586 days.emplace_back(std::move(day));
587 }
588
589 obtainedMonth.days = days;
590 CalendarModelNG calendarModelNG;
591 calendarModelNG.SetCurrentData(obtainedMonth);
592 calendarModelNG.SetPreData(obtainedMonth);
593 calendarModelNG.SetNextData(obtainedMonth);
594
595 CalendarDay calendarDay;
596 calendarDay.index = INDEX_VALUE;
597 calendarDay.day = DAY_VALUE;
598
599 /**
600 * @tc.steps: step2. Set 35days in a month.
601 * @tc.expected: step2. The rows of month is 5.
602 */
603 CalendarMonth calendarMonth;
604 calendarMonth.year = JUMP_YEAR;
605 calendarMonth.month = JUMP_MONTH;
606 calendarDay.month = calendarMonth;
607 calendarModelNG.SetCalendarDay(calendarDay);
608
609 auto paintMethod = AceType::MakeRefPtr<CalendarPaintMethod>(obtainedMonth, calendarDay);
610 Testing::MockCanvas rsCanvas;
611 paintMethod->DrawWeekAndDates(rsCanvas, Offset(0, 0));
612 EXPECT_EQ(paintMethod->rowCount_, WEEKS_COUNT_FIVE);
613 }
614
615 /**
616 * @tc.name: CalendarTest007
617 * @tc.desc: Create calendar, and check the todayStyle focus status.
618 * @tc.type: FUNC
619 */
620 HWTEST_F(CalendarTestNg, CalendarTest007, TestSize.Level1)
621 {
622 /**
623 * @tc.steps: step1. Create Calendar
624 * @tc.expected: step1. Create Calendar successfully.
625 */
626 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
627 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
628 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<CalendarTheme>()));
629
630 // Today style.
631 TodayStyle todayStyle;
632 Color focusedDayColor = Color::WHITE;
633 todayStyle.UpdateFocusedDayColor(focusedDayColor);
634 Color focusedLunarColor = Color::WHITE;
635 todayStyle.UpdateFocusedLunarColor(focusedLunarColor);
636 Color focusedAreaBackgroundColor = Color::BLUE;
637 todayStyle.UpdateFocusedAreaBackgroundColor(focusedAreaBackgroundColor);
638 Dimension focusedAreaRadius = Dimension(DEFAULT_FOCUS_RADIUS, DimensionUnit::VP);
639 todayStyle.UpdateFocusedAreaRadius(focusedAreaRadius);
640
641 // Day style of current month.
642 CurrentDayStyle dayStyle;
643 dayStyle.UpdateDayColor(Color::BLACK);
644
645 CalendarModelData calendarData;
646 auto calendarControllerNg = AceType::MakeRefPtr<CalendarControllerNg>();
647 calendarData.controller = calendarControllerNg;
648 CalendarModelNG calendarModelNG;
649 calendarModelNG.Create(calendarData);
650 calendarModelNG.SetTodayStyle(todayStyle);
651 calendarModelNG.SetCurrentDayStyle(dayStyle);
652 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
653
654 EXPECT_EQ(element->GetTag(), V2::CALENDAR_ETS_TAG);
655 auto frameNode = AceType::DynamicCast<FrameNode>(element);
656 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
657 auto swiperNode = frameNode->GetChildren().front();
658 auto calendarFrameNode = AceType::DynamicCast<FrameNode>(swiperNode->GetChildren().front());
659 auto calendarPaintProperty = calendarFrameNode->GetPaintProperty<CalendarPaintProperty>();
660
661 ObtainedMonth obtainedMonth;
662 obtainedMonth.year = JUMP_YEAR;
663 obtainedMonth.month = JUMP_MONTH;
664 obtainedMonth.firstDayIndex = FIRST_DAY_INDEX_VALUE;
665
666 // Add 31 days.
667 std::vector<CalendarDay> days;
668 for (int32_t i = 0; i < 31; i++) {
669 CalendarDay day;
670 day.index = i;
671 day.month.year = JUMP_YEAR;
672 day.month.month = JUMP_MONTH;
673 day.day = i + 1;
674 if (i == 0) {
675 day.focused = true;
676 }
677 days.emplace_back(std::move(day));
678 }
679 obtainedMonth.days = days;
680
681 calendarModelNG.SetCurrentData(obtainedMonth);
682 calendarModelNG.SetPreData(obtainedMonth);
683 calendarModelNG.SetNextData(obtainedMonth);
684
685 CalendarDay calendarDay;
686 calendarDay.index = INDEX_VALUE;
687 calendarDay.day = DAY_VALUE;
688 calendarDay.today = false;
689 calendarDay.focused = true;
690 calendarDay.touched = true;
691
692 /**
693 * @tc.steps: step2. Set the first day focused, check the first day text style.
694 * @tc.expected: step2. The text color is 0xffffffff.
695 */
696 CalendarMonth calendarMonth;
697 calendarMonth.year = JUMP_YEAR;
698 calendarMonth.month = JUMP_MONTH;
699 calendarDay.month = calendarMonth;
700 calendarModelNG.SetCalendarDay(calendarDay);
701
702 auto paintMethod = AceType::MakeRefPtr<CalendarPaintMethod>(obtainedMonth, calendarDay);
703 Testing::MockCanvas rsCanvas;
704 paintMethod->SetCalendarTheme(calendarPaintProperty);
705 RSTextStyle dateTextStyle;
706 RSTextStyle lunarTextStyle;
707 paintMethod->InitTextStyle(dateTextStyle, lunarTextStyle);
708
709 paintMethod->SetDayTextStyle(dateTextStyle, lunarTextStyle, obtainedMonth.days[0]);
710
711 #ifndef USE_GRAPHIC_TEXT_GINE
712 EXPECT_EQ(dateTextStyle.color_, RSColor(0xffffffff));
713 EXPECT_EQ(lunarTextStyle.color_, RSColor(0xffffffff));
714 #else
715 EXPECT_EQ(dateTextStyle.color, RSColor(0xffffffff));
716 EXPECT_EQ(lunarTextStyle.color, RSColor(0xffffffff));
717 #endif
718
719 /**
720 * @tc.steps: step3. Set the first day focused, check the second day text style.
721 * @tc.expected: step3. The text color is 0xff000000.
722 */
723 paintMethod->SetDayTextStyle(dateTextStyle, lunarTextStyle, obtainedMonth.days[1]);
724 #ifndef USE_GRAPHIC_TEXT_GINE
725 EXPECT_EQ(dateTextStyle.color_, RSColor(0xff000000));
726 EXPECT_EQ(lunarTextStyle.color_, RSColor(0xff000000));
727 #else
728 EXPECT_EQ(dateTextStyle.color, RSColor(0xff000000));
729 EXPECT_EQ(lunarTextStyle.color, RSColor(0xff000000));
730 #endif
731 }
732
733 /**
734 * @tc.name: CalendarTest008
735 * @tc.desc: Create calendar, and check the gregorianDayYAxisOffset.
736 * @tc.type: FUNC
737 */
738 HWTEST_F(CalendarTestNg, CalendarTest008, TestSize.Level1)
739 {
740 /**
741 * @tc.steps: step1. Create Calendar
742 * @tc.expected: step1. Create Calendar successfully.
743 */
744 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
745 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
746 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<CalendarTheme>()));
747
748 // Today style.
749 TodayStyle todayStyle;
750 Color focusedDayColor = Color::WHITE;
751 todayStyle.UpdateFocusedDayColor(focusedDayColor);
752 Color focusedLunarColor = Color::WHITE;
753 todayStyle.UpdateFocusedLunarColor(focusedLunarColor);
754 Color focusedAreaBackgroundColor = Color::BLUE;
755 todayStyle.UpdateFocusedAreaBackgroundColor(focusedAreaBackgroundColor);
756 Dimension focusedAreaRadius = Dimension(DEFAULT_FOCUS_RADIUS, DimensionUnit::VP);
757 todayStyle.UpdateFocusedAreaRadius(focusedAreaRadius);
758
759 // Day style of current month.
760 CurrentDayStyle dayStyle;
761 dayStyle.UpdateDayColor(Color::BLACK);
762 dayStyle.UpdateLunarColor(COLOR_VALUE);
763 dayStyle.UpdateDayHeight(DAY_HEIGHT);
764 dayStyle.UpdateDayWidth(DAY_WIDTH);
765 dayStyle.UpdateGregorianCalendarHeight(GREGORIAN_DAY_HEIGHT);
766 dayStyle.UpdateDayYAxisOffset(GREGORIAN_DAY_OFFSET);
767 dayStyle.UpdateLunarDayYAxisOffset(LUNAR_DAY_OFFSET);
768 dayStyle.UpdateLunarHeight(LUNAR_DAY_HEIGHT);
769
770 CalendarData calendarData;
771 auto calendarControllerNg = AceType::MakeRefPtr<CalendarControllerNg>();
772 calendarData.controller = calendarControllerNg;
773 CalendarModelNG calendarModel;
774 calendarModel.Create(calendarData);
775 calendarModel.SetTodayStyle(todayStyle);
776 calendarModel.SetCurrentDayStyle(dayStyle);
777 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
778
779 EXPECT_EQ(element->GetTag(), V2::CALENDAR_ETS_TAG);
780 auto frameNode = AceType::DynamicCast<FrameNode>(element);
781 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
782 auto swiperNode = frameNode->GetChildren().front();
783 auto calendarFrameNode = AceType::DynamicCast<FrameNode>(swiperNode->GetChildren().front());
784 auto calendarPaintProperty = calendarFrameNode->GetPaintProperty<CalendarPaintProperty>();
785
786 /**
787 * @tc.steps: step1. Check the offset and height.
788 * @tc.expected: step1. Get the offset and height successfully.
789 */
790 EXPECT_EQ(calendarPaintProperty->GetDayHeightValue(SIZE_VALUE), DAY_HEIGHT);
791 EXPECT_EQ(calendarPaintProperty->GetDayWidthValue(SIZE_VALUE), DAY_WIDTH);
792 EXPECT_EQ(calendarPaintProperty->GetGregorianCalendarHeightValue(SIZE_VALUE), GREGORIAN_DAY_HEIGHT);
793 EXPECT_EQ(calendarPaintProperty->GetDayYAxisOffsetValue(SIZE_VALUE), GREGORIAN_DAY_OFFSET);
794 EXPECT_EQ(calendarPaintProperty->GetLunarDayYAxisOffsetValue(SIZE_VALUE), LUNAR_DAY_OFFSET);
795 EXPECT_EQ(calendarPaintProperty->GetLunarHeightValue(SIZE_VALUE), LUNAR_DAY_HEIGHT);
796 }
797
798 /**
799 * @tc.name: CalendarPatternTest001
800 * @tc.desc: Test CalendarPattern OnDirtyLayoutWrapperSwap
801 * @tc.type: FUNC
802 */
803 HWTEST_F(CalendarTestNg, CalendarPatternTest001, TestSize.Level1)
804 {
805 auto* stack = ViewStackProcessor::GetInstance();
806 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140890202() 807 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
808 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
809 ASSERT_NE(calendarPattern, nullptr);
810
811 auto layoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
812 frameNode, AceType::MakeRefPtr<GeometryNode>(), AceType::MakeRefPtr<LayoutProperty>());
813 EXPECT_FALSE(calendarPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, true, true));
814 }
815
816 /**
817 * @tc.name: CalendarPatternTest002
818 * @tc.desc: Test CalendarPattern OnModifyDone ChangeDoneEvent
819 * @tc.type: FUNC
820 */
821 HWTEST_F(CalendarTestNg, CalendarPatternTest002, TestSize.Level1)
822 {
823 auto* stack = ViewStackProcessor::GetInstance();
824 auto nodeId = stack->ClaimNodeId();
825 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140890302() 826 V2::CALENDAR_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<CalendarPattern>(); });
827 auto swiperNode = FrameNode::GetOrCreateFrameNode(V2::SWIPER_ETS_TAG,
__anone77140890402() 828 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<SwiperPattern>(); });
829 swiperNode->MountToParent(frameNode);
830 for (int i = 0; i < 3; i++) {
831 auto monthNode =
832 FrameNode::GetOrCreateFrameNode(V2::CALENDAR_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anone77140890502() 833 []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
834 monthNode->MountToParent(swiperNode);
835 }
836 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
837 ASSERT_NE(calendarPattern, nullptr);
838
839 auto swiperFrameNode = AceType::DynamicCast<FrameNode>(swiperNode);
840 ASSERT_NE(swiperFrameNode, nullptr);
841 auto swiperEventHub = swiperFrameNode->GetEventHub<SwiperEventHub>();
842 ASSERT_NE(swiperEventHub, nullptr);
843 auto calendarEventHub = frameNode->GetEventHub<CalendarEventHub>();
844 ASSERT_NE(calendarEventHub, nullptr);
845
846 calendarPattern->initialize_ = true;
847 calendarPattern->currentMonth_.days.clear();
848 auto currentMonth = calendarPattern->calendarDay_.month;
849 std::string infoDetail;
__anone77140890602(std::string info) 850 auto initRequestDataEvent = [&](std::string info) { infoDetail = std::move(info); };
851 calendarEventHub->SetOnRequestDataEvent(initRequestDataEvent);
852 calendarPattern->OnModifyDone();
853 auto json = JsonUtil::ParseJsonString(infoDetail);
854 EXPECT_EQ(json->GetInt("currentYear"), currentMonth.year);
855 EXPECT_EQ(json->GetInt("currentMonth"), currentMonth.month);
856 EXPECT_EQ(json->GetInt("year"), currentMonth.year);
857 EXPECT_EQ(json->GetInt("month"), currentMonth.month);
858 EXPECT_EQ(json->GetInt("MonthState"), 0);
859
860 swiperEventHub->FireChangeDoneEvent(true);
861 json = JsonUtil::ParseJsonString(infoDetail);
862 EXPECT_EQ(json->GetInt("MonthState"), 2);
863 EXPECT_EQ(json->GetInt("year"), calendarPattern->nextMonth_.year);
864 EXPECT_EQ(json->GetInt("month"), calendarPattern->nextMonth_.month);
865 EXPECT_EQ(json->GetInt("currentYear"), currentMonth.year);
866 EXPECT_EQ(json->GetInt("currentMonth"), currentMonth.month);
867 EXPECT_EQ(calendarPattern->GetMoveDirection(), NG::Direction::NEXT);
868
869 swiperEventHub->FireChangeDoneEvent(false);
870 json = JsonUtil::ParseJsonString(infoDetail);
871 EXPECT_EQ(json->GetInt("MonthState"), 1);
872 EXPECT_EQ(json->GetInt("year"), calendarPattern->preMonth_.year);
873 EXPECT_EQ(json->GetInt("month"), calendarPattern->preMonth_.month);
874 EXPECT_EQ(json->GetInt("currentYear"), currentMonth.year);
875 EXPECT_EQ(json->GetInt("currentMonth"), currentMonth.month);
876 EXPECT_EQ(calendarPattern->GetMoveDirection(), NG::Direction::PRE);
877
878 swiperFrameNode->children_.clear();
879 calendarPattern->OnModifyDone();
880 }
881
882 /**
883 * @tc.name: CalendarPatternTest003
884 * @tc.desc: Test CalendarPattern OnModifyDone currentIndex switch
885 * @tc.type: FUNC
886 */
887 HWTEST_F(CalendarTestNg, CalendarPatternTest003, TestSize.Level1)
888 {
889 auto* stack = ViewStackProcessor::GetInstance();
890 auto nodeId = stack->ClaimNodeId();
891 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140890702() 892 V2::CALENDAR_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<CalendarPattern>(); });
893 auto swiperNode = FrameNode::GetOrCreateFrameNode(V2::SWIPER_ETS_TAG,
__anone77140890802() 894 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<SwiperPattern>(); });
895 swiperNode->MountToParent(frameNode);
896 auto swiperPattern = swiperNode->GetPattern<SwiperPattern>();
897 ASSERT_NE(swiperPattern, nullptr);
898 auto swiperLayoutProperty = swiperPattern->GetLayoutProperty<SwiperLayoutProperty>();
899 ASSERT_NE(swiperLayoutProperty, nullptr);
900 swiperLayoutProperty->UpdateShowIndicator(false);
901 for (int i = 0; i < 3; i++) {
902 auto monthNode =
903 FrameNode::GetOrCreateFrameNode(V2::CALENDAR_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
__anone77140890902() 904 []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
905 monthNode->MountToParent(swiperNode);
906 }
907 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
908 ASSERT_NE(calendarPattern, nullptr);
909
910 auto preFrameNode = AceType::DynamicCast<FrameNode>(swiperNode->GetChildren().front());
911 ASSERT_NE(preFrameNode, nullptr);
912 auto prePattern = preFrameNode->GetPattern<CalendarMonthPattern>();
913 ASSERT_NE(prePattern, nullptr);
914 auto iterator = swiperNode->GetChildren().begin();
915 auto currentFrameNode = AceType::DynamicCast<FrameNode>(*(++iterator));
916 ASSERT_NE(currentFrameNode, nullptr);
917 auto currentPattern = currentFrameNode->GetPattern<CalendarMonthPattern>();
918 ASSERT_NE(currentPattern, nullptr);
919 auto nextFrameNode = AceType::DynamicCast<FrameNode>(swiperNode->GetChildren().back());
920 ASSERT_NE(nextFrameNode, nullptr);
921 auto nextPattern = nextFrameNode->GetPattern<CalendarMonthPattern>();
922 ASSERT_NE(nextPattern, nullptr);
923
924 calendarPattern->backToToday_ = true;
925 calendarPattern->goTo_ = true;
926 CalendarDay calendarDay;
927 calendarDay.month.year = calendarPattern->goToCalendarYear_;
928 calendarDay.month.month = calendarPattern->goToCalendarMonth_;
929 calendarDay.day = calendarPattern->goToCalendarDay_;
930 CalendarDay calendarDay2;
931 calendarDay2.day = calendarPattern->goToCalendarDay_ + 1;
932 calendarPattern->currentMonth_.days.clear();
933 calendarPattern->currentMonth_.days.emplace_back(calendarDay);
934 calendarPattern->currentMonth_.days.emplace_back(calendarDay2);
935
936 swiperPattern->currentIndex_ = 0;
937 calendarPattern->initialize_ = false;
938 calendarPattern->OnModifyDone();
939 EXPECT_TRUE(calendarPattern->currentMonth_.days.front().focused);
940 EXPECT_FALSE(calendarPattern->currentMonth_.days.back().focused);
941 EXPECT_EQ(prePattern->obtainedMonth_.firstDayIndex, calendarPattern->currentMonth_.firstDayIndex);
942 EXPECT_EQ(prePattern->monthState_, MonthState::CUR_MONTH);
943 EXPECT_EQ(currentPattern->obtainedMonth_.firstDayIndex, calendarPattern->nextMonth_.firstDayIndex);
944 EXPECT_EQ(currentPattern->monthState_, MonthState::NEXT_MONTH);
945 EXPECT_EQ(nextPattern->obtainedMonth_.firstDayIndex, calendarPattern->preMonth_.firstDayIndex);
946 EXPECT_EQ(nextPattern->monthState_, MonthState::PRE_MONTH);
947 EXPECT_EQ(prePattern->GetCalendarDay().day, calendarPattern->GetCalendarDay().day);
948
949 calendarPattern->OnModifyDone();
950 EXPECT_EQ(prePattern->obtainedMonth_.firstDayIndex, calendarPattern->currentMonth_.firstDayIndex);
951 EXPECT_EQ(prePattern->monthState_, MonthState::CUR_MONTH);
952 EXPECT_EQ(currentPattern->obtainedMonth_.firstDayIndex, calendarPattern->nextMonth_.firstDayIndex);
953 EXPECT_EQ(currentPattern->monthState_, MonthState::NEXT_MONTH);
954 EXPECT_EQ(nextPattern->obtainedMonth_.firstDayIndex, calendarPattern->preMonth_.firstDayIndex);
955 EXPECT_EQ(nextPattern->monthState_, MonthState::PRE_MONTH);
956
957 swiperPattern->currentIndex_ = 1;
958 calendarPattern->backToToday_ = true;
959 calendarPattern->goTo_ = true;
960 calendarPattern->OnModifyDone();
961 EXPECT_EQ(prePattern->obtainedMonth_.firstDayIndex, calendarPattern->preMonth_.firstDayIndex);
962 EXPECT_EQ(prePattern->monthState_, MonthState::PRE_MONTH);
963 EXPECT_EQ(currentPattern->obtainedMonth_.firstDayIndex, calendarPattern->currentMonth_.firstDayIndex);
964 EXPECT_EQ(currentPattern->monthState_, MonthState::CUR_MONTH);
965 EXPECT_EQ(nextPattern->obtainedMonth_.firstDayIndex, calendarPattern->nextMonth_.firstDayIndex);
966 EXPECT_EQ(nextPattern->monthState_, MonthState::NEXT_MONTH);
967 EXPECT_EQ(currentPattern->GetCalendarDay().day, calendarPattern->GetCalendarDay().day);
968
969 calendarPattern->OnModifyDone();
970 EXPECT_EQ(prePattern->obtainedMonth_.firstDayIndex, calendarPattern->preMonth_.firstDayIndex);
971 EXPECT_EQ(prePattern->monthState_, MonthState::PRE_MONTH);
972 EXPECT_EQ(currentPattern->obtainedMonth_.firstDayIndex, calendarPattern->currentMonth_.firstDayIndex);
973 EXPECT_EQ(currentPattern->monthState_, MonthState::CUR_MONTH);
974 EXPECT_EQ(nextPattern->obtainedMonth_.firstDayIndex, calendarPattern->nextMonth_.firstDayIndex);
975 EXPECT_EQ(nextPattern->monthState_, MonthState::NEXT_MONTH);
976
977 swiperPattern->currentIndex_ = 2;
978 calendarPattern->backToToday_ = true;
979 calendarPattern->goTo_ = true;
980 calendarPattern->OnModifyDone();
981 EXPECT_EQ(prePattern->obtainedMonth_.firstDayIndex, calendarPattern->nextMonth_.firstDayIndex);
982 EXPECT_EQ(prePattern->monthState_, MonthState::NEXT_MONTH);
983 EXPECT_EQ(currentPattern->obtainedMonth_.firstDayIndex, calendarPattern->preMonth_.firstDayIndex);
984 EXPECT_EQ(currentPattern->monthState_, MonthState::PRE_MONTH);
985 EXPECT_EQ(nextPattern->obtainedMonth_.firstDayIndex, calendarPattern->currentMonth_.firstDayIndex);
986 EXPECT_EQ(nextPattern->monthState_, MonthState::CUR_MONTH);
987 EXPECT_EQ(nextPattern->GetCalendarDay().day, calendarPattern->GetCalendarDay().day);
988
989 calendarPattern->OnModifyDone();
990 EXPECT_EQ(prePattern->obtainedMonth_.firstDayIndex, calendarPattern->nextMonth_.firstDayIndex);
991 EXPECT_EQ(prePattern->monthState_, MonthState::NEXT_MONTH);
992 EXPECT_EQ(currentPattern->obtainedMonth_.firstDayIndex, calendarPattern->preMonth_.firstDayIndex);
993 EXPECT_EQ(currentPattern->monthState_, MonthState::PRE_MONTH);
994 EXPECT_EQ(nextPattern->obtainedMonth_.firstDayIndex, calendarPattern->currentMonth_.firstDayIndex);
995 EXPECT_EQ(nextPattern->monthState_, MonthState::CUR_MONTH);
996 EXPECT_EQ(nextPattern->GetCalendarDay().day, calendarPattern->GetCalendarDay().day);
997
998 swiperPattern->currentIndex_ = 3;
999 calendarPattern->backToToday_ = true;
1000 calendarPattern->goTo_ = true;
1001 calendarPattern->OnModifyDone();
1002 calendarPattern->OnModifyDone();
1003 }
1004
1005 /**
1006 * @tc.name: CalendarPatternTest004
1007 * @tc.desc: Test CalendarPattern FlushFocus
1008 * @tc.type: FUNC
1009 */
1010 HWTEST_F(CalendarTestNg, CalendarPatternTest004, TestSize.Level1)
1011 {
1012 auto* stack = ViewStackProcessor::GetInstance();
1013 auto nodeId = stack->ClaimNodeId();
1014 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140890a02() 1015 V2::CALENDAR_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<CalendarPattern>(); });
1016 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
1017 ASSERT_NE(calendarPattern, nullptr);
1018
1019 ObtainedMonth obtainedMonth;
1020 CalendarDay calendarDay;
1021 calendarDay.month.year = calendarPattern->calendarDay_.month.year;
1022 calendarDay.month.month = calendarPattern->calendarDay_.month.month;
1023 calendarDay.day = calendarPattern->calendarDay_.day;
1024 calendarDay.focused = false;
1025 obtainedMonth.days.emplace_back(calendarDay);
1026 calendarPattern->FlushFocus(obtainedMonth);
1027 EXPECT_TRUE(obtainedMonth.days[0].focused);
1028
1029 calendarDay.month.year = calendarPattern->calendarDay_.month.year + 1;
1030 calendarDay.focused = false;
1031 calendarPattern->FlushFocus(obtainedMonth);
1032 EXPECT_TRUE(obtainedMonth.days[0].focused);
1033 }
1034
1035 /**
1036 * @tc.name: CalendarPatternTest005
1037 * @tc.desc: Test CalendarPattern ToJsonValue
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(CalendarTestNg, CalendarPatternTest005, TestSize.Level1)
1041 {
1042 auto* stack = ViewStackProcessor::GetInstance();
1043 auto nodeId = stack->ClaimNodeId();
1044 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140890b02() 1045 V2::CALENDAR_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<CalendarPattern>(); });
1046 auto swiperNode = FrameNode::GetOrCreateFrameNode(V2::SWIPER_ETS_TAG,
__anone77140890c02() 1047 ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<SwiperPattern>(); });
1048 swiperNode->MountToParent(frameNode);
1049 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
1050 ASSERT_NE(calendarPattern, nullptr);
1051
1052 auto json = JsonUtil::Create(true);
1053 auto swiperLayoutProperty = swiperNode->GetLayoutProperty<SwiperLayoutProperty>();
1054 ASSERT_NE(swiperLayoutProperty, nullptr);
1055 auto swiperPaintProperty = swiperNode->GetPaintProperty<SwiperPaintProperty>();
1056 ASSERT_NE(swiperPaintProperty, nullptr);
1057
1058 swiperLayoutProperty->UpdateDisableSwipe(true);
1059 swiperLayoutProperty->UpdateDirection(Axis::VERTICAL);
1060 calendarPattern->ToJsonValue(json, filter);
1061 EXPECT_EQ(json->GetString("needSlide"), "false");
1062 EXPECT_EQ(json->GetString("direction"), "0");
1063
1064 swiperLayoutProperty->UpdateDisableSwipe(false);
1065 swiperLayoutProperty->UpdateDirection(Axis::HORIZONTAL);
1066 json = JsonUtil::Create(true);
1067 calendarPattern->ToJsonValue(json, filter);
1068 EXPECT_EQ(json->GetString("needSlide"), "true");
1069 EXPECT_EQ(json->GetString("direction"), "1");
1070
1071 std::optional<bool> disableSwipe;
1072 std::optional<Axis> direction;
1073 swiperLayoutProperty->propDisableSwipe_ = disableSwipe;
1074 swiperLayoutProperty->propDirection_ = direction;
1075 json = JsonUtil::Create(true);
1076 calendarPattern->ToJsonValue(json, filter);
1077 EXPECT_EQ(json->GetString("needSlide"), "true");
1078 EXPECT_EQ(json->GetString("direction"), "1");
1079 }
1080
1081 /**
1082 * @tc.name: CalendarMonthPatternTest001
1083 * @tc.desc: Test CalendarMonthPattern OnDirtyLayoutWrapperSwap
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(CalendarTestNg, CalendarMonthPatternTest001, TestSize.Level1)
1087 {
1088 auto* stack = ViewStackProcessor::GetInstance();
1089 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140890d02() 1090 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
1091 auto calendarMonthPattern = frameNode->GetPattern<CalendarMonthPattern>();
1092 ASSERT_NE(calendarMonthPattern, nullptr);
1093
1094 auto layoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
1095 frameNode, AceType::MakeRefPtr<GeometryNode>(), AceType::MakeRefPtr<LayoutProperty>());
1096 DirtySwapConfig config;
1097 config.skipMeasure = true;
1098 layoutWrapper->skipMeasureContent_ = std::make_optional<bool>(true);
1099 EXPECT_FALSE(calendarMonthPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, config));
1100
1101 config.skipMeasure = false;
1102 layoutWrapper->skipMeasureContent_ = std::make_optional<bool>(false);
1103 auto layoutAlgorithm = AceType::MakeRefPtr<LayoutAlgorithmWrapper>(AceType::MakeRefPtr<LayoutAlgorithm>());
1104 layoutAlgorithm->skipMeasure_ = false;
1105 layoutWrapper->layoutAlgorithm_ = layoutAlgorithm;
1106 EXPECT_TRUE(calendarMonthPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, config));
1107 }
1108
1109 /**
1110 * @tc.name: CalendarMonthPatternTest002
1111 * @tc.desc: Test CalendarMonthPattern ClickCallback
1112 * @tc.type: FUNC
1113 */
1114 HWTEST_F(CalendarTestNg, CalendarMonthPatternTest002, TestSize.Level1)
1115 {
1116 auto* stack = ViewStackProcessor::GetInstance();
1117 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140890e02() 1118 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
1119 auto calendarMonthEventHub = frameNode->GetEventHub<CalendarEventHub>();
1120 ASSERT_NE(calendarMonthEventHub, nullptr);
1121 auto calendarMonthPattern = frameNode->GetPattern<CalendarMonthPattern>();
1122 ASSERT_NE(calendarMonthPattern, nullptr);
1123 auto paintProperty = frameNode->GetPaintProperty<CalendarPaintProperty>();
1124 ASSERT_NE(paintProperty, nullptr);
1125
1126 auto gesture = frameNode->GetOrCreateGestureEventHub();
1127 calendarMonthPattern->OnModifyDone();
1128 auto clickCallback = gesture->clickEventActuator_->clickEvents_.back()->callback_;
1129
1130 std::string infoDetail;
__anone77140890f02(std::string info) 1131 auto initRequestDataEvent = [&](std::string info) { infoDetail = std::move(info); };
1132 calendarMonthEventHub->SetSelectedChangeEvent(initRequestDataEvent);
1133 calendarMonthPattern->OnModifyDone();
1134
1135 ObtainedMonth obtainedMonth;
1136 calendarMonthPattern->obtainedMonth_ = obtainedMonth;
1137 GestureEvent gestureEvent;
1138 FingerInfo fingerInfo;
1139 fingerInfo.localLocation_ = Offset(OFFSET_X, OFFSET_Y);
1140 calendarMonthPattern->OnClick(fingerInfo.localLocation_, calendarMonthPattern->obtainedMonth_);
1141 EXPECT_TRUE(obtainedMonth.days.empty());
1142
1143 for (int i = 0; i < 3; i++) {
1144 CalendarDay calendarDay;
1145 calendarDay.focused = true;
1146 obtainedMonth.days.emplace_back(calendarDay);
1147 }
1148 calendarMonthPattern->obtainedMonth_ = obtainedMonth;
1149 gestureEvent.fingerList_.clear();
1150 gestureEvent.fingerList_.emplace_back(fingerInfo);
1151 frameNode->geometryNode_->SetFrameSize(SizeF(VALID_LENGTH, VALID_LENGTH));
1152 paintProperty->UpdateDayHeight(Dimension(VALID_LENGTH));
1153 paintProperty->UpdateDayWidth(Dimension(VALID_LENGTH));
1154 calendarMonthPattern->OnClick(fingerInfo.localLocation_, calendarMonthPattern->obtainedMonth_);
1155 EXPECT_TRUE(calendarMonthPattern->obtainedMonth_.days[0].focused);
1156 EXPECT_FALSE(calendarMonthPattern->obtainedMonth_.days[1].focused);
1157 EXPECT_FALSE(calendarMonthPattern->obtainedMonth_.days[2].focused);
1158 auto json = JsonUtil::ParseJsonString(infoDetail);
1159 for (int i = 0; i < 3; i++) {
1160 EXPECT_EQ(json->GetInt("day"), obtainedMonth.days[i].day);
1161 EXPECT_EQ(json->GetInt("month"), obtainedMonth.days[i].month.month);
1162 EXPECT_EQ(json->GetInt("year"), obtainedMonth.days[i].month.year);
1163 }
1164 }
1165
1166 /**
1167 * @tc.name: CalendarMonthPatternTest003
1168 * @tc.desc: Test CalendarMonthPattern JudgeArea
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(CalendarTestNg, CalendarMonthPatternTest003, TestSize.Level1)
1172 {
1173 auto* stack = ViewStackProcessor::GetInstance();
1174 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140891002() 1175 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
1176 auto calendarMonthPattern = frameNode->GetPattern<CalendarMonthPattern>();
1177 ASSERT_NE(calendarMonthPattern, nullptr);
1178 auto paintProperty = frameNode->GetPaintProperty<CalendarPaintProperty>();
1179 ASSERT_NE(paintProperty, nullptr);
1180
1181 for (int i = 0; i < 4; i++) {
1182 double offsetX = 0.0;
1183 double offsetY = 0.0;
1184 float maxWidth = VALID_LENGTH;
1185 float maxHeight = VALID_LENGTH;
1186 if (i == 0) {
1187 offsetX = OFFSET_X;
1188 } else if (i == 1) {
1189 offsetX = -1;
1190 } else if (i == 2) {
1191 offsetX = VALID_LENGTH + 1.0;
1192 } else {
1193 maxWidth = -VALID_LENGTH;
1194 offsetX = -VALID_LENGTH + 1.0;
1195 }
1196
1197 for (int j = 0; j < 4; j++) {
1198 if (j == 0) {
1199 maxHeight = VALID_LENGTH;
1200 offsetY = OFFSET_Y;
1201 } else if (j == 1) {
1202 offsetY = -1;
1203 } else if (j == 2) {
1204 offsetY = VALID_LENGTH + 1.0;
1205 } else {
1206 maxHeight = -VALID_LENGTH;
1207 offsetY = -VALID_LENGTH + 1.0;
1208 }
1209
1210 for (int k = 3; k >= 0; k--) {
1211 if (k == 3) {
1212 frameNode->geometryNode_->SetFrameSize(SizeF(maxWidth, maxHeight));
1213 paintProperty->UpdateDayHeight(Dimension(0.0));
1214 paintProperty->UpdateDayWidth(Dimension(0.0));
1215 EXPECT_EQ(calendarMonthPattern->JudgeArea(Offset(offsetX, offsetY)), -1);
1216 } else if (k == 2) {
1217 frameNode->geometryNode_->SetFrameSize(SizeF(maxWidth, maxHeight));
1218 paintProperty->UpdateDayHeight(Dimension(VALID_LENGTH));
1219 paintProperty->UpdateDayWidth(Dimension(0.0));
1220 EXPECT_EQ(calendarMonthPattern->JudgeArea(Offset(offsetX, offsetY)), -1);
1221 } else if (k == 1) {
1222 frameNode->geometryNode_->SetFrameSize(SizeF(maxWidth, maxHeight));
1223 paintProperty->UpdateDayHeight(Dimension(0.0));
1224 paintProperty->UpdateDayWidth(Dimension(VALID_LENGTH));
1225 EXPECT_EQ(calendarMonthPattern->JudgeArea(Offset(offsetX, offsetY)), -1);
1226 } else {
1227 frameNode->geometryNode_->SetFrameSize(SizeF(maxWidth, maxHeight));
1228 paintProperty->UpdateDayHeight(Dimension(VALID_LENGTH));
1229 paintProperty->UpdateDayWidth(Dimension(VALID_LENGTH));
1230 if (i == 0 && j == 0) {
1231 EXPECT_EQ(calendarMonthPattern->JudgeArea(Offset(offsetX, offsetY)), 0);
1232 } else {
1233 EXPECT_EQ(calendarMonthPattern->JudgeArea(Offset(offsetX, offsetY)), -1);
1234 }
1235 }
1236 }
1237 }
1238 }
1239
1240 frameNode->geometryNode_->SetFrameSize(SizeF(VALID_LENGTH, VALID_LENGTH));
1241 paintProperty->UpdateDayHeight(Dimension(VALID_LENGTH));
1242 paintProperty->UpdateDayWidth(Dimension(VALID_LENGTH));
1243 AceApplicationInfo::GetInstance().isRightToLeft_ = true;
1244 EXPECT_EQ(calendarMonthPattern->JudgeArea(Offset(OFFSET_X, OFFSET_Y)), 6);
1245 AceApplicationInfo::GetInstance().isRightToLeft_ = false;
1246 EXPECT_EQ(calendarMonthPattern->JudgeArea(Offset(OFFSET_X, OFFSET_Y)), 0);
1247 }
1248
1249 /**
1250 * @tc.name: CalendarMonthPatternTest004
1251 * @tc.desc: Test CalendarMonthPattern GetDaySize
1252 * @tc.type: FUNC
1253 */
1254 HWTEST_F(CalendarTestNg, CalendarMonthPatternTest004, TestSize.Level1)
1255 {
1256 auto* stack = ViewStackProcessor::GetInstance();
1257 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140891102() 1258 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
1259 auto calendarMonthPattern = frameNode->GetPattern<CalendarMonthPattern>();
1260 ASSERT_NE(calendarMonthPattern, nullptr);
1261
1262 RefPtr<CalendarTheme> theme = MockPipelineContext::GetCurrent()->GetTheme<CalendarTheme>();
1263 EXPECT_EQ(calendarMonthPattern->GetDaySize(theme).ConvertToVp(), 0.0);
1264 }
1265
1266 /**
1267 * @tc.name: CalendarMonthPatternTest005
1268 * @tc.desc: Test CalendarMonthPattern VirtualNode
1269 * @tc.type: FUNC
1270 */
1271 HWTEST_F(CalendarTestNg, CalendarMonthPatternTest005, TestSize.Level1)
1272 {
1273 auto* stack = ViewStackProcessor::GetInstance();
1274 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140891202() 1275 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
1276 auto calendarMonthPattern = frameNode->GetPattern<CalendarMonthPattern>();
1277 ASSERT_NE(calendarMonthPattern, nullptr);
1278 /**
1279 * @tc.case: case1 InitVirtualNode.
1280 */
1281 CalendarDay today;
1282 today.month.month = JUMP_MONTH;
1283 today.month.year = JUMP_YEAR;
1284 today.day = DAY_VALUE;
1285 calendarMonthPattern->calendarDay_ = today;
1286 ObtainedMonth obtainedMonth;
1287 for (int i = DAY_VALUE; i < WEEKS_COUNT_SIX; i++) {
1288 CalendarDay calendarDay;
1289 calendarDay.month.month = JUMP_MONTH;
1290 calendarDay.month.year = JUMP_YEAR;
1291 calendarDay.day = i;
1292 calendarDay.index = i;
1293 obtainedMonth.days.emplace_back(calendarDay);
1294 }
1295 calendarMonthPattern->obtainedMonth_ = obtainedMonth;
1296 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
1297 calendarMonthPattern->CreateNodePaintMethod();
1298 EXPECT_TRUE(calendarMonthPattern->accessibilityPropertyVec_.size() > 0);
1299 /**
1300 * @tc.case: case2 HandleAccessibilityHoverEvent.
1301 */
1302 AccessibilityHoverInfo hoverInfo;
1303 hoverInfo.SetActionType(AccessibilityHoverAction::HOVER_ENTER);
1304 calendarMonthPattern->HandleAccessibilityHoverEvent(true, hoverInfo);
1305
1306 EXPECT_TRUE(calendarMonthPattern->isOnHover_ == true);
1307 calendarMonthPattern->accessibilityPropertyVec_[0]->OnAccessibilityFocusCallback(true);
1308 auto accessibilityProperty = frameNode->GetAccessibilityProperty<AccessibilityProperty>();
1309 ASSERT_NE(accessibilityProperty, nullptr);
1310 EXPECT_TRUE(calendarMonthPattern->isOnHover_ == true);
1311 AccessibilityHoverInfo enHoverinfo;
1312 enHoverinfo.SetActionType(AccessibilityHoverAction::HOVER_CANCEL);
1313 calendarMonthPattern->HandleAccessibilityHoverEvent(false, enHoverinfo);
1314 EXPECT_TRUE(calendarMonthPattern->isOnHover_ == false);
1315 /**
1316 * @tc.case: case3 SetVirtualNodeUserSelected.
1317 */
1318 std::string infoDetail;
__anone77140891302(std::string info) 1319 auto initRequestDataEvent = [&](std::string info) { infoDetail = std::move(info); };
1320 auto calendarMonthEventHub = frameNode->GetEventHub<CalendarEventHub>();
1321 ASSERT_NE(calendarMonthEventHub, nullptr);
1322 calendarMonthEventHub->SetSelectedChangeEvent(initRequestDataEvent);
1323 calendarMonthPattern->OnModifyDone();
1324 calendarMonthPattern->SetVirtualNodeUserSelected(0);
1325 auto json = JsonUtil::ParseJsonString(infoDetail);
1326 EXPECT_EQ(json->GetInt("day"), obtainedMonth.days[0].day);
1327 EXPECT_EQ(json->GetInt("month"), obtainedMonth.days[0].month.month);
1328 EXPECT_EQ(json->GetInt("year"), obtainedMonth.days[0].month.year);
1329 }
1330
1331 /**
1332 * @tc.name: CalendarLayoutAlgorithmTest001
1333 * @tc.desc: Test CalendarLayoutAlgorithm MeasureContent
1334 * @tc.type: FUNC
1335 */
1336 HWTEST_F(CalendarTestNg, CalendarLayoutAlgorithmTest001, TestSize.Level1)
1337 {
1338 auto* stack = ViewStackProcessor::GetInstance();
1339 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140891402() 1340 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarMonthPattern>(); });
1341 auto layoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
1342 frameNode, AceType::MakeRefPtr<GeometryNode>(), AceType::MakeRefPtr<LayoutProperty>());
1343 auto pipeline = frameNode->GetContextRefPtr();
1344 ASSERT_NE(pipeline, nullptr);
1345 pipeline->rootWidth_ = OFFSET_X;
1346 pipeline->rootHeight_ = OFFSET_Y;
1347
1348 CalendarLayoutAlgorithm calendarLayoutAlgorithm;
1349 LayoutConstraintF contentConstraint;
1350 EXPECT_EQ(
1351 calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Width(), OFFSET_X);
1352 EXPECT_EQ(
1353 calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Height(), OFFSET_Y);
1354
1355 contentConstraint.maxSize.SetWidth(VALID_LENGTH);
1356 contentConstraint.maxSize.SetHeight(Infinity<float>());
1357 EXPECT_EQ(
1358 calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Width(), OFFSET_X);
1359 EXPECT_EQ(
1360 calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Height(), OFFSET_Y);
1361
1362 contentConstraint.maxSize.SetWidth(Infinity<float>());
1363 contentConstraint.maxSize.SetHeight(VALID_LENGTH);
1364 EXPECT_EQ(
1365 calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Width(), OFFSET_X);
1366 EXPECT_EQ(
1367 calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Height(), OFFSET_Y);
1368
1369 contentConstraint.maxSize.SetWidth(VALID_LENGTH);
1370 contentConstraint.maxSize.SetHeight(VALID_LENGTH);
1371 EXPECT_EQ(calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Width(),
1372 VALID_LENGTH);
1373 EXPECT_EQ(calendarLayoutAlgorithm.MeasureContent(contentConstraint, AceType::RawPtr(layoutWrapper))->Height(),
1374 VALID_LENGTH);
1375 }
1376
1377 /**
1378 * @tc.name: CalendarPaintMethodTest001
1379 * @tc.desc: Test CalendarPaintMethod GetContentDrawFunction
1380 * @tc.type: FUNC
1381 */
1382 HWTEST_F(CalendarTestNg, CalendarPaintMethodTest001, TestSize.Level1)
1383 {
1384 auto* stack = ViewStackProcessor::GetInstance();
1385 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140891502() 1386 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
1387 auto calendarPaintProperty = frameNode->GetPaintProperty<PaintProperty>();
1388 ASSERT_NE(calendarPaintProperty, nullptr);
1389 auto geometryNode = frameNode->GetGeometryNode();
1390 ASSERT_NE(geometryNode, nullptr);
1391 auto renderContext = frameNode->GetRenderContext();
1392 ASSERT_NE(renderContext, nullptr);
1393 auto* paintWrapper = new PaintWrapper(renderContext, geometryNode, calendarPaintProperty);
1394 ASSERT_NE(paintWrapper, nullptr);
1395
1396 ObtainedMonth obtainedMonth;
1397 CalendarDay calendarDay;
1398 CalendarPaintMethod calendarPaintMethod(obtainedMonth, calendarDay);
1399 auto paintFunc = calendarPaintMethod.GetContentDrawFunction(paintWrapper);
1400 EXPECT_EQ(calendarPaintMethod.frameSize_, geometryNode->GetFrameSize());
1401 }
1402
1403 /**
1404 * @tc.name: CalendarPaintMethodTest002
1405 * @tc.desc: Test CalendarPaintMethod PaintContent
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(CalendarTestNg, CalendarPaintMethodTest002, TestSize.Level1)
1409 {
1410 auto calendarPaintProperty = AceType::MakeRefPtr<CalendarPaintProperty>();
1411 ASSERT_NE(calendarPaintProperty, nullptr);
1412 ObtainedMonth obtainedMonth;
1413 CalendarDay calendarDay;
1414 CalendarPaintMethod calendarPaintMethod(obtainedMonth, calendarDay);
1415 Testing::MockCanvas rsCanvas;
1416 calendarPaintMethod.PaintContent(rsCanvas, calendarPaintProperty);
1417 EXPECT_TRUE(calendarPaintMethod.obtainedMonth_.days.empty());
1418 EXPECT_TRUE(calendarPaintMethod.calendarDays_.empty());
1419 }
1420
1421 /**
1422 * @tc.name: CalendarPaintMethodTest003
1423 * @tc.desc: Test CalendarPaintMethod DrawCalendar
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(CalendarTestNg, CalendarPaintMethodTest003, TestSize.Level1)
1427 {
1428 ObtainedMonth obtainedMonth;
1429 CalendarDay calendarDay;
1430 CalendarMonth calendarMonth;
1431 calendarDay.month = calendarMonth;
1432 CalendarPaintMethod calendarPaintMethod(obtainedMonth, calendarDay);
1433 calendarPaintMethod.currentMonth_ = calendarMonth;
1434
1435 Testing::MockCanvas rsCanvas;
1436 EXPECT_CALL(rsCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rsCanvas));
1437 EXPECT_CALL(rsCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rsCanvas));
1438 EXPECT_CALL(rsCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rsCanvas));
1439 EXPECT_CALL(rsCanvas, DetachPen()).WillRepeatedly(ReturnRef(rsCanvas));
1440 calendarDay.focused = true;
1441 calendarPaintMethod.DrawCalendar(
1442 rsCanvas, Offset(OFFSET_X, OFFSET_Y), Offset(VALID_LENGTH, VALID_LENGTH), calendarDay);
1443 EXPECT_TRUE(calendarDay.focused && calendarDay.month.month == calendarPaintMethod.currentMonth_.month);
1444 EXPECT_TRUE(calendarPaintMethod.IsToday(calendarDay));
1445
1446 calendarPaintMethod.calendarDay_.day = calendarDay.day + 1;
1447 calendarPaintMethod.DrawCalendar(
1448 rsCanvas, Offset(OFFSET_X, OFFSET_Y), Offset(VALID_LENGTH, VALID_LENGTH), calendarDay);
1449 EXPECT_FALSE(calendarPaintMethod.IsToday(calendarDay));
1450
1451 calendarPaintMethod.showLunar_ = false;
1452 calendarDay.lunarDay.clear();
1453 calendarPaintMethod.DrawCalendar(
1454 rsCanvas, Offset(OFFSET_X, OFFSET_Y), Offset(VALID_LENGTH, VALID_LENGTH), calendarDay);
1455 EXPECT_FALSE(calendarPaintMethod.showLunar_ && !calendarDay.lunarDay.empty());
1456
1457 calendarPaintMethod.showLunar_ = false;
1458 calendarDay.lunarDay = LUNAR_DAY_VALUE;
1459 calendarPaintMethod.DrawCalendar(
1460 rsCanvas, Offset(OFFSET_X, OFFSET_Y), Offset(VALID_LENGTH, VALID_LENGTH), calendarDay);
1461 EXPECT_FALSE(calendarPaintMethod.showLunar_ && !calendarDay.lunarDay.empty());
1462
1463 calendarPaintMethod.showLunar_ = true;
1464 calendarDay.lunarDay.clear();
1465 calendarPaintMethod.DrawCalendar(
1466 rsCanvas, Offset(OFFSET_X, OFFSET_Y), Offset(VALID_LENGTH, VALID_LENGTH), calendarDay);
1467 EXPECT_FALSE(calendarPaintMethod.showLunar_ && !calendarDay.lunarDay.empty());
1468
1469 calendarPaintMethod.showLunar_ = true;
1470 calendarDay.lunarDay = LUNAR_DAY_VALUE;
1471 calendarPaintMethod.DrawCalendar(
1472 rsCanvas, Offset(OFFSET_X, OFFSET_Y), Offset(VALID_LENGTH, VALID_LENGTH), calendarDay);
1473 EXPECT_TRUE(calendarPaintMethod.showLunar_ && !calendarDay.lunarDay.empty());
1474 }
1475
1476 /**
1477 * @tc.name: CalendarPaintMethodTest004
1478 * @tc.desc: Test CalendarPaintMethod PaintDay
1479 * @tc.type: FUNC
1480 */
1481 HWTEST_F(CalendarTestNg, CalendarPaintMethodTest004, TestSize.Level1)
1482 {
1483 ObtainedMonth obtainedMonth;
1484 CalendarDay calendarDay;
1485 CalendarMonth calendarMonth;
1486 calendarDay.month = calendarMonth;
1487 CalendarPaintMethod calendarPaintMethod(obtainedMonth, calendarDay);
1488 calendarPaintMethod.currentMonth_ = calendarMonth;
1489
1490 Testing::MockCanvas rsCanvas;
1491 RSTextStyle rsTextStyle;
1492 calendarDay.dayMark.clear();
1493 calendarPaintMethod.showHoliday_ = false;
1494 calendarPaintMethod.PaintDay(rsCanvas, Offset(OFFSET_X, OFFSET_Y), calendarDay, rsTextStyle);
1495 EXPECT_FALSE(!calendarDay.dayMark.empty() && calendarPaintMethod.showHoliday_);
1496
1497 calendarDay.dayMark = WORK_DAY_MARK;
1498 calendarPaintMethod.PaintDay(rsCanvas, Offset(OFFSET_X, OFFSET_Y), calendarDay, rsTextStyle);
1499 EXPECT_FALSE(!calendarDay.dayMark.empty() && calendarPaintMethod.showHoliday_);
1500
1501 calendarPaintMethod.showHoliday_ = true;
1502 calendarPaintMethod.PaintDay(rsCanvas, Offset(OFFSET_X, OFFSET_Y), calendarDay, rsTextStyle);
1503 EXPECT_TRUE(!calendarDay.dayMark.empty() && calendarPaintMethod.showHoliday_);
1504
1505 calendarDay.dayMark = OFF_DAY_MARK;
1506 calendarPaintMethod.PaintDay(rsCanvas, Offset(OFFSET_X, OFFSET_Y), calendarDay, rsTextStyle);
1507
1508 calendarPaintMethod.currentMonth_.month = calendarDay.month.month + 1;
1509 calendarDay.focused = true;
1510 calendarPaintMethod.PaintDay(rsCanvas, Offset(OFFSET_X, OFFSET_Y), calendarDay, rsTextStyle);
1511
1512 calendarDay.dayMark = WORK_DAY_MARK;
1513 calendarDay.touched = true;
1514 calendarPaintMethod.PaintDay(rsCanvas, Offset(OFFSET_X, OFFSET_Y), calendarDay, rsTextStyle);
1515 }
1516
1517 /**
1518 * @tc.name: CalendarPaintMethodTest005
1519 * @tc.desc: Create calendar, and check today off or work status.
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(CalendarTestNg, CalendarPaintMethodTest005, TestSize.Level1)
1523 {
1524 /**
1525 * @tc.steps: step1. Create Calendar
1526 * @tc.expected: step1. Create Calendar successfully.
1527 */
1528 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
1529 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
1530 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<CalendarTheme>()));
1531
1532 RefPtr<CalendarTheme> theme = MockPipelineContext::GetCurrent()->GetTheme<CalendarTheme>();
1533 theme->GetCalendarTheme().workDayMarkColor = Color::RED;
1534 theme->GetCalendarTheme().offDayMarkColor = Color::BLUE;
1535
1536 // Today style.
1537 TodayStyle todayStyle;
1538 Color focusedDayColor = Color::GREEN;
1539 todayStyle.UpdateFocusedDayColor(focusedDayColor);
1540 Color focusedLunarColor = Color::WHITE;
1541 todayStyle.UpdateFocusedLunarColor(focusedLunarColor);
1542 Color focusedAreaBackgroundColor = Color::BLUE;
1543 todayStyle.UpdateFocusedAreaBackgroundColor(focusedAreaBackgroundColor);
1544 Dimension focusedAreaRadius = Dimension(DEFAULT_FOCUS_RADIUS, DimensionUnit::VP);
1545 todayStyle.UpdateFocusedAreaRadius(focusedAreaRadius);
1546
1547 // Day style of current month.
1548 CalendarModelNG calendarModelNG;
1549 CurrentDayStyle dayStyle;
1550 dayStyle.UpdateDayColor(Color::BLACK);
1551
1552 CalendarData calendarData;
1553 auto calendarControllerNg = AceType::MakeRefPtr<CalendarControllerNg>();
1554 calendarData.controller = calendarControllerNg;
1555 calendarModelNG.Create(calendarData);
1556 calendarModelNG.SetTodayStyle(todayStyle);
1557 calendarModelNG.SetCurrentDayStyle(dayStyle);
1558 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1559
1560 EXPECT_EQ(element->GetTag(), V2::CALENDAR_ETS_TAG);
1561 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1562 auto calendarPattern = frameNode->GetPattern<CalendarPattern>();
1563 auto swiperNode = frameNode->GetChildren().front();
1564 auto calendarFrameNode = AceType::DynamicCast<FrameNode>(swiperNode->GetChildren().front());
1565 auto calendarPaintProperty = calendarFrameNode->GetPaintProperty<CalendarPaintProperty>();
1566
1567 ObtainedMonth obtainedMonth;
1568 obtainedMonth.year = JUMP_YEAR;
1569 obtainedMonth.month = JUMP_MONTH;
1570 obtainedMonth.firstDayIndex = FIRST_DAY_INDEX_VALUE;
1571
1572 // Add 31 days.
1573 std::vector<CalendarDay> days;
1574 for (int32_t i = 0; i < 31; i++) {
1575 CalendarDay day;
1576 day.index = i;
1577 day.month.year = JUMP_YEAR;
1578 day.month.month = JUMP_MONTH;
1579 day.day = i + 1;
1580 if (i == 0) {
1581 day.focused = true;
1582 }
1583 // Saturday and Sunday set off days. Others set work days.
1584 if ((i % 6 == 5) || (i % 6 == 0)) {
1585 day.dayMark = "off";
1586 } else {
1587 day.dayMark = "work";
1588 }
1589 days.emplace_back(std::move(day));
1590 }
1591 obtainedMonth.days = days;
1592
1593 calendarModelNG.SetCurrentData(obtainedMonth);
1594 calendarModelNG.SetPreData(obtainedMonth);
1595 calendarModelNG.SetNextData(obtainedMonth);
1596
1597 CalendarDay calendarDay;
1598 calendarDay.index = 0;
1599 calendarDay.day = 1;
1600 calendarDay.today = false;
1601 calendarDay.focused = true;
1602 calendarDay.touched = true;
1603
1604 /**
1605 * @tc.steps: step2. Set the first day focused, check the first day text style.
1606 * @tc.expected: step2. The text color is 0xffffffff.
1607 */
1608 CalendarMonth calendarMonth;
1609 calendarMonth.year = JUMP_YEAR;
1610 calendarMonth.month = JUMP_MONTH;
1611 calendarDay.month = calendarMonth;
1612 calendarModelNG.SetCalendarDay(calendarDay);
1613
1614 auto paintMethod = AceType::MakeRefPtr<CalendarPaintMethod>(obtainedMonth, calendarDay);
1615 Testing::MockCanvas rsCanvas;
1616 paintMethod->SetCalendarTheme(calendarPaintProperty);
1617
1618 RSTextStyle workOffTextStyle;
1619 /**
1620 * @tc.steps: step3. Set the first day focused, check the offWork color.
1621 * @tc.expected: step3. The focused text color is same as text color, expected 0xff00ff00.
1622 */
1623 paintMethod->SetOffWorkTextStyle(workOffTextStyle, obtainedMonth.days[0]);
1624 #ifndef USE_GRAPHIC_TEXT_GINE
1625 EXPECT_EQ(workOffTextStyle.color_, RSColor(0xff00ff00));
1626 #else
1627 EXPECT_EQ(workOffTextStyle.color, RSColor(0xff00ff00));
1628 #endif
1629
1630 /**
1631 * @tc.steps: step4. Check the offWork color.
1632 * @tc.expected: step4. The text color expected 0xffff0000, it is work.
1633 */
1634 paintMethod->SetOffWorkTextStyle(workOffTextStyle, obtainedMonth.days[2]);
1635 #ifndef USE_GRAPHIC_TEXT_GINE
1636 EXPECT_EQ(workOffTextStyle.color_, RSColor(0xffff0000));
1637 #else
1638 EXPECT_EQ(workOffTextStyle.color, RSColor(0xffff0000));
1639 #endif
1640
1641 /**
1642 * @tc.steps: step5. Check the offWork color.
1643 * @tc.expected: step5. The text color expected 0xffff0000, it is off.
1644 */
1645 paintMethod->SetOffWorkTextStyle(workOffTextStyle, obtainedMonth.days[5]);
1646 #ifndef USE_GRAPHIC_TEXT_GINE
1647 EXPECT_EQ(workOffTextStyle.color_, RSColor(0xff0000ff));
1648 #else
1649 EXPECT_EQ(workOffTextStyle.color, RSColor(0xff0000ff));
1650 #endif
1651
1652 /**
1653 * @tc.steps: step6. Check the offWork color.
1654 * @tc.expected: step6. The text color expected 0xffff0000, it is off.
1655 */
1656 paintMethod->SetOffWorkTextStyle(workOffTextStyle, obtainedMonth.days[6]);
1657 #ifndef USE_GRAPHIC_TEXT_GINE
1658 EXPECT_EQ(workOffTextStyle.color_, RSColor(0xff0000ff));
1659 #else
1660 EXPECT_EQ(workOffTextStyle.color, RSColor(0xff0000ff));
1661 #endif
1662
1663 /**
1664 * @tc.steps: step7. Check the offWork color.
1665 * @tc.expected: step7. The text color expected 0xffff0000, it is work.
1666 */
1667 paintMethod->SetOffWorkTextStyle(workOffTextStyle, obtainedMonth.days[7]);
1668 #ifndef USE_GRAPHIC_TEXT_GINE
1669 EXPECT_EQ(workOffTextStyle.color_, RSColor(0xffff0000));
1670 #else
1671 EXPECT_EQ(workOffTextStyle.color, RSColor(0xffff0000));
1672 #endif
1673
1674 /**
1675 * @tc.steps: step8. Check the offWork color.
1676 * @tc.expected: step8. The text color expected 0xffff0000, it is work.
1677 */
1678 paintMethod->SetOffWorkTextStyle(workOffTextStyle, obtainedMonth.days[9]);
1679 #ifndef USE_GRAPHIC_TEXT_GINE
1680 EXPECT_EQ(workOffTextStyle.color_, RSColor(0xffff0000));
1681 #else
1682 EXPECT_EQ(workOffTextStyle.color, RSColor(0xffff0000));
1683 #endif
1684 }
1685
1686 /**
1687 * @tc.name: CalendarPaintMethodTest006
1688 * @tc.desc: Test CalendarPaintMethod DrawWeekAndDates
1689 * @tc.type: FUNC
1690 */
1691 HWTEST_F(CalendarTestNg, CalendarPaintMethodTest006, TestSize.Level1)
1692 {
1693 auto* stack = ViewStackProcessor::GetInstance();
1694 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone77140891602() 1695 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
1696 auto calendarPaintProperty = frameNode->GetPaintProperty<PaintProperty>();
1697 ASSERT_NE(calendarPaintProperty, nullptr);
1698 auto geometryNode = frameNode->GetGeometryNode();
1699 ASSERT_NE(geometryNode, nullptr);
1700 auto renderContext = frameNode->GetRenderContext();
1701 ASSERT_NE(renderContext, nullptr);
1702 auto* paintWrapper = new PaintWrapper(renderContext, geometryNode, calendarPaintProperty);
1703 ASSERT_NE(paintWrapper, nullptr);
1704
1705 ObtainedMonth obtainedMonth;
1706 CalendarDay calendarDay;
1707 auto paintMethod = AceType::MakeRefPtr<CalendarPaintMethod>(obtainedMonth, calendarDay);
1708 Testing::MockCanvas rsCanvas;
1709 AceApplicationInfo::GetInstance().isRightToLeft_ = true;
1710 paintMethod->DrawWeekAndDates(rsCanvas, Offset(0, 0));
1711
1712 AceApplicationInfo::GetInstance().isRightToLeft_ = false;
1713 paintMethod->DrawWeekAndDates(rsCanvas, Offset(0, 0));
1714 }
1715 } // namespace OHOS::Ace::NG
1716