1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #define private public
18 #include "codegen/cpp_code_emitter.h"
19 #include "metadata/meta_component.h"
20 #include "metadata/meta_type.h"
21 #include "util/string_builder.h"
22 #undef private
23
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace OHOS::Idl;
27
28 namespace OHOS {
29 namespace idl {
30
31 class CppCodeEmitterUnitTest : public testing::Test {
32 public:
CppCodeEmitterUnitTest()33 CppCodeEmitterUnitTest() {}
34
~CppCodeEmitterUnitTest()35 virtual ~CppCodeEmitterUnitTest() {}
36
37 static void SetUpTestCase();
38
39 static void TearDownTestCase();
40
41 void SetUp();
42
43 void TearDown();
44 };
45
SetUpTestCase()46 void CppCodeEmitterUnitTest::SetUpTestCase() {}
47
TearDownTestCase()48 void CppCodeEmitterUnitTest::TearDownTestCase() {}
49
SetUp()50 void CppCodeEmitterUnitTest::SetUp() {}
51
TearDown()52 void CppCodeEmitterUnitTest::TearDown() {}
53
54 /**
55 * @tc.name: EmitInterfaceStdlibInclusions_test_001
56 * @tc.desc: Verify the EmitInterfaceStdlibInclusions function.
57 * @tc.type: FUNC
58 * @tc.require: #I72EZC
59 */
60 HWTEST_F(CppCodeEmitterUnitTest, EmitInterfaceStdlibInclusions_test_001, TestSize.Level1)
61 {
62 GTEST_LOG_(INFO)
63 << "CppCodeEmitterUnitTest, EmitInterfaceStdlibInclusions_test_001, TestSize.Level1";
64
65 MetaComponent mc;
66 mc.typeNumber_ = 1;
67
68 MetaType *mt = new MetaType;
69 mc.types_ = new MetaType *[1];
70 mc.types_[0] = mt;
71
72 CppCodeEmitter codeEmitter(&mc);
73 {
74 mt->kind_ = TypeKind::Byte;
75 StringBuilder sb;
76 codeEmitter.EmitInterfaceStdlibInclusions(sb);
77 EXPECT_STREQ(sb.buffer_, "#include <cstdint>\n");
78 }
79 {
80 mt->kind_ = TypeKind::String;
81 StringBuilder sb;
82 codeEmitter.EmitInterfaceStdlibInclusions(sb);
83 EXPECT_STREQ(sb.buffer_, "#include <string_ex.h>\n");
84 }
85 {
86 mt->kind_ = TypeKind::Array;
87 StringBuilder sb;
88 codeEmitter.EmitInterfaceStdlibInclusions(sb);
89 EXPECT_STREQ(sb.buffer_, "#include <vector>\n");
90 }
91 {
92 mt->kind_ = TypeKind::Map;
93 StringBuilder sb;
94 codeEmitter.EmitInterfaceStdlibInclusions(sb);
95 EXPECT_STREQ(sb.buffer_, "#include <unordered_map>\n");
96 }
97 {
98 mt->kind_ = TypeKind::Unknown;
99 StringBuilder sb;
100 codeEmitter.EmitInterfaceStdlibInclusions(sb);
101 EXPECT_EQ(sb.buffer_, nullptr);
102 }
103 delete mt;
104 delete [] mc.types_;
105 }
106
107 /**
108 * @tc.name: FileName_test_001
109 * @tc.desc: Verify the FileName function.
110 * @tc.type: FUNC
111 * @tc.require: #I72EZC
112 */
113 HWTEST_F(CppCodeEmitterUnitTest, FileName_test_001, TestSize.Level1)
114 {
115 GTEST_LOG_(INFO)
116 << "CppCodeEmitterUnitTest, FileName_test_002, TestSize.Level1";
117
118 MetaComponent mc;
119 CppCodeEmitter codeEmitter(&mc);
120
121 const String inputStr, expectStr;
122 EXPECT_EQ(codeEmitter.FileName(inputStr), expectStr);
123
124 const String inputStr1("abc");
125 const String expectStr1("abc");
126 EXPECT_STREQ(codeEmitter.FileName(inputStr1), expectStr1);
127
128 const String inputStr2("a.b.c");
129 const String expectStr2("a/b/c");
130 EXPECT_STREQ(codeEmitter.FileName(inputStr2), expectStr2);
131
132 const String inputStr3("a..B..C..d..");
133 const String expectStr3("a//b//c//d//");
134 EXPECT_STREQ(codeEmitter.FileName(inputStr3), expectStr3);
135 }
136
137 /**
138 * @tc.name: MacroName_test_001
139 * @tc.desc: Verify the MacroName function.
140 * @tc.type: FUNC
141 * @tc.require: #I72EZC
142 */
143 HWTEST_F(CppCodeEmitterUnitTest, MacroName_test_001, TestSize.Level1)
144 {
145 GTEST_LOG_(INFO)
146 << "CppCodeEmitterUnitTest, MacroName_test_001, TestSize.Level1";
147
148 MetaComponent mc;
149 CppCodeEmitter codeEmitter(&mc);
150
151 const String emptyStr, expectStr;
152 EXPECT_EQ(codeEmitter.MacroName(emptyStr), expectStr);
153
154 const String inputStr1("macro.Str");
155 const String expectStr1("MACRO_STR_H");
156 EXPECT_STREQ(codeEmitter.MacroName(inputStr1), expectStr1);
157 }
158
159 /**
160 * @tc.name: EmitWriteVariable_test_001
161 * @tc.desc: Verify the EmitWriteVariable function.
162 * @tc.type: FUNeC
163 * @tc.require: #I72EZC
164 */
165 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_001, TestSize.Level1)
166 {
167 GTEST_LOG_(INFO)
168 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_001, TestSize.Level1";
169
170 const String parcelName("ParcelName");
171 const String prefix("const ");
172 const std::string name("Name");
173
174 MetaComponent mc;
175 CppCodeEmitter codeEmitter(&mc);
176
177 StringBuilder sb;
178 MetaType mt { .kind_ = TypeKind::Boolean };
179 std::string expectStr("const ParcelNameWriteInt32(Name ? 1 : 0);\n");
180 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
181 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
182 }
183
184 /**
185 * @tc.name: EmitWriteVariable_test_002
186 * @tc.desc: Verify the EmitWriteVariable function.
187 * @tc.type: FUNeC
188 * @tc.require: #I72EZC
189 */
190 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_002, TestSize.Level1)
191 {
192 GTEST_LOG_(INFO)
193 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_002, TestSize.Level1";
194
195 const String parcelName("ParcelName");
196 const String prefix("const ");
197 const std::string name("Name");
198
199 MetaComponent mc;
200 CppCodeEmitter codeEmitter(&mc);
201
202 StringBuilder sb;
203 MetaType mt { .kind_ = TypeKind::Char };
204 std::string expectStr("const ParcelNameWriteInt32(Name);\n");
205 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
206 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
207 }
208
209 /**
210 * @tc.name: EmitWriteVariable_test_003
211 * @tc.desc: Verify the EmitWriteVariable function.
212 * @tc.type: FUNeC
213 * @tc.require: #I72EZC
214 */
215 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_003, TestSize.Level1)
216 {
217 GTEST_LOG_(INFO)
218 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_003, TestSize.Level1";
219
220 const String parcelName("ParcelName");
221 const String prefix("const ");
222 const std::string name("Name");
223
224 MetaComponent mc;
225 CppCodeEmitter codeEmitter(&mc);
226
227 StringBuilder sb;
228 MetaType mt { .kind_ = TypeKind::Long };
229 std::string expectStr("const ParcelNameWriteInt64(Name);\n");
230 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
231 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
232 }
233
234 /**
235 * @tc.name: EmitWriteVariable_test_004
236 * @tc.desc: Verify the EmitWriteVariable function.
237 * @tc.type: FUNeC
238 * @tc.require: #I72EZC
239 */
240 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_004, TestSize.Level1)
241 {
242 GTEST_LOG_(INFO)
243 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_004, TestSize.Level1";
244
245 const String parcelName("ParcelName");
246 const String prefix("const ");
247 const std::string name("Name");
248
249 MetaComponent mc;
250 CppCodeEmitter codeEmitter(&mc);
251
252 StringBuilder sb;
253 MetaType mt { .kind_ = TypeKind::Float };
254 std::string expectStr("const ParcelNameWriteFloat(Name);\n");
255 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
256 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
257 }
258
259 /**
260 * @tc.name: EmitWriteVariable_test_005
261 * @tc.desc: Verify the EmitWriteVariable function.
262 * @tc.type: FUNeC
263 * @tc.require: #I72EZC
264 */
265 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_005, TestSize.Level1)
266 {
267 GTEST_LOG_(INFO)
268 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_005, TestSize.Level1";
269
270 const String parcelName("ParcelName");
271 const String prefix("const ");
272 const std::string name("Name");
273
274 MetaComponent mc;
275 CppCodeEmitter codeEmitter(&mc);
276
277 StringBuilder sb;
278 MetaType mt { .kind_ = TypeKind::Double };
279 std::string expectStr("const ParcelNameWriteDouble(Name);\n");
280 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
281 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
282 }
283
284 /**
285 * @tc.name: EmitWriteVariable_test_006
286 * @tc.desc: Verify the EmitWriteVariable function.
287 * @tc.type: FUNeC
288 * @tc.require: #I72EZC
289 */
290 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_006, TestSize.Level1)
291 {
292 GTEST_LOG_(INFO)
293 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_006, TestSize.Level1";
294
295 const String parcelName("ParcelName");
296 const String prefix("const ");
297 const std::string name("Name");
298
299 MetaComponent mc;
300 CppCodeEmitter codeEmitter(&mc);
301
302 StringBuilder sb;
303 MetaType mt { .kind_ = TypeKind::String };
304 std::string expectStr("const ParcelNameWriteString16(Str8ToStr16(Name));\n");
305 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
306 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
307 }
308
309 /**
310 * @tc.name: EmitWriteVariable_test_007
311 * @tc.desc: Verify the EmitWriteVariable function.
312 * @tc.type: FUNeC
313 * @tc.require: #I72EZC
314 */
315 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_007, TestSize.Level1)
316 {
317 GTEST_LOG_(INFO)
318 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_007, TestSize.Level1";
319
320 const String parcelName("ParcelName");
321 const String prefix("const ");
322 const std::string name("Name");
323
324 MetaComponent mc;
325 CppCodeEmitter codeEmitter(&mc);
326
327 StringBuilder sb;
328 MetaType mt { .kind_ = TypeKind::Sequenceable };
329 std::string expectStr("const ParcelNameWriteParcelable(Name);\n");
330 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
331 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
332 }
333
334 /**
335 * @tc.name: EmitWriteVariable_test_008
336 * @tc.desc: Verify the EmitWriteVariable function.
337 * @tc.type: FUNeC
338 * @tc.require: #I72EZC
339 */
340 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_008, TestSize.Level1)
341 {
342 GTEST_LOG_(INFO)
343 << "CppCodeEmitterUnitTest, EmitWriteVariable_test_008, TestSize.Level1";
344
345 const String parcelName("ParcelName");
346 const String prefix("const ");
347 const std::string name("Name");
348
349 MetaComponent mc;
350 CppCodeEmitter codeEmitter(&mc);
351
352 StringBuilder sb;
353 MetaType mt { .kind_ = TypeKind::Interface };
354 std::string expectStr("const ParcelNameWriteRemoteObject(Name->AsObject());\n");
355 codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
356 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
357 }
358
359 /**
360 * @tc.name: EmitReadVariable_test_001
361 * @tc.desc: Verify the EmitReadVariable function.
362 * @tc.type: FUNC
363 * @tc.require: #I72EZC
364 */
365 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_001, TestSize.Level1)
366 {
367 GTEST_LOG_(INFO)
368 << "CppCodeEmitterUnitTest, EmitReadVariable_test_001, TestSize.Level1";
369
370 const String parcelName("ParcelName");
371 const String prefix("const ");
372 const std::string name("Name");
373
374 MetaComponent mc;
375 CppCodeEmitter codeEmitter(&mc);
376
377 StringBuilder sb;
378 MetaType mt { .kind_ = TypeKind::Boolean };
379 std::string expectStr("const bool Name = ParcelNameReadInt32() == 1 ? true : false;\n");
380 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
381 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
382 }
383
384 /**
385 * @tc.name: EmitReadVariable_test_002
386 * @tc.desc: Verify the EmitReadVariable function.
387 * @tc.type: FUNC
388 * @tc.require: #I72EZC
389 */
390 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_002, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO)
393 << "CppCodeEmitterUnitTest, EmitReadVariable_test_002, TestSize.Level1";
394
395 const String parcelName("ParcelName");
396 const String prefix("const ");
397 const std::string name("Name");
398
399 MetaComponent mc;
400 CppCodeEmitter codeEmitter(&mc);
401
402 StringBuilder sb;
403 MetaType mt { .kind_ = TypeKind::Boolean };
404 std::string expectStr("const Name = ParcelNameReadInt32() == 1 ? true : false;\n");
405 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
406 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
407 }
408
409 /**
410 * @tc.name: EmitReadVariable_test_003
411 * @tc.desc: Verify the EmitReadVariable function.
412 * @tc.type: FUNC
413 * @tc.require: #I72EZC
414 */
415 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_003, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO)
418 << "CppCodeEmitterUnitTest, EmitReadVariable_test_003, TestSize.Level1";
419
420 const String parcelName("ParcelName");
421 const String prefix("const ");
422 const std::string name("Name");
423
424 MetaComponent mc;
425 CppCodeEmitter codeEmitter(&mc);
426
427 StringBuilder sb;
428 MetaType mt { .kind_ = TypeKind::Short };
429 std::string expectStr("const short Name = (short)ParcelNameReadInt32();\n");
430 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
431 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
432 }
433
434 /**
435 * @tc.name: EmitReadVariable_test_004
436 * @tc.desc: Verify the EmitReadVariable function.
437 * @tc.type: FUNC
438 * @tc.require: #I72EZC
439 */
440 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_004, TestSize.Level1)
441 {
442 GTEST_LOG_(INFO)
443 << "CppCodeEmitterUnitTest, EmitReadVariable_test_004, TestSize.Level1";
444
445 const String parcelName("ParcelName");
446 const String prefix("const ");
447 const std::string name("Name");
448
449 MetaComponent mc;
450 CppCodeEmitter codeEmitter(&mc);
451
452 StringBuilder sb;
453 MetaType mt { .kind_ = TypeKind::Short };
454 std::string expectStr("const Name = (short)ParcelNameReadInt32();\n");
455 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
456 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
457 }
458
459 /**
460 * @tc.name: EmitReadVariable_test_005
461 * @tc.desc: Verify the EmitReadVariable function.
462 * @tc.type: FUNC
463 * @tc.require: #I72EZC
464 */
465 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_005, TestSize.Level1)
466 {
467 GTEST_LOG_(INFO)
468 << "CppCodeEmitterUnitTest, EmitReadVariable_test_005, TestSize.Level1";
469
470 const String parcelName("ParcelName");
471 const String prefix("const ");
472 const std::string name("Name");
473
474 MetaComponent mc;
475 CppCodeEmitter codeEmitter(&mc);
476
477 StringBuilder sb;
478 MetaType mt { .kind_ = TypeKind::Integer };
479 std::string expectStr("const int Name = ParcelNameReadInt32();\n");
480 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
481 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
482 }
483
484 /**
485 * @tc.name: EmitReadVariable_test_006
486 * @tc.desc: Verify the EmitReadVariable function.
487 * @tc.type: FUNC
488 * @tc.require: #I72EZC
489 */
490 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_006, TestSize.Level1)
491 {
492 GTEST_LOG_(INFO)
493 << "CppCodeEmitterUnitTest, EmitReadVariable_test_006, TestSize.Level1";
494
495 const String parcelName("ParcelName");
496 const String prefix("const ");
497 const std::string name("Name");
498
499 MetaComponent mc;
500 CppCodeEmitter codeEmitter(&mc);
501
502 StringBuilder sb;
503 MetaType mt { .kind_ = TypeKind::Integer };
504 std::string expectStr("const Name = ParcelNameReadInt32();\n");
505 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
506 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
507 }
508
509 /**
510 * @tc.name: EmitReadVariable_test_007
511 * @tc.desc: Verify the EmitReadVariable function.
512 * @tc.type: FUNC
513 * @tc.require: #I72EZC
514 */
515 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_007, TestSize.Level1)
516 {
517 GTEST_LOG_(INFO)
518 << "CppCodeEmitterUnitTest, EmitReadVariable_test_007, TestSize.Level1";
519
520 const String parcelName("ParcelName");
521 const String prefix("const ");
522 const std::string name("Name");
523
524 MetaComponent mc;
525 CppCodeEmitter codeEmitter(&mc);
526
527 StringBuilder sb;
528 MetaType mt { .kind_ = TypeKind::Long };
529 std::string expectStr("const long Name = ParcelNameReadInt64();\n");
530 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
531 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
532 }
533
534 /**
535 * @tc.name: EmitReadVariable_test_008
536 * @tc.desc: Verify the EmitReadVariable function.
537 * @tc.type: FUNC
538 * @tc.require: #I72EZC
539 */
540 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_008, TestSize.Level1)
541 {
542 GTEST_LOG_(INFO)
543 << "CppCodeEmitterUnitTest, EmitReadVariable_test_008, TestSize.Level1";
544
545 const String parcelName("ParcelName");
546 const String prefix("const ");
547 const std::string name("Name");
548
549 MetaComponent mc;
550 CppCodeEmitter codeEmitter(&mc);
551
552 StringBuilder sb;
553 MetaType mt { .kind_ = TypeKind::Long };
554 std::string expectStr("const Name = ParcelNameReadInt64();\n");
555 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
556 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
557 }
558
559 /**
560 * @tc.name: EmitReadVariable_test_009
561 * @tc.desc: Verify the EmitReadVariable function.
562 * @tc.type: FUNC
563 * @tc.require: #I72EZC
564 */
565 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_009, TestSize.Level1)
566 {
567 GTEST_LOG_(INFO)
568 << "CppCodeEmitterUnitTest, EmitReadVariable_test_009, TestSize.Level1";
569
570 const String parcelName("ParcelName");
571 const String prefix("const ");
572 const std::string name("Name");
573
574 MetaComponent mc;
575 CppCodeEmitter codeEmitter(&mc);
576
577 StringBuilder sb;
578 MetaType mt { .kind_ = TypeKind::Float };
579 std::string expectStr("const float Name = ParcelNameReadFloat();\n");
580 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
581 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
582 }
583
584 /**
585 * @tc.name: EmitReadVariable_test_010
586 * @tc.desc: Verify the EmitReadVariable function.
587 * @tc.type: FUNC
588 * @tc.require: #I72EZC
589 */
590 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_010, TestSize.Level1)
591 {
592 GTEST_LOG_(INFO)
593 << "CppCodeEmitterUnitTest, EmitReadVariable_test_010, TestSize.Level1";
594
595 const String parcelName("ParcelName");
596 const String prefix("const ");
597 const std::string name("Name");
598
599 MetaComponent mc;
600 CppCodeEmitter codeEmitter(&mc);
601
602 StringBuilder sb;
603 MetaType mt { .kind_ = TypeKind::Float };
604 std::string expectStr("const Name = ParcelNameReadFloat();\n");
605 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
606 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
607 }
608
609 /**
610 * @tc.name: EmitReadVariable_test_011
611 * @tc.desc: Verify the EmitReadVariable function.
612 * @tc.type: FUNC
613 * @tc.require: #I72EZC
614 */
615 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_011, TestSize.Level1)
616 {
617 GTEST_LOG_(INFO)
618 << "CppCodeEmitterUnitTest, EmitReadVariable_test_011, TestSize.Level1";
619
620 const String parcelName("ParcelName");
621 const String prefix("const ");
622 const std::string name("Name");
623
624 MetaComponent mc;
625 CppCodeEmitter codeEmitter(&mc);
626
627 StringBuilder sb;
628 MetaType mt { .kind_ = TypeKind::Double };
629 std::string expectStr("const double Name = ParcelNameReadDouble();\n");
630 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
631 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
632 }
633
634 /**
635 * @tc.name: EmitReadVariable_test_012
636 * @tc.desc: Verify the EmitReadVariable function.
637 * @tc.type: FUNC
638 * @tc.require: #I72EZC
639 */
640 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_012, TestSize.Level1)
641 {
642 GTEST_LOG_(INFO)
643 << "CppCodeEmitterUnitTest, EmitReadVariable_test_012, TestSize.Level1";
644
645 const String parcelName("ParcelName");
646 const String prefix("const ");
647 const std::string name("Name");
648
649 MetaComponent mc;
650 CppCodeEmitter codeEmitter(&mc);
651
652 StringBuilder sb;
653 MetaType mt { .kind_ = TypeKind::Double };
654 std::string expectStr("const Name = ParcelNameReadDouble();\n");
655 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
656 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
657 }
658
659 /**
660 * @tc.name: EmitReadVariable_test_013
661 * @tc.desc: Verify the EmitReadVariable function.
662 * @tc.type: FUNC
663 * @tc.require: #I72EZC
664 */
665 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_013, TestSize.Level1)
666 {
667 GTEST_LOG_(INFO)
668 << "CppCodeEmitterUnitTest, EmitReadVariable_test_013, TestSize.Level1";
669
670 const String parcelName("ParcelName");
671 const String prefix("const ");
672 const std::string name("Name");
673
674 MetaComponent mc;
675 CppCodeEmitter codeEmitter(&mc);
676
677 StringBuilder sb;
678 MetaType mt { .kind_ = TypeKind::String };
679 std::string expectStr("const std::string Name = Str16ToStr8(ParcelNameReadString16());\n");
680 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
681 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
682 }
683
684 /**
685 * @tc.name: EmitReadVariable_test_014
686 * @tc.desc: Verify the EmitReadVariable function.
687 * @tc.type: FUNC
688 * @tc.require: #I72EZC
689 */
690 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_014, TestSize.Level1)
691 {
692 GTEST_LOG_(INFO)
693 << "CppCodeEmitterUnitTest, EmitReadVariable_test_014, TestSize.Level1";
694
695 const String parcelName("ParcelName");
696 const String prefix("const ");
697 const std::string name("Name");
698
699 MetaComponent mc;
700 CppCodeEmitter codeEmitter(&mc);
701
702 StringBuilder sb;
703 MetaType mt { .kind_ = TypeKind::String };
704 std::string expectStr("const Name = Str16ToStr8(ParcelNameReadString16());\n");
705 codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
706 EXPECT_STREQ(sb.buffer_, expectStr.c_str());
707 }
708
709 /**
710 * @tc.name: ConstantName_test_001
711 * @tc.desc: Verify the ConstantName function.
712 * @tc.type: FUNC
713 * @tc.require: #I72EZC
714 */
715 HWTEST_F(CppCodeEmitterUnitTest, ConstantName_test_001, TestSize.Level1)
716 {
717 GTEST_LOG_(INFO)
718 << "CppCodeEmitterUnitTest, ConstantName_test_001, TestSize.Level1";
719
720 MetaComponent mc;
721 CppCodeEmitter codeEmitter(&mc);
722
723 const String emptyStr, expectStr;
724 EXPECT_EQ(codeEmitter.ConstantName(emptyStr), expectStr);
725
726 const String inputStr3("aKxZ");
727 const String expectStr3("AKX_Z");
728 EXPECT_STREQ(codeEmitter.ConstantName(inputStr3), expectStr3);
729 }
730
731 /**
732 * @tc.name: UnderlineAdded_test_001
733 * @tc.desc: Verify the UnderlineAdded function.
734 * @tc.type: FUNC
735 * @tc.require: #I72EZC
736 */
737 HWTEST_F(CppCodeEmitterUnitTest, UnderlineAdded_test_001, TestSize.Level1)
738 {
739 GTEST_LOG_(INFO)
740 << "CppCodeEmitterUnitTest, UnderlineAdded_test_001, TestSize.Level1";
741
742 MetaComponent mc;
743 CppCodeEmitter codeEmitter(&mc);
744
745 const String inputStr("origStr");
746 const std::string expectStr("_origStr");
747 EXPECT_STREQ(codeEmitter.UnderlineAdded(inputStr).c_str(), expectStr.c_str());
748 }
749
750 /**
751 * @tc.name: EmitReturnParameter_test_001
752 * @tc.desc: Verify the EmitReturnParameter function.
753 * @tc.type: FUNC
754 * @tc.require: #I72EZC
755 */
756 HWTEST_F(CppCodeEmitterUnitTest, EmitReturnParameter_test_001, TestSize.Level1)
757 {
758 GTEST_LOG_(INFO)
759 << "CppCodeEmitterUnitTest, EmitReturnParameter_test_001, TestSize.Level1";
760
761 MetaComponent mc;
762 CppCodeEmitter codeEmitter(&mc);
763
764 const String name("const_string");
765 {
766 MetaType mt { .kind_ = TypeKind::Char };
767 StringBuilder sb;
768 codeEmitter.EmitReturnParameter(name, &mt, sb);
769 EXPECT_STREQ(sb.buffer_, name.string());
770 }
771 {
772 MetaType mt { .kind_ = TypeKind::Unknown };
773 StringBuilder sb;
774 codeEmitter.EmitReturnParameter(name, &mt, sb);
775 EXPECT_EQ(sb.buffer_, nullptr);
776 }
777 }
778
779 /**
780 * @tc.name: EmitType_test_001
781 * @tc.desc: Verify the EmitType function.
782 * @tc.type: FUNC
783 * @tc.require: #I72EZC
784 */
785 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_001, TestSize.Level1)
786 {
787 GTEST_LOG_(INFO)
788 << "CppCodeEmitterUnitTest, EmitType_test_001, TestSize.Level1";
789
790 MetaComponent mc;
791 CppCodeEmitter codeEmitter(&mc);
792
793 MetaType mt { .kind_ = TypeKind::Char };
794 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
795 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
796
797 EXPECT_STREQ(retStr1, String("zchar"));
798 EXPECT_STREQ(retStr2, String("zchar&"));
799 }
800
801 /**
802 * @tc.name: EmitType_test_002
803 * @tc.desc: Verify the EmitType function.
804 * @tc.type: FUNC
805 * @tc.require: #I72EZC
806 */
807 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_002, TestSize.Level1)
808 {
809 GTEST_LOG_(INFO)
810 << "CppCodeEmitterUnitTest, EmitType_test_002, TestSize.Level1";
811
812 MetaComponent mc;
813 CppCodeEmitter codeEmitter(&mc);
814
815 MetaType mt { .kind_ = TypeKind::Boolean };
816 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
817 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
818
819 EXPECT_STREQ(retStr1, String("bool"));
820 EXPECT_STREQ(retStr2, String("bool&"));
821 }
822
823 /**
824 * @tc.name: EmitType_test_003
825 * @tc.desc: Verify the EmitType function.
826 * @tc.type: FUNC
827 * @tc.require: #I72EZC
828 */
829 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_003, TestSize.Level1)
830 {
831 GTEST_LOG_(INFO)
832 << "CppCodeEmitterUnitTest, EmitType_test_003, TestSize.Level1";
833
834 MetaComponent mc;
835 CppCodeEmitter codeEmitter(&mc);
836
837 MetaType mt { .kind_ = TypeKind::Byte };
838 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
839 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
840
841 EXPECT_STREQ(retStr1, String("int8_t"));
842 EXPECT_STREQ(retStr2, String("int8_t&"));
843 }
844
845 /**
846 * @tc.name: EmitType_test_004
847 * @tc.desc: Verify the EmitType function.
848 * @tc.type: FUNC
849 * @tc.require: #I72EZC
850 */
851 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_004, TestSize.Level1)
852 {
853 GTEST_LOG_(INFO)
854 << "CppCodeEmitterUnitTest, EmitType_test_004, TestSize.Level1";
855
856 MetaComponent mc;
857 CppCodeEmitter codeEmitter(&mc);
858
859 MetaType mt { .kind_ = TypeKind::Short };
860 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
861 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
862
863 EXPECT_STREQ(retStr1, String("short"));
864 EXPECT_STREQ(retStr2, String("short&"));
865 }
866
867 /**
868 * @tc.name: EmitType_test_005
869 * @tc.desc: Verify the EmitType function.
870 * @tc.type: FUNC
871 * @tc.require: #I72EZC
872 */
873 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_005, TestSize.Level1)
874 {
875 GTEST_LOG_(INFO)
876 << "CppCodeEmitterUnitTest, EmitType_test_006, TestSize.Level1";
877
878 MetaComponent mc;
879 CppCodeEmitter codeEmitter(&mc);
880
881 MetaType mt { .kind_ = TypeKind::Integer };
882 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
883 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
884
885 EXPECT_STREQ(retStr1, String("int"));
886 EXPECT_STREQ(retStr2, String("int&"));
887 }
888
889 /**
890 * @tc.name: EmitType_test_006
891 * @tc.desc: Verify the EmitType function.
892 * @tc.type: FUNC
893 * @tc.require: #I72EZC
894 */
895 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_006, TestSize.Level1)
896 {
897 GTEST_LOG_(INFO)
898 << "CppCodeEmitterUnitTest, EmitType_test_006, TestSize.Level1";
899
900 MetaComponent mc;
901 CppCodeEmitter codeEmitter(&mc);
902
903 MetaType mt { .kind_ = TypeKind::Long };
904 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
905 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
906
907 EXPECT_STREQ(retStr1, String("long"));
908 EXPECT_STREQ(retStr2, String("long&"));
909 }
910
911 /**
912 * @tc.name: EmitType_test_007
913 * @tc.desc: Verify the EmitType function.
914 * @tc.type: FUNC
915 * @tc.require: #I72EZC
916 */
917 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_007, TestSize.Level1)
918 {
919 GTEST_LOG_(INFO)
920 << "CppCodeEmitterUnitTest, EmitType_test_007, TestSize.Level1";
921
922 MetaComponent mc;
923 CppCodeEmitter codeEmitter(&mc);
924
925 MetaType mt { .kind_ = TypeKind::Float };
926 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
927 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
928
929 EXPECT_STREQ(retStr1, String("float"));
930 EXPECT_STREQ(retStr2, String("float&"));
931 }
932
933 /**
934 * @tc.name: EmitType_test_008
935 * @tc.desc: Verify the EmitType function.
936 * @tc.type: FUNC
937 * @tc.require: #I72EZC
938 */
939 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_008, TestSize.Level1)
940 {
941 GTEST_LOG_(INFO)
942 << "CppCodeEmitterUnitTest, EmitType_test_008, TestSize.Level1";
943
944 MetaComponent mc;
945 CppCodeEmitter codeEmitter(&mc);
946
947 MetaType mt { .kind_ = TypeKind::Double };
948 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
949 String retStr2 = codeEmitter.EmitType(&mt, 0, true);
950
951 EXPECT_STREQ(retStr1, String("double"));
952 EXPECT_STREQ(retStr2, String("double&"));
953 }
954
955
956 /**
957 * @tc.name: EmitType_test_009
958 * @tc.desc: Verify the EmitType function.
959 * @tc.type: FUNC
960 * @tc.require: #I72EZC
961 */
962 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_009, TestSize.Level1)
963 {
964 GTEST_LOG_(INFO)
965 << "CppCodeEmitterUnitTest, EmitType_test_009, TestSize.Level1";
966
967 MetaComponent mc;
968 CppCodeEmitter codeEmitter(&mc);
969
970 MetaType mt { .kind_ = TypeKind::String };
971 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, false);
972 String retStr2 = codeEmitter.EmitType(&mt, ATTR_IN, true);
973 String retStr3 = codeEmitter.EmitType(&mt, 0, true);
974
975 EXPECT_STREQ(retStr1, String("const std::string&"));
976 EXPECT_STREQ(retStr2, String("std::string"));
977 EXPECT_STREQ(retStr3, String("std::string&"));
978 }
979
980 /**
981 * @tc.name: EmitType_test_010
982 * @tc.desc: Verify the EmitType function.
983 * @tc.type: FUNC
984 * @tc.require: #I72EZC
985 */
986 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_010, TestSize.Level1)
987 {
988 GTEST_LOG_(INFO)
989 << "CppCodeEmitterUnitTest, EmitType_test_010, TestSize.Level1";
990
991 MetaComponent mc;
992 CppCodeEmitter codeEmitter(&mc);
993 }
994
995 /**
996 * @tc.name: EmitType_test_011
997 * @tc.desc: Verify the EmitType function.
998 * @tc.type: FUNC
999 * @tc.require: #I72EZC
1000 */
1001 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_011, TestSize.Level1)
1002 {
1003 GTEST_LOG_(INFO)
1004 << "CppCodeEmitterUnitTest, EmitType_test_011, TestSize.Level1";
1005
1006 MetaComponent mc;
1007 CppCodeEmitter codeEmitter(&mc);
1008
1009 MetaType mt { .kind_ = TypeKind::Void };
1010 String retStr = codeEmitter.EmitType(&mt, ATTR_IN, false);
1011 EXPECT_STREQ(retStr, String("void"));
1012 }
1013
1014 /**
1015 * @tc.name: EmitType_test_012
1016 * @tc.desc: Verify the EmitType function.
1017 * @tc.type: FUNC
1018 * @tc.require: #I72EZC
1019 */
1020 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_012, TestSize.Level1)
1021 {
1022 GTEST_LOG_(INFO)
1023 << "CppCodeEmitterUnitTest, EmitType_test_012, TestSize.Level1";
1024
1025 MetaType mt { .kind_ = TypeKind::Sequenceable, .index_ = 0 };
1026 char mseqName[] = "MetaSequenceable";
1027 MetaSequenceable mp;
1028 mp.name_ = mseqName;
1029
1030 MetaComponent mc;
1031 mc.sequenceables_ = new MetaSequenceable*[1];
1032 mc.sequenceables_[0] = ∓
1033 CppCodeEmitter codeEmitter(&mc);
1034
1035 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN | ATTR_OUT, false);
1036 String retStr2 = codeEmitter.EmitType(&mt, ATTR_IN, false);
1037 String retStr3 = codeEmitter.EmitType(&mt, 0, false);
1038
1039 EXPECT_STREQ(retStr1, String("MetaSequenceable*"));
1040 EXPECT_STREQ(retStr2, String("MetaSequenceable*"));
1041 EXPECT_STREQ(retStr3, String("MetaSequenceable*"));
1042
1043 delete []mc.sequenceables_;
1044 }
1045
1046 /**
1047 * @tc.name: EmitType_test_013
1048 * @tc.desc: Verify the EmitType function.
1049 * @tc.type: FUNC
1050 * @tc.require: #I72EZC
1051 */
1052 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_013, TestSize.Level1)
1053 {
1054 GTEST_LOG_(INFO)
1055 << "CppCodeEmitterUnitTest, EmitType_test_013, TestSize.Level1";
1056
1057 MetaType mt { .kind_ = TypeKind::Interface, .index_ = 0 };
1058 char miName[] = "MetaInterface";
1059 MetaInterface mi;
1060 mi.name_ = miName;
1061
1062 MetaComponent mc;
1063 mc.interfaces_ = new MetaInterface*[1];
1064 mc.interfaces_[0] = &mi;
1065 CppCodeEmitter codeEmitter(&mc);
1066
1067 String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN | ATTR_OUT, false);
1068 String retStr2 = codeEmitter.EmitType(&mt, ATTR_IN, false);
1069 String retStr3 = codeEmitter.EmitType(&mt, 0, false);
1070
1071 EXPECT_STREQ(retStr1.string(), "sptr<MetaInterface>");
1072 EXPECT_STREQ(retStr2.string(), "sptr<MetaInterface>");
1073 EXPECT_STREQ(retStr3.string(), "sptr<MetaInterface>&");
1074
1075 delete []mc.interfaces_;
1076 }
1077
1078 /**
1079 * @tc.name: CppFullName_test_001
1080 * @tc.desc: Verify the CppFullName function.
1081 * @tc.type: FUNC
1082 * @tc.require: #I72EZC
1083 */
1084 HWTEST_F(CppCodeEmitterUnitTest, CppFullName_test_001, TestSize.Level1)
1085 {
1086 GTEST_LOG_(INFO)
1087 << "CppCodeEmitterUnitTest, CppFullName_test_001, TestSize.Level1";
1088
1089 MetaComponent mc;
1090 CppCodeEmitter codeEmitter(&mc);
1091
1092 const String inputStr, expectStr;
1093 EXPECT_STREQ(codeEmitter.CppFullName(inputStr), expectStr);
1094
1095 const String inputStr1("a.b.c.d");
1096 const String expectStr1("a::b::c::d");
1097 EXPECT_STREQ(codeEmitter.CppFullName(inputStr1).string(), expectStr1.string());
1098 }
1099
1100 } // namespace idl
1101 } // namespace OHOS
1102