1 /*
2 * Copyright (c) 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
26 #include "test/mock/base/mock_task_executor.h"
27 #include "test/mock/core/common/mock_theme_manager.h"
28 #include "test/mock/core/pipeline/mock_pipeline_context.h"
29 #include "test/mock/core/render/mock_render_context.h"
30
31 #include "base/geometry/axis.h"
32 #include "base/geometry/dimension.h"
33 #include "base/geometry/ng/size_t.h"
34 #include "base/geometry/offset.h"
35 #include "base/json/json_util.h"
36 #include "base/memory/ace_type.h"
37 #include "base/utils/utils.h"
38 #include "core/components/calendar/calendar_theme.h"
39 #include "core/components/common/properties/shadow_config.h"
40 #include "core/components/theme/icon_theme.h"
41 #include "core/components_ng/base/view_stack_processor.h"
42 #include "core/components_ng/event/focus_hub.h"
43 #include "core/components_ng/pattern/button/button_pattern.h"
44 #include "core/components_ng/pattern/calendar/calendar_month_pattern.h"
45 #include "core/components_ng/pattern/calendar/calendar_paint_property.h"
46 #include "core/components_ng/pattern/calendar/calendar_pattern.h"
47 #include "core/components_ng/pattern/calendar_picker/calendar_dialog_pattern.h"
48 #include "core/components_ng/pattern/calendar_picker/calendar_dialog_view.h"
49 #include "core/components_ng/pattern/calendar_picker/calendar_picker_event_hub.h"
50 #include "core/components_ng/pattern/calendar_picker/calendar_picker_layout_algorithm.h"
51 #include "core/components_ng/pattern/calendar_picker/calendar_picker_layout_property.h"
52 #include "core/components_ng/pattern/calendar_picker/calendar_picker_model_ng.h"
53 #include "core/components_ng/pattern/dialog/dialog_view.h"
54 #include "core/components_ng/pattern/divider/divider_pattern.h"
55 #include "core/components_ng/pattern/flex/flex_layout_pattern.h"
56 #include "core/components_ng/pattern/flex/flex_layout_property.h"
57 #include "core/components_ng/pattern/image/image_pattern.h"
58 #include "core/components_ng/pattern/picker/date_time_animation_controller.h"
59 #include "core/components_ng/pattern/picker/datepicker_pattern.h"
60 #include "core/components_ng/pattern/picker/datepicker_row_layout_property.h"
61 #include "core/components_ng/pattern/stack/stack_pattern.h"
62 #include "core/components_ng/pattern/swiper/swiper_pattern.h"
63 #include "core/components_ng/pattern/text/text_layout_property.h"
64 #include "core/components_ng/pattern/text/text_pattern.h"
65 #include "core/components_ng/pattern/text_field/text_field_pattern.h"
66 #include "core/components_ng/property/measure_property.h"
67 #include "core/components_v2/inspector/inspector_constants.h"
68 #include "core/pipeline/base/element_register.h"
69 #include "core/pipeline_ng/ui_task_scheduler.h"
70
71 #undef private
72 #undef protected
73
74 using namespace testing;
75 using namespace testing::ext;
76 namespace OHOS::Ace::NG {
77 namespace {
78 const InspectorFilter filter;
79 constexpr Dimension TEST_SETTING_RADIUS = Dimension(10.0, DimensionUnit::VP);
80 constexpr int32_t YEAR_INDEX = 0;
81 constexpr int32_t MONTH_INDEX = 2;
82 } // namespace
83 class CalendarPickerTestNg : public testing::Test {
84 public:
85 static void SetUpTestCase();
86 static void TearDownTestCase();
87 void MockPipelineContextGetTheme();
88
89 protected:
90 static void CreateCalendarPicker();
91 static RefPtr<FrameNode> CalendarDialogShow(RefPtr<FrameNode> entryNode);
92 };
93
SetUpTestCase()94 void CalendarPickerTestNg::SetUpTestCase()
95 {
96 MockPipelineContext::SetUp();
97 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
98 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly([](ThemeType type) -> RefPtr<Theme> {
99 if (type == CalendarTheme::TypeId()) {
100 return AceType::MakeRefPtr<CalendarTheme>();
101 } else if (type == IconTheme::TypeId()) {
102 return AceType::MakeRefPtr<IconTheme>();
103 } else if (type == DialogTheme::TypeId()) {
104 return AceType::MakeRefPtr<DialogTheme>();
105 } else {
106 return AceType::MakeRefPtr<PickerTheme>();
107 }
108 });
109 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
110 }
111
TearDownTestCase()112 void CalendarPickerTestNg::TearDownTestCase()
113 {
114 MockPipelineContext::GetCurrent()->SetThemeManager(nullptr);
115 MockPipelineContext::TearDown();
116 }
117
CreateCalendarPicker()118 void CalendarPickerTestNg::CreateCalendarPicker()
119 {
120 CalendarSettingData settingData;
121 CalendarPickerModelNG calendarPickerModel;
122
123 calendarPickerModel.Create(settingData);
124 DimensionOffset offset;
125 calendarPickerModel.SetEdgeAlign(CalendarEdgeAlign::EDGE_ALIGN_START, offset);
126
127 PickerTextStyle textStyle;
128 calendarPickerModel.SetTextStyle(textStyle);
129 auto onChange = [](const std::string& /* info */) {};
130 calendarPickerModel.SetOnChange(onChange);
131 calendarPickerModel.SetChangeEvent(onChange);
132 }
133
CalendarDialogShow(RefPtr<FrameNode> entryNode)134 RefPtr<FrameNode> CalendarPickerTestNg::CalendarDialogShow(RefPtr<FrameNode> entryNode)
135 {
136 CalendarSettingData settingData;
137 DialogProperties properties;
138 properties.alignment = DialogAlignment::BOTTOM;
139 properties.customStyle = false;
140 properties.offset = DimensionOffset(Offset(0, -1.0f));
141 auto selectedDate = PickerDate(2000, 1, 1);
142 settingData.selectedDate = selectedDate;
143 settingData.dayRadius = TEST_SETTING_RADIUS;
144 settingData.entryNode = entryNode;
145 std::map<std::string, NG::DialogEvent> dialogEvent;
146 std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent;
147 std::vector<ButtonInfo> buttonInfos;
148 auto dialogNode = CalendarDialogView::Show(properties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
149 return dialogNode;
150 }
151
152 /**
153 * @tc.name: CalendarModelNGTest001
154 * @tc.desc: Create Calendar Picker Function Test
155 * @tc.type: FUNC
156 */
157 HWTEST_F(CalendarPickerTestNg, CalendarPickerModelNGTest001, TestSize.Level1)
158 {
159 /**
160 * @tc.steps: step1. Create Calendar Picker
161 * @tc.expected: step1. Create Calendar successfully
162 */
163 CreateCalendarPicker();
164
165 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
166 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
167
168 auto frameNode = AceType::DynamicCast<FrameNode>(element);
169 ASSERT_NE(frameNode, nullptr);
170
171 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
172 ASSERT_NE(pickerPattern, nullptr);
173
174 auto layoutProperty = frameNode->GetLayoutProperty();
175 ASSERT_NE(layoutProperty, nullptr);
176
177 RefPtr<CalendarTheme> theme = MockPipelineContext::GetCurrent()->GetTheme<CalendarTheme>();
178 ASSERT_NE(theme, nullptr);
179
180 auto& borderWidthProp = layoutProperty->GetBorderWidthProperty();
181 ASSERT_NE(borderWidthProp, nullptr);
182 EXPECT_EQ(
183 borderWidthProp->leftDimen.value_or(Dimension(1.0)).ConvertToVp(), theme->GetEntryBorderWidth().ConvertToVp());
184
185 auto renderContext = frameNode->GetRenderContext();
186 ASSERT_NE(renderContext, nullptr);
187
188 auto borderColor = renderContext->GetBorderColor();
189 EXPECT_EQ(borderColor->leftColor->ColorToString(), theme->GetEntryBorderColor().ColorToString());
190
191 /**
192 * @tc.steps: step2. Click Calendar Picker
193 * @tc.expected: step2. Show Calendar Dialog
194 */
195 auto gesture = frameNode->GetOrCreateGestureEventHub();
196 ASSERT_NE(gesture, nullptr);
197
198 auto result = gesture->ActClick();
199 EXPECT_TRUE(result);
200
201 /**
202 * @tc.steps: step3. Handle KEY_TAB on Calendar Picker
203 * @tc.expected: step3. Focus changed
204 */
205 auto eventHub = frameNode->GetFocusHub();
206 ASSERT_NE(eventHub, nullptr);
207 KeyEvent keyEventOne(KeyCode::KEY_TAB, KeyAction::DOWN);
208 result = eventHub->ProcessOnKeyEventInternal(keyEventOne);
209
210 /**
211 * @tc.steps: step4. Hover Calendar Picker
212 * @tc.expected: step4. onHoverEvent execute
213 */
214 pickerPattern->HandleTextHoverEvent(true, YEAR_INDEX);
215
216 pickerPattern->HandleTextHoverEvent(true, MONTH_INDEX);
217 auto contentNode = AceType::DynamicCast<FrameNode>(frameNode->GetFirstChild());
218 ASSERT_NE(contentNode, nullptr);
219 auto textFrameNode = AceType::DynamicCast<FrameNode>(contentNode->GetChildAtIndex(MONTH_INDEX));
220 ASSERT_NE(textFrameNode, nullptr);
221 auto textRenderContext = textFrameNode->GetRenderContext();
222 ASSERT_NE(textRenderContext, nullptr);
223
224 EXPECT_EQ(
225 textRenderContext->GetBackgroundColorValue().ColorToString(), theme->GetBackgroundHoverColor().ColorToString());
226 }
227
228 /**
229 * @tc.name: CalendarPickerModelNGTest002
230 * @tc.desc: SetTextStyle Function Test
231 * @tc.type: FUNC
232 */
233 HWTEST_F(CalendarPickerTestNg, CalendarPickerModelNGTest002, TestSize.Level1)
234 {
235 CalendarSettingData settingData;
236 CalendarPickerModelNG calendarPickerModel;
237
238 calendarPickerModel.Create(settingData);
239 PickerTextStyle textStyle;
240 textStyle.fontSize = Dimension(100);
241 calendarPickerModel.SetTextStyle(textStyle);
242
243 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
244 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
245 }
246
247 /**
248 * @tc.name: CalendarPickerModelNGTest003
249 * @tc.desc: SetTextStyle Function Test
250 * @tc.type: FUNC
251 */
252 HWTEST_F(CalendarPickerTestNg, CalendarPickerModelNGTest003, TestSize.Level1)
253 {
254 CalendarSettingData settingData;
255 CalendarPickerModelNG calendarPickerModel;
256
257 calendarPickerModel.Create(settingData);
258 PickerTextStyle textStyle;
259 textStyle.fontSize = Dimension();
260 calendarPickerModel.SetTextStyle(textStyle);
261
262 textStyle.fontSize = Dimension(100);
263 calendarPickerModel.SetTextStyle(textStyle);
264
265 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
266 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
267 }
268
269 /**
270 * @tc.name: CalendarPickerModelNGTest004
271 * @tc.desc: Create Calendar Picker Function Test
272 * @tc.type: FUNC
273 */
274 HWTEST_F(CalendarPickerTestNg, CalendarPickerModelNGTest004, TestSize.Level1)
275 {
276 const std::string language = "false";
277 const std::string countryOrRegion = "";
278 const std::string script = "";
279 const std::string keywordsAndValues = "";
280 const std::string selected = "";
281 Localization::GetInstance()->SetLocaleImpl(language, countryOrRegion, script, selected, keywordsAndValues);
282
283 CalendarSettingData settingData;
284 CalendarPickerModelNG calendarPickerModel;
285
286 calendarPickerModel.Create(settingData);
287 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
288 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
289 auto frameNode = AceType::DynamicCast<FrameNode>(element);
290 ASSERT_NE(frameNode, nullptr);
291 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
292 ASSERT_NE(pickerPattern, nullptr);
293
294 auto json = JsonUtil::Create(true);
295 json->Put("year", 2000);
296 json->Put("month", 2);
297 json->Put("day", 29);
298 pickerPattern->SetDate(json->ToString());
299 auto yearTextNode = calendarPickerModel.GetYearNode(AceType::RawPtr(frameNode));
300 auto yearTextLayoutProperty = yearTextNode->GetLayoutProperty<TextLayoutProperty>();
301 EXPECT_EQ(yearTextLayoutProperty->GetContentValue(), "2000");
302
303 auto monthTextNode = calendarPickerModel.GetMonthNode(AceType::RawPtr(frameNode));
304 auto monthTextLayoutProperty = monthTextNode->GetLayoutProperty<TextLayoutProperty>();
305 EXPECT_EQ(monthTextLayoutProperty->GetContentValue(), "02");
306
307 auto dayTextNode = calendarPickerModel.GetDayNode(AceType::RawPtr(frameNode));
308 auto dayTextLayoutProperty = dayTextNode->GetLayoutProperty<TextLayoutProperty>();
309 EXPECT_EQ(dayTextLayoutProperty->GetContentValue(), "29");
310 }
311
312 /**
313 * @tc.name: CalendarPickerModelNGTest005
314 * @tc.desc: Create Calendar Picker Function Test
315 * @tc.type: FUNC
316 */
317 HWTEST_F(CalendarPickerTestNg, CalendarPickerModelNGTest005, TestSize.Level1)
318 {
319 const std::string language = "zh";
320 const std::string countryOrRegion = "";
321 const std::string script = "";
322 const std::string keywordsAndValues = "";
323 const std::string selected = "";
324 Localization::GetInstance()->SetLocaleImpl(language, countryOrRegion, script, selected, keywordsAndValues);
325
326 CalendarSettingData settingData;
327 CalendarPickerModelNG calendarPickerModel;
328
329 calendarPickerModel.Create(settingData);
330 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
331 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
332 auto frameNode = AceType::DynamicCast<FrameNode>(element);
333 ASSERT_NE(frameNode, nullptr);
334 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
335 ASSERT_NE(pickerPattern, nullptr);
336
337 auto json = JsonUtil::Create(true);
338 json->Put("year", 2000);
339 json->Put("month", 2);
340 json->Put("day", 29);
341 pickerPattern->SetDate(json->ToString());
342
343 auto yearTextNode = calendarPickerModel.GetYearNode(AceType::RawPtr(frameNode));
344 auto yearTextLayoutProperty = yearTextNode->GetLayoutProperty<TextLayoutProperty>();
345 EXPECT_EQ(yearTextLayoutProperty->GetContentValue(), "2000");
346
347 auto monthTextNode = calendarPickerModel.GetMonthNode(AceType::RawPtr(frameNode));
348 auto monthTextLayoutProperty = monthTextNode->GetLayoutProperty<TextLayoutProperty>();
349 EXPECT_EQ(monthTextLayoutProperty->GetContentValue(), "02");
350
351 auto dayTextNode = calendarPickerModel.GetDayNode(AceType::RawPtr(frameNode));
352 auto dayTextLayoutProperty = dayTextNode->GetLayoutProperty<TextLayoutProperty>();
353 EXPECT_EQ(dayTextLayoutProperty->GetContentValue(), "29");
354 }
355
356 /**
357 * @tc.name: CalendarPickerModelNGTest006
358 * @tc.desc: Create Calendar Picker Function Test
359 * @tc.type: FUNC
360 */
361 HWTEST_F(CalendarPickerTestNg, CalendarPickerModelNGTest006, TestSize.Level1)
362 {
363 const std::string language = "ug";
364 const std::string countryOrRegion = "";
365 const std::string script = "";
366 const std::string keywordsAndValues = "";
367 const std::string selected = "";
368 Localization::GetInstance()->SetLocaleImpl(language, countryOrRegion, script, selected, keywordsAndValues);
369
370 CalendarSettingData settingData;
371 CalendarPickerModelNG calendarPickerModel;
372
373 calendarPickerModel.Create(settingData);
374 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
375 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
376 auto frameNode = AceType::DynamicCast<FrameNode>(element);
377 ASSERT_NE(frameNode, nullptr);
378 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
379 ASSERT_NE(pickerPattern, nullptr);
380
381 auto json = JsonUtil::Create(true);
382 json->Put("year", 2000);
383 json->Put("month", 2);
384 json->Put("day", 29);
385 pickerPattern->SetDate(json->ToString());
386
387 auto yearTextNode = calendarPickerModel.GetYearNode(AceType::RawPtr(frameNode));
388 auto yearTextLayoutProperty = yearTextNode->GetLayoutProperty<TextLayoutProperty>();
389 EXPECT_EQ(yearTextLayoutProperty->GetContentValue(), "2000");
390
391 auto monthTextNode = calendarPickerModel.GetMonthNode(AceType::RawPtr(frameNode));
392 auto monthTextLayoutProperty = monthTextNode->GetLayoutProperty<TextLayoutProperty>();
393 EXPECT_EQ(monthTextLayoutProperty->GetContentValue(), "02");
394
395 auto dayTextNode = calendarPickerModel.GetDayNode(AceType::RawPtr(frameNode));
396 auto dayTextLayoutProperty = dayTextNode->GetLayoutProperty<TextLayoutProperty>();
397 EXPECT_EQ(dayTextLayoutProperty->GetContentValue(), "29");
398 }
399
400 /**
401 * @tc.name: CalendarPickerPatternTest001
402 * @tc.desc: HandleFocusEvent Function Test
403 * @tc.type: FUNC
404 */
405 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest001, TestSize.Level1)
406 {
407 CreateCalendarPicker();
408
409 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
410 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
411
412 auto frameNode = AceType::DynamicCast<FrameNode>(element);
413 ASSERT_NE(frameNode, nullptr);
414
415 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
416 ASSERT_NE(pickerPattern, nullptr);
417
418 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
419 KeyEvent keyEventOne(KeyCode::KEY_TAB, KeyAction::DOWN);
420 auto result = pickerPattern->HandleFocusEvent(keyEventOne);
421 EXPECT_TRUE(result);
422
423 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
424 KeyEvent keyEventTwo(KeyCode::KEY_DPAD_LEFT, KeyAction::DOWN);
425 result = pickerPattern->HandleFocusEvent(keyEventTwo);
426 EXPECT_TRUE(result);
427
428 result = pickerPattern->HandleFocusEvent(keyEventTwo);
429 EXPECT_TRUE(result);
430
431 KeyEvent keyEventThree(KeyCode::KEY_DPAD_RIGHT, KeyAction::DOWN);
432 result = pickerPattern->HandleFocusEvent(keyEventThree);
433 EXPECT_TRUE(result);
434
435 result = pickerPattern->HandleFocusEvent(keyEventThree);
436 EXPECT_TRUE(result);
437
438 KeyEvent keyEventFour(KeyCode::KEY_DPAD_UP, KeyAction::DOWN);
439 KeyEvent keyEventFive(KeyCode::KEY_DPAD_DOWN, KeyAction::DOWN);
440 result = pickerPattern->HandleFocusEvent(keyEventFour);
441 EXPECT_TRUE(result);
442 result = pickerPattern->HandleFocusEvent(keyEventFive);
443 EXPECT_TRUE(result);
444
445 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
446 result = pickerPattern->HandleFocusEvent(keyEventFour);
447 EXPECT_TRUE(result);
448 result = pickerPattern->HandleFocusEvent(keyEventFive);
449 EXPECT_TRUE(result);
450
451 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
452 result = pickerPattern->HandleFocusEvent(keyEventFour);
453 EXPECT_TRUE(result);
454 result = pickerPattern->HandleFocusEvent(keyEventFive);
455 EXPECT_TRUE(result);
456
457 KeyEvent keyEventSix(KeyCode::KEY_MOVE_HOME, KeyAction::DOWN);
458 result = pickerPattern->HandleFocusEvent(keyEventSix);
459 EXPECT_TRUE(result);
460
461 KeyEvent keyEventSeven(KeyCode::KEY_MOVE_END, KeyAction::DOWN);
462 result = pickerPattern->HandleFocusEvent(keyEventSeven);
463 EXPECT_TRUE(result);
464
465 KeyEvent keyEventEight(KeyCode::KEY_NUMPAD_ENTER, KeyAction::DOWN);
466 result = pickerPattern->HandleFocusEvent(keyEventEight);
467 EXPECT_TRUE(result);
468 }
469
470 /**
471 * @tc.name: CalendarPickerPatternTest002
472 * @tc.desc: HandleKeyEvent Function Test
473 * @tc.type: FUNC
474 */
475 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest002, TestSize.Level1)
476 {
477 CreateCalendarPicker();
478
479 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
480 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
481
482 auto frameNode = AceType::DynamicCast<FrameNode>(element);
483 ASSERT_NE(frameNode, nullptr);
484
485 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
486 ASSERT_NE(pickerPattern, nullptr);
487
488 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
489
490 KeyEvent keyEventOne(KeyCode::KEY_NUMPAD_1, KeyAction::DOWN);
491 auto result = pickerPattern->HandleKeyEvent(keyEventOne);
492 EXPECT_TRUE(result);
493
494 pickerPattern->isKeyWaiting_ = false;
495 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
496 result = pickerPattern->HandleKeyEvent(keyEventOne);
497 EXPECT_TRUE(result);
498
499 pickerPattern->isKeyWaiting_ = false;
500 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
501 result = pickerPattern->HandleKeyEvent(keyEventOne);
502 EXPECT_TRUE(result);
503
504 pickerPattern->isKeyWaiting_ = true;
505 result = pickerPattern->HandleKeyEvent(keyEventOne);
506 EXPECT_TRUE(result);
507
508 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
509 result = pickerPattern->HandleKeyEvent(keyEventOne);
510 EXPECT_TRUE(result);
511
512 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
513 result = pickerPattern->HandleKeyEvent(keyEventOne);
514 EXPECT_TRUE(result);
515 }
516 /**
517 * @tc.name: CalendarPickerPatternTest003
518 * @tc.desc: HandleBlurEvent Function Test
519 * @tc.type: FUNC
520 */
521 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest003, TestSize.Level1)
522 {
523 CreateCalendarPicker();
524
525 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
526 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
527
528 auto frameNode = AceType::DynamicCast<FrameNode>(element);
529 ASSERT_NE(frameNode, nullptr);
530
531 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
532 ASSERT_NE(pickerPattern, nullptr);
533
534 pickerPattern->HandleBlurEvent();
535 EXPECT_EQ(pickerPattern->selected_, CalendarPickerSelectedType::OTHER);
536 }
537
538 /**
539 * @tc.name: CalendarPickerPatternTest004
540 * @tc.desc: HandleTaskCallback Function Test
541 * @tc.type: FUNC
542 */
543 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest004, TestSize.Level1)
544 {
545 CreateCalendarPicker();
546
547 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
548 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
549
550 auto frameNode = AceType::DynamicCast<FrameNode>(element);
551 ASSERT_NE(frameNode, nullptr);
552
553 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
554 ASSERT_NE(pickerPattern, nullptr);
555
556 pickerPattern->HandleTaskCallback();
557 }
558
559 /**
560 * @tc.name: CalendarPickerPatternTest005
561 * @tc.desc: HandleKeyEvent Number Function Test
562 * @tc.type: FUNC
563 */
564 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest005, TestSize.Level1)
565 {
566 CreateCalendarPicker();
567
568 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
569 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
570
571 auto frameNode = AceType::DynamicCast<FrameNode>(element);
572 ASSERT_NE(frameNode, nullptr);
573
574 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
575 ASSERT_NE(pickerPattern, nullptr);
576
577 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
578
579 KeyEvent keyEventOne(KeyCode::KEY_1, KeyAction::DOWN);
580 auto result = pickerPattern->HandleKeyEvent(keyEventOne);
581 EXPECT_TRUE(result);
582
583 KeyEvent keyEvenTwo(KeyCode::KEY_9, KeyAction::DOWN);
584 result = pickerPattern->HandleKeyEvent(keyEvenTwo);
585 EXPECT_TRUE(result);
586
587 result = pickerPattern->HandleKeyEvent(keyEvenTwo);
588 EXPECT_TRUE(result);
589
590 result = pickerPattern->HandleKeyEvent(keyEvenTwo);
591 EXPECT_TRUE(result);
592 }
593
594 /**
595 * @tc.name: CalendarPickerPatternTest006
596 * @tc.desc: IsDialogShow Function Test
597 * @tc.type: FUNC
598 */
599 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest006, TestSize.Level1)
600 {
601 CreateCalendarPicker();
602
603 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
604 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
605
606 auto frameNode = AceType::DynamicCast<FrameNode>(element);
607 ASSERT_NE(frameNode, nullptr);
608
609 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
610 ASSERT_NE(pickerPattern, nullptr);
611
612 auto layoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
613 frameNode, AceType::MakeRefPtr<GeometryNode>(), AceType::MakeRefPtr<LayoutProperty>());
614 layoutWrapper->skipMeasureContent_ = std::make_optional<bool>(true);
615 pickerPattern->SetDialogShow(true);
616 EXPECT_TRUE(pickerPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, true, true));
617
618 pickerPattern->SetDialogShow(false);
619 EXPECT_TRUE(pickerPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, false, false));
620 }
621
622 /**
623 * @tc.name: CalendarPickerPatternTest007
624 * @tc.desc: SetCalendarEdgeAlign Function Test
625 * @tc.type: FUNC
626 */
627 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest007, TestSize.Level1)
628 {
629 CreateCalendarPicker();
630
631 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
632 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
633
634 auto frameNode = AceType::DynamicCast<FrameNode>(element);
635 ASSERT_NE(frameNode, nullptr);
636
637 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
638 ASSERT_NE(pickerPattern, nullptr);
639
640 auto result = pickerPattern->IsAtomicNode();
641 EXPECT_TRUE(result);
642
643 pickerPattern->SetCalendarEdgeAlign(CalendarEdgeAlign::EDGE_ALIGN_START);
644 pickerPattern->GetCalendarEdgeAlign();
645
646 DimensionOffset offset;
647 pickerPattern->GetCalendarDialogOffset();
648 pickerPattern->SetCalendarDialogOffset(offset);
649 pickerPattern->GetCalendarDialogOffset();
650
651 CalendarSettingData data;
652 pickerPattern->GetCalendarData();
653 pickerPattern->SetCalendarData(data);
654 pickerPattern->GetCalendarData();
655
656 auto layoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
657 frameNode, AceType::MakeRefPtr<GeometryNode>(), AceType::MakeRefPtr<LayoutProperty>());
658 EXPECT_TRUE(pickerPattern->HasButtonFlexNode());
659 EXPECT_TRUE(pickerPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, true, true));
660 }
661
662 /**
663 * @tc.name: CalendarPickerPatternTest008
664 * @tc.desc: hoverCallback Function Test
665 * @tc.type: FUNC
666 */
667 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest008, TestSize.Level1)
668 {
669 CreateCalendarPicker();
670
671 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
672 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
673
674 auto frameNode = AceType::DynamicCast<FrameNode>(element);
675 ASSERT_NE(frameNode, nullptr);
676
677 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
678 ASSERT_NE(pickerPattern, nullptr);
679 ASSERT_NE(pickerPattern->hoverListener_, nullptr);
680 ASSERT_NE(pickerPattern->hoverListener_->onHoverCallback_, nullptr);
681 pickerPattern->hoverListener_->onHoverCallback_(true);
682 }
683
684 /**
685 * @tc.name: CalendarPickerPatternTest010
686 * @tc.desc: HandleBlurEvent Function Test
687 * @tc.type: FUNC
688 */
689 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest010, TestSize.Level1)
690 {
691 CreateCalendarPicker();
692
693 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
694 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
695
696 auto frameNode = AceType::DynamicCast<FrameNode>(element);
697 ASSERT_NE(frameNode, nullptr);
698
699 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
700 ASSERT_NE(pickerPattern, nullptr);
701
702 pickerPattern->SetDialogShow(true);
703 pickerPattern->HandleBlurEvent();
704 }
705
706 /**
707 * @tc.name: CalendarPickerPatternTest011
708 * @tc.desc: HandleBlurEvent Function Test
709 * @tc.type: FUNC
710 */
711 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest011, TestSize.Level1)
712 {
713 CreateCalendarPicker();
714
715 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
716 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
717
718 auto frameNode = AceType::DynamicCast<FrameNode>(element);
719 ASSERT_NE(frameNode, nullptr);
720
721 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
722 ASSERT_NE(pickerPattern, nullptr);
723
724 KeyEvent keyEventOne(KeyCode::KEY_SPACE, KeyAction::UP);
725 pickerPattern->isFirtFocus_ = true;
726 pickerPattern->HandleKeyEvent(keyEventOne);
727
728 KeyEvent keyEventTwo(KeyCode::KEY_TAB, KeyAction::DOWN);
729 pickerPattern->isFirtFocus_ = false;
730 EXPECT_FALSE(pickerPattern->HandleKeyEvent(keyEventTwo));
731 }
732
733 /**
734 * @tc.name: CalendarPickerPatternTest012
735 * @tc.desc: HandleFocusEvent Function Test
736 * @tc.type: FUNC
737 */
738 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest012, TestSize.Level1)
739 {
740 CreateCalendarPicker();
741
742 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
743 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
744
745 auto frameNode = AceType::DynamicCast<FrameNode>(element);
746 ASSERT_NE(frameNode, nullptr);
747
748 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
749 ASSERT_NE(pickerPattern, nullptr);
750
751 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
752 KeyEvent keyEventOne;
753 keyEventOne.code = KeyCode::KEY_TAB;
754 pickerPattern->isFirtFocus_ = true;
755 pickerPattern->SetDialogShow(true);
756 EXPECT_TRUE(pickerPattern->HandleFocusEvent(keyEventOne));
757
758 KeyEvent keyEventTwo;
759 keyEventTwo.code = KeyCode::KEY_TAB, pickerPattern->isFirtFocus_ = true;
760 pickerPattern->SetDialogShow(false);
761 EXPECT_TRUE(pickerPattern->HandleFocusEvent(keyEventTwo));
762
763 pickerPattern->selected_ = CalendarPickerSelectedType::OTHER;
764 KeyEvent keyEventThree;
765 keyEventThree.code = KeyCode::KEY_DPAD_LEFT;
766 EXPECT_TRUE(pickerPattern->HandleFocusEvent(keyEventThree));
767
768 pickerPattern->selected_ = CalendarPickerSelectedType::OTHER;
769 KeyEvent keyEventFour;
770 keyEventFour.code = KeyCode::KEY_DPAD_RIGHT;
771 EXPECT_TRUE(pickerPattern->HandleFocusEvent(keyEventFour));
772
773 KeyEvent keyEventFive;
774 keyEventFive.code = KeyCode::KEY_ENTER;
775 pickerPattern->SetDialogShow(false);
776 pickerPattern->HandleFocusEvent(keyEventFive);
777 pickerPattern->SetDialogShow(true);
778 pickerPattern->HandleFocusEvent(keyEventFive);
779
780 KeyEvent keyEventSix;
781 keyEventSix.code = KeyCode::KEY_DEL;
782 pickerPattern->HandleFocusEvent(keyEventSix);
783
784 KeyEvent keyEventSeven;
785 keyEventSeven.action = KeyAction::UP;
786 pickerPattern->HandleFocusEvent(keyEventSeven);
787 }
788
789 /**
790 * @tc.name: CalendarPickerPatternTest013
791 * @tc.desc: HandleYearKeyEvent Function Test
792 * @tc.type: FUNC
793 */
794 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest013, TestSize.Level1)
795 {
796 CreateCalendarPicker();
797
798 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
799 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
800
801 auto frameNode = AceType::DynamicCast<FrameNode>(element);
802 ASSERT_NE(frameNode, nullptr);
803
804 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
805 ASSERT_NE(pickerPattern, nullptr);
806
807 auto json = JsonUtil::Create(true);
808 pickerPattern->isKeyWaiting_ = true;
809 json->Put("year", 2000);
810 json->Put("month", 2);
811 json->Put("day", 29);
812 pickerPattern->SetDate(json->ToString());
813 EXPECT_TRUE(pickerPattern->HandleYearKeyEvent(2000));
814
815 pickerPattern->isKeyWaiting_ = true;
816 json->Put("year", 10);
817 json->Put("month", 1);
818 json->Put("day", 1);
819 pickerPattern->SetDate(json->ToString());
820 pickerPattern->HandleYearKeyEvent(10);
821 EXPECT_TRUE(pickerPattern->HandleYearKeyEvent(10));
822
823 pickerPattern->isKeyWaiting_ = false;
824 json->Put("year", 0);
825 json->Put("month", 1);
826 json->Put("day", 1);
827 pickerPattern->SetDate(json->ToString());
828 EXPECT_TRUE(pickerPattern->HandleYearKeyEvent(0));
829 }
830
831 /**
832 * @tc.name: CalendarPickerPatternTest014
833 * @tc.desc: HandleYearKeyEvent Function Test
834 * @tc.type: FUNC
835 */
836 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest014, TestSize.Level1)
837 {
838 CreateCalendarPicker();
839
840 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
841 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
842
843 auto frameNode = AceType::DynamicCast<FrameNode>(element);
844 ASSERT_NE(frameNode, nullptr);
845
846 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
847 ASSERT_NE(pickerPattern, nullptr);
848
849 auto json = JsonUtil::Create(true);
850 pickerPattern->isKeyWaiting_ = true;
851 json->Put("year", 999);
852 json->Put("month", 1);
853 json->Put("day", 1);
854 pickerPattern->SetDate(json->ToString());
855 EXPECT_TRUE(pickerPattern->HandleYearKeyEvent(999));
856 }
857
858 /**
859 * @tc.name: CalendarPickerPatternTest015
860 * @tc.desc: HandleYearKeyEvent Function Test
861 * @tc.type: FUNC
862 */
863 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest015, TestSize.Level1)
864 {
865 CreateCalendarPicker();
866
867 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
868 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
869
870 auto frameNode = AceType::DynamicCast<FrameNode>(element);
871 ASSERT_NE(frameNode, nullptr);
872
873 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
874 ASSERT_NE(pickerPattern, nullptr);
875
876 auto json = JsonUtil::Create(true);
877 pickerPattern->isKeyWaiting_ = true;
878 json->Put("year", 800);
879 json->Put("month", 2);
880 json->Put("day", 29);
881 pickerPattern->SetDate(json->ToString());
882 EXPECT_TRUE(pickerPattern->HandleYearKeyEvent(799));
883 }
884
885 /**
886 * @tc.name: CalendarPickerPatternTest016
887 * @tc.desc: HandleMonthKeyEvent Function Test
888 * @tc.type: FUNC
889 */
890 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest016, TestSize.Level1)
891 {
892 CreateCalendarPicker();
893
894 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
895 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
896
897 auto frameNode = AceType::DynamicCast<FrameNode>(element);
898 ASSERT_NE(frameNode, nullptr);
899
900 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
901 ASSERT_NE(pickerPattern, nullptr);
902
903 auto json = JsonUtil::Create(true);
904 pickerPattern->isKeyWaiting_ = true;
905 json->Put("year", 2000);
906 json->Put("month", 10);
907 json->Put("day", 1);
908 pickerPattern->SetDate(json->ToString());
909 EXPECT_TRUE(pickerPattern->HandleMonthKeyEvent(10));
910
911 pickerPattern->isKeyWaiting_ = true;
912 json->Put("year", 2000);
913 json->Put("month", 3);
914 json->Put("day", 31);
915 pickerPattern->SetDate(json->ToString());
916 pickerPattern->HandleMonthKeyEvent(3);
917 EXPECT_TRUE(pickerPattern->isKeyWaiting_);
918
919 pickerPattern->isKeyWaiting_ = false;
920 json->Put("year", 2000);
921 json->Put("month", 0);
922 json->Put("day", 1);
923 pickerPattern->SetDate(json->ToString());
924 EXPECT_TRUE(pickerPattern->HandleMonthKeyEvent(0));
925
926 pickerPattern->isKeyWaiting_ = false;
927 json->Put("year", 2000);
928 json->Put("month", 10);
929 json->Put("day", 31);
930 pickerPattern->SetDate(json->ToString());
931 pickerPattern->HandleMonthKeyEvent(10);
932 EXPECT_TRUE(pickerPattern->isKeyWaiting_);
933 }
934
935 /**
936 * @tc.name: CalendarPickerPatternTest017
937 * @tc.desc: HandleMonthKeyEvent Function Test
938 * @tc.type: FUNC
939 */
940 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest017, TestSize.Level1)
941 {
942 CreateCalendarPicker();
943
944 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
945 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
946
947 auto frameNode = AceType::DynamicCast<FrameNode>(element);
948 ASSERT_NE(frameNode, nullptr);
949
950 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
951 ASSERT_NE(pickerPattern, nullptr);
952
953 auto json = JsonUtil::Create(true);
954 pickerPattern->isKeyWaiting_ = true;
955 json->Put("year", 799);
956 json->Put("month", 1);
957 json->Put("day", 31);
958 pickerPattern->SetDate(json->ToString());
959 pickerPattern->HandleMonthKeyEvent(1);
960 }
961
962 /**
963 * @tc.name: CalendarPickerPatternTest018
964 * @tc.desc: HandleDayKeyEvent Function Test
965 * @tc.type: FUNC
966 */
967 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest018, TestSize.Level1)
968 {
969 CreateCalendarPicker();
970
971 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
972 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
973
974 auto frameNode = AceType::DynamicCast<FrameNode>(element);
975 ASSERT_NE(frameNode, nullptr);
976
977 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
978 ASSERT_NE(pickerPattern, nullptr);
979
980 auto json = JsonUtil::Create(true);
981 pickerPattern->isKeyWaiting_ = true;
982 json->Put("year", 2000);
983 json->Put("month", 1);
984 json->Put("day", 31);
985 pickerPattern->SetDate(json->ToString());
986 EXPECT_TRUE(pickerPattern->HandleDayKeyEvent(31));
987
988 pickerPattern->isKeyWaiting_ = false;
989 json->Put("year", 2000);
990 json->Put("month", 1);
991 json->Put("day", 0);
992 pickerPattern->SetDate(json->ToString());
993 EXPECT_TRUE(pickerPattern->HandleDayKeyEvent(0));
994
995 pickerPattern->isKeyWaiting_ = false;
996 json->Put("year", 2000);
997 json->Put("month", 1);
998 json->Put("day", 1);
999 pickerPattern->SetDate(json->ToString());
1000 pickerPattern->HandleDayKeyEvent(1);
1001 }
1002
1003 /**
1004 * @tc.name: CalendarPickerPatternTest019
1005 * @tc.desc: HandleDayKeyEvent Function Test
1006 * @tc.type: FUNC
1007 */
1008 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest019, TestSize.Level1)
1009 {
1010 CreateCalendarPicker();
1011
1012 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1013 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1014
1015 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1016 ASSERT_NE(frameNode, nullptr);
1017
1018 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1019 ASSERT_NE(pickerPattern, nullptr);
1020
1021 auto json = JsonUtil::Create(true);
1022 pickerPattern->isKeyWaiting_ = true;
1023 json->Put("year", 2000);
1024 json->Put("month", 1);
1025 json->Put("day", 1);
1026 pickerPattern->SetDate(json->ToString());
1027 pickerPattern->HandleDayKeyEvent(1);
1028 }
1029
1030 /**
1031 * @tc.name: CalendarPickerPatternTest020
1032 * @tc.desc: HandleNumberKeyEvent Function Test
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest020, TestSize.Level1)
1036 {
1037 CreateCalendarPicker();
1038
1039 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1040 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1041
1042 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1043 ASSERT_NE(frameNode, nullptr);
1044
1045 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1046 ASSERT_NE(pickerPattern, nullptr);
1047
1048 KeyEvent keyEventOne;
1049 keyEventOne.code = KeyCode::KEY_STAR;
1050 EXPECT_FALSE(pickerPattern->HandleNumberKeyEvent(keyEventOne));
1051
1052 KeyEvent keyEventTwo;
1053 keyEventTwo.code = KeyCode::KEY_NUMPAD_0;
1054 EXPECT_FALSE(pickerPattern->HandleNumberKeyEvent(keyEventTwo));
1055
1056 KeyEvent keyEventThree;
1057 keyEventThree.code = KeyCode::KEY_0;
1058 EXPECT_FALSE(pickerPattern->HandleNumberKeyEvent(keyEventThree));
1059 }
1060
1061 /**
1062 * @tc.name: CalendarPickerPatternTest021
1063 * @tc.desc: HandleTaskCallback Function Test
1064 * @tc.type: FUNC
1065 */
1066 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest021, TestSize.Level1)
1067 {
1068 CreateCalendarPicker();
1069
1070 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1071 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1072
1073 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1074 ASSERT_NE(frameNode, nullptr);
1075
1076 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1077 ASSERT_NE(pickerPattern, nullptr);
1078
1079 pickerPattern->taskCount_ = 2;
1080 pickerPattern->HandleTaskCallback();
1081
1082 pickerPattern->taskCount_ = 0;
1083 pickerPattern->HandleTaskCallback();
1084 EXPECT_EQ(pickerPattern->taskCount_, 0);
1085
1086 pickerPattern->taskCount_ = 1;
1087 pickerPattern->isKeyWaiting_ = true;
1088 auto json = JsonUtil::Create(true);
1089 json->Put("year", 1000);
1090 json->Put("month", 1);
1091 json->Put("day", 1);
1092 pickerPattern->SetDate(json->ToString());
1093 pickerPattern->HandleTaskCallback();
1094 EXPECT_FALSE(pickerPattern->isKeyWaiting_);
1095
1096 pickerPattern->taskCount_ = 1;
1097 pickerPattern->isKeyWaiting_ = false;
1098 pickerPattern->HandleTaskCallback();
1099 }
1100
1101 /**
1102 * @tc.name: CalendarPickerPatternTest022
1103 * @tc.desc: HandleTaskCallback Function Test
1104 * @tc.type: FUNC
1105 */
1106 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest022, TestSize.Level1)
1107 {
1108 CreateCalendarPicker();
1109
1110 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1111 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1112
1113 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1114 ASSERT_NE(frameNode, nullptr);
1115
1116 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1117 ASSERT_NE(pickerPattern, nullptr);
1118
1119 pickerPattern->taskCount_ = 1;
1120 pickerPattern->isKeyWaiting_ = true;
1121 auto json = JsonUtil::Create(true);
1122 json->Put("year", 801);
1123 json->Put("month", 2);
1124 json->Put("day", 29);
1125 pickerPattern->SetDate(json->ToString());
1126 pickerPattern->HandleTaskCallback();
1127 EXPECT_FALSE(pickerPattern->isKeyWaiting_);
1128 }
1129
1130 /**
1131 * @tc.name: CalendarPickerPatternTest023
1132 * @tc.desc: HandleTextHoverEvent Function Test
1133 * @tc.type: FUNC
1134 */
1135 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest023, TestSize.Level1)
1136 {
1137 CreateCalendarPicker();
1138
1139 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1140 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1141
1142 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1143 ASSERT_NE(frameNode, nullptr);
1144
1145 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1146 ASSERT_NE(pickerPattern, nullptr);
1147
1148 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
1149 pickerPattern->HandleTextHoverEvent(true, 0);
1150
1151 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
1152 pickerPattern->HandleTextHoverEvent(true, 2);
1153
1154 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1155 pickerPattern->HandleTextHoverEvent(true, 4);
1156
1157 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
1158 pickerPattern->HandleTextHoverEvent(false, 4);
1159 }
1160
1161 /**
1162 * @tc.name: CalendarPickerPatternTest024
1163 * @tc.desc: HandleAddButtonClick Function Test
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest024, TestSize.Level1)
1167 {
1168 CreateCalendarPicker();
1169
1170 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1171 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1172
1173 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1174 ASSERT_NE(frameNode, nullptr);
1175
1176 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1177 ASSERT_NE(pickerPattern, nullptr);
1178
1179 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
1180 auto json = JsonUtil::Create(true);
1181 json->Put("year", 801);
1182 json->Put("month", 2);
1183 json->Put("day", 29);
1184 pickerPattern->SetDate(json->ToString());
1185 pickerPattern->HandleAddButtonClick();
1186 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1187 EXPECT_EQ(json->GetUInt("year"), 802);
1188 EXPECT_EQ(json->GetUInt("month"), 2);
1189 EXPECT_EQ(json->GetUInt("day"), 28);
1190
1191 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1192 json->Put("year", 801);
1193 json->Put("month", 2);
1194 json->Put("day", 29);
1195 pickerPattern->SetDate(json->ToString());
1196 pickerPattern->HandleAddButtonClick();
1197 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1198 EXPECT_EQ(json->GetUInt("year"), 802);
1199 EXPECT_EQ(json->GetUInt("month"), 3);
1200 EXPECT_EQ(json->GetUInt("day"), 1);
1201 }
1202
1203 /**
1204 * @tc.name: CalendarPickerPatternTest025
1205 * @tc.desc: HandleAddButtonClick Function Test
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest025, TestSize.Level1)
1209 {
1210 CreateCalendarPicker();
1211
1212 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1213 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1214
1215 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1216 ASSERT_NE(frameNode, nullptr);
1217
1218 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1219 ASSERT_NE(pickerPattern, nullptr);
1220
1221 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
1222 auto json = JsonUtil::Create(true);
1223 json->Put("year", 800);
1224 json->Put("month", 10);
1225 json->Put("day", 31);
1226 pickerPattern->SetDate(json->ToString());
1227 pickerPattern->HandleAddButtonClick();
1228 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1229 EXPECT_EQ(json->GetUInt("year"), 800);
1230 EXPECT_EQ(json->GetUInt("month"), 11);
1231 EXPECT_EQ(json->GetUInt("day"), 30);
1232 }
1233
1234 /**
1235 * @tc.name: CalendarPickerPatternTest026
1236 * @tc.desc: HandleAddButtonClick Function Test
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest026, TestSize.Level1)
1240 {
1241 CreateCalendarPicker();
1242
1243 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1244 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1245
1246 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1247 ASSERT_NE(frameNode, nullptr);
1248
1249 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1250 ASSERT_NE(pickerPattern, nullptr);
1251
1252 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
1253 auto json = JsonUtil::Create(true);
1254 json->Put("year", 800);
1255 json->Put("month", 12);
1256 json->Put("day", 31);
1257 pickerPattern->SetDate(json->ToString());
1258 pickerPattern->HandleAddButtonClick();
1259 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1260 EXPECT_EQ(json->GetUInt("year"), 801);
1261 EXPECT_EQ(json->GetUInt("month"), 1);
1262 EXPECT_EQ(json->GetUInt("day"), 31);
1263 }
1264
1265 /**
1266 * @tc.name: CalendarPickerPatternTest027
1267 * @tc.desc: HandleAddButtonClick Function Test
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest027, TestSize.Level1)
1271 {
1272 CreateCalendarPicker();
1273
1274 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1275 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1276
1277 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1278 ASSERT_NE(frameNode, nullptr);
1279
1280 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1281 ASSERT_NE(pickerPattern, nullptr);
1282
1283 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1284 auto json = JsonUtil::Create(true);
1285 json->Put("year", 801);
1286 json->Put("month", 12);
1287 json->Put("day", 32);
1288 pickerPattern->SetDate(json->ToString());
1289 pickerPattern->HandleAddButtonClick();
1290 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1291 EXPECT_EQ(json->GetUInt("year"), 802);
1292 EXPECT_EQ(json->GetUInt("month"), 1);
1293 EXPECT_EQ(json->GetUInt("day"), 1);
1294 }
1295
1296 /**
1297 * @tc.name: CalendarPickerPatternTest028
1298 * @tc.desc: HandleSubButtonClick Function Test
1299 * @tc.type: FUNC
1300 */
1301 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest028, TestSize.Level1)
1302 {
1303 CreateCalendarPicker();
1304
1305 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1306 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1307
1308 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1309 ASSERT_NE(frameNode, nullptr);
1310
1311 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1312 ASSERT_NE(pickerPattern, nullptr);
1313
1314 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
1315 auto json = JsonUtil::Create(true);
1316 json->Put("year", 802);
1317 json->Put("month", 2);
1318 json->Put("day", 30);
1319 pickerPattern->SetDate(json->ToString());
1320 pickerPattern->HandleSubButtonClick();
1321 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1322 EXPECT_EQ(json->GetUInt("year"), 801);
1323 EXPECT_EQ(json->GetUInt("month"), 2);
1324 EXPECT_EQ(json->GetUInt("day"), 28);
1325 }
1326
1327 /**
1328 * @tc.name: CalendarPickerPatternTest029
1329 * @tc.desc: HandleSubButtonClick Function Test
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest029, TestSize.Level1)
1333 {
1334 CreateCalendarPicker();
1335
1336 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1337 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1338
1339 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1340 ASSERT_NE(frameNode, nullptr);
1341
1342 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1343 ASSERT_NE(pickerPattern, nullptr);
1344
1345 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
1346 auto json = JsonUtil::Create(true);
1347 json->Put("year", 801);
1348 json->Put("month", 1);
1349 json->Put("day", 32);
1350 pickerPattern->SetDate(json->ToString());
1351 pickerPattern->HandleSubButtonClick();
1352 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1353 EXPECT_EQ(json->GetUInt("year"), 800);
1354 EXPECT_EQ(json->GetUInt("month"), 12);
1355 EXPECT_EQ(json->GetUInt("day"), 31);
1356 }
1357
1358 /**
1359 * @tc.name: CalendarPickerPatternTest030
1360 * @tc.desc: HandleSubButtonClick Function Test
1361 * @tc.type: FUNC
1362 */
1363 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest030, TestSize.Level1)
1364 {
1365 CreateCalendarPicker();
1366
1367 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1368 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1369
1370 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1371 ASSERT_NE(frameNode, nullptr);
1372
1373 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1374 ASSERT_NE(pickerPattern, nullptr);
1375
1376 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
1377 auto json = JsonUtil::Create(true);
1378 json->Put("year", 801);
1379 json->Put("month", 7);
1380 json->Put("day", 31);
1381 pickerPattern->SetDate(json->ToString());
1382 pickerPattern->HandleSubButtonClick();
1383 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1384 EXPECT_EQ(json->GetUInt("year"), 801);
1385 EXPECT_EQ(json->GetUInt("month"), 6);
1386 EXPECT_EQ(json->GetUInt("day"), 30);
1387 }
1388
1389 /**
1390 * @tc.name: CalendarPickerPatternTest031
1391 * @tc.desc: HandleSubButtonClick Function Test
1392 * @tc.type: FUNC
1393 */
1394 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest031, TestSize.Level1)
1395 {
1396 CreateCalendarPicker();
1397
1398 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1399 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1400
1401 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1402 ASSERT_NE(frameNode, nullptr);
1403
1404 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1405 ASSERT_NE(pickerPattern, nullptr);
1406
1407 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1408 auto json = JsonUtil::Create(true);
1409 json->Put("year", 801);
1410 json->Put("month", 2);
1411 json->Put("day", 1);
1412 pickerPattern->SetDate(json->ToString());
1413 pickerPattern->HandleSubButtonClick();
1414 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1415 EXPECT_EQ(json->GetUInt("year"), 801);
1416 EXPECT_EQ(json->GetUInt("month"), 1);
1417 EXPECT_EQ(json->GetUInt("day"), 31);
1418 }
1419
1420 /**
1421 * @tc.name: CalendarPickerPatternTest032
1422 * @tc.desc: HandleSubButtonClick Function Test
1423 * @tc.type: FUNC
1424 */
1425 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest032, TestSize.Level1)
1426 {
1427 CreateCalendarPicker();
1428
1429 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1430 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1431
1432 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1433 ASSERT_NE(frameNode, nullptr);
1434
1435 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1436 ASSERT_NE(pickerPattern, nullptr);
1437
1438 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1439 auto json = JsonUtil::Create(true);
1440 json->Put("year", 801);
1441 json->Put("month", 1);
1442 json->Put("day", 1);
1443 pickerPattern->SetDate(json->ToString());
1444 pickerPattern->HandleSubButtonClick();
1445 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1446 EXPECT_EQ(json->GetUInt("year"), 800);
1447 EXPECT_EQ(json->GetUInt("month"), 12);
1448 EXPECT_EQ(json->GetUInt("day"), 31);
1449 }
1450
1451 /**
1452 * @tc.name: CalendarPickerPatternTest033
1453 * @tc.desc: HandleSubButtonClick Function Test
1454 * @tc.type: FUNC
1455 */
1456 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest033, TestSize.Level1)
1457 {
1458 CreateCalendarPicker();
1459
1460 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1461 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1462
1463 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1464 ASSERT_NE(frameNode, nullptr);
1465
1466 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1467 ASSERT_NE(pickerPattern, nullptr);
1468
1469 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1470 auto json = JsonUtil::Create(true);
1471 json->Put("year", 801);
1472 json->Put("month", 2);
1473 json->Put("day", 1);
1474 pickerPattern->SetDate(json->ToString());
1475 pickerPattern->HandleSubButtonClick();
1476 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1477 EXPECT_EQ(json->GetUInt("year"), 801);
1478 EXPECT_EQ(json->GetUInt("month"), 1);
1479 EXPECT_EQ(json->GetUInt("day"), 31);
1480 }
1481
1482 /**
1483 * @tc.name: CalendarPickerPatternTest034
1484 * @tc.desc: HandleSubButtonClick Function Test
1485 * @tc.type: FUNC
1486 */
1487 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest034, TestSize.Level1)
1488 {
1489 CreateCalendarPicker();
1490
1491 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1492 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1493
1494 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1495 ASSERT_NE(frameNode, nullptr);
1496
1497 auto layoutProperty = frameNode->GetLayoutProperty<CalendarPickerLayoutProperty>();
1498 ASSERT_NE(layoutProperty, nullptr);
1499 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1500 ASSERT_NE(pickerPattern, nullptr);
1501
1502 layoutProperty->UpdateDialogAlignType(CalendarEdgeAlign::EDGE_ALIGN_CENTER);
1503 pickerPattern->CalculateDialogOffset();
1504 }
1505
1506 /**
1507 * @tc.name: CalendarPickerPatternTest035
1508 * @tc.desc: CalculateDialogOffset Function Test
1509 * @tc.type: FUNC
1510 */
1511 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest035, TestSize.Level1)
1512 {
1513 CreateCalendarPicker();
1514
1515 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1516 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1517
1518 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1519 ASSERT_NE(frameNode, nullptr);
1520
1521 auto layoutProperty = frameNode->GetLayoutProperty<CalendarPickerLayoutProperty>();
1522 ASSERT_NE(layoutProperty, nullptr);
1523 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1524 ASSERT_NE(pickerPattern, nullptr);
1525
1526 layoutProperty->UpdateDialogAlignType(CalendarEdgeAlign::EDGE_ALIGN_END);
1527 pickerPattern->CalculateDialogOffset();
1528 }
1529
1530 /**
1531 * @tc.name: CalendarPickerPatternTest036
1532 * @tc.desc: GetEntryDateInfo Function Test
1533 * @tc.type: FUNC
1534 */
1535 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest036, TestSize.Level1)
1536 {
1537 auto pickerPattern = AceType::MakeRefPtr<CalendarPickerPattern>();
1538
1539 const std::string info = " ";
1540 pickerPattern->GetEntryDateInfo();
1541 pickerPattern->SetDate(info);
1542 pickerPattern->FlushTextStyle();
1543 }
1544
1545 /**
1546 * @tc.name: CalendarPickerPatternTest037
1547 * @tc.desc: HandleAddButtonClick Function Test
1548 * @tc.type: FUNC
1549 */
1550 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest037, TestSize.Level1)
1551 {
1552 CreateCalendarPicker();
1553
1554 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1555 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1556
1557 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1558 ASSERT_NE(frameNode, nullptr);
1559
1560 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1561 ASSERT_NE(pickerPattern, nullptr);
1562
1563 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
1564 auto json = JsonUtil::Create(true);
1565 json->Put("year", 5000);
1566 json->Put("month", 1);
1567 json->Put("day", 31);
1568 pickerPattern->SetDate(json->ToString());
1569 pickerPattern->HandleAddButtonClick();
1570 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1571 EXPECT_EQ(json->GetUInt("year"), 1);
1572 EXPECT_EQ(json->GetUInt("month"), 1);
1573 EXPECT_EQ(json->GetUInt("day"), 31);
1574 }
1575
1576 /**
1577 * @tc.name: CalendarPickerPatternTest038
1578 * @tc.desc: HandleAddButtonClick Function Test
1579 * @tc.type: FUNC
1580 */
1581 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest038, TestSize.Level1)
1582 {
1583 CreateCalendarPicker();
1584
1585 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1586 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1587
1588 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1589 ASSERT_NE(frameNode, nullptr);
1590
1591 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1592 ASSERT_NE(pickerPattern, nullptr);
1593
1594 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
1595 auto json = JsonUtil::Create(true);
1596 json->Put("year", 5000);
1597 json->Put("month", 12);
1598 json->Put("day", 31);
1599 pickerPattern->SetDate(json->ToString());
1600 pickerPattern->HandleAddButtonClick();
1601 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1602 EXPECT_EQ(json->GetUInt("year"), 1);
1603 EXPECT_EQ(json->GetUInt("month"), 1);
1604 EXPECT_EQ(json->GetUInt("day"), 31);
1605 }
1606
1607 /**
1608 * @tc.name: CalendarPickerPatternTest039
1609 * @tc.desc: HandleAddButtonClick Function Test
1610 * @tc.type: FUNC
1611 */
1612 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest039, TestSize.Level1)
1613 {
1614 CreateCalendarPicker();
1615
1616 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1617 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1618
1619 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1620 ASSERT_NE(frameNode, nullptr);
1621
1622 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1623 ASSERT_NE(pickerPattern, nullptr);
1624
1625 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1626 auto json = JsonUtil::Create(true);
1627 json->Put("year", 5000);
1628 json->Put("month", 12);
1629 json->Put("day", 32);
1630 pickerPattern->SetDate(json->ToString());
1631 pickerPattern->HandleAddButtonClick();
1632 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1633 EXPECT_EQ(json->GetUInt("year"), 1);
1634 EXPECT_EQ(json->GetUInt("month"), 1);
1635 EXPECT_EQ(json->GetUInt("day"), 1);
1636 }
1637
1638 /**
1639 * @tc.name: CalendarPickerPatternTest040
1640 * @tc.desc: HandleSubButtonClick Function Test
1641 * @tc.type: FUNC
1642 */
1643 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest040, TestSize.Level1)
1644 {
1645 CreateCalendarPicker();
1646
1647 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1648 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1649
1650 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1651 ASSERT_NE(frameNode, nullptr);
1652
1653 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1654 ASSERT_NE(pickerPattern, nullptr);
1655
1656 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
1657 auto json = JsonUtil::Create(true);
1658 json->Put("year", 1);
1659 json->Put("month", 2);
1660 json->Put("day", 30);
1661 pickerPattern->SetDate(json->ToString());
1662 pickerPattern->HandleSubButtonClick();
1663 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1664 EXPECT_EQ(json->GetUInt("year"), 5000);
1665 EXPECT_EQ(json->GetUInt("month"), 2);
1666 EXPECT_EQ(json->GetUInt("day"), 28);
1667 }
1668
1669 /**
1670 * @tc.name: CalendarPickerPatternTest041
1671 * @tc.desc: HandleSubButtonClick Function Test
1672 * @tc.type: FUNC
1673 */
1674 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest041, TestSize.Level1)
1675 {
1676 CreateCalendarPicker();
1677
1678 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1679 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1680
1681 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1682 ASSERT_NE(frameNode, nullptr);
1683
1684 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1685 ASSERT_NE(pickerPattern, nullptr);
1686
1687 pickerPattern->selected_ = CalendarPickerSelectedType::MONTH;
1688 auto json = JsonUtil::Create(true);
1689 json->Put("year", 1);
1690 json->Put("month", 1);
1691 json->Put("day", 32);
1692 pickerPattern->SetDate(json->ToString());
1693 pickerPattern->HandleSubButtonClick();
1694 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1695 EXPECT_EQ(json->GetUInt("year"), 5000);
1696 EXPECT_EQ(json->GetUInt("month"), 12);
1697 EXPECT_EQ(json->GetUInt("day"), 31);
1698 }
1699
1700 /**
1701 * @tc.name: CalendarPickerPatternTest042
1702 * @tc.desc: HandleSubButtonClick Function Test
1703 * @tc.type: FUNC
1704 */
1705 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest042, TestSize.Level1)
1706 {
1707 CreateCalendarPicker();
1708
1709 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1710 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1711
1712 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1713 ASSERT_NE(frameNode, nullptr);
1714
1715 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1716 ASSERT_NE(pickerPattern, nullptr);
1717
1718 pickerPattern->selected_ = CalendarPickerSelectedType::DAY;
1719 auto json = JsonUtil::Create(true);
1720 json->Put("year", 1);
1721 json->Put("month", 1);
1722 json->Put("day", 1);
1723 pickerPattern->SetDate(json->ToString());
1724 pickerPattern->HandleSubButtonClick();
1725 json = JsonUtil::ParseJsonString(pickerPattern->GetEntryDateInfo());
1726 EXPECT_EQ(json->GetUInt("year"), 5000);
1727 EXPECT_EQ(json->GetUInt("month"), 12);
1728 EXPECT_EQ(json->GetUInt("day"), 31);
1729 }
1730
1731 /**
1732 * @tc.name: CalendarPickerPatternTest043
1733 * @tc.desc: blurTask Function Test
1734 * @tc.type: FUNC
1735 */
1736 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest043, TestSize.Level1)
1737 {
1738 CreateCalendarPicker();
1739
1740 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1741 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1742
1743 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1744 ASSERT_NE(frameNode, nullptr);
1745
1746 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1747 ASSERT_NE(pickerPattern, nullptr);
1748
1749 auto focusHub = frameNode->GetOrCreateFocusHub();
1750 ASSERT_NE(focusHub, nullptr);
1751 ASSERT_NE(focusHub->onBlurInternal_, nullptr);
1752
1753 focusHub->onBlurInternal_();
1754 }
1755
1756 /**
1757 * @tc.name: CalendarPickerPatternTest044
1758 * @tc.desc: blurTask Function Test
1759 * @tc.type: FUNC
1760 */
1761 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest044, TestSize.Level1)
1762 {
1763 CreateCalendarPicker();
1764
1765 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1766 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1767
1768 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1769 ASSERT_NE(frameNode, nullptr);
1770 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1771 ASSERT_NE(pickerPattern, nullptr);
1772
1773 auto focusHub = frameNode->GetOrCreateFocusHub();
1774 ASSERT_NE(focusHub, nullptr);
1775
1776 KeyEvent event;
1777 EXPECT_FALSE(pickerPattern->HandleBlurEvent(event));
1778 }
1779
1780 /**
1781 * @tc.name: CalendarPickerPatternTest045
1782 * @tc.desc: PostTaskToUI Function Test
1783 * @tc.type: FUNC
1784 */
1785 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest045, TestSize.Level1)
1786 {
1787 CreateCalendarPicker();
1788
1789 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1790 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1791
1792 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1793 ASSERT_NE(frameNode, nullptr);
1794 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1795 ASSERT_NE(pickerPattern, nullptr);
1796
1797 auto context = frameNode->GetContextRefPtr();
1798 ASSERT_NE(context, nullptr);
1799 context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
1800
1801 std::function<void()> task;
1802 pickerPattern->PostTaskToUI(task, "ArkUITask");
1803 }
1804
1805 /**
1806 * @tc.name: CalendarPickerPatternTest046
1807 * @tc.desc: OnWindowSizeChanged Function Test
1808 * @tc.type: FUNC
1809 */
1810 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest046, TestSize.Level1)
1811 {
1812 CreateCalendarPicker();
1813
1814 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1815 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1816
1817 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1818 ASSERT_NE(frameNode, nullptr);
1819 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1820 ASSERT_NE(pickerPattern, nullptr);
1821
1822 pickerPattern->OnWindowSizeChanged(100, 200, WindowSizeChangeReason::ROTATION);
1823 pickerPattern->OnWindowSizeChanged(100, 200, WindowSizeChangeReason::RECOVER);
1824 }
1825 /**
1826 * @tc.name: CalendarPickerPatternTest047
1827 * @tc.desc: HandleFocusEvent Function Test
1828 * @tc.type: FUNC
1829 */
1830 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest047, TestSize.Level1)
1831 {
1832 CreateCalendarPicker();
1833
1834 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1835 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1836
1837 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1838 ASSERT_NE(frameNode, nullptr);
1839
1840 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1841 ASSERT_NE(pickerPattern, nullptr);
1842
1843 pickerPattern->selected_ = CalendarPickerSelectedType::YEAR;
1844 KeyEvent keyEvent;
1845 keyEvent.code = KeyCode::KEY_TAB, pickerPattern->isFirtFocus_ = false;
1846 pickerPattern->SetDialogShow(false);
1847 EXPECT_FALSE(pickerPattern->HandleFocusEvent(keyEvent));
1848 }
1849
1850 /**
1851 * @tc.name: CalendarPickerPatternTest048
1852 * @tc.desc: HandleButtonTouchEvent Function Test
1853 * @tc.type: FUNC
1854 */
1855 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest048, TestSize.Level1)
1856 {
1857 CreateCalendarPicker();
1858
1859 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1860 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1861
1862 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1863 ASSERT_NE(frameNode, nullptr);
1864 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1865 ASSERT_NE(pickerPattern, nullptr);
1866 bool isPressed = true;
1867 pickerPattern->HandleButtonTouchEvent(isPressed, 0);
1868 }
1869
1870 /**
1871 * @tc.name: CalendarPickerPatternTest049
1872 * @tc.desc: ShowDialog Function Test
1873 * @tc.type: FUNC
1874 */
1875 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest049, TestSize.Level1)
1876 {
1877 CreateCalendarPicker();
1878
1879 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1880 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1881
1882 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1883 ASSERT_NE(frameNode, nullptr);
1884 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1885 ASSERT_NE(pickerPattern, nullptr);
1886 pickerPattern->SetDialogShow(true);
1887 pickerPattern->ShowDialog();
1888 }
1889
1890 /**
1891 * @tc.name: CalendarPickerPatternTest050
1892 * @tc.desc: InitDateIndex Function Test
1893 * @tc.type: FUNC
1894 */
1895 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest050, TestSize.Level1)
1896 {
1897 const std::string language = "false";
1898 const std::string countryOrRegion = "";
1899 const std::string script = "";
1900 const std::string keywordsAndValues = "";
1901 const std::string selected = "";
1902 Localization::GetInstance()->SetLocaleImpl(language, countryOrRegion, script, selected, keywordsAndValues);
1903 CreateCalendarPicker();
1904
1905 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1906 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1907
1908 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1909 ASSERT_NE(frameNode, nullptr);
1910 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1911 ASSERT_NE(pickerPattern, nullptr);
1912
1913 pickerPattern->InitDateIndex();
1914 EXPECT_EQ(pickerPattern->yearIndex_, 0);
1915 EXPECT_EQ(pickerPattern->monthIndex_, 2);
1916 EXPECT_EQ(pickerPattern->dayIndex_, 4);
1917 }
1918
1919 /**
1920 * @tc.name: CalendarPickerPatternTest051
1921 * @tc.desc: InitDateIndex Function Test
1922 * @tc.type: FUNC
1923 */
1924 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest051, TestSize.Level1)
1925 {
1926 const std::string language = "zh";
1927 const std::string countryOrRegion = "";
1928 const std::string script = "";
1929 const std::string keywordsAndValues = "";
1930 const std::string selected = "";
1931 Localization::GetInstance()->SetLocaleImpl(language, countryOrRegion, script, selected, keywordsAndValues);
1932 CreateCalendarPicker();
1933
1934 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1935 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1936
1937 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1938 ASSERT_NE(frameNode, nullptr);
1939 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1940 ASSERT_NE(pickerPattern, nullptr);
1941
1942 pickerPattern->InitDateIndex();
1943
1944 EXPECT_EQ(pickerPattern->yearIndex_, 0);
1945 EXPECT_EQ(pickerPattern->monthIndex_, 2);
1946 EXPECT_EQ(pickerPattern->dayIndex_, 4);
1947 }
1948
1949 /**
1950 * @tc.name: CalendarPickerPatternTest052
1951 * @tc.desc: InitDateIndex Function Test
1952 * @tc.type: FUNC
1953 */
1954 HWTEST_F(CalendarPickerTestNg, CalendarPickerPatternTest052, TestSize.Level1)
1955 {
1956 const std::string language = "ug";
1957 const std::string countryOrRegion = "";
1958 const std::string script = "";
1959 const std::string keywordsAndValues = "";
1960 const std::string selected = "";
1961 Localization::GetInstance()->SetLocaleImpl(language, countryOrRegion, script, selected, keywordsAndValues);
1962 CreateCalendarPicker();
1963
1964 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1965 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1966
1967 auto frameNode = AceType::DynamicCast<FrameNode>(element);
1968 ASSERT_NE(frameNode, nullptr);
1969 auto pickerPattern = frameNode->GetPattern<CalendarPickerPattern>();
1970 ASSERT_NE(pickerPattern, nullptr);
1971
1972 pickerPattern->InitDateIndex();
1973
1974 EXPECT_EQ(pickerPattern->yearIndex_, 4);
1975 EXPECT_EQ(pickerPattern->monthIndex_, 0);
1976 EXPECT_EQ(pickerPattern->dayIndex_, 2);
1977 }
1978
1979 /**
1980 * @tc.name: CalendarDialogViewTest001
1981 * @tc.desc: Calendar Dialog Show Function Test
1982 * @tc.type: FUNC
1983 */
1984 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest001, TestSize.Level1)
1985 {
1986 CreateCalendarPicker();
1987
1988 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
1989 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
1990
1991 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
1992 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
1993
1994 auto contentWrapper = dialogNode->GetChildAtIndex(0);
1995 ASSERT_NE(contentWrapper, nullptr);
1996 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
1997 ASSERT_NE(calendarDialogNode, nullptr);
1998
1999 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2000 TouchEventInfo info("touch");
2001 TouchLocationInfo touchInfo1(1);
2002 touchInfo1.SetTouchType(TouchType::DOWN);
2003 info.AddTouchLocationInfo(std::move(touchInfo1));
2004 dialogPattern->touchListener_->GetTouchEventCallback()(info);
2005
2006 auto gesture = calendarDialogNode->GetOrCreateGestureEventHub();
2007 ASSERT_NE(gesture, nullptr);
2008
2009 auto result = gesture->ActClick();
2010 EXPECT_TRUE(result);
2011 }
2012
2013 /**
2014 * @tc.name: CalendarDialogViewTest002
2015 * @tc.desc: Create Calendar Dialog Without EntryNode Function Test
2016 * @tc.type: FUNC
2017 */
2018 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest002, TestSize.Level1)
2019 {
2020 CalendarDialogView calendarDialogView;
2021 CalendarSettingData settingData;
2022 DialogProperties properties;
2023 properties.alignment = DialogAlignment::BOTTOM;
2024 properties.customStyle = false;
2025 properties.offset = DimensionOffset(Offset(0, -1.0f));
2026 auto selectedDate = PickerDate(2000, 1, 1);
2027 settingData.selectedDate = selectedDate;
2028 settingData.dayRadius = TEST_SETTING_RADIUS;
2029 std::map<std::string, NG::DialogEvent> dialogEvent;
2030 std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent;
2031 std::vector<ButtonInfo> buttonInfos;
2032 auto dialogNode = calendarDialogView.Show(properties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
2033 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2034
2035 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2036 ASSERT_NE(contentWrapper, nullptr);
2037 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2038 ASSERT_NE(calendarDialogNode, nullptr);
2039
2040 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2041 ASSERT_NE(dialogPattern, nullptr);
2042
2043 TouchEventInfo info("touch");
2044 TouchLocationInfo touchInfo1(1);
2045 touchInfo1.SetTouchType(TouchType::DOWN);
2046 info.AddTouchLocationInfo(std::move(touchInfo1));
2047 dialogPattern->touchListener_->GetTouchEventCallback()(info);
2048
2049 auto gesture = calendarDialogNode->GetOrCreateGestureEventHub();
2050 ASSERT_NE(gesture, nullptr);
2051
2052 gesture->ActClick();
2053 }
2054
2055 /**
2056 * @tc.name: CalendarDialogViewTest003
2057 * @tc.desc: SetDialogChange Function Test
2058 * @tc.type: FUNC
2059 */
2060 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest003, TestSize.Level1)
2061 {
2062 int32_t calendarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2063 auto calendarNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a30402() 2064 V2::CALENDAR_ETS_TAG, calendarNodeId, []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2065 ASSERT_NE(calendarNode, nullptr);
2066 CalendarDialogView calendarDialogView;
2067 DialogEvent event;
2068 calendarDialogView.SetDialogChange(calendarNode, std::move(event));
2069 }
2070
2071 /**
2072 * @tc.name: CalendarDialogViewTest004
2073 * @tc.desc: callback Function Test
2074 * @tc.type: FUNC
2075 */
2076 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest004, TestSize.Level1)
2077 {
2078 CalendarDialogView calendarDialogView;
2079 CalendarSettingData settingData;
2080 DialogProperties properties;
2081 properties.alignment = DialogAlignment::BOTTOM;
2082 properties.customStyle = false;
2083 properties.offset = DimensionOffset(Offset(0, -1.0f));
2084 auto selectedDate = PickerDate(2000, 1, 1);
2085 settingData.selectedDate = selectedDate;
2086 settingData.dayRadius = TEST_SETTING_RADIUS;
2087 std::map<std::string, NG::DialogEvent> dialogEvent;
2088 std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent;
2089 std::vector<ButtonInfo> buttonInfos;
2090 auto dialogNode = calendarDialogView.Show(properties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
2091 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2092
2093 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2094 ASSERT_NE(contentWrapper, nullptr);
2095 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2096 ASSERT_NE(calendarDialogNode, nullptr);
2097 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2098 ASSERT_NE(dialogPattern, nullptr);
2099 auto calendarNode = dialogPattern->GetCalendarFrameNode();
2100 ASSERT_NE(calendarNode, nullptr);
2101 auto eventHub = calendarNode->GetEventHub<CalendarEventHub>();
2102 ASSERT_NE(eventHub, nullptr);
2103
2104 std::string info = " ";
2105 eventHub->UpdateRequestDataEvent(info);
2106 }
2107
2108 /**
2109 * @tc.name: CalendarDialogViewTest005
2110 * @tc.desc: clickCallback Function Test
2111 * @tc.type: FUNC
2112 */
2113 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest005, TestSize.Level1)
2114 {
2115 int32_t calendarNodeId = ElementRegister::GetInstance()->MakeUniqueId();
2116 auto calendarNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a30502() 2117 V2::CALENDAR_ETS_TAG, calendarNodeId, []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2118 ASSERT_NE(calendarNode, nullptr);
2119 DialogEvent event;
2120 std::vector<ButtonInfo> buttonInfos;
2121 auto buttonConfirmNode = CalendarDialogView::CreateConfirmNode(calendarNode, event, buttonInfos);
2122 ASSERT_NE(buttonConfirmNode, nullptr);
2123
2124 auto gesture = buttonConfirmNode->GetOrCreateGestureEventHub();
2125 ASSERT_NE(gesture, nullptr);
2126 gesture->CheckClickActuator();
2127 gesture->ActClick();
2128 }
2129
2130 /**
2131 * @tc.name: CalendarDialogViewTest006
2132 * @tc.desc: OnSelectedChangeEvent Function Test
2133 * @tc.type: FUNC
2134 */
2135 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest006, TestSize.Level1)
2136 {
2137 CreateCalendarPicker();
2138 auto* stack = ViewStackProcessor::GetInstance();
2139 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a30602() 2140 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2141
2142 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2143 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2144
2145 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2146 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2147
2148 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2149 ASSERT_NE(contentWrapper, nullptr);
2150 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2151 ASSERT_NE(calendarDialogNode, nullptr);
2152
2153 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2154 ASSERT_NE(dialogPattern, nullptr);
2155
2156 auto json = JsonUtil::Create(true);
2157 json->Put("year", 2001);
2158 json->Put("month", 2);
2159 json->Put("day", 20);
2160 auto info = json->ToString();
2161 CalendarDialogView calendarDialogView;
__anone691f4a30702(const std::string& ) 2162 auto changeEvent = [](const std::string& /* info */) {};
2163 CalendarSettingData settingData;
2164 calendarDialogView.OnSelectedChangeEvent(1, info, changeEvent, settingData);
2165 }
2166
2167 /**
2168 * @tc.name: CalendarDialogViewTest007
2169 * @tc.desc: OnSelectedChangeEvent Function Test
2170 * @tc.type: FUNC
2171 */
2172 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest007, TestSize.Level1)
2173 {
2174 CreateCalendarPicker();
2175 auto* stack = ViewStackProcessor::GetInstance();
2176 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a30802() 2177 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2178
2179 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2180 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2181
2182 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2183 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2184
2185 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2186 ASSERT_NE(contentWrapper, nullptr);
2187 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2188 ASSERT_NE(calendarDialogNode, nullptr);
2189
2190 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2191 ASSERT_NE(dialogPattern, nullptr);
2192
2193 const std::string callbackInfo;
2194 CalendarDialogView calendarDialogView;
__anone691f4a30902(const std::string& ) 2195 auto changeEvent = [](const std::string& /* info */) {};
2196 CalendarSettingData settingData;
2197 calendarDialogView.OnSelectedChangeEvent(1, callbackInfo, changeEvent, settingData);
2198 }
2199
2200 /**
2201 * @tc.name: CalendarDialogViewTest008
2202 * @tc.desc: Show Function Test
2203 * @tc.type: FUNC
2204 */
2205 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest008, TestSize.Level1)
2206 {
2207 /**
2208 * @tc.steps: step1. mock PlatformVersion VERSION_ELEVEN.
2209 * @tc.expected: mock successfully.
2210 */
2211 MockPipelineContext::GetCurrent()->SetMinPlatformVersion(static_cast<int32_t>(PlatformVersion::VERSION_ELEVEN));
2212 /**
2213 * @tc.steps: step2. create dialogNodeProps.
2214 * @tc.expected: the dialogNodeProps created successfully.
2215 */
2216 CalendarSettingData settingData;
2217 DialogProperties properties;
2218 properties.alignment = DialogAlignment::BOTTOM;
2219 properties.customStyle = true;
2220 properties.offset = DimensionOffset(Offset(0, -1.0f));
2221 auto selectedDate = PickerDate(2000, 1, 1);
2222 settingData.selectedDate = selectedDate;
2223 settingData.dayRadius = TEST_SETTING_RADIUS;
2224 std::map<std::string, NG::DialogEvent> dialogEvent;
2225 std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent;
2226 /**
2227 * @tc.steps: step3. execute CalendarDialogView::Show.
2228 * @tc.expected: show successfully.
2229 */
2230 std::vector<ButtonInfo> buttonInfos;
2231 auto dialogNode = CalendarDialogView::Show(properties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
2232 /**
2233 * @tc.steps: step4. get dialogNode's grandsonNode.
2234 * @tc.expected: getNode successfully.
2235 */
2236 auto contentNode = AceType::DynamicCast<FrameNode>(dialogNode->GetFirstChild());
2237 ASSERT_NE(contentNode, nullptr);
2238 /**
2239 * @tc.steps: step5. test dialogNode's RenderContext's BackBlurStyle value.
2240 * @tc.expected: equal COMPONENT_ULTRA_THICK.
2241 */
2242 EXPECT_EQ(contentNode->GetRenderContext()->GetBackBlurStyle()->blurStyle, BlurStyle::COMPONENT_ULTRA_THICK);
2243 }
2244
2245 /**
2246 * @tc.name: CalendarPickerEventHubTest001
2247 * @tc.desc: SetChangeEvent Function Test
2248 * @tc.type: FUNC
2249 */
2250 HWTEST_F(CalendarPickerTestNg, CalendarPickerEventHubTest001, TestSize.Level1)
2251 {
2252 CreateCalendarPicker();
2253
2254 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2255 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2256
2257 auto frameNode = AceType::DynamicCast<FrameNode>(element);
2258 ASSERT_NE(frameNode, nullptr);
2259 auto calendarpickerEventHub = frameNode->GetEventHub<CalendarPickerEventHub>();
2260 ASSERT_NE(calendarpickerEventHub, nullptr);
2261 std::string info = " ";
2262 calendarpickerEventHub->UpdateInputChangeEvent(info);
2263 calendarpickerEventHub->UpdateChangeEvent(info);
2264 calendarpickerEventHub->UpdateOnChangeEvent(info);
2265 calendarpickerEventHub->FireLayoutChangeEvent();
2266
__anone691f4a30a02(const std::string& ) 2267 auto changeEvent1 = [](const std::string& /* info */) {};
__anone691f4a30b02(const std::string& ) 2268 auto changeEvent2 = [](const std::string& /* info */) {};
__anone691f4a30c02(const std::string& ) 2269 auto changeEvent3 = [](const std::string& /* info */) {};
2270 calendarpickerEventHub->SetInputChangeEvent(std::move(changeEvent1));
2271 calendarpickerEventHub->SetChangeEvent(std::move(changeEvent2));
2272 calendarpickerEventHub->SetOnChangeEvent(std::move(changeEvent3));
2273
2274 calendarpickerEventHub->UpdateInputChangeEvent(info);
2275 calendarpickerEventHub->UpdateChangeEvent(info);
2276 calendarpickerEventHub->UpdateOnChangeEvent(info);
2277 calendarpickerEventHub->FireLayoutChangeEvent();
2278 }
2279
2280 /**
2281 * @tc.name: CalendarDialogPatternTest001
2282 * @tc.desc: HandleKeyEvent Function Test
2283 * @tc.type: FUNC
2284 */
2285 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest001, TestSize.Level1)
2286 {
2287 CreateCalendarPicker();
2288
2289 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2290 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2291
2292 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2293 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2294
2295 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2296 ASSERT_NE(contentWrapper, nullptr);
2297 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2298 ASSERT_NE(calendarDialogNode, nullptr);
2299
2300 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2301 ASSERT_NE(dialogPattern, nullptr);
2302
2303 KeyEvent keyEventOne(KeyCode::KEY_TAB, KeyAction::DOWN);
2304 auto result = dialogPattern->HandleKeyEvent(keyEventOne);
2305 EXPECT_TRUE(result);
2306
2307 KeyEvent keyEventTwo(KeyCode::KEY_DPAD_LEFT, KeyAction::DOWN);
2308 result = dialogPattern->HandleKeyEvent(keyEventTwo);
2309 EXPECT_TRUE(result);
2310
2311 KeyEvent keyEventThree(KeyCode::KEY_DPAD_RIGHT, KeyAction::DOWN);
2312 result = dialogPattern->HandleKeyEvent(keyEventThree);
2313 EXPECT_TRUE(result);
2314
2315 KeyEvent keyEventFour(KeyCode::KEY_DPAD_UP, KeyAction::DOWN);
2316 result = dialogPattern->HandleKeyEvent(keyEventFour);
2317 EXPECT_TRUE(result);
2318
2319 KeyEvent keyEventFive(KeyCode::KEY_DPAD_DOWN, KeyAction::DOWN);
2320 result = dialogPattern->HandleKeyEvent(keyEventFive);
2321 EXPECT_TRUE(result);
2322
2323 KeyEvent keyEventSix(KeyCode::KEY_MOVE_HOME, KeyAction::DOWN);
2324 result = dialogPattern->HandleKeyEvent(keyEventSix);
2325 EXPECT_TRUE(result);
2326
2327 KeyEvent keyEventSeven(KeyCode::KEY_MOVE_END, KeyAction::DOWN);
2328 result = dialogPattern->HandleKeyEvent(keyEventSeven);
2329 EXPECT_TRUE(result);
2330
2331 KeyEvent keyEventEight(KeyCode::KEY_SPACE, KeyAction::DOWN);
2332 result = dialogPattern->HandleKeyEvent(keyEventEight);
2333 EXPECT_TRUE(result);
2334 }
2335
2336 /**
2337 * @tc.name: CalendarDialogPatternTest002
2338 * @tc.desc: HandleKeyEvent Function Test
2339 * @tc.type: FUNC
2340 */
2341 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest002, TestSize.Level1)
2342 {
2343 CreateCalendarPicker();
2344
2345 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2346 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2347
2348 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2349 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2350
2351 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2352 ASSERT_NE(contentWrapper, nullptr);
2353 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2354 ASSERT_NE(calendarDialogNode, nullptr);
2355
2356 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2357 ASSERT_NE(dialogPattern, nullptr);
2358
2359 KeyEvent keyEventOne(KeyCode::KEY_TAB, KeyAction::DOWN);
2360 auto result = dialogPattern->HandleKeyEvent(keyEventOne);
2361 EXPECT_TRUE(result);
2362
2363 result = dialogPattern->HandleKeyEvent(keyEventOne);
2364 EXPECT_TRUE(result);
2365
2366 KeyEvent keyEventTwo(KeyCode::KEY_DPAD_LEFT, KeyAction::DOWN);
2367 result = dialogPattern->HandleKeyEvent(keyEventTwo);
2368 EXPECT_TRUE(result);
2369
2370 KeyEvent keyEventThree(KeyCode::KEY_DPAD_RIGHT, KeyAction::DOWN);
2371 result = dialogPattern->HandleKeyEvent(keyEventThree);
2372 EXPECT_TRUE(result);
2373
2374 KeyEvent keyEventFour(KeyCode::KEY_MOVE_HOME, KeyAction::DOWN);
2375 result = dialogPattern->HandleKeyEvent(keyEventFour);
2376 EXPECT_TRUE(result);
2377
2378 KeyEvent keyEventFive(KeyCode::KEY_MOVE_END, KeyAction::DOWN);
2379 result = dialogPattern->HandleKeyEvent(keyEventFive);
2380 EXPECT_TRUE(result);
2381
2382 KeyEvent keyEventSix(KeyCode::KEY_SPACE, KeyAction::DOWN);
2383 result = dialogPattern->HandleKeyEvent(keyEventSix);
2384 EXPECT_TRUE(result);
2385
2386 KeyEvent keyEventSeven(KeyCode::KEY_ENTER, KeyAction::DOWN);
2387 result = dialogPattern->HandleKeyEvent(keyEventSeven);
2388 EXPECT_TRUE(result);
2389 }
2390
2391 /**
2392 * @tc.name: CalendarDialogPatternTest003
2393 * @tc.desc: AddHotZoneRect Function Test
2394 * @tc.type: FUNC
2395 */
2396 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest003, TestSize.Level1)
2397 {
2398 CreateCalendarPicker();
2399
2400 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2401 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2402
2403 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2404 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2405
2406 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2407 ASSERT_NE(contentWrapper, nullptr);
2408 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2409 ASSERT_NE(calendarDialogNode, nullptr);
2410
2411 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2412 ASSERT_NE(dialogPattern, nullptr);
2413
2414 dialogPattern->AddHotZoneRect();
2415 }
2416
2417 /**
2418 * @tc.name: CalendarDialogPatternTest004
2419 * @tc.desc: HandleEntryChange Function Test
2420 * @tc.type: FUNC
2421 */
2422 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest004, TestSize.Level1)
2423 {
2424 CreateCalendarPicker();
2425
2426 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2427 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2428
2429 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2430 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2431
2432 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2433 ASSERT_NE(contentWrapper, nullptr);
2434 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2435 ASSERT_NE(calendarDialogNode, nullptr);
2436
2437 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2438 ASSERT_NE(dialogPattern, nullptr);
2439
2440 auto json = JsonUtil::Create(true);
2441 json->Put("year", 799);
2442 json->Put("month", 2);
2443 json->Put("day", 28);
2444 auto info = json->ToString();
2445
2446 dialogPattern->HandleEntryChange(info);
2447 auto calendarNode = dialogPattern->GetCalendarFrameNode();
2448 ASSERT_NE(calendarNode, nullptr);
2449 auto calendarPattern = calendarNode->GetPattern<CalendarPattern>();
2450 ASSERT_NE(calendarPattern, nullptr);
2451 auto newSelectedDay = calendarPattern->GetSelectedDay();
2452 EXPECT_EQ(newSelectedDay.GetYear(), 799);
2453 EXPECT_EQ(newSelectedDay.GetMonth(), 2);
2454 EXPECT_EQ(newSelectedDay.GetDay(), 28);
2455 }
2456
2457 /**
2458 * @tc.name: CalendarDialogPatternTest005
2459 * @tc.desc: IsAtomicNode Function Test
2460 * @tc.type: FUNC
2461 */
2462 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest005, TestSize.Level1)
2463 {
2464 CreateCalendarPicker();
2465
2466 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2467 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2468
2469 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2470 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2471
2472 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2473 ASSERT_NE(contentWrapper, nullptr);
2474 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2475 ASSERT_NE(calendarDialogNode, nullptr);
2476
2477 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2478 ASSERT_NE(dialogPattern, nullptr);
2479
2480 auto result = dialogPattern->IsAtomicNode();
2481 EXPECT_TRUE(result);
2482 }
2483
2484 /**
2485 * @tc.name: CalendarDialogPatternTest006
2486 * @tc.desc: HandleEntryLayoutChange Function Test
2487 * @tc.type: FUNC
2488 */
2489 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest006, TestSize.Level1)
2490 {
2491 CreateCalendarPicker();
2492
2493 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2494 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2495
2496 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2497 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2498
2499 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2500 ASSERT_NE(contentWrapper, nullptr);
2501 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2502 ASSERT_NE(calendarDialogNode, nullptr);
2503
2504 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2505 ASSERT_NE(dialogPattern, nullptr);
2506
2507 dialogPattern->HandleEntryLayoutChange();
2508 EXPECT_FALSE(dialogPattern->isFirstAddhotZoneRect_);
2509 }
2510
2511 /**
2512 * @tc.name: CalendarDialogPatternTest007
2513 * @tc.desc: GetEntryNode & GetDialogOffset Function Test
2514 * @tc.type: FUNC
2515 */
2516 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest007, TestSize.Level1)
2517 {
2518 CreateCalendarPicker();
2519 auto* stack = ViewStackProcessor::GetInstance();
2520 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a30d02() 2521 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2522
2523 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2524 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2525
2526 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2527 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2528
2529 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2530 ASSERT_NE(contentWrapper, nullptr);
2531 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2532 ASSERT_NE(calendarDialogNode, nullptr);
2533
2534 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2535 ASSERT_NE(dialogPattern, nullptr);
2536
2537 dialogPattern->GetDialogOffset();
2538
2539 auto layoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
2540 frameNode, AceType::MakeRefPtr<GeometryNode>(), AceType::MakeRefPtr<LayoutProperty>());
2541 EXPECT_TRUE(dialogPattern->OnDirtyLayoutWrapperSwap(layoutWrapper, true, true));
2542 }
2543
2544 /**
2545 * @tc.name: CalendarDialogPatternTest008
2546 * @tc.desc: onKeyEvent Function Test
2547 * @tc.type: FUNC
2548 */
2549 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest008, TestSize.Level1)
2550 {
2551 CreateCalendarPicker();
2552
2553 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2554 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2555
2556 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2557 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2558
2559 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2560 ASSERT_NE(contentWrapper, nullptr);
2561 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2562 ASSERT_NE(calendarDialogNode, nullptr);
2563
2564 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2565 ASSERT_NE(dialogPattern, nullptr);
2566
2567 auto eventHub = calendarDialogNode->GetOrCreateFocusHub();
2568 ASSERT_NE(eventHub, nullptr);
2569
2570 KeyEvent keyEventOne(KeyCode::KEY_0, KeyAction::DOWN);
2571 eventHub->ProcessOnKeyEventInternal(keyEventOne);
2572
2573 KeyEvent keyEventOne1(KeyCode::KEY_TAB, KeyAction::DOWN);
2574 eventHub->ProcessOnKeyEventInternal(keyEventOne1);
2575
2576 KeyEvent keyEventOne2(KeyCode::KEY_0, KeyAction::UP);
2577 eventHub->ProcessOnKeyEventInternal(keyEventOne2);
2578
2579 KeyEvent keyEventTwo(KeyCode::KEY_TAB, KeyAction::UP);
2580 eventHub->ProcessOnKeyEventInternal(keyEventTwo);
2581 dialogPattern->isFocused_ = true;
2582 dialogPattern->isCalendarFirstFocused_ = false;
2583 dialogPattern->focusAreaID_ = 1;
2584 eventHub->ProcessOnKeyEventInternal(keyEventTwo);
2585 EXPECT_TRUE(dialogPattern->isCalendarFirstFocused_);
2586
2587 KeyEvent keyEventTwo1(KeyCode::KEY_TAB, KeyAction::UP);
2588 eventHub->ProcessOnKeyEventInternal(keyEventTwo);
2589 dialogPattern->isFocused_ = false;
2590 dialogPattern->isCalendarFirstFocused_ = false;
2591 dialogPattern->focusAreaID_ = 1;
2592 eventHub->ProcessOnKeyEventInternal(keyEventTwo1);
2593
2594 KeyEvent keyEventTwo2(KeyCode::KEY_TAB, KeyAction::UP);
2595 eventHub->ProcessOnKeyEventInternal(keyEventTwo);
2596 dialogPattern->isFocused_ = true;
2597 dialogPattern->isCalendarFirstFocused_ = true;
2598 dialogPattern->focusAreaID_ = 1;
2599 eventHub->ProcessOnKeyEventInternal(keyEventTwo2);
2600
2601 KeyEvent keyEventTwo3(KeyCode::KEY_TAB, KeyAction::UP);
2602 eventHub->ProcessOnKeyEventInternal(keyEventTwo);
2603 dialogPattern->isFocused_ = true;
2604 dialogPattern->isCalendarFirstFocused_ = false;
2605 dialogPattern->focusAreaID_ = 3;
2606 eventHub->ProcessOnKeyEventInternal(keyEventTwo3);
2607
2608 KeyEvent keyEventThree(KeyCode::KEY_TAB, KeyAction::DOWN);
2609 dialogPattern->isFocused_ = true;
2610 dialogPattern->isCalendarFirstFocused_ = true;
2611 dialogPattern->focusAreaID_ = 3;
2612 eventHub->ProcessOnKeyEventInternal(keyEventThree);
2613 EXPECT_TRUE(dialogPattern->HandleKeyEvent(keyEventThree));
2614
2615 KeyEvent keyEventThree1(KeyCode::KEY_TAB, KeyAction::DOWN);
2616 dialogPattern->isFocused_ = false;
2617 dialogPattern->isCalendarFirstFocused_ = true;
2618 dialogPattern->focusAreaID_ = 3;
2619 eventHub->ProcessOnKeyEventInternal(keyEventThree1);
2620
2621 KeyEvent keyEventFour(KeyCode::KEY_TAB, KeyAction::UP);
2622 dialogPattern->isFocused_ = false;
2623 eventHub->ProcessOnKeyEventInternal(keyEventFour);
2624 }
2625
2626 /**
2627 * @tc.name: CalendarDialogPatternTest009
2628 * @tc.desc: getInnerPaintRectCallback Function Test
2629 * @tc.type: FUNC
2630 */
2631 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest009, TestSize.Level1)
2632 {
2633 CreateCalendarPicker();
2634
2635 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2636 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2637
2638 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2639 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2640
2641 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2642 ASSERT_NE(contentWrapper, nullptr);
2643 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2644 ASSERT_NE(calendarDialogNode, nullptr);
2645
2646 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2647 ASSERT_NE(dialogPattern, nullptr);
2648
2649 auto eventHub = calendarDialogNode->GetOrCreateFocusHub();
2650 ASSERT_NE(eventHub, nullptr);
2651
2652 PipelineContext::GetCurrentContext()->isFocusActive_ = true;
2653 eventHub->focusType_ = FocusType::NODE;
2654 eventHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
2655 eventHub->PaintFocusState();
2656 }
2657
2658 /**
2659 * @tc.name: CalendarDialogPatternTest010
2660 * @tc.desc: event Function Test
2661 * @tc.type: FUNC
2662 */
2663 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest010, TestSize.Level1)
2664 {
2665 CreateCalendarPicker();
2666
2667 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2668 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2669
2670 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2671 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2672
2673 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2674 ASSERT_NE(contentWrapper, nullptr);
2675 auto contentNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2676 ASSERT_NE(contentNode, nullptr);
2677 auto columnNode = AceType::DynamicCast<FrameNode>(contentNode->GetChildAtIndex(0));
2678 ASSERT_NE(columnNode, nullptr);
2679
2680 auto operationsNode = AceType::DynamicCast<FrameNode>(columnNode->GetLastChild());
2681 ASSERT_NE(operationsNode, nullptr);
2682 auto buttonConfirmNode = AceType::DynamicCast<FrameNode>(operationsNode->GetLastChild());
2683 ASSERT_NE(buttonConfirmNode, nullptr);
2684
2685 auto gesture = buttonConfirmNode->GetOrCreateGestureEventHub();
2686 ASSERT_NE(gesture, nullptr);
2687 gesture->CheckClickActuator();
2688 gesture->ActClick();
2689 }
2690
2691 /**
2692 * @tc.name: CalendarDialogPatternTest011
2693 * @tc.desc: InitOnTouchEvent Function Test
2694 * @tc.type: FUNC
2695 */
2696 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest011, TestSize.Level1)
2697 {
2698 CreateCalendarPicker();
2699 auto* stack = ViewStackProcessor::GetInstance();
2700 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a30e02() 2701 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2702
2703 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2704 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2705
2706 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2707 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2708
2709 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2710 ASSERT_NE(contentWrapper, nullptr);
2711 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2712 ASSERT_NE(calendarDialogNode, nullptr);
2713
2714 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2715 ASSERT_NE(dialogPattern, nullptr);
2716 dialogPattern->InitOnTouchEvent();
2717
2718 TouchEventInfo info("test");
2719 TouchLocationInfo lInfo(1);
2720 lInfo.SetTouchType(TouchType::UP);
2721 info.touches_.emplace_front(lInfo);
2722 dialogPattern->isFocused_ = true;
2723
2724 dialogPattern->touchListener_->callback_(info);
2725 EXPECT_TRUE(dialogPattern->isFocused_);
2726
2727 lInfo.SetTouchType(TouchType::DOWN);
2728 info.touches_.emplace_front(lInfo);
2729 dialogPattern->touchListener_->callback_(info);
2730 EXPECT_FALSE(dialogPattern->isFocused_);
2731 }
2732
2733 /**
2734 * @tc.name: CalendarDialogPatternTest012
2735 * @tc.desc: HandleKeyEvent Function Test
2736 * @tc.type: FUNC
2737 */
2738 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest012, TestSize.Level1)
2739 {
2740 CreateCalendarPicker();
2741 auto* stack = ViewStackProcessor::GetInstance();
2742 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a30f02() 2743 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2744
2745 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2746 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2747
2748 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2749 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2750
2751 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2752 ASSERT_NE(contentWrapper, nullptr);
2753 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2754 ASSERT_NE(calendarDialogNode, nullptr);
2755
2756 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2757 ASSERT_NE(dialogPattern, nullptr);
2758
2759 KeyEvent keyEventOne(KeyCode::KEY_0, KeyAction::DOWN);
2760 dialogPattern->focusAreaID_ = 3;
2761 EXPECT_FALSE(dialogPattern->HandleKeyEvent(keyEventOne));
2762
2763 KeyEvent keyEventLeftOne(KeyCode::KEY_DPAD_LEFT, KeyAction::DOWN);
2764 dialogPattern->focusAreaID_ = 2;
2765 dialogPattern->focusAreaChildID_ = 2;
2766 dialogPattern->HandleKeyEvent(keyEventLeftOne);
2767 EXPECT_EQ(dialogPattern->focusAreaChildID_, 0);
2768
2769 KeyEvent keyEventLeftTwo(KeyCode::KEY_DPAD_LEFT, KeyAction::DOWN);
2770 dialogPattern->focusAreaID_ = 2;
2771 dialogPattern->focusAreaChildID_ = 3;
2772 dialogPattern->HandleKeyEvent(keyEventLeftTwo);
2773 EXPECT_EQ(dialogPattern->focusAreaChildID_, 2);
2774
2775 KeyEvent keyEventLeftThree(KeyCode::KEY_DPAD_LEFT, KeyAction::DOWN);
2776 dialogPattern->focusAreaID_ = 0;
2777 dialogPattern->focusAreaChildID_ = 2;
2778 dialogPattern->HandleKeyEvent(keyEventLeftThree);
2779 EXPECT_EQ(dialogPattern->focusAreaChildID_, 1);
2780
2781 KeyEvent keyEventRightOne(KeyCode::KEY_DPAD_RIGHT, KeyAction::DOWN);
2782 dialogPattern->focusAreaID_ = 0;
2783 dialogPattern->focusAreaChildID_ = 1;
2784 dialogPattern->HandleKeyEvent(keyEventRightOne);
2785 EXPECT_EQ(dialogPattern->focusAreaChildID_, 3);
2786
2787 KeyEvent keyEventEnter(KeyCode::KEY_ENTER, KeyAction::DOWN);
2788 dialogPattern->focusAreaID_ = 2;
2789 EXPECT_FALSE(dialogPattern->HandleKeyEvent(keyEventEnter));
2790
2791 KeyEvent keyEventCall(KeyCode::KEY_CALL, KeyAction::DOWN);
2792 dialogPattern->focusAreaID_ = 0;
2793 EXPECT_FALSE(dialogPattern->HandleKeyEvent(keyEventCall));
2794 }
2795
2796 /**
2797 * @tc.name: CalendarDialogPatternTest013
2798 * @tc.desc: HandleTabKeyEvent Function Test
2799 * @tc.type: FUNC
2800 */
2801 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest013, TestSize.Level1)
2802 {
2803 CreateCalendarPicker();
2804 auto* stack = ViewStackProcessor::GetInstance();
2805 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31002() 2806 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2807
2808 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2809 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2810
2811 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2812 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2813
2814 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2815 ASSERT_NE(contentWrapper, nullptr);
2816 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2817 ASSERT_NE(calendarDialogNode, nullptr);
2818
2819 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2820 ASSERT_NE(dialogPattern, nullptr);
2821
2822 KeyEvent keyEventLeft;
2823 keyEventLeft.code = KeyCode::KEY_DPAD_RIGHT;
2824 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventLeft));
2825 keyEventLeft.code = KeyCode::KEY_DPAD_LEFT;
2826 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventLeft));
2827
2828 KeyEvent keyEventRight;
2829 keyEventRight.code = KeyCode::KEY_DPAD_LEFT;
2830 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventRight));
2831 keyEventRight.code = KeyCode::KEY_DPAD_RIGHT;
2832 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventRight));
2833
2834 KeyEvent keyEventUp;
2835 keyEventUp.code = KeyCode::KEY_DPAD_UP;
2836 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventUp));
2837 keyEventUp.code = KeyCode::KEY_DPAD_UP;
2838 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventUp));
2839 keyEventUp.code = KeyCode::KEY_DPAD_UP;
2840 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventUp));
2841 keyEventUp.code = KeyCode::KEY_DPAD_UP;
2842 EXPECT_FALSE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventUp));
2843 keyEventUp.code = KeyCode::KEY_DPAD_UP;
2844 EXPECT_FALSE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventUp));
2845 keyEventUp.code = KeyCode::KEY_DPAD_UP;
2846 EXPECT_FALSE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventUp));
2847
2848 KeyEvent keyEventDown;
2849 keyEventDown.code = KeyCode::KEY_DPAD_DOWN;
2850 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventDown));
2851 keyEventDown.code = KeyCode::KEY_DPAD_DOWN;
2852 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventDown));
2853 keyEventDown.code = KeyCode::KEY_DPAD_DOWN;
2854 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventDown));
2855 keyEventDown.code = KeyCode::KEY_DPAD_DOWN;
2856 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventDown));
2857 keyEventDown.code = KeyCode::KEY_DPAD_DOWN;
2858 EXPECT_FALSE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventDown));
2859 keyEventDown.code = KeyCode::KEY_DPAD_DOWN;
2860 EXPECT_FALSE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventDown));
2861
2862 KeyEvent keyEventOne;
2863 keyEventOne.code = KeyCode::KEY_1;
2864
2865 KeyEvent keyEvent;
2866 keyEvent.action = KeyAction::DOWN;
2867 EXPECT_FALSE(dialogPattern->HandleCalendarNodeKeyEvent(keyEvent));
2868 }
2869
2870 /**
2871 * @tc.name: CalendarDialogPatternTest014
2872 * @tc.desc: HandleTabKeyEvent & UpdateSwiperNodeFocusedDay Function Test
2873 * @tc.type: FUNC
2874 */
2875 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest014, TestSize.Level1)
2876 {
2877 CreateCalendarPicker();
2878 auto* stack = ViewStackProcessor::GetInstance();
2879 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31102() 2880 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2881
2882 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2883 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2884
2885 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2886 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2887
2888 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2889 ASSERT_NE(contentWrapper, nullptr);
2890 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2891 ASSERT_NE(calendarDialogNode, nullptr);
2892
2893 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2894 ASSERT_NE(dialogPattern, nullptr);
2895
2896 dialogPattern->focusedDay_.day = 0;
2897 dialogPattern->FocusedLastFocusedDay();
2898
2899 KeyEvent keyEventRight;
2900 keyEventRight.code = KeyCode::KEY_DPAD_LEFT;
2901 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventRight));
2902 keyEventRight.code = KeyCode::KEY_DPAD_RIGHT;
2903 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventRight));
2904 dialogPattern->FocusedLastFocusedDay();
2905
2906 KeyEvent keyEventIsPrev;
2907 keyEventIsPrev.code = KeyCode::KEY_DPAD_RIGHT;
2908 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventIsPrev));
2909 keyEventIsPrev.code = KeyCode::KEY_DPAD_LEFT;
2910 EXPECT_TRUE(dialogPattern->HandleCalendarNodeKeyEvent(keyEventIsPrev));
2911 dialogPattern->FocusedLastFocusedDay();
2912
2913 CalendarDay focusedDayTrue;
2914 focusedDayTrue.day = 1;
2915 focusedDayTrue.month.year = 2000;
2916 focusedDayTrue.month.month = 1;
2917 dialogPattern->FocusedLastFocusedDay();
2918 dialogPattern->UpdateSwiperNodeFocusedDay(focusedDayTrue, true);
2919
2920 CalendarDay focusedDay;
2921 focusedDay.day = 1;
2922 focusedDay.month.year = 2000;
2923 focusedDay.month.month = 2;
2924 dialogPattern->FocusedLastFocusedDay();
2925 dialogPattern->UpdateSwiperNodeFocusedDay(focusedDay, false);
2926
2927 CalendarDay isPrev;
2928 isPrev.day = 1;
2929 isPrev.month.year = 1999;
2930 isPrev.month.month = 2;
2931 dialogPattern->FocusedLastFocusedDay();
2932 }
2933
2934 /**
2935 * @tc.name: CalendarDialogPatternTest015
2936 * @tc.desc: PaintNonCurrentMonthFocusState Function Test
2937 * @tc.type: FUNC
2938 */
2939 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest015, TestSize.Level1)
2940 {
2941 CreateCalendarPicker();
2942 auto* stack = ViewStackProcessor::GetInstance();
2943 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31202() 2944 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2945
2946 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2947 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2948
2949 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2950 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2951
2952 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2953 ASSERT_NE(contentWrapper, nullptr);
2954 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2955 ASSERT_NE(calendarDialogNode, nullptr);
2956
2957 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2958 ASSERT_NE(dialogPattern, nullptr);
2959
2960 auto currentMonthData = dialogPattern->GetCalendarPattern()->GetCurrentMonthData();
2961
2962 dialogPattern->PaintNonCurrentMonthFocusState(-1);
2963 dialogPattern->PaintNonCurrentMonthFocusState(-2);
2964 dialogPattern->PaintNonCurrentMonthFocusState(currentMonthData.days.size());
2965 dialogPattern->PaintNonCurrentMonthFocusState(currentMonthData.days.size() + 1);
2966 dialogPattern->PaintNonCurrentMonthFocusState(0);
2967 dialogPattern->PaintNonCurrentMonthFocusState(currentMonthData.days.size() - 1);
2968 }
2969
2970 /**
2971 * @tc.name: CalendarDialogPatternTest016
2972 * @tc.desc: GetInnerFocusPaintRect Function Test
2973 * @tc.type: FUNC
2974 */
2975 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest016, TestSize.Level1)
2976 {
2977 CreateCalendarPicker();
2978 auto* stack = ViewStackProcessor::GetInstance();
2979 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31302() 2980 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
2981
2982 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
2983 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
2984
2985 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
2986 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
2987
2988 auto contentWrapper = dialogNode->GetChildAtIndex(0);
2989 ASSERT_NE(contentWrapper, nullptr);
2990 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
2991 ASSERT_NE(calendarDialogNode, nullptr);
2992
2993 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
2994 ASSERT_NE(dialogPattern, nullptr);
2995
2996 RoundRect paintRect;
2997 dialogPattern->focusAreaID_ = 1;
2998 dialogPattern->GetInnerFocusPaintRect(paintRect);
2999 }
3000
3001 /**
3002 * @tc.name: CalendarDialogPatternTest017
3003 * @tc.desc: ChangeEntryState Function Test
3004 * @tc.type: FUNC
3005 */
3006 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest017, TestSize.Level1)
3007 {
3008 CreateCalendarPicker();
3009 auto* stack = ViewStackProcessor::GetInstance();
3010 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31402() 3011 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
3012
3013 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3014 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3015
3016 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3017 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3018
3019 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3020 ASSERT_NE(contentWrapper, nullptr);
3021 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3022 ASSERT_NE(calendarDialogNode, nullptr);
3023
3024 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3025 ASSERT_NE(dialogPattern, nullptr);
3026
3027 dialogPattern->focusAreaID_ = 0;
3028 dialogPattern->focusAreaChildID_ = 0;
3029 dialogPattern->ChangeEntryState();
3030
3031 dialogPattern->focusAreaID_ = 0;
3032 dialogPattern->focusAreaChildID_ = 3;
3033 dialogPattern->ChangeEntryState();
3034
3035 dialogPattern->focusAreaID_ = 2;
3036 dialogPattern->focusAreaChildID_ = 2;
3037 dialogPattern->ChangeEntryState();
3038 }
3039
3040 /**
3041 * @tc.name: CalendarDialogPatternTest018
3042 * @tc.desc: HandleTitleArrowsClickEvent Function Test
3043 * @tc.type: FUNC
3044 */
3045 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest018, TestSize.Level1)
3046 {
3047 CalendarDialogView calendarDialogView;
3048 CalendarSettingData settingData;
3049 DialogProperties properties;
3050 properties.alignment = DialogAlignment::BOTTOM;
3051 properties.customStyle = false;
3052 properties.offset = DimensionOffset(Offset(0, -1.0f));
3053 auto selectedDate = PickerDate(1, 1, 1);
3054 settingData.selectedDate = selectedDate;
3055 settingData.dayRadius = TEST_SETTING_RADIUS;
3056 std::map<std::string, NG::DialogEvent> dialogEvent;
3057 std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent;
3058 std::vector<ButtonInfo> buttonInfos;
3059 auto dialogNode = calendarDialogView.Show(properties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
3060 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3061 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3062 ASSERT_NE(contentWrapper, nullptr);
3063 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3064 ASSERT_NE(calendarDialogNode, nullptr);
3065
3066 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3067 ASSERT_NE(dialogPattern, nullptr);
3068
3069 auto currentMonthData = dialogPattern->GetCalendarPattern()->GetCurrentMonthData();
3070 dialogPattern->HandleTitleArrowsClickEvent(0);
3071 dialogPattern->HandleTitleArrowsClickEvent(1);
3072 dialogPattern->HandleTitleArrowsClickEvent(2);
3073 dialogPattern->HandleTitleArrowsClickEvent(3);
3074 dialogPattern->HandleTitleArrowsClickEvent(4);
3075 }
3076
3077 /**
3078 * @tc.name: CalendarDialogPatternTest019
3079 * @tc.desc: OnDirtyLayoutWrapperSwap Function Test
3080 * @tc.type: FUNC
3081 */
3082 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest019, TestSize.Level1)
3083 {
3084 auto dialogPattern = AceType::MakeRefPtr<CalendarDialogPattern>();
3085
3086 dialogPattern->OnDirtyLayoutWrapperSwap(nullptr, true, true);
3087 dialogPattern->OnDirtyLayoutWrapperSwap(nullptr, true, true);
3088 }
3089
3090 /**
3091 * @tc.name: CalendarDialogPatternTest020
3092 * @tc.desc: GetNextMonth Function Test
3093 * @tc.type: FUNC
3094 */
3095 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest020, TestSize.Level1)
3096 {
3097 CreateCalendarPicker();
3098 auto* stack = ViewStackProcessor::GetInstance();
3099 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31502() 3100 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
3101
3102 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3103 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3104
3105 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3106 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3107
3108 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3109 ASSERT_NE(contentWrapper, nullptr);
3110 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3111 ASSERT_NE(calendarDialogNode, nullptr);
3112
3113 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3114 ASSERT_NE(dialogPattern, nullptr);
3115
3116 CalendarMonth calendarMax;
3117 calendarMax.year = 5000;
3118 calendarMax.month = 12;
3119 dialogPattern->GetNextMonth(calendarMax);
3120 }
3121
3122 /**
3123 * @tc.name: CalendarDialogPatternTest021
3124 * @tc.desc: GetLastMonth Function Test
3125 * @tc.type: FUNC
3126 */
3127 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest021, TestSize.Level1)
3128 {
3129 CreateCalendarPicker();
3130 auto* stack = ViewStackProcessor::GetInstance();
3131 auto frameNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31602() 3132 V2::CALENDAR_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<CalendarPattern>(); });
3133
3134 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3135 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3136
3137 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3138 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3139
3140 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3141 ASSERT_NE(contentWrapper, nullptr);
3142 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3143 ASSERT_NE(calendarDialogNode, nullptr);
3144
3145 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3146 ASSERT_NE(dialogPattern, nullptr);
3147
3148 CalendarMonth calendarMin;
3149 calendarMin.year = 1;
3150 calendarMin.month = 1;
3151 dialogPattern->GetLastMonth(calendarMin);
3152 }
3153
3154 /**
3155 * @tc.name: CalendarDialogPatternTest022
3156 * @tc.desc: HandleTitleArrowsClickEvent Function Test
3157 * @tc.type: FUNC
3158 */
3159 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest022, TestSize.Level1)
3160 {
3161 CalendarDialogView calendarDialogView;
3162 CalendarSettingData settingData;
3163 DialogProperties properties;
3164 properties.alignment = DialogAlignment::BOTTOM;
3165 properties.customStyle = false;
3166 properties.offset = DimensionOffset(Offset(0, -1.0f));
3167 auto selectedDate = PickerDate(5000, 12, 31);
3168 settingData.selectedDate = selectedDate;
3169 settingData.dayRadius = TEST_SETTING_RADIUS;
3170 std::map<std::string, NG::DialogEvent> dialogEvent;
3171 std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent;
3172 std::vector<ButtonInfo> buttonInfos;
3173 auto dialogNode = calendarDialogView.Show(properties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
3174 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3175 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3176 ASSERT_NE(contentWrapper, nullptr);
3177 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3178 ASSERT_NE(calendarDialogNode, nullptr);
3179
3180 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3181 ASSERT_NE(dialogPattern, nullptr);
3182
3183 auto currentMonthData = dialogPattern->GetCalendarPattern()->GetCurrentMonthData();
3184 dialogPattern->HandleTitleArrowsClickEvent(0);
3185 dialogPattern->HandleTitleArrowsClickEvent(1);
3186 dialogPattern->HandleTitleArrowsClickEvent(2);
3187 dialogPattern->HandleTitleArrowsClickEvent(3);
3188 dialogPattern->HandleTitleArrowsClickEvent(4);
3189 }
3190
3191 /**
3192 * @tc.name: CalendarDialogPatternTest023
3193 * @tc.desc: mouseCallback Function Test
3194 * @tc.type: FUNC
3195 */
3196 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest023, TestSize.Level1)
3197 {
3198 CreateCalendarPicker();
3199
3200 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3201 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3202
3203 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3204 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3205
3206 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3207 ASSERT_NE(contentWrapper, nullptr);
3208 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3209 ASSERT_NE(calendarDialogNode, nullptr);
3210
3211 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3212 ASSERT_NE(dialogPattern, nullptr);
3213 dialogPattern->SetHoverState(true);
3214 auto inputHub = calendarDialogNode->GetOrCreateInputEventHub();
3215 ASSERT_NE(inputHub, nullptr);
3216 ASSERT_NE(inputHub->mouseEventActuator_, nullptr);
3217 ASSERT_NE(inputHub->mouseEventActuator_->userCallback_, nullptr);
3218 ASSERT_NE(inputHub->mouseEventActuator_->userCallback_->onMouseCallback_, nullptr);
3219
3220 MouseInfo info;
3221 inputHub->mouseEventActuator_->userCallback_->onMouseCallback_(info);
3222 }
3223
3224 /**
3225 * @tc.name: CalendarDialogPatternTest024
3226 * @tc.desc: hoverCallback Function Test
3227 * @tc.type: FUNC
3228 */
3229 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest024, TestSize.Level1)
3230 {
3231 CreateCalendarPicker();
3232
3233 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3234 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3235
3236 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3237 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3238
3239 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3240 ASSERT_NE(contentWrapper, nullptr);
3241 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3242 ASSERT_NE(calendarDialogNode, nullptr);
3243
3244 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3245 ASSERT_NE(dialogPattern, nullptr);
3246
3247 ASSERT_NE(dialogPattern, nullptr);
3248 ASSERT_NE(dialogPattern->hoverListener_, nullptr);
3249 ASSERT_NE(dialogPattern->hoverListener_->onHoverCallback_, nullptr);
3250 dialogPattern->hoverListener_->onHoverCallback_(false);
3251 }
3252
3253 /**
3254 * @tc.name: CalendarDialogPatternTest025
3255 * @tc.desc: HandleEntryNodeHoverEvent Function Test
3256 * @tc.type: FUNC
3257 */
3258 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest025, TestSize.Level1)
3259 {
3260 CreateCalendarPicker();
3261
3262 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3263 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3264
3265 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3266 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3267
3268 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3269 ASSERT_NE(contentWrapper, nullptr);
3270 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3271 ASSERT_NE(calendarDialogNode, nullptr);
3272
3273 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3274 ASSERT_NE(dialogPattern, nullptr);
3275
3276 Offset globalLocation;
3277 dialogPattern->HandleEntryNodeHoverEvent(true, globalLocation);
3278 }
3279
3280 /**
3281 * @tc.name: CalendarDialogPatternTest026
3282 * @tc.desc: blurTask Function Test
3283 * @tc.type: FUNC
3284 */
3285 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest026, TestSize.Level1)
3286 {
3287 CreateCalendarPicker();
3288
3289 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3290 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3291
3292 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3293 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3294
3295 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3296 ASSERT_NE(contentWrapper, nullptr);
3297 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3298 ASSERT_NE(calendarDialogNode, nullptr);
3299
3300 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3301 ASSERT_NE(dialogPattern, nullptr);
3302
3303 auto eventHub = calendarDialogNode->GetOrCreateFocusHub();
3304 ASSERT_NE(eventHub, nullptr);
3305 ASSERT_NE(eventHub->onBlurInternal_, nullptr);
3306
3307 eventHub->onBlurInternal_();
3308 }
3309
3310 /**
3311 * @tc.name: CalendarDialogPatternTest027
3312 * @tc.desc: hoverCallback Function Test
3313 * @tc.type: FUNC
3314 */
3315 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest027, TestSize.Level1)
3316 {
3317 CreateCalendarPicker();
3318
3319 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3320 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3321
3322 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3323 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3324
3325 auto contentWrapper = dialogNode->GetChildAtIndex(0);
3326 ASSERT_NE(contentWrapper, nullptr);
3327 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3328 ASSERT_NE(calendarDialogNode, nullptr);
3329
3330 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3331 ASSERT_NE(dialogPattern, nullptr);
3332
3333 ASSERT_NE(dialogPattern, nullptr);
3334 ASSERT_NE(dialogPattern->hoverListener_, nullptr);
3335 ASSERT_NE(dialogPattern->hoverListener_->onHoverCallback_, nullptr);
3336 dialogPattern->hoverListener_->onHoverCallback_(true);
3337 }
3338
3339 /**
3340 * @tc.name: CalendarDialogPatternTest028
3341 * @tc.desc: UpdateDialogBackgroundColor Function Test
3342 * @tc.type: FUNC
3343 */
3344 HWTEST_F(CalendarPickerTestNg, CalendarDialogPatternTest028, TestSize.Level1)
3345 {
3346 /**
3347 * @tc.steps: step1. CreateCalendarPicker.
3348 * @tc.expected: create successfully.
3349 */
3350 CreateCalendarPicker();
3351
3352 /**
3353 * @tc.steps: step2. create dialogPattern.
3354 * @tc.expected: create successfully.
3355 */
3356 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3357 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3358 auto dialogNode = CalendarDialogShow(AceType::DynamicCast<FrameNode>(element));
3359 EXPECT_EQ(dialogNode->GetTag(), V2::DIALOG_ETS_TAG);
3360 auto contentWrapper = AceType::DynamicCast<FrameNode>(dialogNode->GetChildAtIndex(0));
3361 ASSERT_NE(contentWrapper, nullptr);
3362 auto calendarDialogNode = AceType::DynamicCast<FrameNode>(contentWrapper->GetChildAtIndex(0));
3363 ASSERT_NE(calendarDialogNode, nullptr);
3364 auto dialogPattern = calendarDialogNode->GetPattern<CalendarDialogPattern>();
3365 /**
3366 * @tc.steps: step3. mock PlatformVersion VERSION_ELEVEN and CalendarTheme.
3367 * @tc.expected: mock successfully.
3368 */
3369 RefPtr<CalendarTheme> theme = MockPipelineContext::GetCurrent()->GetTheme<CalendarTheme>();
3370 MockPipelineContext::GetCurrent()->SetMinPlatformVersion(static_cast<int32_t>(PlatformVersion::VERSION_ELEVEN));
3371 /**
3372 * @tc.steps: step4. execute UpdateDialogBackgroundColor.
3373 * @tc.expected: execute successfully.
3374 */
3375 dialogPattern->UpdateDialogBackgroundColor();
3376 /**
3377 * @tc.steps: step5. test calendarDialogNode's RenderContext's BackgroundColorValue value.
3378 * @tc.expected: equal TRANSPARENT.
3379 */
3380 EXPECT_EQ(contentWrapper->GetRenderContext()->GetBackgroundColorValue(Color::TRANSPARENT).ColorToString(),
3381 Color::TRANSPARENT.ColorToString());
3382 /**
3383 * @tc.steps: step6. mock PlatformVersion VERSION_TEN.
3384 * @tc.expected: mock successfully.
3385 */
3386 MockPipelineContext::GetCurrent()->SetMinPlatformVersion(static_cast<int32_t>(PlatformVersion::VERSION_TEN));
3387 /**
3388 * @tc.steps: step7. test calendarDialogNode's RenderContext's BackgroundColorValue value.
3389 * @tc.expected: equal themeColor.
3390 */
3391 dialogPattern->UpdateDialogBackgroundColor();
3392 EXPECT_EQ(contentWrapper->GetRenderContext()->GetBackgroundColorValue(Color::TRANSPARENT).ColorToString(),
3393 theme->GetDialogBackgroundColor().ColorToString());
3394 }
3395
3396 /**
3397 * @tc.name: CalendarPickerTextDirectionTest001
3398 * @tc.desc: CalendarPicker TextDirection Test
3399 * @tc.type: FUNC
3400 */
3401 HWTEST_F(CalendarPickerTestNg, CalendarPickerTextDirectionTest001, TestSize.Level1)
3402 {
3403 AceApplicationInfo::GetInstance().isRightToLeft_ = true;
3404 CreateCalendarPicker();
3405
3406 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3407 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3408
3409 auto frameNode = AceType::DynamicCast<FrameNode>(element);
3410 ASSERT_NE(frameNode, nullptr);
3411 auto contentFrameNode = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
3412 ASSERT_NE(contentFrameNode, nullptr);
3413 auto contentLayoutProperty = contentFrameNode->GetLayoutProperty<LinearLayoutProperty>();
3414 ASSERT_NE(contentLayoutProperty, nullptr);
3415 EXPECT_EQ(contentLayoutProperty->GetLayoutDirection(), TextDirection::LTR);
3416 }
3417
3418 /**
3419 * @tc.name: CalendarPickerLayoutPropertyTest001
3420 * @tc.desc: Calendar Picker LayoutProperty Function Test
3421 * @tc.type: FUNC
3422 */
3423 HWTEST_F(CalendarPickerTestNg, CalendarPickerLayoutPropertyTest001, TestSize.Level1)
3424 {
3425 CreateCalendarPicker();
3426
3427 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3428 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3429
3430 auto frameNode = AceType::DynamicCast<FrameNode>(element);
3431 ASSERT_NE(frameNode, nullptr);
3432 auto layoutProperty = frameNode->GetLayoutProperty<CalendarPickerLayoutProperty>();
3433 ASSERT_NE(layoutProperty, nullptr);
3434 auto clone = layoutProperty->Clone();
3435
3436 std::unique_ptr<JsonValue> json = std::make_unique<JsonValue>();
3437 layoutProperty->ToJsonValue(json, filter);
3438 layoutProperty->Reset();
3439 clone.Reset();
3440
3441 ASSERT_NE(json, nullptr);
3442 }
3443
3444 /**
3445 * @tc.name: CalendarPickerLayoutPropertyTest002
3446 * @tc.desc: CalendarPicker LayoutAlgorithm Measure Function Test
3447 * @tc.type: FUNC
3448 */
3449 HWTEST_F(CalendarPickerTestNg, CalendarPickerLayoutPropertyTest002, TestSize.Level1)
3450 {
3451 CreateCalendarPicker();
3452
3453 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3454 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3455
3456 auto frameNode = AceType::DynamicCast<FrameNode>(element);
3457 ASSERT_NE(frameNode, nullptr);
3458 auto layoutProperty = frameNode->GetLayoutProperty<CalendarPickerLayoutProperty>();
3459 ASSERT_NE(layoutProperty, nullptr);
3460
3461 std::unique_ptr<JsonValue> json = std::make_unique<JsonValue>();
3462
3463 layoutProperty->propDialogAlignType_ = CalendarEdgeAlign::EDGE_ALIGN_START;
3464 layoutProperty->ToJsonValue(json, filter);
3465 layoutProperty->propDialogAlignType_ = CalendarEdgeAlign::EDGE_ALIGN_CENTER;
3466 layoutProperty->ToJsonValue(json, filter);
3467 layoutProperty->propDialogAlignType_ = CalendarEdgeAlign::EDGE_ALIGN_END;
3468 layoutProperty->ToJsonValue(json, filter);
3469 }
3470
3471 /**
3472 * @tc.name: CalendarPickerLayoutAlgorithmTest001
3473 * @tc.desc: CalendarPicker LayoutAlgorithm Measure Function Test
3474 * @tc.type: FUNC
3475 */
3476 HWTEST_F(CalendarPickerTestNg, CalendarPickerLayoutAlgorithmTest001, TestSize.Level1)
3477 {
3478 CreateCalendarPicker();
3479
3480 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3481 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3482
3483 auto frameNode = AceType::DynamicCast<FrameNode>(element);
3484 ASSERT_NE(frameNode, nullptr);
3485
3486 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
3487 ASSERT_NE(geometryNode, nullptr);
3488 RefPtr<LayoutWrapperNode> layoutWrapper =
3489 AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
3490 auto layoutAlgorithmPattern = AceType::DynamicCast<CalendarPickerPattern>(frameNode->GetPattern());
3491 ASSERT_NE(layoutAlgorithmPattern, nullptr);
3492 auto calendarPickerLayoutAlgorithm = layoutAlgorithmPattern->CreateLayoutAlgorithm();
3493 ASSERT_NE(calendarPickerLayoutAlgorithm, nullptr);
3494 layoutWrapper->SetLayoutAlgorithm(AceType::MakeRefPtr<LayoutAlgorithmWrapper>(calendarPickerLayoutAlgorithm));
3495
3496 auto contentFrameNode = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
3497 ASSERT_NE(contentFrameNode, nullptr);
3498 auto contentLayoutProperty = contentFrameNode->GetLayoutProperty<LinearLayoutProperty>();
3499 RefPtr<GeometryNode> contentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3500 RefPtr<LayoutWrapperNode> contentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3501 contentFrameNode, contentFrameNodeGeometryNode, contentFrameNode->GetLayoutProperty());
3502 ASSERT_NE(contentNodeLayoutWrapper, nullptr);
3503 layoutWrapper->AppendChild(contentNodeLayoutWrapper);
3504
3505 auto flexFrameNode = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(1));
3506 ASSERT_NE(flexFrameNode, nullptr);
3507 auto flexLayoutProperty = flexFrameNode->GetLayoutProperty<FlexLayoutProperty>();
3508 RefPtr<GeometryNode> flexFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3509 RefPtr<LayoutWrapperNode> flexNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3510 flexFrameNode, flexFrameNodeGeometryNode, flexFrameNode->GetLayoutProperty());
3511 ASSERT_NE(flexNodeLayoutWrapper, nullptr);
3512 layoutWrapper->AppendChild(flexNodeLayoutWrapper);
3513
3514 auto yearNode = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(0));
3515 auto yearContentLayoutProperty = yearNode->GetLayoutProperty<TextLayoutProperty>();
3516 RefPtr<GeometryNode> yearContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3517 RefPtr<LayoutWrapperNode> yearContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3518 yearNode, yearContentFrameNodeGeometryNode, yearNode->GetLayoutProperty());
3519 ASSERT_NE(yearContentNodeLayoutWrapper, nullptr);
3520 contentNodeLayoutWrapper->AppendChild(yearContentNodeLayoutWrapper);
3521
3522 auto textNode1 = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(1));
3523 auto text1ContentLayoutProperty = textNode1->GetLayoutProperty<TextLayoutProperty>();
3524 RefPtr<GeometryNode> text1ContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3525 RefPtr<LayoutWrapperNode> text1ContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3526 textNode1, text1ContentFrameNodeGeometryNode, textNode1->GetLayoutProperty());
3527 ASSERT_NE(text1ContentNodeLayoutWrapper, nullptr);
3528 contentNodeLayoutWrapper->AppendChild(text1ContentNodeLayoutWrapper);
3529
3530 auto monthNode = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(2));
3531 auto monthContentLayoutProperty = monthNode->GetLayoutProperty<TextLayoutProperty>();
3532 RefPtr<GeometryNode> monthContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3533 RefPtr<LayoutWrapperNode> monthContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3534 monthNode, monthContentFrameNodeGeometryNode, monthNode->GetLayoutProperty());
3535 ASSERT_NE(monthContentNodeLayoutWrapper, nullptr);
3536 contentNodeLayoutWrapper->AppendChild(monthContentNodeLayoutWrapper);
3537
3538 auto textNode2 = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(3));
3539 auto text2ContentLayoutProperty = textNode2->GetLayoutProperty<TextLayoutProperty>();
3540 RefPtr<GeometryNode> text2ContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3541 RefPtr<LayoutWrapperNode> text2ContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3542 textNode2, text2ContentFrameNodeGeometryNode, textNode2->GetLayoutProperty());
3543 ASSERT_NE(text2ContentNodeLayoutWrapper, nullptr);
3544 contentNodeLayoutWrapper->AppendChild(text2ContentNodeLayoutWrapper);
3545
3546 auto dayNode = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(4));
3547 auto dayContentLayoutProperty = dayNode->GetLayoutProperty<TextLayoutProperty>();
3548 RefPtr<GeometryNode> dayContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3549 RefPtr<LayoutWrapperNode> dayContentNodeLayoutWrapper =
3550 AceType::MakeRefPtr<LayoutWrapperNode>(dayNode, dayContentFrameNodeGeometryNode, dayNode->GetLayoutProperty());
3551 ASSERT_NE(dayContentNodeLayoutWrapper, nullptr);
3552 contentNodeLayoutWrapper->AppendChild(dayContentNodeLayoutWrapper);
3553
3554 auto buttonNode1 = AceType::DynamicCast<FrameNode>(flexFrameNode->GetOrCreateChildByIndex(0));
3555 auto button1LayoutProperty = buttonNode1->GetLayoutProperty<ButtonLayoutProperty>();
3556 RefPtr<GeometryNode> button1NodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3557 RefPtr<LayoutWrapperNode> button1NodeLayoutWrapper =
3558 AceType::MakeRefPtr<LayoutWrapperNode>(buttonNode1, button1NodeGeometryNode, buttonNode1->GetLayoutProperty());
3559 ASSERT_NE(button1NodeLayoutWrapper, nullptr);
3560 flexNodeLayoutWrapper->AppendChild(button1NodeLayoutWrapper);
3561
3562 auto buttonNode2 = AceType::DynamicCast<FrameNode>(flexFrameNode->GetOrCreateChildByIndex(1));
3563 auto button2LayoutProperty = buttonNode2->GetLayoutProperty<ButtonLayoutProperty>();
3564 RefPtr<GeometryNode> button2NodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3565 RefPtr<LayoutWrapperNode> button2NodeLayoutWrapper =
3566 AceType::MakeRefPtr<LayoutWrapperNode>(buttonNode2, button2NodeGeometryNode, buttonNode2->GetLayoutProperty());
3567 ASSERT_NE(button2NodeLayoutWrapper, nullptr);
3568 flexNodeLayoutWrapper->AppendChild(button2NodeLayoutWrapper);
3569
3570 auto imageNode1 = AceType::DynamicCast<FrameNode>(buttonNode1->GetOrCreateChildByIndex(0));
3571 auto image1LayoutProperty = imageNode1->GetLayoutProperty<ImageLayoutProperty>();
3572 RefPtr<GeometryNode> image1NodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3573 RefPtr<LayoutWrapperNode> image1NodeLayoutWrapper =
3574 AceType::MakeRefPtr<LayoutWrapperNode>(imageNode1, image1NodeGeometryNode, imageNode1->GetLayoutProperty());
3575 ASSERT_NE(image1NodeLayoutWrapper, nullptr);
3576 layoutWrapper->AppendChild(image1NodeLayoutWrapper);
3577
3578 auto imageNode2 = AceType::DynamicCast<FrameNode>(buttonNode2->GetOrCreateChildByIndex(0));
3579 auto image2LayoutProperty = imageNode2->GetLayoutProperty<ImageLayoutProperty>();
3580 RefPtr<GeometryNode> image2NodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3581 RefPtr<LayoutWrapperNode> image2NodeLayoutWrapper =
3582 AceType::MakeRefPtr<LayoutWrapperNode>(imageNode2, image2NodeGeometryNode, imageNode2->GetLayoutProperty());
3583 ASSERT_NE(image2NodeLayoutWrapper, nullptr);
3584 layoutWrapper->AppendChild(image2NodeLayoutWrapper);
3585
3586 LayoutConstraintF LayoutConstraintVaildSize;
3587 LayoutConstraintVaildSize.selfIdealSize.SetWidth(10000);
3588 LayoutConstraintVaildSize.selfIdealSize.SetHeight(25000);
3589 layoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(LayoutConstraintVaildSize);
3590 layoutWrapper->GetLayoutProperty()->UpdateContentConstraint();
3591
3592 calendarPickerLayoutAlgorithm->Measure(AccessibilityManager::RawPtr(layoutWrapper));
3593 EXPECT_NE(calendarPickerLayoutAlgorithm, nullptr);
3594 }
3595
3596 /**
3597 * @tc.name: CalendarPickerLayoutAlgorithmTest002
3598 * @tc.desc: CalendarPicker Measure Function Test
3599 * @tc.type: FUNC
3600 */
3601 HWTEST_F(CalendarPickerTestNg, CalendarPickerLayoutAlgorithmTest002, TestSize.Level1)
3602 {
3603 CreateCalendarPicker();
3604
3605 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3606 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3607
3608 auto frameNode = AceType::DynamicCast<FrameNode>(element);
3609 ASSERT_NE(frameNode, nullptr);
3610
3611 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
3612 ASSERT_NE(geometryNode, nullptr);
3613 RefPtr<LayoutWrapperNode> layoutWrapper =
3614 AceType::MakeRefPtr<LayoutWrapperNode>(frameNode, geometryNode, frameNode->GetLayoutProperty());
3615 auto searchPattern = AceType::DynamicCast<CalendarPickerPattern>(frameNode->GetPattern());
3616 ASSERT_NE(searchPattern, nullptr);
3617 auto searchLayoutAlgorithm = searchPattern->CreateLayoutAlgorithm();
3618 ASSERT_NE(searchLayoutAlgorithm, nullptr);
3619 layoutWrapper->SetLayoutAlgorithm(AceType::MakeRefPtr<LayoutAlgorithmWrapper>(searchLayoutAlgorithm));
3620
3621 auto contentFrameNode = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(0));
3622 ASSERT_NE(contentFrameNode, nullptr);
3623 auto contentLayoutProperty = contentFrameNode->GetLayoutProperty<LinearLayoutProperty>();
3624 RefPtr<GeometryNode> contentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3625 RefPtr<LayoutWrapperNode> contentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3626 contentFrameNode, contentFrameNodeGeometryNode, contentFrameNode->GetLayoutProperty());
3627 ASSERT_NE(contentNodeLayoutWrapper, nullptr);
3628 layoutWrapper->AppendChild(contentNodeLayoutWrapper);
3629
3630 auto flexFrameNode = AceType::DynamicCast<FrameNode>(frameNode->GetChildAtIndex(1));
3631 ASSERT_NE(flexFrameNode, nullptr);
3632 auto flexLayoutProperty = flexFrameNode->GetLayoutProperty<FlexLayoutProperty>();
3633 RefPtr<GeometryNode> flexFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3634 RefPtr<LayoutWrapperNode> flexNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3635 flexFrameNode, flexFrameNodeGeometryNode, flexFrameNode->GetLayoutProperty());
3636 ASSERT_NE(flexNodeLayoutWrapper, nullptr);
3637 layoutWrapper->AppendChild(flexNodeLayoutWrapper);
3638
3639 auto yearNode = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(0));
3640 auto yearContentLayoutProperty = yearNode->GetLayoutProperty<TextLayoutProperty>();
3641 RefPtr<GeometryNode> yearContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3642 RefPtr<LayoutWrapperNode> yearContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3643 yearNode, yearContentFrameNodeGeometryNode, yearNode->GetLayoutProperty());
3644 ASSERT_NE(yearContentNodeLayoutWrapper, nullptr);
3645 contentNodeLayoutWrapper->AppendChild(yearContentNodeLayoutWrapper);
3646
3647 auto textNode1 = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(1));
3648 auto text1ContentLayoutProperty = textNode1->GetLayoutProperty<TextLayoutProperty>();
3649 RefPtr<GeometryNode> text1ContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3650 RefPtr<LayoutWrapperNode> text1ContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3651 textNode1, text1ContentFrameNodeGeometryNode, textNode1->GetLayoutProperty());
3652 ASSERT_NE(text1ContentNodeLayoutWrapper, nullptr);
3653 contentNodeLayoutWrapper->AppendChild(text1ContentNodeLayoutWrapper);
3654
3655 auto monthNode = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(2));
3656 auto monthContentLayoutProperty = monthNode->GetLayoutProperty<TextLayoutProperty>();
3657 RefPtr<GeometryNode> monthContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3658 RefPtr<LayoutWrapperNode> monthContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3659 monthNode, monthContentFrameNodeGeometryNode, monthNode->GetLayoutProperty());
3660 ASSERT_NE(monthContentNodeLayoutWrapper, nullptr);
3661 contentNodeLayoutWrapper->AppendChild(monthContentNodeLayoutWrapper);
3662
3663 auto textNode2 = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(3));
3664 auto text2ContentLayoutProperty = textNode2->GetLayoutProperty<TextLayoutProperty>();
3665 RefPtr<GeometryNode> text2ContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3666 RefPtr<LayoutWrapperNode> text2ContentNodeLayoutWrapper = AceType::MakeRefPtr<LayoutWrapperNode>(
3667 textNode2, text2ContentFrameNodeGeometryNode, textNode2->GetLayoutProperty());
3668 ASSERT_NE(text2ContentNodeLayoutWrapper, nullptr);
3669 contentNodeLayoutWrapper->AppendChild(text2ContentNodeLayoutWrapper);
3670
3671 auto dayNode = AceType::DynamicCast<FrameNode>(contentFrameNode->GetOrCreateChildByIndex(4));
3672 auto dayContentLayoutProperty = dayNode->GetLayoutProperty<TextLayoutProperty>();
3673 RefPtr<GeometryNode> dayContentFrameNodeGeometryNode = AceType::MakeRefPtr<GeometryNode>();
3674 RefPtr<LayoutWrapperNode> dayContentNodeLayoutWrapper =
3675 AceType::MakeRefPtr<LayoutWrapperNode>(dayNode, dayContentFrameNodeGeometryNode, dayNode->GetLayoutProperty());
3676 ASSERT_NE(dayContentNodeLayoutWrapper, nullptr);
3677 contentNodeLayoutWrapper->AppendChild(dayContentNodeLayoutWrapper);
3678
3679 LayoutConstraintF LayoutConstraintVaildSize;
3680 layoutWrapper->GetLayoutProperty()->UpdateLayoutConstraint(LayoutConstraintVaildSize);
3681 layoutWrapper->GetLayoutProperty()->UpdateContentConstraint();
3682
3683 auto layoutAlgorithmWrapper = AceType::DynamicCast<LayoutAlgorithmWrapper>(layoutWrapper->GetLayoutAlgorithm());
3684 EXPECT_NE(layoutAlgorithmWrapper, nullptr);
3685 auto calendarPickerLayoutAlgorithm =
3686 AceType::DynamicCast<CalendarPickerLayoutAlgorithm>(layoutAlgorithmWrapper->GetLayoutAlgorithm());
3687 EXPECT_NE(calendarPickerLayoutAlgorithm, nullptr);
3688 calendarPickerLayoutAlgorithm->Measure(AccessibilityManager::RawPtr(layoutWrapper));
3689 EXPECT_NE(calendarPickerLayoutAlgorithm, nullptr);
3690 }
3691 /**
3692 * @tc.name: CalendarPickerUpdateButtonStyles001
3693 * @tc.desc: Test UpdateButtonStyle.
3694 * @tc.type: FUNC
3695 */
3696 HWTEST_F(CalendarPickerTestNg, CalendarPickerUpdateButtonStyles001, TestSize.Level1)
3697 {
3698 std::vector<ButtonInfo> buttonInfos;
3699 ButtonInfo info1;
3700 info1.fontWeight = FontWeight::W100;
3701 buttonInfos.push_back(info1);
3702
3703 size_t sizet = 0;
3704
3705 auto* stack = ViewStackProcessor::GetInstance();
3706 ASSERT_NE(stack, nullptr);
3707
3708 RefPtr<CalendarTheme> theme = MockPipelineContext::GetCurrent()->GetTheme<CalendarTheme>();
3709 ASSERT_NE(theme, nullptr);
3710
3711 CreateCalendarPicker();
3712 RefPtr<UINode> element = ViewStackProcessor::GetInstance()->Finish();
3713 EXPECT_EQ(element->GetTag(), V2::CALENDAR_PICKER_ETS_TAG);
3714
3715 auto frameNode = AceType::DynamicCast<FrameNode>(element);
3716 ASSERT_NE(frameNode, nullptr);
3717 auto layoutProperty = frameNode->GetLayoutProperty<CalendarPickerLayoutProperty>();
3718 ASSERT_NE(layoutProperty, nullptr);
3719
3720 auto buttonNode = FrameNode::GetOrCreateFrameNode(
__anone691f4a31702() 3721 V2::BUTTON_ETS_TAG, stack->ClaimNodeId(), []() { return AceType::MakeRefPtr<ButtonPattern>(); });
3722 ASSERT_NE(buttonNode, nullptr);
3723 auto buttonLayoutProperty = buttonNode->GetLayoutProperty<ButtonLayoutProperty>();
3724 ASSERT_NE(buttonLayoutProperty, nullptr);
3725 auto renderContext = buttonNode->GetRenderContext();
3726 ASSERT_NE(renderContext, nullptr);
3727 auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
3728 ASSERT_NE(themeManager, nullptr);
3729 MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
3730 auto buttonTheme = AceType::MakeRefPtr<ButtonTheme>();
3731 ASSERT_NE(buttonTheme, nullptr);
3732 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(buttonTheme));
3733 CalendarDialogView::UpdateButtonStyles(buttonInfos, sizet, buttonLayoutProperty, renderContext);
3734 ASSERT_NE(buttonLayoutProperty, nullptr);
3735 auto testval = buttonLayoutProperty->GetFontWeightValue();
3736
3737 EXPECT_EQ(testval, FontWeight::W100);
3738 }
3739 /**
3740 * @tc.name: CalendarDialogViewTest0050
3741 * @tc.desc: Show Function Test
3742 * @tc.type: FUNC
3743 */
3744 HWTEST_F(CalendarPickerTestNg, CalendarDialogViewTest0050, TestSize.Level1)
3745 {
3746 CalendarPickerTestNg::SetUpTestCase();
3747
3748 CalendarDialogView calendarDialogView;
3749 CalendarSettingData settingData;
3750 DialogProperties properties;
3751 properties.alignment = DialogAlignment::BOTTOM;
3752 properties.customStyle = false;
3753 properties.offset = DimensionOffset(Offset(0, -1.0f));
3754 auto selectedDate = PickerDate(2000, 1, 1);
3755 settingData.selectedDate = selectedDate;
3756 settingData.dayRadius = TEST_SETTING_RADIUS;
3757 std::map<std::string, NG::DialogEvent> dialogEvent;
3758 std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent;
3759
3760 std::vector<ButtonInfo> buttonInfos;
3761 ButtonInfo info1;
3762 info1.fontWeight = FontWeight::W100;
3763 buttonInfos.push_back(info1);
3764
3765 auto dialogNode = calendarDialogView.Show(properties, settingData, buttonInfos, dialogEvent, dialogCancelEvent);
3766 ASSERT_NE(dialogNode, nullptr);
3767 }
3768 } // namespace OHOS::Ace::NG
3769