1 /*
2 * Copyright (c) 2021-2022 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 "gtest/gtest.h"
17
18 #include "core/components/theme/theme_constants.h"
19 #include "core/components/theme/theme_manager_impl.h"
20 #include "core/components/theme/theme_constants_defines.h"
21 #include "frameworks/bridge/common/dom/dom_slider.h"
22 #include "frameworks/bridge/test/unittest/jsfrontend/dom_node_factory.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS::Ace::Framework {
28 namespace {
29
30 constexpr double VALUE_DEFAULT = 0.0;
31 constexpr double MIN_DEFAULT = 0.0;
32 constexpr double MAX_DEFAULT = 100.0;
33 constexpr double STEP_DEFAULT = 1.0;
34 constexpr double PADDING_DEFAULT = 32;
35 constexpr double TEST_PADDING_LEFT = 20.0;
36 constexpr double TEST_PADDING_RIGHT = 20.0;
37 constexpr double TEST_MIN_VALUE = 1.0;
38 constexpr double TEST_MAX_VALUE = 50.0;
39 constexpr double TEST_STEP_VALUE = 2.0;
40 constexpr double TEST_VALUE_VALUE = 10.0;
41 const std::string TEST_COLOR_VALUE = "#12345678";
42 constexpr double TEST_MIN_VALUE_004 = -1.0;
43 constexpr double TEST_MAX_VALUE_004 = 50.0;
44 constexpr double TEST_STEP_VALUE_004 = 2.0;
45 constexpr double TEST_VALUE_VALUE_004 = 10.0;
46 constexpr double TEST_MIN_VALUE_005 = 50.0;
47 constexpr double TEST_MAX_VALUE_005 = 60.0;
48 constexpr double TEST_STEP_VALUE_005 = 2.0;
49 constexpr double TEST_VALUE_VALUE_005 = 10.0;
50 constexpr double TEST_MIN_VALUE_006 = 10.0;
51 constexpr double TEST_MAX_VALUE_006 = 50.0;
52 constexpr double TEST_STEP_VALUE_006 = 2.0;
53 constexpr double TEST_VALUE_VALUE_006 = 1.0;
54 constexpr double TEST_MIN_VALUE_007 = 10.0;
55 constexpr double TEST_MAX_VALUE_007 = 50.0;
56 constexpr double TEST_STEP_VALUE_007 = 2.0;
57 constexpr double TEST_VALUE_VALUE_007 = 60.0;
58 constexpr double TEST_MIN_VALUE_008 = 10.0;
59 constexpr double TEST_MAX_VALUE_008 = 50.0;
60 constexpr double TEST_STEP_VALUE_008 = 1.0;
61 constexpr double TEST_VALUE_VALUE_008 = 20.0;
62 constexpr double TEST_MIN_VALUE_009 = 10.0;
63 constexpr double TEST_MAX_VALUE_009 = 50.0;
64 constexpr double TEST_STEP_VALUE_009 = 40.0;
65 constexpr double TEST_VALUE_VALUE_009 = 20.0;
66 const auto THEME_MANAGER = AceType::MakeRefPtr<ThemeManagerImpl>();
67
68 } // namespace
69
70 class DomSliderTest : public testing::Test {
71 public:
72 static void SetUpTestCase();
73 static void TearDownTestCase();
74 void SetUp() override;
75 void TearDown() override;
76 };
77
SetUpTestCase()78 void DomSliderTest::SetUpTestCase() {}
TearDownTestCase()79 void DomSliderTest::TearDownTestCase() {}
SetUp()80 void DomSliderTest::SetUp() {}
TearDown()81 void DomSliderTest::TearDown() {}
82
83 /**
84 * @tc.name: DomSliderCreator001
85 * @tc.desc: Test slider node and child slider component are created as expected.
86 * @tc.type: FUNC
87 */
88 HWTEST_F(DomSliderTest, DomSliderCreatorTest001, TestSize.Level1)
89 {
90 /**
91 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
92 * @tc.expected: step1. Slider node and child slider component are created successfully.
93 */
94 const std::string sliderTestStr = "{ "
95 " \"tag\": \"slider\", "
96 " \"attr\": [{ "
97 " \"min\" : \"1.0\" "
98 " }, "
99 " {"
100 " \"max\" : \"50.0\" "
101 " }, "
102 " {"
103 " \"value\" : \"10.0\" "
104 " }, "
105 " {"
106 " \"step\" : \"2.0\" "
107 " }], "
108 " \"style\": [{"
109 " \"color\" : \"#12345678\" "
110 " }, "
111 " {"
112 " \"selectedColor\" : \"#12345678\" "
113 " }, "
114 " {"
115 " \"paddingLeft\" : \"20\" "
116 " }, "
117 " {"
118 " \"paddingRight\" : \"20\" "
119 " }] "
120 "}";
121 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
122 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
123 ASSERT_TRUE(boxChild);
124 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
125 ASSERT_TRUE(padding);
126 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
127 ASSERT_TRUE(sliderComponent);
128
129 /**
130 * @tc.steps: step2. check all property matched
131 * @tc.expected: step2. all property match
132 */
133 auto track = sliderComponent->GetTrack();
134 auto block = sliderComponent->GetBlock();
135 ASSERT_TRUE(track);
136 ASSERT_TRUE(block);
137 EXPECT_TRUE(NearEqual(padding->GetPadding().Left().Value(), TEST_PADDING_LEFT));
138 EXPECT_TRUE(NearEqual(padding->GetPadding().Right().Value(), TEST_PADDING_RIGHT));
139 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), TEST_MIN_VALUE));
140 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), TEST_MAX_VALUE));
141 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), TEST_STEP_VALUE));
142 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), TEST_VALUE_VALUE));
143 EXPECT_EQ(track->GetBackgroundColor(), Color::FromString(TEST_COLOR_VALUE));
144 EXPECT_EQ(track->GetSelectColor(), Color::FromString(TEST_COLOR_VALUE));
145 }
146
147 /**
148 * @tc.name: DomSliderCreator002
149 * @tc.desc: Test slider node and child slider component are created defaultly.
150 * @tc.type: FUNC
151 */
152 HWTEST_F(DomSliderTest, DomSliderCreatorTest002, TestSize.Level1)
153 {
154 /**
155 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
156 * @tc.expected: step1. Slider node and child slider component are created successfully.
157 */
158 const std::string sliderTestStr = "{ "
159 " \"tag\": \"slider\" "
160 "}";
161 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
162 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
163 ASSERT_TRUE(boxChild);
164 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
165 ASSERT_TRUE(padding);
166 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
167 ASSERT_TRUE(sliderComponent);
168
169 /**
170 * @tc.steps: step2. check all property matched
171 * @tc.expected: step2. all property match
172 */
173 auto track = sliderComponent->GetTrack();
174 auto block = sliderComponent->GetBlock();
175 ASSERT_TRUE(track);
176 ASSERT_TRUE(block);
177 EXPECT_TRUE(NearEqual(padding->GetPadding().Left().Value(), PADDING_DEFAULT));
178 EXPECT_TRUE(NearEqual(padding->GetPadding().Right().Value(), PADDING_DEFAULT));
179 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), MIN_DEFAULT));
180 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), MAX_DEFAULT));
181 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), STEP_DEFAULT));
182 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), VALUE_DEFAULT));
183 auto themeConstants = THEME_MANAGER->GetThemeConstants();
184 ASSERT_NE(themeConstants, nullptr);
185 EXPECT_EQ(track->GetBackgroundColor(), themeConstants->GetColor(THEME_SLIDER_TRACK_BG));
186 EXPECT_EQ(track->GetSelectColor(), themeConstants->GetColor(THEME_SLIDER_TRACK_SELECTED));
187 }
188
189 /**
190 * @tc.name: DomSliderCreator003
191 * @tc.desc: Test add event to slider component successfully.
192 * @tc.type: FUNC
193 */
194 HWTEST_F(DomSliderTest, DomSliderCreatorTest003, TestSize.Level1)
195 {
196 /**
197 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
198 * @tc.expected: step1. Slider node and child slider component are created successfully.
199 */
200 const std::string sliderTestStr = "{ "
201 " \"tag\": \"slider\", "
202 " \"event\": [ \"change\" ] "
203 "}";
204 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
205 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
206 ASSERT_TRUE(boxChild);
207 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
208 ASSERT_TRUE(padding);
209 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
210 ASSERT_TRUE(sliderComponent);
211
212 /**
213 * @tc.steps: step2. Check eventId of created slider component.
214 * @tc.expected: step2. The eventId value of slider component is as expected.
215 */
216 EXPECT_TRUE(sliderComponent->GetOnMovingEventId() == std::to_string(slider->GetNodeId()));
217 }
218
219 /**
220 * @tc.name: DomSliderCreator004
221 * @tc.desc: Test slider node and child slider component are created successfully when min < 0.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(DomSliderTest, DomSliderCreatorTest004, TestSize.Level1)
225 {
226 /**
227 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
228 * @tc.expected: step1. Slider node and child slider component are created successfully.
229 */
230 const std::string sliderTestStr = "{ "
231 " \"tag\": \"slider\", "
232 " \"attr\": [{"
233 " \"min\" : \"-1\" "
234 " }, "
235 " {"
236 " \"max\" : \"50.0\" "
237 " }, "
238 " {"
239 " \"value\" : \"10.0\" "
240 " }, "
241 " {"
242 " \"step\" : \"2.0\" "
243 " }] "
244 "}";
245 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
246 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
247 ASSERT_TRUE(boxChild);
248 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
249 ASSERT_TRUE(padding);
250 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
251 ASSERT_TRUE(sliderComponent);
252
253 /**
254 * @tc.steps: step2. check all property matched
255 * @tc.expected: step2. all property match
256 */
257 auto track = sliderComponent->GetTrack();
258 auto block = sliderComponent->GetBlock();
259 ASSERT_TRUE(track);
260 ASSERT_TRUE(block);
261 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), TEST_MIN_VALUE_004));
262 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), TEST_MAX_VALUE_004));
263 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), TEST_STEP_VALUE_004));
264 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), TEST_VALUE_VALUE_004));
265 }
266
267 /**
268 * @tc.name: DomSliderCreator005
269 * @tc.desc: Test slider node and child slider component are created successfully when min > max.
270 * @tc.type: FUNC
271 */
272 HWTEST_F(DomSliderTest, DomSliderCreatorTest005, TestSize.Level1)
273 {
274 /**
275 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
276 * @tc.expected: step1. Slider node and child slider component are created successfully.
277 */
278 const std::string sliderTestStr = "{ "
279 " \"tag\": \"slider\", "
280 " \"attr\": [{"
281 " \"min\" : \"60.0\" "
282 " }, "
283 " {"
284 " \"max\" : \"50.0\" "
285 " }, "
286 " {"
287 " \"value\" : \"10.0\" "
288 " }, "
289 " {"
290 " \"step\" : \"2.0\" "
291 " }] "
292 "}";
293 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
294 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
295 ASSERT_TRUE(boxChild);
296 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
297 ASSERT_TRUE(padding);
298 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
299 ASSERT_TRUE(sliderComponent);
300
301 /**
302 * @tc.steps: step2. check all property matched
303 * @tc.expected: step2. all property match
304 */
305 auto track = sliderComponent->GetTrack();
306 auto block = sliderComponent->GetBlock();
307 ASSERT_TRUE(track);
308 ASSERT_TRUE(block);
309 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), TEST_MIN_VALUE_005));
310 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), TEST_MAX_VALUE_005));
311 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), TEST_STEP_VALUE_005));
312 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), TEST_VALUE_VALUE_005));
313 }
314
315 /**
316 * @tc.name: DomSliderCreator006
317 * @tc.desc: Test slider node and child slider component are created successfully when min > value.
318 * @tc.type: FUNC
319 */
320 HWTEST_F(DomSliderTest, DomSliderCreatorTest006, TestSize.Level1)
321 {
322 /**
323 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
324 * @tc.expected: step1. Slider node and child slider component are created successfully.
325 */
326 const std::string sliderTestStr = "{ "
327 " \"tag\": \"slider\", "
328 " \"attr\": [{"
329 " \"min\" : \"10.0\" "
330 " }, "
331 " {"
332 " \"max\" : \"50.0\" "
333 " }, "
334 " {"
335 " \"value\" : \"1.0\" "
336 " }, "
337 " {"
338 " \"step\" : \"2.0\" "
339 " }] "
340 "}";
341 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
342 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
343 ASSERT_TRUE(boxChild);
344 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
345 ASSERT_TRUE(padding);
346 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
347 ASSERT_TRUE(sliderComponent);
348
349 /**
350 * @tc.steps: step2. check all property matched
351 * @tc.expected: step2. all property match
352 */
353 auto track = sliderComponent->GetTrack();
354 auto block = sliderComponent->GetBlock();
355 ASSERT_TRUE(track);
356 ASSERT_TRUE(block);
357 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), TEST_MIN_VALUE_006));
358 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), TEST_MAX_VALUE_006));
359 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), TEST_STEP_VALUE_006));
360 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), TEST_VALUE_VALUE_006));
361 }
362
363 /**
364 * @tc.name: DomSliderCreator007
365 * @tc.desc: Test slider node and child slider component are created successfully when max < value.
366 * @tc.type: FUNC
367 */
368 HWTEST_F(DomSliderTest, DomSliderCreatorTest007, TestSize.Level1)
369 {
370 /**
371 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
372 * @tc.expected: step1. Slider node and child slider component are created successfully.
373 */
374 const std::string sliderTestStr = "{ "
375 " \"tag\": \"slider\", "
376 " \"attr\": [{"
377 " \"min\" : \"10.0\" "
378 " }, "
379 " {"
380 " \"max\" : \"50.0\" "
381 " }, "
382 " {"
383 " \"value\" : \"60.0\" "
384 " }, "
385 " {"
386 " \"step\" : \"2.0\" "
387 " }] "
388 "}";
389 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
390 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
391 ASSERT_TRUE(boxChild);
392 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
393 ASSERT_TRUE(padding);
394 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
395 ASSERT_TRUE(sliderComponent);
396
397 /**
398 * @tc.steps: step2. check all property matched
399 * @tc.expected: step2. all property match
400 */
401 auto track = sliderComponent->GetTrack();
402 auto block = sliderComponent->GetBlock();
403 ASSERT_TRUE(track);
404 ASSERT_TRUE(block);
405 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), TEST_MIN_VALUE_007));
406 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), TEST_MAX_VALUE_007));
407 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), TEST_STEP_VALUE_007));
408 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), TEST_VALUE_VALUE_007));
409 }
410
411 /**
412 * @tc.name: DomSliderCreator008
413 * @tc.desc: Test slider node and child slider component are created successfully when step < 0.
414 * @tc.type: FUNC
415 */
416 HWTEST_F(DomSliderTest, DomSliderCreatorTest008, TestSize.Level1)
417 {
418 /**
419 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
420 * @tc.expected: step1. Slider node and child slider component are created successfully.
421 */
422 const std::string sliderTestStr = "{ "
423 " \"tag\": \"slider\", "
424 " \"attr\": [{"
425 " \"min\" : \"10.0\" "
426 " }, "
427 " {"
428 " \"max\" : \"50.0\" "
429 " }, "
430 " {"
431 " \"value\" : \"20.0\" "
432 " }, "
433 " {"
434 " \"step\" : \"-2.0\" "
435 " }] "
436 "}";
437 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
438 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
439 ASSERT_TRUE(boxChild);
440 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
441 ASSERT_TRUE(padding);
442 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
443 ASSERT_TRUE(sliderComponent);
444
445 /**
446 * @tc.steps: step2. check all property matched
447 * @tc.expected: step2. all property match
448 */
449 auto track = sliderComponent->GetTrack();
450 auto block = sliderComponent->GetBlock();
451 ASSERT_TRUE(track);
452 ASSERT_TRUE(block);
453 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), TEST_MIN_VALUE_008));
454 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), TEST_MAX_VALUE_008));
455 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), TEST_STEP_VALUE_008));
456 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), TEST_VALUE_VALUE_008));
457 }
458
459 /**
460 * @tc.name: DomSliderCreator009
461 * @tc.desc: Test slider node and child slider component are created successfully when step > max - min.
462 * @tc.type: FUNC
463 */
464 HWTEST_F(DomSliderTest, DomSliderCreatorTest009, TestSize.Level1)
465 {
466 /**
467 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
468 * @tc.expected: step1. Slider node and child slider component are created successfully.
469 */
470 const std::string sliderTestStr = "{ "
471 " \"tag\": \"slider\", "
472 " \"attr\": [{"
473 " \"min\" : \"10.0\" "
474 " }, "
475 " {"
476 " \"max\" : \"50.0\" "
477 " }, "
478 " {"
479 " \"value\" : \"20.0\" "
480 " }, "
481 " {"
482 " \"step\" : \"50.0\" "
483 " }] "
484 "}";
485 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
486 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
487 ASSERT_TRUE(boxChild);
488 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
489 ASSERT_TRUE(padding);
490 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
491 ASSERT_TRUE(sliderComponent);
492
493 /**
494 * @tc.steps: step2. check all property matched
495 * @tc.expected: step2. all property match
496 */
497 auto track = sliderComponent->GetTrack();
498 auto block = sliderComponent->GetBlock();
499 ASSERT_TRUE(track);
500 ASSERT_TRUE(block);
501 EXPECT_TRUE(NearEqual(sliderComponent->GetMinValue(), TEST_MIN_VALUE_009));
502 EXPECT_TRUE(NearEqual(sliderComponent->GetMaxValue(), TEST_MAX_VALUE_009));
503 EXPECT_TRUE(NearEqual(sliderComponent->GetStep(), TEST_STEP_VALUE_009));
504 EXPECT_TRUE(NearEqual(sliderComponent->GetValue(), TEST_VALUE_VALUE_009));
505 }
506
507 /**
508 * @tc.name: DomSliderCreator010
509 * @tc.desc: Test slider node and child slider component are created successfully when step > max - min.
510 * @tc.type: FUNC
511 */
512 HWTEST_F(DomSliderTest, DomSliderCreatorTest010, TestSize.Level1)
513 {
514 /**
515 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
516 * @tc.expected: step1. Slider node and child slider component are created successfully.
517 */
518 const std::string sliderTestStr = "{ "
519 " \"tag\": \"slider\", "
520 " \"attr\": [{"
521 " \"min\" : \"10.0\" "
522 " }, "
523 " {"
524 " \"max\" : \"50.0\" "
525 " }, "
526 " {"
527 " \"value\" : \"20.0\" "
528 " }, "
529 " {"
530 " \"step\" : \"50.0\" "
531 " }] "
532 "}";
533 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
534 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
535 ASSERT_TRUE(boxChild);
536 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
537 ASSERT_TRUE(padding);
538 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
539 ASSERT_TRUE(sliderComponent);
540
541 /**
542 * @tc.steps: step2. check all property matched
543 * @tc.expected: step2. all property match
544 */
545 auto track = sliderComponent->GetTrack();
546 auto block = sliderComponent->GetBlock();
547 ASSERT_TRUE(track);
548 ASSERT_TRUE(block);
549 EXPECT_FALSE(sliderComponent->NeedShowSteps());
550 EXPECT_FALSE(sliderComponent->NeedShowTips());
551 EXPECT_FALSE(sliderComponent->GetSliderMode() == SliderMode::INSET);
552 }
553
554 /**
555 * @tc.name: DomSliderCreator011
556 * @tc.desc: Test slider node and child slider component are created successfully when step > max - min.
557 * @tc.type: FUNC
558 */
559 HWTEST_F(DomSliderTest, DomSliderCreatorTest011, TestSize.Level1)
560 {
561 /**
562 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
563 * @tc.expected: step1. Slider node and child slider component are created successfully.
564 */
565 const std::string sliderTestStr = "{ "
566 " \"tag\": \"slider\", "
567 " \"attr\": [{"
568 " \"mode\" : \"inset\" "
569 " }, "
570 " {"
571 " \"step\" : \"20\" "
572 " }, "
573 " {"
574 " \"showtips\" : \"true\" "
575 " }, "
576 " {"
577 " \"showsteps\" : \"true\" "
578 " }] "
579 "}";
580 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
581 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
582 ASSERT_TRUE(boxChild);
583 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
584 ASSERT_TRUE(padding);
585 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
586 ASSERT_TRUE(sliderComponent);
587
588 /**
589 * @tc.steps: step2. check all property matched
590 * @tc.expected: step2. all property match
591 */
592 auto track = sliderComponent->GetTrack();
593 auto block = sliderComponent->GetBlock();
594 ASSERT_TRUE(track);
595 ASSERT_TRUE(block);
596 EXPECT_TRUE(sliderComponent->NeedShowSteps());
597 EXPECT_TRUE(sliderComponent->NeedShowTips());
598 EXPECT_TRUE(sliderComponent->GetSliderMode() == SliderMode::INSET);
599 }
600
601 /**
602 * @tc.name: DomSliderCreator012
603 * @tc.desc: Test slider node and child slider component are created successfully when step > max - min.
604 * @tc.type: FUNC
605 */
606 HWTEST_F(DomSliderTest, DomSliderCreatorTest012, TestSize.Level1)
607 {
608 /**
609 * @tc.steps: step1. Construct string with right fields, then create slider node with it.
610 * @tc.expected: step1. Slider node and child slider component are created successfully.
611 */
612 const std::string sliderTestStr = "{ "
613 " \"tag\": \"slider\", "
614 " \"attr\": [{"
615 " \"mode\" : \"inset\" "
616 " }, "
617 " {"
618 " \"step\" : \"120.0\" "
619 " }, "
620 " {"
621 " \"max\" : \"0\" "
622 " }, "
623 " {"
624 " \"min\" : \"100\" "
625 " }] "
626 "}";
627 auto slider = DOMNodeFactory::GetInstance().CreateDOMNodeFromDsl(sliderTestStr);
628 auto boxChild = DOMNodeFactory::GetInstance().GetBoxChildComponent(slider);
629 ASSERT_TRUE(boxChild);
630 auto padding = AceType::DynamicCast<PaddingComponent>(boxChild->GetChild());
631 ASSERT_TRUE(padding);
632 RefPtr<SliderComponent> sliderComponent = AceType::DynamicCast<SliderComponent>(padding->GetChild());
633 ASSERT_TRUE(sliderComponent);
634
635 /**
636 * @tc.steps: step2. check all property matched
637 * @tc.expected: step2. all property match
638 */
639 auto track = sliderComponent->GetTrack();
640 auto block = sliderComponent->GetBlock();
641 ASSERT_TRUE(track);
642 ASSERT_TRUE(block);
643 EXPECT_EQ(sliderComponent->GetStep(), 100.0);
644 EXPECT_EQ(sliderComponent->GetMaxValue(), 100.0);
645 EXPECT_EQ(sliderComponent->GetMinValue(), 0.0);
646 }
647
648 } // namespace OHOS::Ace::Framework
649