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 "base/test/mock/mock_asset_manager.h"
19 #include "core/components/test/unittest/mock/mock_render_common.h"
20 #define private public
21 #define protected public
22 #include "bridge/card_frontend/card_frontend.h"
23 #include "bridge/card_frontend/js_card_parser.h"
24 #undef private
25 #undef protected
26 #include "base/test/mock/mock_task_executor.h"
27 #include "bridge/common/utils/utils.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS::Ace::Framework {
33 namespace {
34 constexpr int32_t COMMAND_SIZE = 1;
35 constexpr int32_t DEVICE_WIDTH = 720;
36 constexpr int32_t DEVICE_HEIGHT = 1280;
37 constexpr double_t DENSITY = 1.5;
38 } // namespace
39
40 class CardFrontendTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46 };
47
SetUpTestCase()48 void CardFrontendTest::SetUpTestCase() {}
TearDownTestCase()49 void CardFrontendTest::TearDownTestCase() {}
SetUp()50 void CardFrontendTest::SetUp()
51 {
52 SystemProperties::SetColorMode(ColorMode::LIGHT);
53 }
TearDown()54 void CardFrontendTest::TearDown() {}
55
56 /**
57 * @tc.name: CardFrontendTest001
58 * @tc.desc: Test data binding.
59 * @tc.type: FUNC
60 */
61 HWTEST_F(CardFrontendTest, CardFrontendTest001, TestSize.Level1)
62 {
63 /**
64 * @tc.steps: step1. construct json string.
65 */
66 const std::string rootJson = "{\n"
67 "\t\"template\": {\n"
68 "\t\t\"attr\": {\n"
69 "\t\t\t\"value\": \"{{variable}}\"\n"
70 "\t\t},\n"
71 "\t\t\"type\": \"text\",\n"
72 "\t\t\"shown\": \"{{show}}\"\n"
73 "\t},\n"
74 "\t\"styles\": {},\n"
75 "\t\"actions\": {},\n"
76 "\t\"data\": {\n"
77 "\t\t\"show\": false,\n"
78 "\t\t\"variable\": \"hello!\"\n"
79 "\t}\n"
80 "}";
81 auto rootBody = JsonUtil::ParseJsonString(rootJson);
82 auto rootTemplate = rootBody->GetValue("template");
83 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
84 jsCardParser->Initialize();
85 auto document = AceType::MakeRefPtr<DOMDocument>(1);
86 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
87 jsCardParser->CreateDomNode(page, rootTemplate, -1);
88 auto shown = rootTemplate->GetValue("shown");
89 auto shownValue = shown->GetString();
90 int32_t nodeId = 1;
91
92 /**
93 * @tc.steps: step2. Get the value of the shown attribute.
94 * @tc.expected: step2. shown value is false.
95 */
96 jsCardParser->GetShownValue(shownValue);
97 ASSERT_TRUE(shownValue == "false");
98
99 /**
100 * @tc.steps: step3. Get the value of the attribute.
101 * @tc.expected: step3. Property value is correct.
102 */
103 std::vector<std::pair<std::string, std::string>> attrs;
104 auto type = rootTemplate->GetValue("type")->GetString();
105 RefPtr<Framework::JsCommandDomElementCreator> command =
106 Referenced::MakeRefPtr<Framework::JsCommandAddDomElement>(type, nodeId, 0);
107 auto ptr = Referenced::RawPtr(command);
108 jsCardParser->ParseAttributes(rootTemplate, nodeId, attrs, (Framework::JsCommandDomElementOperator*)ptr);
109 ASSERT_TRUE(attrs.size() == COMMAND_SIZE);
110 ASSERT_TRUE(attrs[0].first == "value" && attrs[0].second == "hello!");
111 }
112
113 /**
114 * @tc.name: CardFrontendTest002
115 * @tc.desc: Test data binding.
116 * @tc.type: FUNC
117 */
118 HWTEST_F(CardFrontendTest, CardFrontendTest002, TestSize.Level1)
119 {
120 /**
121 * @tc.steps: step1. construct json string.
122 */
123 const std::string rootJson = "{\n"
124 "\t\"template\": {\n"
125 "\t\t\"attr\": {\n"
126 "\t\t\t\"value\": \"{{}}\"\n"
127 "\t\t},\n"
128 "\t\t\"type\": \"text\",\n"
129 "\t\t\"shown\": \"{{}\"\n"
130 "\t},\n"
131 "\t\"styles\": {},\n"
132 "\t\"actions\": {},\n"
133 "\t\"data\": {}\n"
134 "}";
135 auto rootBody = JsonUtil::ParseJsonString(rootJson);
136 auto rootTemplate = rootBody->GetValue("template");
137 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
138 jsCardParser->Initialize();
139 auto document = AceType::MakeRefPtr<DOMDocument>(1);
140 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
141 jsCardParser->CreateDomNode(page, rootTemplate, -1);
142
143 /**
144 * @tc.steps: step2. Get the value of the shown attribute.
145 * @tc.expected: step2. shown value is not true.
146 */
147 auto shown = rootTemplate->GetValue("shown");
148 auto shownValue = shown->GetString();
149 int32_t nodeId = 1;
150 jsCardParser->GetShownValue(shownValue);
151 ASSERT_TRUE(shownValue != "true");
152
153 /**
154 * @tc.steps: step3. Get the value of the attribute.
155 * @tc.expected: step3. Property value is "{{}}".
156 */
157 std::vector<std::pair<std::string, std::string>> attrs;
158 auto type = rootTemplate->GetValue("type")->GetString();
159 RefPtr<Framework::JsCommandDomElementCreator> command =
160 Referenced::MakeRefPtr<Framework::JsCommandAddDomElement>(type, nodeId, 0);
161 auto ptr = Referenced::RawPtr(command);
162 jsCardParser->ParseAttributes(rootTemplate, nodeId, attrs, (Framework::JsCommandDomElementOperator*)ptr);
163 ASSERT_TRUE(attrs.size() == COMMAND_SIZE);
164 ASSERT_TRUE(attrs[0].first == "value" && attrs[0].second == "{{}}");
165 }
166
167 /**
168 * @tc.name: CardFrontendTest003
169 * @tc.desc: Test data binding.
170 * @tc.type: FUNC
171 */
172 HWTEST_F(CardFrontendTest, CardFrontendTest003, TestSize.Level1)
173 {
174 /**
175 * @tc.steps: step1. construct json string.
176 */
177 const std::string rootJson = "{\n"
178 "\t\"template\": {\n"
179 "\t\t\"attr\": {},\n"
180 "\t\t\"type\": \"text\",\n"
181 "\t\t\"style\": {\n"
182 "\t\t\t\"color\": \"{{{variable}}\",\n"
183 "\t\t\t\"strokeColor\": \"{{variable}}\"\n"
184 "\t\t}\n"
185 "\t},\n"
186 "\t\"styles\": {},\n"
187 "\t\"actions\": {},\n"
188 "\t\"data\": {\n"
189 "\t\t\"variable\": \"0xffffff\"\n"
190 "\t}\n"
191 "}";
192 auto rootBody = JsonUtil::ParseJsonString(rootJson);
193 auto rootTemplate = rootBody->GetValue("template");
194 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
195 jsCardParser->Initialize();
196 auto document = AceType::MakeRefPtr<DOMDocument>(1);
197 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
198 jsCardParser->CreateDomNode(page, rootTemplate, -1);
199
200 /**
201 * @tc.steps: step2. Get the value of the style.
202 * @tc.expected: step2. The style value meets expectations.
203 */
204 int32_t nodeId = 1;
205 std::vector<std::pair<std::string, std::string>> styles;
206 auto type = rootTemplate->GetValue("type")->GetString();
207 jsCardParser->ParseStyles(rootTemplate, nodeId, styles);
208 ASSERT_TRUE(styles.size() == 2);
209 ASSERT_TRUE(styles[0].first == "color" && styles[0].second == "{{{variable}}");
210 ASSERT_TRUE(styles[1].first == "strokeColor" && styles[1].second == "0xffffff");
211 }
212
213 /**
214 * @tc.name: CardFrontendTest004
215 * @tc.desc: Test condition rendering.
216 * @tc.type: FUNC
217 */
218 HWTEST_F(CardFrontendTest, CardFrontendTest004, TestSize.Level1)
219 {
220 /**
221 * @tc.steps: step1. construct json string.
222 */
223 const std::string rootJson = "{\n"
224 "\t\"template\": {\n"
225 "\t\t\"attr\": {},\n"
226 "\t\t\"type\": \"text\",\n"
227 "\t\t\"shown\": \"{{show}} && {{display}}\"\n"
228 "\t},\n"
229 "\t\"styles\": {},\n"
230 "\t\"actions\": {},\n"
231 "\t\"data\": {\n"
232 "\t\t\"display\": true,\n"
233 "\t\t\"show\": false\n"
234 "\t}\n"
235 "}";
236 auto rootBody = JsonUtil::ParseJsonString(rootJson);
237 auto rootTemplate = rootBody->GetValue("template");
238 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
239 jsCardParser->Initialize();
240 auto document = AceType::MakeRefPtr<DOMDocument>(1);
241 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
242 jsCardParser->CreateDomNode(page, rootTemplate, -1);
243
244 /**
245 * @tc.steps: step2. Get the value of the shown.
246 * @tc.expected: step2. The shown value meets expectations.
247 */
248 auto shown = rootTemplate->GetValue("shown");
249 auto shownValue = shown->GetString();
250 jsCardParser->GetShownValue(shownValue);
251 ASSERT_TRUE(shownValue == "false");
252 }
253
254 /**
255 * @tc.name: CardFrontendTest005
256 * @tc.desc: Test condition rendering.
257 * @tc.type: FUNC
258 */
259 HWTEST_F(CardFrontendTest, CardFrontendTest005, TestSize.Level1)
260 {
261 /**
262 * @tc.steps: step1. construct json string.
263 */
264 const std::string rootJson = "{\n"
265 "\t\"template\": {\n"
266 "\t\t\"attr\": {},\n"
267 "\t\t\"type\": \"text\",\n"
268 "\t\t\"shown\": \"{{show}} && !{{display}}\"\n"
269 "\t},\n"
270 "\t\"styles\": {},\n"
271 "\t\"actions\": {},\n"
272 "\t\"data\": {\n"
273 "\t\t\"display\": false,\n"
274 "\t\t\"show\": false\n"
275 "\t}\n"
276 "}";
277 auto rootBody = JsonUtil::ParseJsonString(rootJson);
278 auto rootTemplate = rootBody->GetValue("template");
279 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
280 jsCardParser->Initialize();
281 auto document = AceType::MakeRefPtr<DOMDocument>(1);
282 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
283 jsCardParser->CreateDomNode(page, rootTemplate, -1);
284
285 /**
286 * @tc.steps: step2. Get the value of the shown.
287 * @tc.expected: step2. The shown value meets expectations.
288 */
289 auto shown = rootTemplate->GetValue("shown");
290 auto shownValue = shown->GetString();
291 jsCardParser->GetShownValue(shownValue);
292 ASSERT_TRUE(shownValue == "false");
293 }
294
295 /**
296 * @tc.name: CardFrontendTest006
297 * @tc.desc: Test condition rendering.
298 * @tc.type: FUNC
299 */
300 HWTEST_F(CardFrontendTest, CardFrontendTest006, TestSize.Level1)
301 {
302 /**
303 * @tc.steps: step1. construct json string.
304 */
305 const std::string rootJson = "{\n"
306 "\t\"template\": {\n"
307 "\t\t\"attr\": {},\n"
308 "\t\t\"type\": \"text\",\n"
309 "\t\t\"shown\": \"!{{show}} && !{{display}}\"\n"
310 "\t},\n"
311 "\t\"styles\": {},\n"
312 "\t\"actions\": {},\n"
313 "\t\"data\": {\n"
314 "\t\t\"display\": false,\n"
315 "\t\t\"show\": false\n"
316 "\t}\n"
317 "}";
318 auto rootBody = JsonUtil::ParseJsonString(rootJson);
319 auto rootTemplate = rootBody->GetValue("template");
320 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
321 jsCardParser->Initialize();
322 auto document = AceType::MakeRefPtr<DOMDocument>(1);
323 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
324 jsCardParser->CreateDomNode(page, rootTemplate, -1);
325
326 /**
327 * @tc.steps: step2. Get the value of the shown.
328 * @tc.expected: step2. The shown value meets expectations.
329 */
330 auto shown = rootTemplate->GetValue("shown");
331 auto shownValue = shown->GetString();
332 jsCardParser->GetShownValue(shownValue);
333 ASSERT_TRUE(shownValue == "true");
334 }
335
336 /**
337 * @tc.name: CardFrontendTest007
338 * @tc.desc: Test condition rendering.
339 * @tc.type: FUNC
340 */
341 HWTEST_F(CardFrontendTest, CardFrontendTest007, TestSize.Level1)
342 {
343 /**
344 * @tc.steps: step1. construct json string.
345 */
346 const std::string rootJson = "{\n"
347 "\t\"template\": {\n"
348 "\t\t\"attr\": {},\n"
349 "\t\t\"type\": \"text\",\n"
350 "\t\t\"shown\": \"{{show}} && {{xdisplay}}\"\n"
351 "\t},\n"
352 "\t\"styles\": {},\n"
353 "\t\"actions\": {},\n"
354 "\t\"data\": {\n"
355 "\t\t\"display\": true,\n"
356 "\t\t\"show\": true\n"
357 "\t}\n"
358 "}";
359 auto rootBody = JsonUtil::ParseJsonString(rootJson);
360 auto rootTemplate = rootBody->GetValue("template");
361 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
362 jsCardParser->Initialize();
363 auto document = AceType::MakeRefPtr<DOMDocument>(1);
364 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
365 jsCardParser->CreateDomNode(page, rootTemplate, -1);
366
367 /**
368 * @tc.steps: step2. Get the value of the shown.
369 * @tc.expected: step2. The shown value meets expectations.
370 */
371 auto shown = rootTemplate->GetValue("shown");
372 auto shownValue = shown->GetString();
373 jsCardParser->GetShownValue(shownValue);
374 ASSERT_TRUE(shownValue != "true");
375 }
376
377 /**
378 * @tc.name: CardFrontendTest008
379 * @tc.desc: Test "repeat" attr: for = "{{list}}".
380 * @tc.type: FUNC
381 */
382 HWTEST_F(CardFrontendTest, CardFrontendTest008, TestSize.Level1)
383 {
384 /**
385 * @tc.steps: step1. construct json string.
386 */
387 const std::string rootJson = "{\n"
388 "\t\"template\": {\n"
389 "\t\t\"attr\": {},\n"
390 "\t\t\"type\": \"text\",\n"
391 "\t\t\"repeat\": \"{{list}}\"\n"
392 "\t},\n"
393 "\t\"styles\": {},\n"
394 "\t\"actions\": {},\n"
395 "\t\"data\": {\n"
396 "\t\t\"list\": [\n"
397 "\t\t\t{\n"
398 "\t\t\t\t\"name\": \"aa\",\n"
399 "\t\t\t\t\"idx\": 1\n"
400 "\t\t\t},\n"
401 "\t\t\t{\n"
402 "\t\t\t\t\"name\": \"bb\",\n"
403 "\t\t\t\t\"idx\": 2\n"
404 "\t\t\t},\n"
405 "\t\t\t{\n"
406 "\t\t\t\t\"name\": \"cc\",\n"
407 "\t\t\t\t\"idx\": 1\n"
408 "\t\t\t}\n"
409 "\t\t]\n"
410 "\t}\n"
411 "}";
412 auto rootBody = JsonUtil::ParseJsonString(rootJson);
413 auto rootTemplate = rootBody->GetValue("template");
414 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
415 jsCardParser->Initialize();
416 auto document = AceType::MakeRefPtr<DOMDocument>(1);
417 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
418 jsCardParser->CreateDomNode(page, rootTemplate, -1);
419
420 /**
421 * @tc.steps: step2. Get the value of the repeat.
422 * @tc.expected: step2. The repeat value meets expectations.
423 */
424 auto repeatValue = rootTemplate->GetValue("repeat");
425 std::string key;
426 jsCardParser->GetRepeatData(repeatValue, key);
427
428 ASSERT_EQ(repeatValue->GetArraySize(), 3);
429 auto item = repeatValue->GetChild();
430 auto itemName = item->GetValue("name")->GetString();
431 auto itemIndex = item->GetValue("idx")->GetInt();
432 ASSERT_EQ(itemName, "aa");
433 ASSERT_EQ(itemIndex, 1);
434 }
435
436 /**
437 * @tc.name: CardFrontendTest009
438 * @tc.desc: Test "repeat" attr: for = "value in list".
439 * @tc.type: FUNC
440 */
441 HWTEST_F(CardFrontendTest, CardFrontendTest009, TestSize.Level1)
442 {
443 /**
444 * @tc.steps: step1. construct json string.
445 */
446 const std::string rootJson = "{\n"
447 "\t\"template\": {\n"
448 "\t\t\"attr\": {\n"
449 "\t\t\t\"value\": \"{{item.name}}\",\n"
450 "\t\t\t\"index\": \"{{item.idx}}\"\n"
451 "\t\t},\n"
452 "\t\t\"type\": \"text\",\n"
453 "\t\t\"repeat\": {\n"
454 "\t\t\t\"exp\": \"{{list}}\",\n"
455 "\t\t\t\"value\": \"item\"\n"
456 "\t\t}\n"
457 "\t},\n"
458 "\t\"styles\": {},\n"
459 "\t\"actions\": {},\n"
460 "\t\"data\": {\n"
461 "\t\t\"list\": [\n"
462 "\t\t\t{\n"
463 "\t\t\t\t\"name\": \"aa\",\n"
464 "\t\t\t\t\"idx\": 1\n"
465 "\t\t\t},\n"
466 "\t\t\t{\n"
467 "\t\t\t\t\"name\": \"bb\",\n"
468 "\t\t\t\t\"idx\": 2\n"
469 "\t\t\t},\n"
470 "\t\t\t{\n"
471 "\t\t\t\t\"name\": \"cc\",\n"
472 "\t\t\t\t\"idx\": 1\n"
473 "\t\t\t}\n"
474 "\t\t]\n"
475 "\t}\n"
476 "}";
477 auto rootBody = JsonUtil::ParseJsonString(rootJson);
478 auto rootTemplate = rootBody->GetValue("template");
479 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
480 jsCardParser->Initialize();
481 jsCardParser->SetIsRepeat(true);
482 auto document = AceType::MakeRefPtr<DOMDocument>(1);
483 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
484 jsCardParser->CreateDomNode(page, rootTemplate, -1);
485
486 /**
487 * @tc.steps: step2. Get the value of the repeat and parse data.
488 */
489 auto repeatValue = rootTemplate->GetValue("repeat");
490 jsCardParser->ParseRepeatIndexItem(repeatValue);
491 auto expValue = repeatValue->GetValue("exp");
492 std::string key;
493 jsCardParser->GetRepeatData(expValue, key);
494 jsCardParser->SetRepeatItemValue(0, expValue, true);
495
496 /**
497 * @tc.steps: step3. Parse repeat attr and assert value of repeat.
498 * @tc.expected: step3. The repeat value meets expectations.
499 */
500 std::vector<std::pair<std::string, std::string>> attrs;
501 auto type = rootTemplate->GetValue("type")->GetString();
502 RefPtr<Framework::JsCommandDomElementCreator> command =
503 Referenced::MakeRefPtr<Framework::JsCommandAddDomElement>(type, 1, 0);
504 auto ptr = Referenced::RawPtr(command);
505 jsCardParser->ParseAttributes(rootTemplate, 1, attrs, (Framework::JsCommandDomElementOperator*)ptr);
506
507 ASSERT_EQ(attrs.begin()->first, "value");
508 ASSERT_EQ(attrs.begin()->second, "aa");
509
510 ASSERT_EQ(attrs.rbegin()->first, "index");
511 ASSERT_EQ(attrs.rbegin()->second, "1");
512
513 jsCardParser->SetRepeatItemValue(1, expValue, true);
514 attrs.clear();
515 jsCardParser->ParseAttributes(rootTemplate, 1, attrs, (Framework::JsCommandDomElementOperator*)ptr);
516 ASSERT_EQ(attrs.begin()->first, "value");
517 ASSERT_EQ(attrs.begin()->second, "bb");
518
519 ASSERT_EQ(attrs.rbegin()->first, "index");
520 ASSERT_EQ(attrs.rbegin()->second, "2");
521 }
522
523 /**
524 * @tc.name: CardFrontendTest010
525 * @tc.desc: Test "repeat" attr: for = "(index, item) in list".
526 * @tc.type: FUNC
527 */
528 HWTEST_F(CardFrontendTest, CardFrontendTest010, TestSize.Level1)
529 {
530 /**
531 * @tc.steps: step1. construct json string.
532 */
533 const std::string rootJson = "{\n"
534 "\t\"template\": {\n"
535 "\t\t\"attr\": {\n"
536 "\t\t\t\"value\": \"{{$item.name}}\",\n"
537 "\t\t\t\"index\": \"{{$idx}}\"\n"
538 "\t\t},\n"
539 "\t\t\"type\": \"text\",\n"
540 "\t\t\"repeat\": {\n"
541 "\t\t\t\"exp\": \"{{list}}\",\n"
542 "\t\t\t\"key\": \"index\",\n"
543 "\t\t\t\"value\": \"item\"\n"
544 "\t\t}\n"
545 "\t},\n"
546 "\t\"styles\": {},\n"
547 "\t\"actions\": {},\n"
548 "\t\"data\": {\n"
549 "\t\t\"list\": [\n"
550 "\t\t\t{\n"
551 "\t\t\t\t\"name\": \"aa\",\n"
552 "\t\t\t\t\"idx\": 1\n"
553 "\t\t\t},\n"
554 "\t\t\t{\n"
555 "\t\t\t\t\"name\": \"bb\",\n"
556 "\t\t\t\t\"idx\": 2\n"
557 "\t\t\t},\n"
558 "\t\t\t{\n"
559 "\t\t\t\t\"name\": \"cc\",\n"
560 "\t\t\t\t\"idx\": 3\n"
561 "\t\t\t}\n"
562 "\t\t]\n"
563 "\t}\n"
564 "}";
565 auto rootBody = JsonUtil::ParseJsonString(rootJson);
566 auto rootTemplate = rootBody->GetValue("template");
567 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
568 jsCardParser->Initialize();
569 jsCardParser->SetIsRepeat(true);
570 auto document = AceType::MakeRefPtr<DOMDocument>(1);
571 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
572 jsCardParser->CreateDomNode(page, rootTemplate, -1);
573
574 /**
575 * @tc.steps: step2. Get the value of the repeat and parse data.
576 */
577 auto repeatValue = rootTemplate->GetValue("repeat");
578 jsCardParser->ParseRepeatIndexItem(repeatValue);
579 auto expValue = repeatValue->GetValue("exp");
580 std::string key;
581 jsCardParser->GetRepeatData(expValue, key);
582 jsCardParser->SetRepeatItemValue(2, expValue, true);
583
584 /**
585 * @tc.steps: step3. Parse repeat attr and assert value of repeat.
586 * @tc.expected: step3. The repeat value meets expectations.
587 */
588 std::vector<std::pair<std::string, std::string>> attrs;
589 auto type = rootTemplate->GetValue("type")->GetString();
590 RefPtr<Framework::JsCommandDomElementCreator> command =
591 Referenced::MakeRefPtr<Framework::JsCommandAddDomElement>(type, 1, 0);
592 auto ptr = Referenced::RawPtr(command);
593 jsCardParser->ParseAttributes(rootTemplate, 1, attrs, (Framework::JsCommandDomElementOperator*)ptr);
594
595 ASSERT_EQ(attrs.begin()->first, "value");
596 ASSERT_EQ(attrs.begin()->second, "cc");
597
598 ASSERT_EQ(attrs.rbegin()->first, "index");
599 ASSERT_EQ(attrs.rbegin()->second, "2");
600
601 jsCardParser->SetRepeatItemValue(1, expValue, true);
602 attrs.clear();
603 jsCardParser->ParseAttributes(rootTemplate, 1, attrs, (Framework::JsCommandDomElementOperator*)ptr);
604 ASSERT_EQ(attrs.begin()->first, "value");
605 ASSERT_EQ(attrs.begin()->second, "bb");
606
607 ASSERT_EQ(attrs.rbegin()->first, "index");
608 ASSERT_EQ(attrs.rbegin()->second, "1");
609 }
610
611 /**
612 * @tc.name: CardFrontendTest011
613 * @tc.desc: Test point operation.
614 * @tc.type: FUNC
615 */
616 HWTEST_F(CardFrontendTest, CardFrontendTest011, TestSize.Level1)
617 {
618 const std::string rootJson = "{\n"
619 "\t\"template\": {\n"
620 "\t\t\"attr\": {},\n"
621 "\t\t\"type\": \"text\"\n"
622 "\t},\n"
623 "\t\"styles\": {},\n"
624 "\t\"actions\": {},\n"
625 "\t\"data\": {\n"
626 "\t\t\"number\": {\n"
627 "\t\t\t\"key\": 1\n"
628 "\t\t}\n"
629 "\t}\n"
630 "}";
631 auto rootBody = JsonUtil::ParseJsonString(rootJson);
632 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
633 jsCardParser->Initialize();
634 std::string value = "{{number.key}}";
635 jsCardParser->ParseVariable(value);
636 ASSERT_EQ(value, "1");
637 }
638
639 /**
640 * @tc.name: CardFrontendTest012
641 * @tc.desc: Test array operations.
642 * @tc.type: FUNC
643 */
644 HWTEST_F(CardFrontendTest, CardFrontendTest012, TestSize.Level1)
645 {
646 const std::string rootJson = "{\n"
647 "\t\"template\": {\n"
648 "\t\t\"attr\": {},\n"
649 "\t\t\"type\": \"text\"\n"
650 "\t},\n"
651 "\t\"styles\": {},\n"
652 "\t\"actions\": {},\n"
653 "\t\"data\": {\n"
654 "\t\t\"index\": [\n"
655 "\t\t\t0,\n"
656 "\t\t\t3,\n"
657 "\t\t\t4\n"
658 "\t\t]\n"
659 "\t}\n"
660 "}";
661 auto rootBody = JsonUtil::ParseJsonString(rootJson);
662 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
663 jsCardParser->Initialize();
664 std::string value = "{{index[0]}}";
665 jsCardParser->ParseVariable(value);
666 ASSERT_EQ(value, "0");
667 value = "{{index[1]}}";
668 jsCardParser->ParseVariable(value);
669 ASSERT_EQ(value, "3");
670 value = "{{index[2]}}";
671 jsCardParser->ParseVariable(value);
672 ASSERT_EQ(value, "4");
673 }
674
675 /**
676 * @tc.name: CardFrontendTest013
677 * @tc.desc: Test complex expressions.
678 * @tc.type: FUNC
679 */
680 HWTEST_F(CardFrontendTest, CardFrontendTest013, TestSize.Level1)
681 {
682 const std::string rootJson = "{\n"
683 "\t\"template\": {\n"
684 "\t\t\"attr\": {},\n"
685 "\t\t\"type\": \"text\"\n"
686 "\t},\n"
687 "\t\"styles\": {},\n"
688 "\t\"actions\": {},\n"
689 "\t\"data\": {\n"
690 "\t\t\"hours\": [\n"
691 "\t\t\t{\n"
692 "\t\t\t\t\"time\": [\n"
693 "\t\t\t\t\t8,\n"
694 "\t\t\t\t\t2,\n"
695 "\t\t\t\t\t3\n"
696 "\t\t\t\t],\n"
697 "\t\t\t\t\"src\": \"src/XXX.png\",\n"
698 "\t\t\t\t\"prop\": 10,\n"
699 "\t\t\t\t\"isPast\": false,\n"
700 "\t\t\t\t\"temperature\": \"22°\",\n"
701 "\t\t\t\t\"description\": \"\"\n"
702 "\t\t\t},\n"
703 "\t\t\t{\n"
704 "\t\t\t\t\"time\": \"3:00\",\n"
705 "\t\t\t\t\"src\": \"src/XXX.png\",\n"
706 "\t\t\t\t\"prop\": 11,\n"
707 "\t\t\t\t\"isPast\": false,\n"
708 "\t\t\t\t\"temperature\": \"22°\",\n"
709 "\t\t\t\t\"description\": \"\"\n"
710 "\t\t\t}\n"
711 "\t\t],\n"
712 "\t\t\"number\": {\n"
713 "\t\t\t\"key\": 1\n"
714 "\t\t}\n"
715 "\t}\n"
716 "}";
717 auto rootBody = JsonUtil::ParseJsonString(rootJson);
718 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
719 jsCardParser->Initialize();
720 std::string value = "{{hours[0].time[0]}}";
721 jsCardParser->ParseVariable(value);
722 ASSERT_EQ(value, "8");
723 value = "{{hours[number.key].time}}";
724 jsCardParser->ParseVariable(value);
725 ASSERT_EQ(value, "3:00");
726 value = "{{hours[0].time}}";
727 jsCardParser->ParseVariable(value);
728 ASSERT_EQ(value, "[8,2,3]");
729 }
730
731 /**
732 * @tc.name: CardFrontendTest014
733 * @tc.desc: Test error expression.
734 * @tc.type: FUNC
735 */
736 HWTEST_F(CardFrontendTest, CardFrontendTest014, TestSize.Level1)
737 {
738 const std::string rootJson = "{\n"
739 "\t\"template\": {\n"
740 "\t\t\"attr\": {},\n"
741 "\t\t\"type\": \"text\"\n"
742 "\t},\n"
743 "\t\"styles\": {},\n"
744 "\t\"actions\": {},\n"
745 "\t\"data\": {\n"
746 "\t\t\"hours\": [\n"
747 "\t\t\t{\n"
748 "\t\t\t\t\"time\": [\n"
749 "\t\t\t\t\t8,\n"
750 "\t\t\t\t\t2,\n"
751 "\t\t\t\t\t3\n"
752 "\t\t\t\t],\n"
753 "\t\t\t\t\"src\": \"src/XXX.png\",\n"
754 "\t\t\t\t\"prop\": 10,\n"
755 "\t\t\t\t\"isPast\": false,\n"
756 "\t\t\t\t\"temperature\": \"22°\",\n"
757 "\t\t\t\t\"description\": \"\"\n"
758 "\t\t\t},\n"
759 "\t\t\t{\n"
760 "\t\t\t\t\"time\": \"3:00\",\n"
761 "\t\t\t\t\"src\": \"src/XXX.png\",\n"
762 "\t\t\t\t\"prop\": 11,\n"
763 "\t\t\t\t\"isPast\": false,\n"
764 "\t\t\t\t\"temperature\": \"22°\",\n"
765 "\t\t\t\t\"description\": \"\"\n"
766 "\t\t\t}\n"
767 "\t\t],\n"
768 "\t\t\"number\": {\n"
769 "\t\t\t\"key\": 1\n"
770 "\t\t}\n"
771 "\t}\n"
772 "}";
773 auto rootBody = JsonUtil::ParseJsonString(rootJson);
774 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
775 jsCardParser->Initialize();
776 std::string value = "{{hours[key].time}}";
777 jsCardParser->ParseVariable(value);
778 ASSERT_EQ(value, "{{hours[key].time}}");
779 value = "{{key.number}}";
780 jsCardParser->ParseVariable(value);
781 ASSERT_EQ(value, "{{key.number}}");
782 value = "{{number.key}}}";
783 jsCardParser->ParseVariable(value);
784 ASSERT_EQ(value, "{{number.key}}}");
785 }
786
787 /**
788 * @tc.name: CardFrontendDataBindingTest001
789 * @tc.desc: Test data binding for {{key1}}.{{key2}
790 * @tc.type: FUNC
791 */
792 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest001, TestSize.Level1)
793 {
794 const std::string rootJson = "{\n"
795 "\t\"template\": {\n"
796 "\t\t\"attr\": {\n"
797 "\t\t\t\"value\": \"$f({{aaa}}.{{ddd}})\",\n"
798 "\t\t\t\"index\": \"$f({{bbb}}.{{ccc}})\"\n"
799 "\t\t},\n"
800 "\t\t\"type\": \"text\"\n"
801 "\t},\n"
802 "\t\"styles\": {},\n"
803 "\t\"actions\": {},\n"
804 "\t\"data\": {\n"
805 "\t\t\"aaa\": \"abc\",\n"
806 "\t\t\"bbb\": \"true\",\n"
807 "\t\t\"ccc\": \"false\",\n"
808 "\t\t\"ddd\": \"123\"\n"
809 "\t}\n"
810 "}";
811 auto rootBody = JsonUtil::ParseJsonString(rootJson);
812 auto rootTemplate = rootBody->GetValue("template");
813 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
814 jsCardParser->Initialize();
815 auto document = AceType::MakeRefPtr<DOMDocument>(1);
816 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
817 jsCardParser->CreateDomNode(page, rootTemplate, -1);
818
819 auto attrValue = rootTemplate->GetValue("attr");
820 auto value = attrValue->GetValue("value")->GetString();
821
822 // {{aaa}}.{{ddd}} == abc.123
823 jsCardParser->ParseMultiVariable(value);
824 ASSERT_EQ(value, "abc.123");
825
826 // {{bbb}}.{{ccc}} = true.false
827 value = attrValue->GetValue("index")->GetString();
828 jsCardParser->ParseMultiVariable(value);
829 ASSERT_EQ(value, "true.false");
830 }
831
832 /**
833 * @tc.name: CardFrontendDataBindingTest002
834 * @tc.desc: Test data binding for {{key1}}.{{key2}.{{key3}}
835 * @tc.type: FUNC
836 */
837 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest002, TestSize.Level1)
838 {
839 const std::string rootJson = "{\n"
840 "\t\"template\": {\n"
841 "\t\t\"attr\": {\n"
842 "\t\t\t\"value\": \"$f({{aaa}}.{{bbb}}.{{ccc}})\",\n"
843 "\t\t\t\"index\": \"$f({{aaa}}.{{bbb}}.{{ccc}}.{{ddd}})\"\n"
844 "\t\t},\n"
845 "\t\t\"type\": \"text\"\n"
846 "\t},\n"
847 "\t\"styles\": {},\n"
848 "\t\"actions\": {},\n"
849 "\t\"data\": {\n"
850 "\t\t\"aaa\": \"abc\",\n"
851 "\t\t\"bbb\": \"true\",\n"
852 "\t\t\"ccc\": \"false\",\n"
853 "\t\t\"ddd\": \"123\"\n"
854 "\t}\n"
855 "}";
856 auto rootBody = JsonUtil::ParseJsonString(rootJson);
857 auto rootTemplate = rootBody->GetValue("template");
858 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
859 jsCardParser->Initialize();
860 auto document = AceType::MakeRefPtr<DOMDocument>(1);
861 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
862 jsCardParser->CreateDomNode(page, rootTemplate, -1);
863
864 auto attrValue = rootTemplate->GetValue("attr");
865 auto value = attrValue->GetValue("value")->GetString();
866
867 // {{aaa}}.{{bbb}}.{{ccc}} == abc.true.false
868 jsCardParser->ParseMultiVariable(value);
869 ASSERT_EQ(value, "abc.true.false");
870
871 // {{aaa}}.{{bbb}}.{{ccc}}.{{ddd}} = abc.true.false.123
872 value = attrValue->GetValue("index")->GetString();
873 jsCardParser->ParseMultiVariable(value);
874 ASSERT_EQ(value, "abc.true.false.123");
875 }
876
877 /**
878 * @tc.name: CardFrontendDataBindingTest003
879 * @tc.desc: Test data binding for {{flag1 ? key1 : key2}}.
880 * @tc.type: FUNC
881 */
882 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest003, TestSize.Level1)
883 {
884 const std::string rootJson = "{\n"
885 "\t\"template\": {\n"
886 "\t\t\"attr\": {\n"
887 "\t\t\t\"value\": \"{{bbb ? aaa : bbb}}\",\n"
888 "\t\t\t\"index\": \"{{ccc ? aaa : ddd}}\"\n"
889 "\t\t},\n"
890 "\t\t\"type\": \"text\"\n"
891 "\t},\n"
892 "\t\"styles\": {},\n"
893 "\t\"actions\": {},\n"
894 "\t\"data\": {\n"
895 "\t\t\"aaa\": \"abc\",\n"
896 "\t\t\"bbb\": \"true\",\n"
897 "\t\t\"ccc\": \"false\",\n"
898 "\t\t\"ddd\": \"123\"\n"
899 "\t}\n"
900 "}";
901 auto rootBody = JsonUtil::ParseJsonString(rootJson);
902 auto rootTemplate = rootBody->GetValue("template");
903 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
904 jsCardParser->Initialize();
905 auto document = AceType::MakeRefPtr<DOMDocument>(1);
906 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
907 jsCardParser->CreateDomNode(page, rootTemplate, -1);
908
909 auto attrValue = rootTemplate->GetValue("attr");
910 auto value = attrValue->GetValue("value")->GetString();
911
912 // bbb = true, value = {{aaa}}
913 jsCardParser->ParseVariable(value);
914 ASSERT_EQ(value, "abc");
915
916 // ccc = false, value = {{ddd}}
917 value = attrValue->GetValue("index")->GetString();
918 jsCardParser->ParseVariable(value);
919 ASSERT_EQ(value, "123");
920 }
921
922 /**
923 * @tc.name: CardFrontendDataBindingTest004
924 * @tc.desc: Test data binding for illegal {{flag1 ? key1 : key2}}.
925 * @tc.type: FUNC
926 */
927 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest004, TestSize.Level1)
928 {
929 const std::string rootJson = "{\n"
930 "\t\"template\": {\n"
931 "\t\t\"attr\": {\n"
932 "\t\t\t\"value\": \"{{aaa ? bbb : ccc}}\",\n"
933 "\t\t\t\"index\": \"{{ccc ? aaa : eee}}\"\n"
934 "\t\t},\n"
935 "\t\t\"type\": \"text\"\n"
936 "\t},\n"
937 "\t\"styles\": {},\n"
938 "\t\"actions\": {},\n"
939 "\t\"data\": {\n"
940 "\t\t\"aaa\": \"abc\",\n"
941 "\t\t\"bbb\": \"true\",\n"
942 "\t\t\"ccc\": \"false\",\n"
943 "\t\t\"ddd\": \"123\"\n"
944 "\t}\n"
945 "}";
946 auto rootBody = JsonUtil::ParseJsonString(rootJson);
947 auto rootTemplate = rootBody->GetValue("template");
948 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
949 jsCardParser->Initialize();
950 auto document = AceType::MakeRefPtr<DOMDocument>(1);
951 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
952 jsCardParser->CreateDomNode(page, rootTemplate, -1);
953
954 auto attrValue = rootTemplate->GetValue("attr");
955 auto value = attrValue->GetValue("value")->GetString();
956
957 // aaa if not a bool value, set aaa = false, and value = {{ccc}}
958 jsCardParser->ParseVariable(value);
959 ASSERT_EQ(value, "false");
960
961 // ccc = false, value = {{eee}}, eee does not belong to the data domain.
962 value = attrValue->GetValue("index")->GetString();
963 jsCardParser->ParseVariable(value);
964 ASSERT_EQ(value, "eee");
965 }
966
967 /**
968 * @tc.name: CardFrontendDataBindingTest005
969 * @tc.desc: Test data binding for {{flag1 && flag2}}.
970 * @tc.type: FUNC
971 */
972 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest005, TestSize.Level1)
973 {
974 const std::string rootJson = "{\n"
975 "\t\"template\": {\n"
976 "\t\t\"attr\": {\n"
977 "\t\t\t\"value\": \"{{bbb && ccc}}\",\n"
978 "\t\t\t\"index\": \"{{bbb && bbb}}\"\n"
979 "\t\t},\n"
980 "\t\t\"type\": \"text\"\n"
981 "\t},\n"
982 "\t\"styles\": {},\n"
983 "\t\"actions\": {},\n"
984 "\t\"data\": {\n"
985 "\t\t\"aaa\": \"abc\",\n"
986 "\t\t\"bbb\": \"true\",\n"
987 "\t\t\"ccc\": \"false\",\n"
988 "\t\t\"ddd\": \"123\"\n"
989 "\t}\n"
990 "}";
991 auto rootBody = JsonUtil::ParseJsonString(rootJson);
992 auto rootTemplate = rootBody->GetValue("template");
993 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
994 jsCardParser->Initialize();
995 auto document = AceType::MakeRefPtr<DOMDocument>(1);
996 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
997 jsCardParser->CreateDomNode(page, rootTemplate, -1);
998
999 auto attrValue = rootTemplate->GetValue("attr");
1000 auto value = attrValue->GetValue("value")->GetString();
1001
1002 // bbb = true, ccc = false, value = (bbb && ccc) = false.
1003 jsCardParser->ParseVariable(value);
1004 ASSERT_EQ(value, "false");
1005
1006 // bbb = true, value = (bbb && bbb) = true.
1007 value = attrValue->GetValue("index")->GetString();
1008 jsCardParser->ParseVariable(value);
1009 ASSERT_EQ(value, "true");
1010 }
1011
1012 /**
1013 * @tc.name: CardFrontendDataBindingTest006
1014 * @tc.desc: Test data binding for {{flag1 || flag2}}.
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest006, TestSize.Level1)
1018 {
1019 const std::string rootJson = "{\n"
1020 "\t\"template\": {\n"
1021 "\t\t\"attr\": {\n"
1022 "\t\t\t\"value\": \"{{bbb || ccc}}\",\n"
1023 "\t\t\t\"index\": \"{{ccc || ccc}}\"\n"
1024 "\t\t},\n"
1025 "\t\t\"type\": \"text\"\n"
1026 "\t},\n"
1027 "\t\"styles\": {},\n"
1028 "\t\"actions\": {},\n"
1029 "\t\"data\": {\n"
1030 "\t\t\"aaa\": \"abc\",\n"
1031 "\t\t\"bbb\": \"true\",\n"
1032 "\t\t\"ccc\": \"false\",\n"
1033 "\t\t\"ddd\": \"123\"\n"
1034 "\t}\n"
1035 "}";
1036 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1037 auto rootTemplate = rootBody->GetValue("template");
1038 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1039 jsCardParser->Initialize();
1040 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1041 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1042 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1043
1044 auto attrValue = rootTemplate->GetValue("attr");
1045 auto value = attrValue->GetValue("value")->GetString();
1046
1047 // bbb = true, ccc = false, value = (bbb || ccc) = true.
1048 jsCardParser->ParseVariable(value);
1049 ASSERT_EQ(value, "true");
1050
1051 // ccc = false, value = (ccc || ccc) = false.
1052 value = attrValue->GetValue("index")->GetString();
1053 jsCardParser->ParseVariable(value);
1054 ASSERT_EQ(value, "false");
1055 }
1056
1057 /**
1058 * @tc.name: CardFrontendDataBindingTest007
1059 * @tc.desc: Test data binding for {{!flag1}}.
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest007, TestSize.Level1)
1063 {
1064 const std::string rootJson = "{\n"
1065 "\t\"template\": {\n"
1066 "\t\t\"attr\": {\n"
1067 "\t\t\t\"value\": \"{{!bbb}}\",\n"
1068 "\t\t\t\"index\": \"{{!ccc}}\"\n"
1069 "\t\t},\n"
1070 "\t\t\"type\": \"text\"\n"
1071 "\t},\n"
1072 "\t\"styles\": {},\n"
1073 "\t\"actions\": {},\n"
1074 "\t\"data\": {\n"
1075 "\t\t\"aaa\": \"abc\",\n"
1076 "\t\t\"bbb\": \"true\",\n"
1077 "\t\t\"ccc\": \"false\",\n"
1078 "\t\t\"ddd\": \"123\"\n"
1079 "\t}\n"
1080 "}";
1081 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1082 auto rootTemplate = rootBody->GetValue("template");
1083 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1084 jsCardParser->Initialize();
1085 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1086 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1087 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1088
1089 auto attrValue = rootTemplate->GetValue("attr");
1090 auto value = attrValue->GetValue("value")->GetString();
1091
1092 // bbb = true, !bbb = false.
1093 jsCardParser->ParseVariable(value);
1094 ASSERT_EQ(value, "false");
1095
1096 // ccc = false, !ccc = true.
1097 value = attrValue->GetValue("index")->GetString();
1098 jsCardParser->ParseVariable(value);
1099 ASSERT_EQ(value, "true");
1100 }
1101
1102 /**
1103 * @tc.name: CardFrontendDataBindingTest008
1104 * @tc.desc: Test data binding for {{flag1 && flag2 && flag3}} (not support now).
1105 * @tc.type: FUNC
1106 */
1107 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest008, TestSize.Level1)
1108 {
1109 const std::string rootJson = "{\n"
1110 "\t\"template\": {\n"
1111 "\t\t\"attr\": {\n"
1112 "\t\t\t\"value\": \"{{bbb && ccc && aaa}}\",\n"
1113 "\t\t\t\"index\": \"{{bbb && bbb && ccc}}\"\n"
1114 "\t\t},\n"
1115 "\t\t\"type\": \"text\"\n"
1116 "\t},\n"
1117 "\t\"styles\": {},\n"
1118 "\t\"actions\": {},\n"
1119 "\t\"data\": {\n"
1120 "\t\t\"aaa\": \"abc\",\n"
1121 "\t\t\"bbb\": \"true\",\n"
1122 "\t\t\"ccc\": \"false\",\n"
1123 "\t\t\"ddd\": \"123\"\n"
1124 "\t}\n"
1125 "}";
1126 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1127 auto rootTemplate = rootBody->GetValue("template");
1128 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1129 jsCardParser->Initialize();
1130 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1131 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1132 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1133
1134 auto attrValue = rootTemplate->GetValue("attr");
1135 auto value = attrValue->GetValue("value")->GetString();
1136
1137 // When more than two variables want to &&, return itself.
1138 jsCardParser->ParseVariable(value);
1139 ASSERT_EQ(value, "{{bbb && ccc && aaa}}");
1140
1141 value = attrValue->GetValue("index")->GetString();
1142 jsCardParser->ParseVariable(value);
1143 ASSERT_EQ(value, "{{bbb && bbb && ccc}}");
1144 }
1145
1146 /**
1147 * @tc.name: CardFrontendDataBindingTest009
1148 * @tc.desc: Test data binding for {{flag1 || flag2 || flag3}} (not support now).
1149 * @tc.type: FUNC
1150 */
1151 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest009, TestSize.Level1)
1152 {
1153 const std::string rootJson = "{\n"
1154 "\t\"template\": {\n"
1155 "\t\t\"attr\": {\n"
1156 "\t\t\t\"value\": \"{{bbb || ccc || aaa}}\",\n"
1157 "\t\t\t\"index\": \"{{bbb || bbb || ccc}}\"\n"
1158 "\t\t},\n"
1159 "\t\t\"type\": \"text\"\n"
1160 "\t},\n"
1161 "\t\"styles\": {},\n"
1162 "\t\"actions\": {},\n"
1163 "\t\"data\": {\n"
1164 "\t\t\"aaa\": \"abc\",\n"
1165 "\t\t\"bbb\": \"true\",\n"
1166 "\t\t\"ccc\": \"false\",\n"
1167 "\t\t\"ddd\": \"123\"\n"
1168 "\t}\n"
1169 "}";
1170 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1171 auto rootTemplate = rootBody->GetValue("template");
1172 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1173 jsCardParser->Initialize();
1174 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1175 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1176 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1177
1178 auto attrValue = rootTemplate->GetValue("attr");
1179 auto value = attrValue->GetValue("value")->GetString();
1180
1181 // When more than two variables want to ||, return itself.
1182 jsCardParser->ParseVariable(value);
1183 ASSERT_EQ(value, "{{bbb || ccc || aaa}}");
1184
1185 value = attrValue->GetValue("index")->GetString();
1186 jsCardParser->ParseVariable(value);
1187 ASSERT_EQ(value, "{{bbb || bbb || ccc}}");
1188 }
1189
1190 /**
1191 * @tc.name: CardFrontendDataBindingTest010
1192 * @tc.desc: Test data binding for {{flag1 && flag2 || flag3}} (not support now).
1193 * @tc.type: FUNC
1194 */
1195 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest010, TestSize.Level1)
1196 {
1197 const std::string rootJson = "{\n"
1198 "\t\"template\": {\n"
1199 "\t\t\"attr\": {\n"
1200 "\t\t\t\"value\": \"{{bbb && ccc || aaa}}\",\n"
1201 "\t\t\t\"index\": \"{{bbb || bbb && ccc}}\"\n"
1202 "\t\t},\n"
1203 "\t\t\"type\": \"text\"\n"
1204 "\t},\n"
1205 "\t\"styles\": {},\n"
1206 "\t\"actions\": {},\n"
1207 "\t\"data\": {\n"
1208 "\t\t\"aaa\": \"abc\",\n"
1209 "\t\t\"bbb\": \"true\",\n"
1210 "\t\t\"ccc\": \"false\",\n"
1211 "\t\t\"ddd\": \"123\"\n"
1212 "\t}\n"
1213 "}";
1214 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1215 auto rootTemplate = rootBody->GetValue("template");
1216 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1217 jsCardParser->Initialize();
1218 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1219 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1220 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1221
1222 auto attrValue = rootTemplate->GetValue("attr");
1223 auto value = attrValue->GetValue("value")->GetString();
1224
1225 // When more than two variables want to || or &&, return itself.
1226 jsCardParser->ParseVariable(value);
1227 ASSERT_EQ(value, "{{bbb && ccc || aaa}}");
1228
1229 value = attrValue->GetValue("index")->GetString();
1230 jsCardParser->ParseVariable(value);
1231 ASSERT_EQ(value, "{{bbb || bbb && ccc}}");
1232 }
1233
1234 /**
1235 * @tc.name: CardFrontendDataBindingTest011
1236 * @tc.desc: Test data binding for {{!flag1 && flag2}} (not support now).
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest011, TestSize.Level1)
1240 {
1241 const std::string rootJson = "{\n"
1242 "\t\"template\": {\n"
1243 "\t\t\"attr\": {\n"
1244 "\t\t\t\"value\": \"{{!bbb && ccc}}\",\n"
1245 "\t\t\t\"index\": \"{{!ccc || bbb}}\"\n"
1246 "\t\t},\n"
1247 "\t\t\"type\": \"text\"\n"
1248 "\t},\n"
1249 "\t\"styles\": {},\n"
1250 "\t\"actions\": {},\n"
1251 "\t\"data\": {\n"
1252 "\t\t\"aaa\": \"abc\",\n"
1253 "\t\t\"bbb\": \"true\",\n"
1254 "\t\t\"ccc\": \"false\",\n"
1255 "\t\t\"ddd\": \"123\"\n"
1256 "\t}\n"
1257 "}";
1258 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1259 auto rootTemplate = rootBody->GetValue("template");
1260 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1261 jsCardParser->Initialize();
1262 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1263 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1264 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1265
1266 auto attrValue = rootTemplate->GetValue("attr");
1267 auto value = attrValue->GetValue("value")->GetString();
1268
1269 jsCardParser->ParseVariable(value);
1270 ASSERT_EQ(value, "{{!bbb && ccc}}");
1271
1272 value = attrValue->GetValue("index")->GetString();
1273 jsCardParser->ParseVariable(value);
1274 ASSERT_EQ(value, "{{!ccc || bbb}}");
1275 }
1276
1277 /**
1278 * @tc.name: CardFrontendDataBindingTest012
1279 * @tc.desc: Test data binding for {{!flag1}}.{{!flag2}}.
1280 * @tc.type: FUNC
1281 */
1282 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest012, TestSize.Level1)
1283 {
1284 const std::string rootJson = "{\n"
1285 "\t\"template\": {\n"
1286 "\t\t\"attr\": {\n"
1287 "\t\t\t\"value\": \"$f({{!bbb}}.{{!ccc}})\",\n"
1288 "\t\t\t\"index\": \"$f({{!aaa}}.{{!ccc}})\"\n"
1289 "\t\t},\n"
1290 "\t\t\"type\": \"text\"\n"
1291 "\t},\n"
1292 "\t\"styles\": {},\n"
1293 "\t\"actions\": {},\n"
1294 "\t\"data\": {\n"
1295 "\t\t\"aaa\": \"abc\",\n"
1296 "\t\t\"bbb\": \"true\",\n"
1297 "\t\t\"ccc\": \"false\",\n"
1298 "\t\t\"ddd\": \"123\"\n"
1299 "\t}\n"
1300 "}";
1301 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1302 auto rootTemplate = rootBody->GetValue("template");
1303 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1304 jsCardParser->Initialize();
1305 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1306 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1307 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1308
1309 auto attrValue = rootTemplate->GetValue("attr");
1310 auto value = attrValue->GetValue("value")->GetString();
1311
1312 // !bbb = false, !ccc = true.
1313 jsCardParser->ParseMultiVariable(value);
1314 ASSERT_EQ(value, "false.true");
1315
1316 // aaa is not bool value, so aaa = false, !aaa = true.
1317 value = attrValue->GetValue("index")->GetString();
1318 jsCardParser->ParseMultiVariable(value);
1319 ASSERT_EQ(value, "true.true");
1320 }
1321
1322 /**
1323 * @tc.name: CardFrontendDataBindingTest013
1324 * @tc.desc: Test data binding for {{key1}}.{{!flag1}}.
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest013, TestSize.Level1)
1328 {
1329 const std::string rootJson = "{\n"
1330 "\t\"template\": {\n"
1331 "\t\t\"attr\": {\n"
1332 "\t\t\t\"value\": \"$f({{bbb}}.{{!ccc}})\",\n"
1333 "\t\t\t\"index\": \"$f({{aaa}}.{{!ccc}})\"\n"
1334 "\t\t},\n"
1335 "\t\t\"type\": \"text\"\n"
1336 "\t},\n"
1337 "\t\"styles\": {},\n"
1338 "\t\"actions\": {},\n"
1339 "\t\"data\": {\n"
1340 "\t\t\"aaa\": \"abc\",\n"
1341 "\t\t\"bbb\": \"true\",\n"
1342 "\t\t\"ccc\": \"false\",\n"
1343 "\t\t\"ddd\": \"123\"\n"
1344 "\t}\n"
1345 "}";
1346 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1347 auto rootTemplate = rootBody->GetValue("template");
1348 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1349 jsCardParser->Initialize();
1350 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1351 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1352 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1353
1354 auto attrValue = rootTemplate->GetValue("attr");
1355 auto value = attrValue->GetValue("value")->GetString();
1356
1357 jsCardParser->ParseMultiVariable(value);
1358 ASSERT_EQ(value, "true.true");
1359
1360 value = attrValue->GetValue("index")->GetString();
1361 jsCardParser->ParseMultiVariable(value);
1362 ASSERT_EQ(value, "abc.true");
1363 }
1364
1365 /**
1366 * @tc.name: CardFrontendDataBindingTest014
1367 * @tc.desc: Test data binding for constant + variable.
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest014, TestSize.Level1)
1371 {
1372 const std::string rootJson = "{\n"
1373 "\t\"template\": {\n"
1374 "\t\t\"attr\": {\n"
1375 "\t\t\t\"value\": \"$f(value1 is : {{aaa}})\",\n"
1376 "\t\t\t\"index\": \"$f(ccc is: {{ccc}}, bbb is {{bbb}}.)\"\n"
1377 "\t\t},\n"
1378 "\t\t\"type\": \"text\"\n"
1379 "\t},\n"
1380 "\t\"styles\": {},\n"
1381 "\t\"actions\": {},\n"
1382 "\t\"data\": {\n"
1383 "\t\t\"aaa\": \"abc\",\n"
1384 "\t\t\"bbb\": \"true\",\n"
1385 "\t\t\"ccc\": \"false\",\n"
1386 "\t\t\"ddd\": \"123\"\n"
1387 "\t}\n"
1388 "}";
1389 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1390 auto rootTemplate = rootBody->GetValue("template");
1391 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1392 jsCardParser->Initialize();
1393 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1394 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1395 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1396
1397 auto attrValue = rootTemplate->GetValue("attr");
1398 auto value = attrValue->GetValue("value")->GetString();
1399
1400 jsCardParser->ParseMultiVariable(value);
1401 ASSERT_EQ(value, "value1 is : abc");
1402
1403 value = attrValue->GetValue("index")->GetString();
1404 jsCardParser->ParseMultiVariable(value);
1405 ASSERT_EQ(value, "ccc is: false, bbb is true.");
1406 }
1407
1408 /**
1409 * @tc.name: CardFrontendDataBindingTest015
1410 * @tc.desc: Test data binding for {{!flag1}}.{{flag2 && flag3}}
1411 * @tc.type: FUNC
1412 */
1413 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest015, TestSize.Level1)
1414 {
1415 const std::string rootJson = "{\n"
1416 "\t\"template\": {\n"
1417 "\t\t\"attr\": {\n"
1418 "\t\t\t\"value\": \"$f({{!bbb}}.{{bbb && ccc}})\",\n"
1419 "\t\t\t\"index\": \"$f({{aaa}}.{{bbb || ccc}})\"\n"
1420 "\t\t},\n"
1421 "\t\t\"type\": \"text\"\n"
1422 "\t},\n"
1423 "\t\"styles\": {},\n"
1424 "\t\"actions\": {},\n"
1425 "\t\"data\": {\n"
1426 "\t\t\"aaa\": \"abc\",\n"
1427 "\t\t\"bbb\": \"true\",\n"
1428 "\t\t\"ccc\": \"false\",\n"
1429 "\t\t\"ddd\": \"123\"\n"
1430 "\t}\n"
1431 "}";
1432 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1433 auto rootTemplate = rootBody->GetValue("template");
1434 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1435 jsCardParser->Initialize();
1436 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1437 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1438 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1439
1440 auto attrValue = rootTemplate->GetValue("attr");
1441 auto value = attrValue->GetValue("value")->GetString();
1442
1443 jsCardParser->ParseMultiVariable(value);
1444 ASSERT_EQ(value, "false.false");
1445
1446 value = attrValue->GetValue("index")->GetString();
1447 jsCardParser->ParseMultiVariable(value);
1448 ASSERT_EQ(value, "abc.true");
1449 }
1450
1451 /**
1452 * @tc.name: CardFrontendDataBindingTest016
1453 * @tc.desc: Test data binding for error expression.
1454 * @tc.type: FUNC
1455 */
1456 HWTEST_F(CardFrontendTest, CardFrontendDataBindingTest016, TestSize.Level1)
1457 {
1458 const std::string rootJson = "{\n"
1459 "\t\"template\": {\n"
1460 "\t\t\"attr\": {\n"
1461 "\t\t\t\"value\": \"$f({{aaa}}.{{eee}})\",\n"
1462 "\t\t\t\"value1\": \"{{aaa ? bbb : ddd}}\",\n"
1463 "\t\t\t\"value2\": \"{{aaa && ddd}}\",\n"
1464 "\t\t\t\"value3\": \"{{aaa || ddd}}\",\n"
1465 "\t\t\t\"value4\": \"{{!ddd}}\"\n"
1466 "\t\t},\n"
1467 "\t\t\"type\": \"text\"\n"
1468 "\t},\n"
1469 "\t\"styles\": {},\n"
1470 "\t\"actions\": {},\n"
1471 "\t\"data\": {\n"
1472 "\t\t\"aaa\": \"abc\",\n"
1473 "\t\t\"bbb\": \"true\",\n"
1474 "\t\t\"ccc\": \"false\",\n"
1475 "\t\t\"ddd\": \"123\"\n"
1476 "\t}\n"
1477 "}";
1478 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1479 auto rootTemplate = rootBody->GetValue("template");
1480 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1481 jsCardParser->Initialize();
1482 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1483 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1484 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1485
1486 auto attrValue = rootTemplate->GetValue("attr");
1487 auto value = attrValue->GetValue("value")->GetString();
1488
1489 // {{aaa}}.{{eee}}, eee does not belong to the data field.
1490 jsCardParser->ParseMultiVariable(value);
1491 ASSERT_EQ(value, "abc.{{eee}}");
1492
1493 // aaa ? bbb : ddd, aaa is not bool variable, the default setting is false.
1494 value = attrValue->GetValue("value1")->GetString();
1495 jsCardParser->ParseVariable(value);
1496 ASSERT_EQ(value, "123");
1497
1498 // aaa && ddd, aaa and ddd are not bool variables, the default setting is false.
1499 value = attrValue->GetValue("value2")->GetString();
1500 jsCardParser->ParseVariable(value);
1501 ASSERT_EQ(value, "false");
1502
1503 // aaa || ddd, aaa and ddd are not bool variables, the default setting is false.
1504 value = attrValue->GetValue("value3")->GetString();
1505 jsCardParser->ParseVariable(value);
1506 ASSERT_EQ(value, "false");
1507
1508 // ddd is not a bool variable, the default setting is false.
1509 value = attrValue->GetValue("value4")->GetString();
1510 jsCardParser->ParseVariable(value);
1511 ASSERT_EQ(value, "true");
1512 }
1513
1514 /**
1515 * @tc.name: JsCardParserCreateDomNodeTest001
1516 * @tc.desc: Test create dom node when type is text with children list.
1517 * @tc.type: FUNC
1518 */
1519 HWTEST_F(CardFrontendTest, JsCardParserCreateDomNodeTest001, TestSize.Level1)
1520 {
1521 /**
1522 * @tc.steps: step1. construct json string.
1523 */
1524 const std::string rootJson = "{\n"
1525 "\t\"template\": {\n"
1526 "\t\t\"attr\": {},\n"
1527 "\t\t\"type\": \"text\",\n"
1528 "\t\t\"children\": [\n"
1529 "\t\t\t{\n"
1530 "\t\t\t\t\"name\": \"aa\",\n"
1531 "\t\t\t\t\"idx\": 1\n"
1532 "\t\t\t},\n"
1533 "\t\t\t{\n"
1534 "\t\t\t\t\"name\": \"bb\",\n"
1535 "\t\t\t\t\"idx\": 2\n"
1536 "\t\t\t},\n"
1537 "\t\t\t{\n"
1538 "\t\t\t\t\"name\": \"cc\",\n"
1539 "\t\t\t\t\"idx\": 1\n"
1540 "\t\t\t}\n"
1541 "\t\t]\n"
1542 "\t},\n"
1543 "\t\"styles\": {},\n"
1544 "\t\"actions\": {}\n"
1545 "}";
1546 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1547 auto rootTemplate = rootBody->GetValue("template");
1548 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1549 jsCardParser->Initialize();
1550 jsCardParser->SetIsRepeat(true);
1551 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1552 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1553 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1554
1555 auto childList = rootTemplate->GetValue("children");
1556 ASSERT_EQ(childList->GetArraySize(), 3);
1557 if (childList && childList->IsValid()) {
1558 auto child = childList->GetChild();
1559 int32_t count = 0;
1560 while (child && child->IsValid()) {
1561 auto itemName = child->GetValue("name")->GetString();
1562 auto itemIndex = child->GetValue("idx")->GetInt();
1563 if (count == 0) {
1564 ASSERT_EQ(itemName, "aa");
1565 ASSERT_EQ(itemIndex, 1);
1566 } else if (count == 1) {
1567 ASSERT_EQ(itemName, "bb");
1568 ASSERT_EQ(itemIndex, 2);
1569 } else {
1570 ASSERT_EQ(itemName, "cc");
1571 ASSERT_EQ(itemIndex, 1);
1572 }
1573 count++;
1574 child = child->GetNext();
1575 }
1576 }
1577 }
1578
1579 /**
1580 * @tc.name: JsCardParserCreateDomNodeTest002
1581 * @tc.desc: Test create dom node when type is block with children list.
1582 * @tc.type: FUNC
1583 */
1584 HWTEST_F(CardFrontendTest, JsCardParserCreateDomNodeTest002, TestSize.Level1)
1585 {
1586 /**
1587 * @tc.steps: step1. construct json string.
1588 */
1589 const std::string rootJson = "{\n"
1590 "\t\"template\": {\n"
1591 "\t\t\"attr\": {},\n"
1592 "\t\t\"type\": \"block\",\n"
1593 "\t\t\"children\": [\n"
1594 "\t\t\t{\n"
1595 "\t\t\t\t\"name\": \"aa\",\n"
1596 "\t\t\t\t\"idx\": 1\n"
1597 "\t\t\t},\n"
1598 "\t\t\t{\n"
1599 "\t\t\t\t\"name\": \"bb\",\n"
1600 "\t\t\t\t\"idx\": 2\n"
1601 "\t\t\t},\n"
1602 "\t\t\t{\n"
1603 "\t\t\t\t\"name\": \"cc\",\n"
1604 "\t\t\t\t\"idx\": 1\n"
1605 "\t\t\t}\n"
1606 "\t\t]\n"
1607 "\t},\n"
1608 "\t\"styles\": {},\n"
1609 "\t\"actions\": {}\n"
1610 "}";
1611 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1612 auto rootTemplate = rootBody->GetValue("template");
1613 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1614 jsCardParser->Initialize();
1615 jsCardParser->SetIsRepeat(true);
1616 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1617 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1618 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1619
1620 auto childList = rootTemplate->GetValue("children");
1621 ASSERT_EQ(childList->GetArraySize(), 3);
1622 if (childList && childList->IsValid()) {
1623 auto child = childList->GetChild();
1624 int32_t count = 0;
1625 while (child && child->IsValid()) {
1626 auto itemName = child->GetValue("name")->GetString();
1627 auto itemIndex = child->GetValue("idx")->GetInt();
1628 if (count == 0) {
1629 ASSERT_EQ(itemName, "aa");
1630 ASSERT_EQ(itemIndex, 1);
1631 } else if (count == 1) {
1632 ASSERT_EQ(itemName, "bb");
1633 ASSERT_EQ(itemIndex, 2);
1634 } else {
1635 ASSERT_EQ(itemName, "cc");
1636 ASSERT_EQ(itemIndex, 1);
1637 }
1638 count++;
1639 child = child->GetNext();
1640 }
1641 }
1642 }
1643
1644 /**
1645 * @tc.name: JsCardParserCreateDomNodeTest003
1646 * @tc.desc: Test create dom node when type is block without children list.
1647 * @tc.type: FUNC
1648 */
1649 HWTEST_F(CardFrontendTest, JsCardParserCreateDomNodeTest003, TestSize.Level1)
1650 {
1651 /**
1652 * @tc.steps: step1. construct json string.
1653 */
1654 const std::string rootJson = "{\n"
1655 "\t\"template\": {\n"
1656 "\t\t\"attr\": {},\n"
1657 "\t\t\"type\": \"block\",\n"
1658 "\t\t\"repeat\": \"{{list}}\"\n"
1659 "\t},\n"
1660 "\t\"styles\": {},\n"
1661 "\t\"actions\": {},\n"
1662 "\t\"data\": {\n"
1663 "\t\t\"list\": [\n"
1664 "\t\t\t{\n"
1665 "\t\t\t\t\"name\": \"aa\",\n"
1666 "\t\t\t\t\"idx\": 1\n"
1667 "\t\t\t},\n"
1668 "\t\t\t{\n"
1669 "\t\t\t\t\"name\": \"bb\",\n"
1670 "\t\t\t\t\"idx\": 2\n"
1671 "\t\t\t},\n"
1672 "\t\t\t{\n"
1673 "\t\t\t\t\"name\": \"cc\",\n"
1674 "\t\t\t\t\"idx\": 1\n"
1675 "\t\t\t}\n"
1676 "\t\t]\n"
1677 "\t}\n"
1678 "}";
1679 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1680 auto rootTemplate = rootBody->GetValue("template");
1681 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1682 jsCardParser->Initialize();
1683 jsCardParser->SetIsRepeat(true);
1684 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1685 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1686 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1687
1688 auto repeatValue = rootTemplate->GetValue("repeat");
1689 std::string key;
1690 jsCardParser->GetRepeatData(repeatValue, key);
1691
1692 ASSERT_EQ(repeatValue->GetArraySize(), 3);
1693 auto item = repeatValue->GetChild();
1694 auto itemName = item->GetValue("name")->GetString();
1695 auto itemIndex = item->GetValue("idx")->GetInt();
1696 ASSERT_EQ(itemName, "aa");
1697 ASSERT_EQ(itemIndex, 1);
1698 }
1699
1700 /**
1701 * @tc.name: JsCardParserCreateDomNodeTest004
1702 * @tc.desc: Test create dom node when rootBody dosen't contains type.
1703 * @tc.type: FUNC
1704 */
1705 HWTEST_F(CardFrontendTest, JsCardParserCreateDomNodeTest004, TestSize.Level1)
1706 {
1707 /**
1708 * @tc.steps: step1. construct json string.
1709 */
1710 const std::string rootJson = "{\n"
1711 "\t\"template\": {\n"
1712 "\t\t\"attr\": {},\n"
1713 "\t\t\"repeat\": \"{{list}}\"\n"
1714 "\t},\n"
1715 "\t\"styles\": {},\n"
1716 "\t\"actions\": {},\n"
1717 "\t\"data\": {\n"
1718 "\t\t\"list\": [\n"
1719 "\t\t\t{\n"
1720 "\t\t\t\t\"name\": \"aa\",\n"
1721 "\t\t\t\t\"idx\": 1\n"
1722 "\t\t\t},\n"
1723 "\t\t\t{\n"
1724 "\t\t\t\t\"name\": \"bb\",\n"
1725 "\t\t\t\t\"idx\": 2\n"
1726 "\t\t\t},\n"
1727 "\t\t\t{\n"
1728 "\t\t\t\t\"name\": \"cc\",\n"
1729 "\t\t\t\t\"idx\": 1\n"
1730 "\t\t\t}\n"
1731 "\t\t]\n"
1732 "\t}\n"
1733 "}";
1734 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1735 auto rootTemplate = rootBody->GetValue("template");
1736 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1737 jsCardParser->Initialize();
1738 jsCardParser->SetIsRepeat(true);
1739 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1740 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1741 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1742
1743 auto repeatValue = rootTemplate->GetValue("repeat");
1744 std::string key;
1745 jsCardParser->GetRepeatData(repeatValue, key);
1746
1747 ASSERT_EQ(repeatValue->GetArraySize(), 3);
1748 auto item = repeatValue->GetChild();
1749 auto itemName = item->GetValue("name")->GetString();
1750 auto itemIndex = item->GetValue("idx")->GetInt();
1751 ASSERT_EQ(itemName, "aa");
1752 ASSERT_EQ(itemIndex, 1);
1753 }
1754
1755 /**
1756 * @tc.name: JsCardParserCreateDomNodeTest005
1757 * @tc.desc: Test create dom node when repeat is invalid.
1758 * @tc.type: FUNC
1759 */
1760 HWTEST_F(CardFrontendTest, JsCardParserCreateDomNodeTest005, TestSize.Level1)
1761 {
1762 /**
1763 * @tc.steps: step1. construct json string.
1764 */
1765 const std::string rootJson = "{\n"
1766 "\t\"template\": {\n"
1767 "\t\t\"attr\": {},\n"
1768 "\t\t\"repeat\": \"{{list}}\"\n"
1769 "\t},\n"
1770 "\t\"styles\": {},\n"
1771 "\t\"actions\": {},\n"
1772 "\t\"data\": {\n"
1773 "\t\t\"list\": [\n"
1774 "\t\t\t{\n"
1775 "\t\t\t\t\"name\": \"aa\",\n"
1776 "\t\t\t\t\"idx\": 1\n"
1777 "\t\t\t}\n"
1778 "\t\t\t{\n"
1779 "\t\t\t\t\"name\": \"bb\",\n"
1780 "\t\t\t\t\"idx\": 2\n"
1781 "\t\t\t},\n"
1782 "\t\t\t{\n"
1783 "\t\t\t\t\"name\": \"cc\",\n"
1784 "\t\t\t\t\"idx\": 1\n"
1785 "\t\t\t}\n"
1786 "\t\t]\n"
1787 "\t}\n"
1788 "}";
1789 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1790 auto rootTemplate = rootBody->GetValue("template");
1791 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1792 jsCardParser->Initialize();
1793 jsCardParser->SetIsRepeat(true);
1794 auto document = AceType::MakeRefPtr<DOMDocument>(1);
1795 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
1796 jsCardParser->CreateDomNode(page, rootTemplate, -1);
1797
1798 auto repeatValue = rootTemplate->GetValue("repeat");
1799 std::string key;
1800 jsCardParser->GetRepeatData(repeatValue, key);
1801
1802 ASSERT_EQ(repeatValue->GetArraySize(), 0);
1803 }
1804
1805 /**
1806 * @tc.name: JsCardParserInitialize001
1807 * @tc.desc: Test js card parser initialize when template is invalid.
1808 * @tc.type: FUNC
1809 */
1810 HWTEST_F(CardFrontendTest, JsCardParserInitialize001, TestSize.Level1)
1811 {
1812 /**
1813 * @tc.steps: step1. construct json string.
1814 */
1815 const std::string rootJson = "{\n"
1816 "\t\"template\": {\n"
1817 "\t\t\"attr\": {}\n"
1818 "\t\t\"repeat\": \"{{list}}\"\n"
1819 "\t},\n"
1820 "\t\"styles\": {},\n"
1821 "\t\"actions\": {},\n"
1822 "\t\"data\": {\n"
1823 "\t\t\"list\": [\n"
1824 "\t\t\t{\n"
1825 "\t\t\t\t\"name\": \"aa\",\n"
1826 "\t\t\t\t\"idx\": 1\n"
1827 "\t\t\t},\n"
1828 "\t\t\t{\n"
1829 "\t\t\t\t\"name\": \"bb\",\n"
1830 "\t\t\t\t\"idx\": 2\n"
1831 "\t\t\t},\n"
1832 "\t\t\t{\n"
1833 "\t\t\t\t\"name\": \"cc\",\n"
1834 "\t\t\t\t\"idx\": 1\n"
1835 "\t\t\t}\n"
1836 "\t\t]\n"
1837 "\t}\n"
1838 "}";
1839 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1840 auto rootTemplate = rootBody->GetValue("template");
1841 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1842 bool ret = jsCardParser->Initialize();
1843 ASSERT_EQ(ret, false);
1844 }
1845
1846 /**
1847 * @tc.name: JsCardParserInitialize002
1848 * @tc.desc: Test js card parser initialize when styles is invalid.
1849 * @tc.type: FUNC
1850 */
1851 HWTEST_F(CardFrontendTest, JsCardParserInitialize002, TestSize.Level1)
1852 {
1853 /**
1854 * @tc.steps: step1. construct json string.
1855 */
1856 const std::string rootJson = "{\n"
1857 "\t\"template\": {\n"
1858 "\t\t\"attr\": {},\n"
1859 "\t\t\"repeat\": \"{{list}}\"\n"
1860 "\t},\n"
1861 "\t\"styles\": {,\n"
1862 "\t\"actions\": {},\n"
1863 "\t\"data\": {\n"
1864 "\t\t\"list\": [\n"
1865 "\t\t\t{\n"
1866 "\t\t\t\t\"name\": \"aa\",\n"
1867 "\t\t\t\t\"idx\": 1\n"
1868 "\t\t\t},\n"
1869 "\t\t\t{\n"
1870 "\t\t\t\t\"name\": \"bb\",\n"
1871 "\t\t\t\t\"idx\": 2\n"
1872 "\t\t\t},\n"
1873 "\t\t\t{\n"
1874 "\t\t\t\t\"name\": \"cc\",\n"
1875 "\t\t\t\t\"idx\": 1\n"
1876 "\t\t\t}\n"
1877 "\t\t]\n"
1878 "\t}\n"
1879 "}";
1880 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1881 auto rootTemplate = rootBody->GetValue("template");
1882 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1883 bool ret = jsCardParser->Initialize();
1884 ASSERT_EQ(ret, false);
1885 }
1886
1887 /**
1888 * @tc.name: JsCardParserInitialize003
1889 * @tc.desc: Test js card parser initialize when actions is invalid.
1890 * @tc.type: FUNC
1891 */
1892 HWTEST_F(CardFrontendTest, JsCardParserInitialize003, TestSize.Level1)
1893 {
1894 /**
1895 * @tc.steps: step1. construct json string.
1896 */
1897 const std::string rootJson = "{\n"
1898 "\t\"template\": {\n"
1899 "\t\t\"attr\": {},\n"
1900 "\t\t\"repeat\": \"{{list}}\"\n"
1901 "\t},\n"
1902 "\t\"styles\": {},\n"
1903 "\t\"actions\": {,\n"
1904 "\t\"data\": {\n"
1905 "\t\t\"list\": [\n"
1906 "\t\t\t{\n"
1907 "\t\t\t\t\"name\": \"aa\",\n"
1908 "\t\t\t\t\"idx\": 1\n"
1909 "\t\t\t},\n"
1910 "\t\t\t{\n"
1911 "\t\t\t\t\"name\": \"bb\",\n"
1912 "\t\t\t\t\"idx\": 2\n"
1913 "\t\t\t},\n"
1914 "\t\t\t{\n"
1915 "\t\t\t\t\"name\": \"cc\",\n"
1916 "\t\t\t\t\"idx\": 1\n"
1917 "\t\t\t}\n"
1918 "\t\t]\n"
1919 "\t}\n"
1920 "}";
1921 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1922 auto rootTemplate = rootBody->GetValue("template");
1923 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1924 bool ret = jsCardParser->Initialize();
1925 ASSERT_EQ(ret, false);
1926 }
1927
1928 /**
1929 * @tc.name: JsCardParserInitialize004
1930 * @tc.desc: Test js card parser initialize when data is invalid.
1931 * @tc.type: FUNC
1932 */
1933 HWTEST_F(CardFrontendTest, JsCardParserInitialize004, TestSize.Level1)
1934 {
1935 /**
1936 * @tc.steps: step1. construct json string.
1937 */
1938 const std::string rootJson = "{\n"
1939 "\t\"template\": {\n"
1940 "\t\t\"attr\": {},\n"
1941 "\t\t\"repeat\": \"{{list}}\"\n"
1942 "\t},\n"
1943 "\t\"styles\": {},\n"
1944 "\t\"actions\": {},\n"
1945 "\t\"data\": \n"
1946 "\t\t\"list\": [\n"
1947 "\t\t\t{\n"
1948 "\t\t\t\t\"name\": \"aa\",\n"
1949 "\t\t\t\t\"idx\": 1\n"
1950 "\t\t\t},\n"
1951 "\t\t\t{\n"
1952 "\t\t\t\t\"name\": \"bb\",\n"
1953 "\t\t\t\t\"idx\": 2\n"
1954 "\t\t\t},\n"
1955 "\t\t\t{\n"
1956 "\t\t\t\t\"name\": \"cc\",\n"
1957 "\t\t\t\t\"idx\": 1\n"
1958 "\t\t\t}\n"
1959 "\t\t]\n"
1960 "\t}\n"
1961 "}";
1962 auto rootBody = JsonUtil::ParseJsonString(rootJson);
1963 auto rootTemplate = rootBody->GetValue("template");
1964 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
1965 bool ret = jsCardParser->Initialize();
1966 ASSERT_EQ(ret, false);
1967 }
1968
1969 /**
1970 * @tc.name: JsCardParserParseVersionAndUpdateData001
1971 * @tc.desc: Test js card parser ParseVersionAndUpdateData when apiVersion is valid.
1972 * @tc.type: FUNC
1973 */
1974 HWTEST_F(CardFrontendTest, JsCardParserParseVersionAndUpdateData001, TestSize.Level1)
1975 {
1976 /**
1977 * @tc.steps: step1. construct json string.
1978 */
1979 const std::string rootJson = "{\n"
1980 "\t\"template\": {\n"
1981 "\t\t\"attr\": {},\n"
1982 "\t\t\"type\": \"text\"\n"
1983 "\t},\n"
1984 "\t\"styles\": {},\n"
1985 "\t\"actions\": {},\n"
1986 "\t\"data\": {},\n"
1987 "\t\"apiVersion\": [\n"
1988 "\t\t{\n"
1989 "\t\t\t\"version1\": \"1.0\"\n"
1990 "\t\t},\n"
1991 "\t\t{\n"
1992 "\t\t\t\"version2\": \"2.0\"\n"
1993 "\t\t},\n"
1994 "\t\t{\n"
1995 "\t\t\t\"version3\": 3.0\n"
1996 "\t\t}\n"
1997 "\t]\n"
1998 "}";
1999 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2000 auto rootTemplate = rootBody->GetValue("template");
2001 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2002 bool ret = jsCardParser->Initialize();
2003 ASSERT_EQ(ret, true);
2004 SystemProperties::InitDeviceInfo(DEVICE_WIDTH, DEVICE_HEIGHT, 0, DENSITY, false);
2005 jsCardParser->ParseVersionAndUpdateData();
2006 }
2007
2008 /**
2009 * @tc.name: JsCardParserParseVersionAndUpdateData002
2010 * @tc.desc: Test js card parser ParseVersionAndUpdateData when apiVersion is valid and systemapiversion is invalid.
2011 * @tc.type: FUNC
2012 */
2013 HWTEST_F(CardFrontendTest, JsCardParserParseVersionAndUpdateData002, TestSize.Level1)
2014 {
2015 /**
2016 * @tc.steps: step1. construct json string.
2017 */
2018 const std::string rootJson = "{\n"
2019 "\t\"template\": {\n"
2020 "\t\t\"attr\": {},\n"
2021 "\t\t\"type\": \"text\"\n"
2022 "\t},\n"
2023 "\t\"styles\": {},\n"
2024 "\t\"actions\": {},\n"
2025 "\t\"data\": {},\n"
2026 "\t\"apiVersion\": [\n"
2027 "\t\t{\n"
2028 "\t\t\t\"version1\": \"1.0\"\n"
2029 "\t\t},\n"
2030 "\t\t{\n"
2031 "\t\t\t\"version2\": \"2.0\"\n"
2032 "\t\t},\n"
2033 "\t\t{\n"
2034 "\t\t\t\"version3\": 3.0\n"
2035 "\t\t}\n"
2036 "\t]\n"
2037 "}";
2038 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2039 auto rootTemplate = rootBody->GetValue("template");
2040 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2041 bool ret = jsCardParser->Initialize();
2042 ASSERT_EQ(ret, true);
2043 jsCardParser->ParseVersionAndUpdateData();
2044 }
2045
2046 /**
2047 * @tc.name: JsCardParserParseVersionAndUpdateData003
2048 * @tc.desc: Test js card parser ParseVersionAndUpdateData when apiVersion is invalid.
2049 * @tc.type: FUNC
2050 */
2051 HWTEST_F(CardFrontendTest, JsCardParserParseVersionAndUpdateData003, TestSize.Level1)
2052 {
2053 /**
2054 * @tc.steps: step1. construct json string.
2055 */
2056 const std::string rootJson = "{\n"
2057 "\t\"template\": {\n"
2058 "\t\t\"attr\": {},\n"
2059 "\t\t\"type\": \"text\"\n"
2060 "\t},\n"
2061 "\t\"styles\": {},\n"
2062 "\t\"actions\": {},\n"
2063 "\t\"data\": {},\n"
2064 "\t\"apiVersion\": \n"
2065 "\t\t{\n"
2066 "\t\t\t\"version1\": \"1.0\"\n"
2067 "\t\t},\n"
2068 "\t\t{\n"
2069 "\t\t\t\"version2\": \"2.0\"\n"
2070 "\t\t},\n"
2071 "\t\t{\n"
2072 "\t\t\t\"version3\": 3.0\n"
2073 "\t\t}\n"
2074 "\t]\n"
2075 "}";
2076 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2077 auto rootTemplate = rootBody->GetValue("template");
2078 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2079 bool ret = jsCardParser->Initialize();
2080 SystemProperties::InitDeviceInfo(DEVICE_WIDTH, DEVICE_HEIGHT, 0, DENSITY, false);
2081 jsCardParser->ParseVersionAndUpdateData();
2082 ASSERT_EQ(ret, false);
2083 }
2084
2085 /**
2086 * @tc.name: JsCardParserParseVersionAndUpdateData004
2087 * @tc.desc: Test js card parser ParseVersionAndUpdateData when apiVersion child is invalid.
2088 * @tc.type: FUNC
2089 */
2090 HWTEST_F(CardFrontendTest, JsCardParserParseVersionAndUpdateData004, TestSize.Level1)
2091 {
2092 /**
2093 * @tc.steps: step1. construct json string.
2094 */
2095 const std::string rootJson = "{\n"
2096 "\t\"template\": {\n"
2097 "\t\t\"attr\": {},\n"
2098 "\t\t\"type\": \"text\"\n"
2099 "\t},\n"
2100 "\t\"styles\": {},\n"
2101 "\t\"actions\": {},\n"
2102 "\t\"data\": {},\n"
2103 "\t\"apiVersion\": [\n"
2104 "\t\t{\n"
2105 "\t\t\t\"version1\": \"1.0\"\n"
2106 "\t\t}\n"
2107 "\t\t{\n"
2108 "\t\t\t\"version2\": \"2.0\"\n"
2109 "\t\t},\n"
2110 "\t\t{\n"
2111 "\t\t\t\"version3\": 3.0\n"
2112 "\t\t}\n"
2113 "\t]\n"
2114 "}";
2115 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2116 auto rootTemplate = rootBody->GetValue("template");
2117 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2118 bool ret = jsCardParser->Initialize();
2119 SystemProperties::InitDeviceInfo(DEVICE_WIDTH, DEVICE_HEIGHT, 0, DENSITY, false);
2120 jsCardParser->ParseVersionAndUpdateData();
2121 ASSERT_EQ(ret, false);
2122 }
2123
2124 /**
2125 * @tc.name: JsCardParserCreateRepeatDomNode001
2126 * @tc.desc: Test js card parser CreateRepeatDomNode when repeat is invalid.
2127 * @tc.type: FUNC
2128 */
2129 HWTEST_F(CardFrontendTest, JsCardParserCreateRepeatDomNode001, TestSize.Level1)
2130 {
2131 /**
2132 * @tc.steps: step1. construct json string.
2133 */
2134 const std::string rootJson = "{\n"
2135 "\t\"template\": {\n"
2136 "\t\t\"attr\": {},\n"
2137 "\t\t\"repeat\": }\"{{list}}\"\n"
2138 "\t},\n"
2139 "\t\"styles\": {},\n"
2140 "\t\"actions\": {},\n"
2141 "\t\"data\": {\n"
2142 "\t\t\"list\": [\n"
2143 "\t\t\t{\n"
2144 "\t\t\t\t\"name\": \"aa\",\n"
2145 "\t\t\t\t\"idx\": 1\n"
2146 "\t\t\t},\n"
2147 "\t\t\t{\n"
2148 "\t\t\t\t\"name\": \"bb\",\n"
2149 "\t\t\t\t\"idx\": 2\n"
2150 "\t\t\t},\n"
2151 "\t\t\t{\n"
2152 "\t\t\t\t\"name\": \"cc\",\n"
2153 "\t\t\t\t\"idx\": 1\n"
2154 "\t\t\t}\n"
2155 "\t\t]\n"
2156 "\t}\n"
2157 "}";
2158 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2159 auto rootTemplate = rootBody->GetValue("template");
2160 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2161 bool ret = jsCardParser->Initialize();
2162 auto document = AceType::MakeRefPtr<DOMDocument>(1);
2163 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
2164 jsCardParser->CreateRepeatDomNode(page, rootTemplate, 1);
2165 ASSERT_EQ(ret, false);
2166 }
2167
2168 /**
2169 * @tc.name: JsCardParserCreateRepeatDomNode002
2170 * @tc.desc: Test js card parser CreateRepeatDomNode when repeatValue is
2171 * {{list}} and repeat data does not contains list value.
2172 * @tc.type: FUNC
2173 */
2174 HWTEST_F(CardFrontendTest, JsCardParserCreateRepeatDomNode002, TestSize.Level1)
2175 {
2176 /**
2177 * @tc.steps: step1. construct json string.
2178 */
2179 const std::string rootJson = "{\n"
2180 "\t\"template\": {\n"
2181 "\t\t\"attr\": {},\n"
2182 "\t\t\"repeat\": \"{{list}}\"\n"
2183 "\t},\n"
2184 "\t\"styles\": {},\n"
2185 "\t\"actions\": {},\n"
2186 "\t\"data\": {\n"
2187 "\t\t\"list1\": [\n"
2188 "\t\t\t{\n"
2189 "\t\t\t\t\"name\": \"aa\",\n"
2190 "\t\t\t\t\"idx\": 1\n"
2191 "\t\t\t},\n"
2192 "\t\t\t{\n"
2193 "\t\t\t\t\"name\": \"bb\",\n"
2194 "\t\t\t\t\"idx\": 2\n"
2195 "\t\t\t},\n"
2196 "\t\t\t{\n"
2197 "\t\t\t\t\"name\": \"cc\",\n"
2198 "\t\t\t\t\"idx\": 1\n"
2199 "\t\t\t}\n"
2200 "\t\t]\n"
2201 "\t}\n"
2202 "}";
2203 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2204 auto rootTemplate = rootBody->GetValue("template");
2205 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2206 bool ret = jsCardParser->Initialize();
2207 auto document = AceType::MakeRefPtr<DOMDocument>(1);
2208 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
2209 jsCardParser->CreateRepeatDomNode(page, rootTemplate, 1);
2210 ASSERT_EQ(ret, true);
2211 }
2212
2213 /**
2214 * @tc.name: JsCardParserCreateRepeatDomNode003
2215 * @tc.desc: Test js card parser CreateRepeatDomNode when repeatValue is
2216 * {"exp": {{list}}, "key":"index", "value": "item"} and repeat data does not contains exp value.
2217 * @tc.type: FUNC
2218 */
2219 HWTEST_F(CardFrontendTest, JsCardParserCreateRepeatDomNode003, TestSize.Level1)
2220 {
2221 /**
2222 * @tc.steps: step1. construct json string.
2223 */
2224 const std::string rootJson = "{\n"
2225 "\t\"template\": {\n"
2226 "\t\t\"attr\": {\n"
2227 "\t\t\t\"value\": \"{{item.name}}\",\n"
2228 "\t\t\t\"index\": \"{{item.idx}}\"\n"
2229 "\t\t},\n"
2230 "\t\t\"type\": \"text\",\n"
2231 "\t\t\"repeat\": {\n"
2232 "\t\t\t\"exp1\": \"{{list}}\",\n"
2233 "\t\t\t\"value\": \"item\"\n"
2234 "\t\t}\n"
2235 "\t},\n"
2236 "\t\"styles\": {},\n"
2237 "\t\"actions\": {},\n"
2238 "\t\"data\": {\n"
2239 "\t\t\"list\": [\n"
2240 "\t\t\t{\n"
2241 "\t\t\t\t\"name\": \"aa\",\n"
2242 "\t\t\t\t\"idx\": 1\n"
2243 "\t\t\t},\n"
2244 "\t\t\t{\n"
2245 "\t\t\t\t\"name\": \"bb\",\n"
2246 "\t\t\t\t\"idx\": 2\n"
2247 "\t\t\t},\n"
2248 "\t\t\t{\n"
2249 "\t\t\t\t\"name\": \"cc\",\n"
2250 "\t\t\t\t\"idx\": 1\n"
2251 "\t\t\t}\n"
2252 "\t\t]\n"
2253 "\t}\n"
2254 "}";
2255 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2256 auto rootTemplate = rootBody->GetValue("template");
2257 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2258 bool ret = jsCardParser->Initialize();
2259 auto document = AceType::MakeRefPtr<DOMDocument>(1);
2260 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
2261 jsCardParser->CreateRepeatDomNode(page, rootTemplate, 1);
2262 ASSERT_EQ(ret, true);
2263 }
2264
2265 /**
2266 * @tc.name: JsCardParserCreateRepeatDomNode004
2267 * @tc.desc: Test js card parser CreateRepeatDomNode when repeatValue is
2268 * {"exp": {{list}}, "key":"index", "value": "item"} and exp does not contains list value.
2269 * @tc.type: FUNC
2270 */
2271 HWTEST_F(CardFrontendTest, JsCardParserCreateRepeatDomNode004, TestSize.Level1)
2272 {
2273 /**
2274 * @tc.steps: step1. construct json string.
2275 */
2276 const std::string rootJson = "{\n"
2277 "\t\"template\": {\n"
2278 "\t\t\"attr\": {\n"
2279 "\t\t\t\"value\": \"{{item.name}}\",\n"
2280 "\t\t\t\"index\": \"{{item.idx}}\"\n"
2281 "\t\t},\n"
2282 "\t\t\"type\": \"text\",\n"
2283 "\t\t\"repeat\": {\n"
2284 "\t\t\t\"exp\": \"{{list}}\",\n"
2285 "\t\t\t\"value\": \"item\"\n"
2286 "\t\t}\n"
2287 "\t},\n"
2288 "\t\"styles\": {},\n"
2289 "\t\"actions\": {},\n"
2290 "\t\"data\": {\n"
2291 "\t\t\"list1\": [\n"
2292 "\t\t\t{\n"
2293 "\t\t\t\t\"name\": \"aa\",\n"
2294 "\t\t\t\t\"idx\": 1\n"
2295 "\t\t\t},\n"
2296 "\t\t\t{\n"
2297 "\t\t\t\t\"name\": \"bb\",\n"
2298 "\t\t\t\t\"idx\": 2\n"
2299 "\t\t\t},\n"
2300 "\t\t\t{\n"
2301 "\t\t\t\t\"name\": \"cc\",\n"
2302 "\t\t\t\t\"idx\": 1\n"
2303 "\t\t\t}\n"
2304 "\t\t]\n"
2305 "\t}\n"
2306 "}";
2307 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2308 auto rootTemplate = rootBody->GetValue("template");
2309 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2310 bool ret = jsCardParser->Initialize();
2311 auto document = AceType::MakeRefPtr<DOMDocument>(1);
2312 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
2313 jsCardParser->CreateRepeatDomNode(page, rootTemplate, 1);
2314 ASSERT_EQ(ret, true);
2315 }
2316
2317 /**
2318 * @tc.name: JsCardParserGetClockConfig001
2319 * @tc.desc: Test js card parser GetClockConfig when clockconfig value is string value.
2320 * @tc.type: FUNC
2321 */
2322 HWTEST_F(CardFrontendTest, JsCardParserGetClockConfig001, TestSize.Level1)
2323 {
2324 /**
2325 * @tc.steps: step1. construct json string.
2326 */
2327 const std::string rootJson = "{\n"
2328 "\t\"template\": {\n"
2329 "\t\t\"attr\": {},\n"
2330 "\t\t\"repeat\": \"{{list}}\"\n"
2331 "\t},\n"
2332 "\t\"styles\": {},\n"
2333 "\t\"actions\": {},\n"
2334 "\t\"data\": {\n"
2335 "\t\t\"list\": [\n"
2336 "\t\t\t{\n"
2337 "\t\t\t\t\"name\": \"aa\",\n"
2338 "\t\t\t\t\"idx\": 1\n"
2339 "\t\t\t},\n"
2340 "\t\t\t{\n"
2341 "\t\t\t\t\"name\": \"bb\",\n"
2342 "\t\t\t\t\"idx\": 2\n"
2343 "\t\t\t},\n"
2344 "\t\t\t{\n"
2345 "\t\t\t\t\"name\": \"cc\",\n"
2346 "\t\t\t\t\"idx\": 1\n"
2347 "\t\t\t}\n"
2348 "\t\t]\n"
2349 "\t},\n"
2350 "\t\"clockconfig\": {\n"
2351 "\t\t\"digitColor\": \"digitColor\",\n"
2352 "\t\t\"digitColorNight\": \"digitColorNight\",\n"
2353 "\t\t\"digitRadiusRatio\": \"100\",\n"
2354 "\t\t\"digitSizeRatio\": \"300\",\n"
2355 "\t\t\"face\": \"face\",\n"
2356 "\t\t\"faceNight\": \"faceNight\",\n"
2357 "\t\t\"hourHand\": \"hourHand\",\n"
2358 "\t\t\"hourHandNight\": \"hourHandNight\",\n"
2359 "\t\t\"minuteHand\": \"minuteHand\",\n"
2360 "\t\t\"minuteHandNight\": \"minuteHandNight\",\n"
2361 "\t\t\"secondHand\": \"secondHand\",\n"
2362 "\t\t\"secondHandNight\": \"secondHandNight\",\n"
2363 "\t\t\"showdigit\": \"showdigit\"\n"
2364 "\t}\n"
2365 "}";
2366 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2367 auto rootTemplate = rootBody->GetValue("clockconfig");
2368 ASSERT_EQ(rootTemplate->GetArraySize(), 13);
2369 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2370 bool ret = jsCardParser->Initialize();
2371 ClockConfig clockConfig;
2372 jsCardParser->GetClockConfig(rootTemplate, clockConfig);
2373 ASSERT_EQ(ret, true);
2374 ASSERT_EQ(clockConfig.digitColor_, "digitColor");
2375 ASSERT_EQ(clockConfig.digitColorNight_, "digitColorNight");
2376 ASSERT_EQ(clockConfig.digitRadiusRatio_, 100);
2377 ASSERT_EQ(clockConfig.digitSizeRatio_, 300);
2378 ASSERT_EQ(clockConfig.clockFaceSrc_, "face");
2379 ASSERT_EQ(clockConfig.clockFaceNightSrc_, "faceNight");
2380 ASSERT_EQ(clockConfig.hourHandSrc_, "hourHand");
2381 ASSERT_EQ(clockConfig.hourHandNightSrc_, "hourHandNight");
2382 ASSERT_EQ(clockConfig.minuteHandSrc_, "minuteHand");
2383 ASSERT_EQ(clockConfig.minuteHandNightSrc_, "minuteHandNight");
2384 ASSERT_EQ(clockConfig.secondHandSrc_, "secondHand");
2385 ASSERT_EQ(clockConfig.secondHandNightSrc_, "secondHandNight");
2386 }
2387
2388 /**
2389 * @tc.name: JsCardParserGetClockConfig002
2390 * @tc.desc: Test js card parser GetClockConfig when clockconfig value is variable value.
2391 * @tc.type: FUNC
2392 */
2393 HWTEST_F(CardFrontendTest, JsCardParserGetClockConfig002, TestSize.Level1)
2394 {
2395 /**
2396 * @tc.steps: step1. construct json string.
2397 */
2398 const std::string rootJson = "{\n"
2399 "\t\"template\": {\n"
2400 "\t\t\"attr\": {},\n"
2401 "\t\t\"repeat\": \"{{list}}\"\n"
2402 "\t},\n"
2403 "\t\"styles\": {},\n"
2404 "\t\"actions\": {},\n"
2405 "\t\"data\": {\n"
2406 "\t\t\"face\": \"face\",\n"
2407 "\t\t\"faceNight\": \"faceNight\",\n"
2408 "\t\t\"hourHand\": \"hourHand\",\n"
2409 "\t\t\"hourHandNight\": \"hourHandNight\",\n"
2410 "\t\t\"minuteHand\": \"minuteHand\",\n"
2411 "\t\t\"minuteHandNight\": \"minuteHandNight\",\n"
2412 "\t\t\"secondHand\": \"secondHand\",\n"
2413 "\t\t\"secondHandNight\": \"secondHandNight\"\n"
2414 "\t},\n"
2415 "\t\"clockconfig\": {\n"
2416 "\t\t\"digitColor\": \"digitColor\",\n"
2417 "\t\t\"digitColorNight\": \"digitColorNight\",\n"
2418 "\t\t\"digitRadiusRatio\": \"100\",\n"
2419 "\t\t\"digitSizeRatio\": \"300\",\n"
2420 "\t\t\"face\": \"{{face}}\",\n"
2421 "\t\t\"faceNight\": \"{{faceNight}}\",\n"
2422 "\t\t\"hourHand\": \"{{hourHand}}\",\n"
2423 "\t\t\"hourHandNight\": \"{{hourHandNight}}\",\n"
2424 "\t\t\"minuteHand\": \"{{minuteHand}}\",\n"
2425 "\t\t\"minuteHandNight\": \"{{minuteHandNight}}\",\n"
2426 "\t\t\"secondHand\": \"{{secondHand}}\",\n"
2427 "\t\t\"secondHandNight\": \"{{secondHandNight}}\",\n"
2428 "\t\t\"showdigit\": \"showdigit\"\n"
2429 "\t}\n"
2430 "}";
2431 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2432 auto rootTemplate = rootBody->GetValue("clockconfig");
2433 ASSERT_EQ(rootTemplate->GetArraySize(), 13);
2434 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2435 bool ret = jsCardParser->Initialize();
2436 ClockConfig clockConfig;
2437 jsCardParser->GetClockConfig(rootTemplate, clockConfig);
2438 ASSERT_EQ(ret, true);
2439 ASSERT_EQ(clockConfig.digitColor_, "digitColor");
2440 ASSERT_EQ(clockConfig.digitColorNight_, "digitColorNight");
2441 ASSERT_EQ(clockConfig.digitRadiusRatio_, 100);
2442 ASSERT_EQ(clockConfig.digitSizeRatio_, 300);
2443 ASSERT_EQ(clockConfig.clockFaceSrc_, "face");
2444 ASSERT_EQ(clockConfig.clockFaceNightSrc_, "faceNight");
2445 ASSERT_EQ(clockConfig.hourHandSrc_, "hourHand");
2446 ASSERT_EQ(clockConfig.hourHandNightSrc_, "hourHandNight");
2447 ASSERT_EQ(clockConfig.minuteHandSrc_, "minuteHand");
2448 ASSERT_EQ(clockConfig.minuteHandNightSrc_, "minuteHandNight");
2449 ASSERT_EQ(clockConfig.secondHandSrc_, "secondHand");
2450 ASSERT_EQ(clockConfig.secondHandNightSrc_, "secondHandNight");
2451 }
2452
2453 /**
2454 * @tc.name: JsCardParserGetClockConfig003
2455 * @tc.desc: Test js card parser GetClockConfig when clockconfig is invalid.
2456 * @tc.type: FUNC
2457 */
2458 HWTEST_F(CardFrontendTest, JsCardParserGetClockConfig003, TestSize.Level1)
2459 {
2460 /**
2461 * @tc.steps: step1. construct json string.
2462 */
2463 const std::string rootJson = "{\n"
2464 "\t\"template\": {\n"
2465 "\t\t\"attr\": {},\n"
2466 "\t\t\"repeat\": \"{{list}}\"\n"
2467 "\t},\n"
2468 "\t\"styles\": {},\n"
2469 "\t\"actions\": {},\n"
2470 "\t\"data\": {\n"
2471 "\t\t\"face\": \"face\",\n"
2472 "\t\t\"faceNight\": \"faceNight\",\n"
2473 "\t\t\"hourHand\": \"hourHand\",\n"
2474 "\t\t\"hourHandNight\": \"hourHandNight\",\n"
2475 "\t\t\"minuteHand\": \"minuteHand\",\n"
2476 "\t\t\"minuteHandNight\": \"minuteHandNight\",\n"
2477 "\t\t\"secondHand\": \"secondHand\",\n"
2478 "\t\t\"secondHandNight\": \"secondHandNight\"\n"
2479 "\t},\n"
2480 "\t\"clockconfig\": \n"
2481 "\t\t\"digitColor\": \"digitColor\",\n"
2482 "\t\t\"digitColorNight\": \"digitColorNight\",\n"
2483 "\t\t\"digitRadiusRatio\": \"100\",\n"
2484 "\t\t\"digitSizeRatio\": \"300\",\n"
2485 "\t\t\"face\": \"{{face}}\",\n"
2486 "\t\t\"faceNight\": \"{{faceNight}}\",\n"
2487 "\t\t\"hourHand\": \"{{hourHand}}\",\n"
2488 "\t\t\"hourHandNight\": \"{{hourHandNight}}\",\n"
2489 "\t\t\"minuteHand\": \"{{minuteHand}}\",\n"
2490 "\t\t\"minuteHandNight\": \"{{minuteHandNight}}\",\n"
2491 "\t\t\"secondHand\": \"{{secondHand}}\",\n"
2492 "\t\t\"secondHandNight\": \"{{secondHandNight}}\",\n"
2493 "\t\t\"showdigit\": \"showdigit\"\n"
2494 "\t}\n"
2495 "}";
2496 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2497 auto rootTemplate = rootBody->GetValue("clockconfig");
2498 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2499 bool ret = jsCardParser->Initialize();
2500 ClockConfig clockConfig;
2501 jsCardParser->GetClockConfig(rootTemplate, clockConfig);
2502 ASSERT_EQ(ret, false);
2503 ASSERT_EQ(clockConfig.digitColor_, "");
2504 ASSERT_EQ(clockConfig.digitColorNight_, "#00000000");
2505 ASSERT_EQ(clockConfig.digitRadiusRatio_, 0.7);
2506 ASSERT_EQ(clockConfig.digitSizeRatio_, 0.08);
2507 ASSERT_EQ(clockConfig.clockFaceSrc_, "");
2508 ASSERT_EQ(clockConfig.clockFaceNightSrc_, "");
2509 ASSERT_EQ(clockConfig.hourHandSrc_, "");
2510 ASSERT_EQ(clockConfig.hourHandNightSrc_, "");
2511 ASSERT_EQ(clockConfig.minuteHandSrc_, "");
2512 ASSERT_EQ(clockConfig.minuteHandNightSrc_, "");
2513 ASSERT_EQ(clockConfig.secondHandSrc_, "");
2514 ASSERT_EQ(clockConfig.secondHandNightSrc_, "");
2515 }
2516
2517 /**
2518 * @tc.name: JsCardParserGetClockConfig004
2519 * @tc.desc: Test js card parser GetClockConfig when attr contains clockconfig value.
2520 * @tc.type: FUNC
2521 */
2522 HWTEST_F(CardFrontendTest, JsCardParserGetClockConfig004, TestSize.Level1)
2523 {
2524 /**
2525 * @tc.steps: step1. construct json string.
2526 */
2527 const std::string rootJson = "{\n"
2528 "\t\"template\": {\n"
2529 "\t\t\"attr\": {\n"
2530 "\t\t\t\"clockconfig\": {\n"
2531 "\t\t\t\t\"digitColor\": \"digitColor\",\n"
2532 "\t\t\t\t\"digitColorNight\": \"digitColorNight\",\n"
2533 "\t\t\t\t\"digitRadiusRatio\": \"100\",\n"
2534 "\t\t\t\t\"digitSizeRatio\": \"300\",\n"
2535 "\t\t\t\t\"face\": \"{{face}}\",\n"
2536 "\t\t\t\t\"faceNight\": \"{{faceNight}}\",\n"
2537 "\t\t\t\t\"hourHand\": \"{{hourHand}}\",\n"
2538 "\t\t\t\t\"hourHandNight\": \"{{hourHandNight}}\",\n"
2539 "\t\t\t\t\"minuteHand\": \"{{minuteHand}}\",\n"
2540 "\t\t\t\t\"minuteHandNight\": \"{{minuteHandNight}}\",\n"
2541 "\t\t\t\t\"secondHand\": \"{{secondHand}}\",\n"
2542 "\t\t\t\t\"secondHandNight\": \"{{secondHandNight}}\",\n"
2543 "\t\t\t\t\"showdigit\": \"showdigit\"\n"
2544 "\t\t\t}\n"
2545 "\t\t}\n"
2546 "\t},\n"
2547 "\t\"styles\": {},\n"
2548 "\t\"actions\": {},\n"
2549 "\t\"data\": {\n"
2550 "\t\t\"face\": \"face\",\n"
2551 "\t\t\"faceNight\": \"faceNight\",\n"
2552 "\t\t\"hourHand\": \"hourHand\",\n"
2553 "\t\t\"hourHandNight\": \"hourHandNight\",\n"
2554 "\t\t\"minuteHand\": \"minuteHand\",\n"
2555 "\t\t\"minuteHandNight\": \"minuteHandNight\",\n"
2556 "\t\t\"secondHand\": \"secondHand\",\n"
2557 "\t\t\"secondHandNight\": \"secondHandNight\"\n"
2558 "\t}\n"
2559 "}";
2560 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2561 auto rootTemplate = rootBody->GetValue("template");
2562 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2563 bool ret = jsCardParser->Initialize();
2564 jsCardParser->SetIsRepeat(true);
2565 auto document = AceType::MakeRefPtr<DOMDocument>(1);
2566 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
2567 jsCardParser->CreateDomNode(page, rootTemplate, -1);
2568 ASSERT_EQ(ret, true);
2569 }
2570
2571 /**
2572 * @tc.name: JsCardParserGetClockConfig005
2573 * @tc.desc: Test js card parser GetClockConfig when clockconfig is invalid.
2574 * @tc.type: FUNC
2575 */
2576 HWTEST_F(CardFrontendTest, JsCardParserGetClockConfig005, TestSize.Level1)
2577 {
2578 /**
2579 * @tc.steps: step1. construct json string.
2580 */
2581 const std::string rootJson = "{\n"
2582 "\t\"template\": {\n"
2583 "\t\t\"attr\": {\n"
2584 "\t\t\t\"clockconfig1\": {\n"
2585 "\t\t\t\t\"digitColor\": \"digitColor\",\n"
2586 "\t\t\t\t\"digitColorNight\": \"digitColorNight\",\n"
2587 "\t\t\t\t\"digitRadiusRatio\": \"100\",\n"
2588 "\t\t\t\t\"digitSizeRatio\": \"300\",\n"
2589 "\t\t\t\t\"face\": \"{{face}}\",\n"
2590 "\t\t\t\t\"faceNight\": \"{{faceNight}}\",\n"
2591 "\t\t\t\t\"hourHand\": \"{{hourHand}}\",\n"
2592 "\t\t\t\t\"hourHandNight\": \"{{hourHandNight}}\",\n"
2593 "\t\t\t\t\"minuteHand\": \"{{minuteHand}}\",\n"
2594 "\t\t\t\t\"minuteHandNight\": \"{{minuteHandNight}}\",\n"
2595 "\t\t\t\t\"secondHand\": \"{{secondHand}}\",\n"
2596 "\t\t\t\t\"secondHandNight\": \"{{secondHandNight}}\",\n"
2597 "\t\t\t\t\"showdigit\": \"showdigit\"\n"
2598 "\t\t\t}\n"
2599 "\t\t}\n"
2600 "\t},\n"
2601 "\t\"styles\": {},\n"
2602 "\t\"actions\": {},\n"
2603 "\t\"data\": {\n"
2604 "\t\t\"face\": \"face\",\n"
2605 "\t\t\"faceNight\": \"faceNight\",\n"
2606 "\t\t\"hourHand\": \"hourHand\",\n"
2607 "\t\t\"hourHandNight\": \"hourHandNight\",\n"
2608 "\t\t\"minuteHand\": \"minuteHand\",\n"
2609 "\t\t\"minuteHandNight\": \"minuteHandNight\",\n"
2610 "\t\t\"secondHand\": \"secondHand\",\n"
2611 "\t\t\"secondHandNight\": \"secondHandNight\"\n"
2612 "\t}\n"
2613 "}";
2614 auto rootBody = JsonUtil::ParseJsonString(rootJson);
2615 auto rootTemplate = rootBody->GetValue("template");
2616 auto jsCardParser = AceType::MakeRefPtr<JsCardParser>(nullptr, nullptr, std::move(rootBody));
2617 bool ret = jsCardParser->Initialize();
2618 jsCardParser->SetIsRepeat(true);
2619 auto document = AceType::MakeRefPtr<DOMDocument>(1);
2620 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
2621 jsCardParser->CreateDomNode(page, rootTemplate, -1);
2622 ASSERT_EQ(ret, true);
2623 }
2624
2625 /**
2626 * @tc.name: CardFrontendInitialize001
2627 * @tc.desc: Test card frontend Initialize method.
2628 * @tc.type: FUNC
2629 */
2630 HWTEST_F(CardFrontendTest, CardFrontendInitialize001, TestSize.Level1)
2631 {
2632 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2633 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2634 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2635 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2636 ASSERT_NE(cardFrontend->delegate_, nullptr);
2637 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2638 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2639 }
2640
2641 /**
2642 * @tc.name: CardFrontendDestroy001
2643 * @tc.desc: Test card frontend Destroy method.
2644 * @tc.type: FUNC
2645 */
2646 HWTEST_F(CardFrontendTest, CardFrontendDestroy001, TestSize.Level1)
2647 {
2648 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2649 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2650 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2651 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2652 ASSERT_NE(cardFrontend->delegate_, nullptr);
2653 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2654 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2655 cardFrontend->Destroy();
2656 ASSERT_EQ(cardFrontend->parseJsCard_, nullptr);
2657 ASSERT_EQ(cardFrontend->delegate_, nullptr);
2658 ASSERT_EQ(cardFrontend->eventHandler_, nullptr);
2659 }
2660
2661 /**
2662 * @tc.name: CardFrontendAttachPipelineContext001
2663 * @tc.desc: Test card frontend AttachPipelineContext method.
2664 * @tc.type: FUNC
2665 */
2666 HWTEST_F(CardFrontendTest, CardFrontendAttachPipelineContext001, TestSize.Level1)
2667 {
2668 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2669 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2670 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2671 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2672 ASSERT_NE(cardFrontend->delegate_, nullptr);
2673 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2674 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2675 auto pipeline = MockRenderCommon::GetMockContext();
2676 cardFrontend->AttachPipelineContext(pipeline);
2677 ASSERT_NE(cardFrontend->eventHandler_, nullptr);
2678 cardFrontend->AttachPipelineContext(nullptr);
2679 ASSERT_NE(cardFrontend->eventHandler_, nullptr);
2680 }
2681
2682 /**
2683 * @tc.name: CardFrontendSetAssetManager001
2684 * @tc.desc: Test card frontend SetAssetManager method.
2685 * @tc.type: FUNC
2686 */
2687 HWTEST_F(CardFrontendTest, CardFrontendSetAssetManager001, TestSize.Level1)
2688 {
2689 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2690 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2691 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2692 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2693 ASSERT_NE(cardFrontend->delegate_, nullptr);
2694 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2695 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2696 auto assetManager = Referenced::MakeRefPtr<MockAssetManager>();
2697 cardFrontend->SetAssetManager(assetManager);
2698 ASSERT_NE(cardFrontend->assetManager_, nullptr);
2699 }
2700
2701 /**
2702 * @tc.name: CardFrontendParseManifest001
2703 * @tc.desc: Test card frontend ParseManifest method.
2704 * @tc.type: FUNC
2705 */
2706 HWTEST_F(CardFrontendTest, CardFrontendParseManifest001, TestSize.Level1)
2707 {
2708 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2709 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2710 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2711 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2712 ASSERT_NE(cardFrontend->delegate_, nullptr);
2713 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2714 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2715 cardFrontend->ParseManifest();
2716 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2717 ASSERT_NE(cardFrontend->delegate_, nullptr);
2718 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2719 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2720 }
2721
2722 /**
2723 * @tc.name: CardFrontendRunPage001
2724 * @tc.desc: Test card frontend RunPage method.
2725 * @tc.type: FUNC
2726 */
2727 HWTEST_F(CardFrontendTest, CardFrontendRunPage001, TestSize.Level1)
2728 {
2729 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2730 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2731 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2732 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2733 ASSERT_NE(cardFrontend->delegate_, nullptr);
2734 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2735 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2736 cardFrontend->RunPage(1, "", "");
2737 cardFrontend->RunPage(1, "test", "test");
2738 cardFrontend->RunPage(1, "", "test");
2739 cardFrontend->RunPage(1, "test", "");
2740 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2741 ASSERT_NE(cardFrontend->delegate_, nullptr);
2742 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2743 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2744 }
2745
2746 /**
2747 * @tc.name: CardFrontendGetFormSrcPath001
2748 * @tc.desc: Test card frontend GetFormSrcPath method.
2749 * @tc.type: FUNC
2750 */
2751 HWTEST_F(CardFrontendTest, CardFrontendGetFormSrcPath001, TestSize.Level1)
2752 {
2753 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2754 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2755 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2756 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2757 ASSERT_NE(cardFrontend->delegate_, nullptr);
2758 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2759 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2760 auto path = cardFrontend->GetFormSrcPath("", "");
2761 ASSERT_EQ(path, "");
2762 path = cardFrontend->GetFormSrcPath("test", "test");
2763 ASSERT_EQ(path, "testtest");
2764 path = cardFrontend->GetFormSrcPath("test", "");
2765 ASSERT_EQ(path, "test");
2766 path = cardFrontend->GetFormSrcPath("", "test");
2767 ASSERT_EQ(path, "");
2768 }
2769
2770 /**
2771 * @tc.name: CardFrontendGetPage001
2772 * @tc.desc: Test card frontend GetPage method.
2773 * @tc.type: FUNC
2774 */
2775 HWTEST_F(CardFrontendTest, CardFrontendGetPage001, TestSize.Level1)
2776 {
2777 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2778 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2779 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2780 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2781 ASSERT_NE(cardFrontend->delegate_, nullptr);
2782 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2783 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2784 auto page = cardFrontend->GetPage(1);
2785 ASSERT_EQ(page, nullptr);
2786 }
2787
2788 /**
2789 * @tc.name: CardFrontendGetWindowConfig001
2790 * @tc.desc: Test card frontend GetWindowConfig method.
2791 * @tc.type: FUNC
2792 */
2793 HWTEST_F(CardFrontendTest, CardFrontendGetWindowConfig001, TestSize.Level1)
2794 {
2795 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2796 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2797 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2798 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2799 ASSERT_NE(cardFrontend->delegate_, nullptr);
2800 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2801 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2802 auto config = cardFrontend->GetWindowConfig();
2803 ASSERT_EQ(config.designWidth, DEFAULT_DESIGN_WIDTH);
2804 ASSERT_EQ(config.autoDesignWidth, false);
2805 ASSERT_EQ(config.boxWrap, false);
2806 ASSERT_EQ(config.designWidthScale, 0.0);
2807 }
2808
2809 /**
2810 * @tc.name: CardFrontendLoadPage001
2811 * @tc.desc: Test card frontend LoadPage method.
2812 * @tc.type: FUNC
2813 */
2814 HWTEST_F(CardFrontendTest, CardFrontendLoadPage001, TestSize.Level1)
2815 {
2816 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2817 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2818 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2819 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2820 ASSERT_NE(cardFrontend->delegate_, nullptr);
2821 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2822 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2823 cardFrontend->LoadPage("", "");
2824 cardFrontend->LoadPage("test", "test");
2825 cardFrontend->LoadPage("", "test");
2826 cardFrontend->LoadPage("test", "");
2827 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2828 ASSERT_NE(cardFrontend->delegate_, nullptr);
2829 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2830 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2831 }
2832
2833 /**
2834 * @tc.name: CardFrontendParsePage001
2835 * @tc.desc: Test card frontend ParsePage method.
2836 * @tc.type: FUNC
2837 */
2838 HWTEST_F(CardFrontendTest, CardFrontendParsePage001, TestSize.Level1)
2839 {
2840 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2841 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2842 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2843 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2844 ASSERT_NE(cardFrontend->delegate_, nullptr);
2845 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2846 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2847 auto pipeline = MockRenderCommon::GetMockContext();
2848 cardFrontend->AttachPipelineContext(pipeline);
2849 auto document = AceType::MakeRefPtr<DOMDocument>(1);
2850 auto page = AceType::MakeRefPtr<Framework::JsAcePage>(1, document, "", nullptr);
2851 cardFrontend->ParsePage(pipeline, "", "", page);
2852 cardFrontend->ParsePage(pipeline, "test", "test", page);
2853 cardFrontend->ParsePage(pipeline, "", "test", page);
2854 cardFrontend->ParsePage(pipeline, "test", "", page);
2855 cardFrontend->ParsePage(pipeline, "test", "", nullptr);
2856 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2857 ASSERT_NE(cardFrontend->delegate_, nullptr);
2858 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2859 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2860 }
2861
2862 /**
2863 * @tc.name: CardFrontendUpdateData001
2864 * @tc.desc: Test card frontend UpdateData method.
2865 * @tc.type: FUNC
2866 */
2867 HWTEST_F(CardFrontendTest, CardFrontendUpdateData001, TestSize.Level1)
2868 {
2869 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2870 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2871 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2872 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2873 ASSERT_NE(cardFrontend->delegate_, nullptr);
2874 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2875 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2876 cardFrontend->UpdateData("");
2877 cardFrontend->UpdateData("test");
2878 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2879 ASSERT_NE(cardFrontend->delegate_, nullptr);
2880 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2881 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2882 }
2883
2884 /**
2885 * @tc.name: CardFrontendUpdatePageData001
2886 * @tc.desc: Test card frontend UpdatePageData method.
2887 * @tc.type: FUNC
2888 */
2889 HWTEST_F(CardFrontendTest, CardFrontendUpdatePageData001, TestSize.Level1)
2890 {
2891 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2892 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2893 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2894 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2895 ASSERT_NE(cardFrontend->delegate_, nullptr);
2896 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2897 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2898 cardFrontend->UpdatePageData("");
2899 cardFrontend->UpdatePageData("test");
2900 cardFrontend->delegate_ = nullptr;
2901 cardFrontend->parseJsCard_ = nullptr;
2902 cardFrontend->UpdatePageData("test");
2903 ASSERT_EQ(cardFrontend->delegate_, nullptr);
2904 ASSERT_EQ(cardFrontend->parseJsCard_, nullptr);
2905 }
2906
2907 /**
2908 * @tc.name: CardFrontendSetColorMode001
2909 * @tc.desc: Test card frontend SetColorMode method.
2910 * @tc.type: FUNC
2911 */
2912 HWTEST_F(CardFrontendTest, CardFrontendSetColorMode001, TestSize.Level1)
2913 {
2914 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2915 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2916 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2917 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2918 ASSERT_NE(cardFrontend->delegate_, nullptr);
2919 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2920 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2921 cardFrontend->SetColorMode(ColorMode::LIGHT);
2922 ASSERT_EQ(cardFrontend->colorMode_, ColorMode::LIGHT);
2923 }
2924
2925 /**
2926 * @tc.name: CardFrontendRebuildAllPages001
2927 * @tc.desc: Test card frontend RebuildAllPages method.
2928 * @tc.type: FUNC
2929 */
2930 HWTEST_F(CardFrontendTest, CardFrontendRebuildAllPages001, TestSize.Level1)
2931 {
2932 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2933 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2934 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2935 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2936 ASSERT_NE(cardFrontend->delegate_, nullptr);
2937 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2938 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2939 cardFrontend->RebuildAllPages();
2940 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2941 ASSERT_NE(cardFrontend->delegate_, nullptr);
2942 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2943 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2944 }
2945
2946 /**
2947 * @tc.name: CardFrontendOnSurfaceChanged001
2948 * @tc.desc: Test card frontend OnSurfaceChanged method.
2949 * @tc.type: FUNC
2950 */
2951 HWTEST_F(CardFrontendTest, CardFrontendOnSurfaceChanged001, TestSize.Level1)
2952 {
2953 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2954 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2955 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2956 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2957 ASSERT_NE(cardFrontend->delegate_, nullptr);
2958 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2959 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2960 cardFrontend->OnSurfaceChanged(0, 0);
2961 cardFrontend->OnSurfaceChanged(100, 100);
2962 cardFrontend->OnSurfaceChanged(-100, -100);
2963 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2964 ASSERT_NE(cardFrontend->delegate_, nullptr);
2965 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2966 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2967 }
2968
2969 /**
2970 * @tc.name: CardFrontendHandleSurfaceChanged001
2971 * @tc.desc: Test card frontend HandleSurfaceChanged method.
2972 * @tc.type: FUNC
2973 */
2974 HWTEST_F(CardFrontendTest, CardFrontendHandleSurfaceChanged001, TestSize.Level1)
2975 {
2976 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
2977 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
2978 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
2979 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2980 ASSERT_NE(cardFrontend->delegate_, nullptr);
2981 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2982 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2983 cardFrontend->HandleSurfaceChanged(0, 0);
2984 cardFrontend->HandleSurfaceChanged(100, 100);
2985 cardFrontend->HandleSurfaceChanged(-100, -100);
2986 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
2987 ASSERT_NE(cardFrontend->delegate_, nullptr);
2988 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
2989 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
2990 }
2991
2992 /**
2993 * @tc.name: CardFrontendOnMediaFeatureUpdate001
2994 * @tc.desc: Test card frontend OnMediaFeatureUpdate method.
2995 * @tc.type: FUNC
2996 */
2997 HWTEST_F(CardFrontendTest, CardFrontendOnMediaFeatureUpdate001, TestSize.Level1)
2998 {
2999 auto cardFrontend = AceType::MakeRefPtr<CardFrontend>();
3000 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
3001 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
3002 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
3003 ASSERT_NE(cardFrontend->delegate_, nullptr);
3004 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
3005 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
3006 cardFrontend->OnMediaFeatureUpdate();
3007 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
3008 ASSERT_NE(cardFrontend->delegate_, nullptr);
3009 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
3010 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
3011 }
3012 } // namespace OHOS::Ace::Framework
