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 #define protected public
19 #include "codegen/cpp_code_emitter.h"
20 #include "metadata/meta_component.h"
21 #include "metadata/meta_type.h"
22 #include "util/string_builder.h"
23 #undef protected
24 #undef private
25 
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS::Idl;
29 
30 namespace OHOS {
31 namespace idl {
32 
33 class CppCodeEmitterUnitTest : public testing::Test {
34 public:
CppCodeEmitterUnitTest()35     CppCodeEmitterUnitTest() {}
36 
~CppCodeEmitterUnitTest()37     virtual ~CppCodeEmitterUnitTest() {}
38 
39     static void SetUpTestCase();
40 
41     static void TearDownTestCase();
42 
43     void SetUp();
44 
45     void TearDown();
46 };
47 
SetUpTestCase()48 void CppCodeEmitterUnitTest::SetUpTestCase() {}
49 
TearDownTestCase()50 void CppCodeEmitterUnitTest::TearDownTestCase() {}
51 
SetUp()52 void CppCodeEmitterUnitTest::SetUp() {}
53 
TearDown()54 void CppCodeEmitterUnitTest::TearDown() {}
55 
56 /**
57  * @tc.name: EmitInterfaceStdlibInclusions_test_001
58  * @tc.desc: Verify the EmitInterfaceStdlibInclusions function.
59  * @tc.type: FUNC
60  * @tc.require: #I72EZC
61  */
62 HWTEST_F(CppCodeEmitterUnitTest, EmitInterfaceStdlibInclusions_test_001, TestSize.Level1)
63 {
64     GTEST_LOG_(INFO)
65         << "CppCodeEmitterUnitTest, EmitInterfaceStdlibInclusions_test_001, TestSize.Level1";
66 
67     MetaComponent mc;
68     mc.typeNumber_ = 1;
69 
70     MetaType *mt = new MetaType;
71     mc.types_ = new MetaType *[1];
72     mc.types_[0] = mt;
73 
74     CppCodeEmitter codeEmitter(&mc);
75     {
76         mt->kind_ = TypeKind::Byte;
77         StringBuilder sb;
78         codeEmitter.EmitInterfaceStdlibInclusions(sb);
79         EXPECT_STREQ(sb.buffer_, "#include <cstdint>\n");
80     }
81     {
82         mt->kind_ = TypeKind::String;
83         StringBuilder sb;
84         codeEmitter.EmitInterfaceStdlibInclusions(sb);
85         EXPECT_STREQ(sb.buffer_, "#include <string_ex.h>\n");
86     }
87     {
88         mt->kind_ = TypeKind::Array;
89         StringBuilder sb;
90         codeEmitter.EmitInterfaceStdlibInclusions(sb);
91         EXPECT_STREQ(sb.buffer_, "#include <vector>\n");
92     }
93     {
94         mt->kind_ = TypeKind::Map;
95         StringBuilder sb;
96         codeEmitter.EmitInterfaceStdlibInclusions(sb);
97         EXPECT_STREQ(sb.buffer_, "#include <unordered_map>\n");
98     }
99     {
100         mt->kind_ = TypeKind::Unknown;
101         StringBuilder sb;
102         codeEmitter.EmitInterfaceStdlibInclusions(sb);
103         EXPECT_EQ(sb.buffer_, nullptr);
104     }
105     delete mt;
106     delete [] mc.types_;
107 }
108 
109 /**
110  * @tc.name: FileName_test_001
111  * @tc.desc: Verify the FileName function.
112  * @tc.type: FUNC
113  * @tc.require: #I72EZC
114  */
115 HWTEST_F(CppCodeEmitterUnitTest, FileName_test_001, TestSize.Level1)
116 {
117     GTEST_LOG_(INFO)
118         << "CppCodeEmitterUnitTest, FileName_test_002, TestSize.Level1";
119 
120     MetaComponent mc;
121     CppCodeEmitter codeEmitter(&mc);
122 
123     const String inputStr, expectStr;
124     EXPECT_EQ(codeEmitter.FileName(inputStr), expectStr);
125 
126     const String inputStr1("abc");
127     const String expectStr1("abc");
128     EXPECT_STREQ(codeEmitter.FileName(inputStr1), expectStr1);
129 
130     const String inputStr2("a.b.c");
131     const String expectStr2("a/b/c");
132     EXPECT_STREQ(codeEmitter.FileName(inputStr2), expectStr2);
133 
134     const String inputStr3("a..B..C..d..");
135     const String expectStr3("a//b//c//d//");
136     EXPECT_STREQ(codeEmitter.FileName(inputStr3), expectStr3);
137 }
138 
139 /**
140  * @tc.name: MacroName_test_001
141  * @tc.desc: Verify the MacroName function.
142  * @tc.type: FUNC
143  * @tc.require: #I72EZC
144  */
145 HWTEST_F(CppCodeEmitterUnitTest, MacroName_test_001, TestSize.Level1)
146 {
147     GTEST_LOG_(INFO)
148         << "CppCodeEmitterUnitTest, MacroName_test_001, TestSize.Level1";
149 
150     MetaComponent mc;
151     CppCodeEmitter codeEmitter(&mc);
152 
153     const String emptyStr, expectStr;
154     EXPECT_EQ(codeEmitter.MacroName(emptyStr), expectStr);
155 
156     const String inputStr1("macro.Str");
157     const String expectStr1("MACRO_STR_H");
158     EXPECT_STREQ(codeEmitter.MacroName(inputStr1), expectStr1);
159 }
160 
161 /**
162  * @tc.name: EmitWriteVariable_test_001
163  * @tc.desc: Verify the EmitWriteVariable function.
164  * @tc.type: FUNeC
165  * @tc.require: #I72EZC
166  */
167 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_001, TestSize.Level1)
168 {
169     GTEST_LOG_(INFO)
170         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_001, TestSize.Level1";
171 
172     const String parcelName("ParcelName");
173     const String prefix("const ");
174     const std::string name("Name");
175 
176     MetaComponent mc;
177     CppCodeEmitter codeEmitter(&mc);
178 
179     StringBuilder sb;
180     MetaType mt { .kind_ = TypeKind::Boolean };
181     std::string expectStr(
182         "const if (!ParcelNameWriteInt32(Name ? 1 : 0)) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
183     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
184     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
185 }
186 
187 /**
188  * @tc.name: EmitWriteVariable_test_002
189  * @tc.desc: Verify the EmitWriteVariable function.
190  * @tc.type: FUNeC
191  * @tc.require: #I72EZC
192  */
193 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_002, TestSize.Level1)
194 {
195     GTEST_LOG_(INFO)
196         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_002, TestSize.Level1";
197 
198     const String parcelName("ParcelName");
199     const String prefix("const ");
200     const std::string name("Name");
201 
202     MetaComponent mc;
203     CppCodeEmitter codeEmitter(&mc);
204 
205     StringBuilder sb;
206     MetaType mt { .kind_ = TypeKind::Char };
207     std::string expectStr("const if (!ParcelNameWriteInt32(Name)) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
208     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
209     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
210 }
211 
212 /**
213  * @tc.name: EmitWriteVariable_test_003
214  * @tc.desc: Verify the EmitWriteVariable function.
215  * @tc.type: FUNeC
216  * @tc.require: #I72EZC
217  */
218 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_003, TestSize.Level1)
219 {
220     GTEST_LOG_(INFO)
221         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_003, TestSize.Level1";
222 
223     const String parcelName("ParcelName");
224     const String prefix("const ");
225     const std::string name("Name");
226 
227     MetaComponent mc;
228     CppCodeEmitter codeEmitter(&mc);
229 
230     StringBuilder sb;
231     MetaType mt { .kind_ = TypeKind::Long };
232     std::string expectStr("const if (!ParcelNameWriteInt64(Name)) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
233     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
234     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
235 }
236 
237 /**
238  * @tc.name: EmitWriteVariable_test_004
239  * @tc.desc: Verify the EmitWriteVariable function.
240  * @tc.type: FUNeC
241  * @tc.require: #I72EZC
242  */
243 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_004, TestSize.Level1)
244 {
245     GTEST_LOG_(INFO)
246         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_004, TestSize.Level1";
247 
248     const String parcelName("ParcelName");
249     const String prefix("const ");
250     const std::string name("Name");
251 
252     MetaComponent mc;
253     CppCodeEmitter codeEmitter(&mc);
254 
255     StringBuilder sb;
256     MetaType mt { .kind_ = TypeKind::Float };
257     std::string expectStr("const if (!ParcelNameWriteFloat(Name)) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
258     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
259     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
260 }
261 
262 /**
263  * @tc.name: EmitWriteVariable_test_005
264  * @tc.desc: Verify the EmitWriteVariable function.
265  * @tc.type: FUNeC
266  * @tc.require: #I72EZC
267  */
268 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_005, TestSize.Level1)
269 {
270     GTEST_LOG_(INFO)
271         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_005, TestSize.Level1";
272 
273     const String parcelName("ParcelName");
274     const String prefix("const ");
275     const std::string name("Name");
276 
277     MetaComponent mc;
278     CppCodeEmitter codeEmitter(&mc);
279 
280     StringBuilder sb;
281     MetaType mt { .kind_ = TypeKind::Double };
282     std::string expectStr("const if (!ParcelNameWriteDouble(Name)) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
283     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
284     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
285 }
286 
287 /**
288  * @tc.name: EmitWriteVariable_test_006
289  * @tc.desc: Verify the EmitWriteVariable function.
290  * @tc.type: FUNeC
291  * @tc.require: #I72EZC
292  */
293 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_006, TestSize.Level1)
294 {
295     GTEST_LOG_(INFO)
296         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_006, TestSize.Level1";
297 
298     const String parcelName("ParcelName");
299     const String prefix("const ");
300     const std::string name("Name");
301 
302     MetaComponent mc;
303     CppCodeEmitter codeEmitter(&mc);
304 
305     StringBuilder sb;
306     MetaType mt { .kind_ = TypeKind::String };
307     std::string expectStr(
308         "const if (!ParcelNameWriteString16(Str8ToStr16(Name))) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
309     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
310     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
311 }
312 
313 /**
314  * @tc.name: EmitWriteVariable_test_007
315  * @tc.desc: Verify the EmitWriteVariable function.
316  * @tc.type: FUNeC
317  * @tc.require: #I72EZC
318  */
319 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_007, TestSize.Level1)
320 {
321     GTEST_LOG_(INFO)
322         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_007, TestSize.Level1";
323 
324     const String parcelName("ParcelName");
325     const String prefix("const ");
326     const std::string name("Name");
327 
328     MetaComponent mc;
329     CppCodeEmitter codeEmitter(&mc);
330 
331     StringBuilder sb;
332     MetaType mt { .kind_ = TypeKind::Sequenceable };
333     std::string expectStr(
334         "const if (!ParcelNameWriteParcelable(&Name)) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
335     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
336     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
337 }
338 
339 /**
340  * @tc.name: EmitWriteVariable_test_008
341  * @tc.desc: Verify the EmitWriteVariable function.
342  * @tc.type: FUNeC
343  * @tc.require: #I72EZC
344  */
345 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_008, TestSize.Level1)
346 {
347     GTEST_LOG_(INFO)
348         << "CppCodeEmitterUnitTest, EmitWriteVariable_test_008, TestSize.Level1";
349 
350     const String parcelName("ParcelName");
351     const String prefix("const ");
352     const std::string name("Name");
353 
354     MetaComponent mc;
355     CppCodeEmitter codeEmitter(&mc);
356 
357     StringBuilder sb;
358     MetaType mt { .kind_ = TypeKind::Interface };
359     std::string expectStr(
360         "const if (Name == nullptr) {\nconst     return ERR_INVALID_DATA;\nconst }\nconst if "
361         "(!ParcelNameWriteRemoteObject(Name->AsObject())) {\nconst     return ERR_INVALID_DATA;\nconst }\n");
362     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
363     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
364 }
365 
366 /**
367  * @tc.name: EmitReadVariable_test_001
368  * @tc.desc: Verify the EmitReadVariable function.
369  * @tc.type: FUNC
370  * @tc.require: #I72EZC
371  */
372 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_001, TestSize.Level1)
373 {
374     GTEST_LOG_(INFO)
375         << "CppCodeEmitterUnitTest, EmitReadVariable_test_001, TestSize.Level1";
376 
377     const String parcelName("ParcelName");
378     const String prefix("const ");
379     const std::string name("Name");
380 
381     MetaComponent mc;
382     CppCodeEmitter codeEmitter(&mc);
383 
384     StringBuilder sb;
385     MetaType mt { .kind_ = TypeKind::Boolean };
386     std::string expectStr("const bool Name = ParcelNameReadInt32() == 1 ? true : false;\n");
387     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
388     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
389 }
390 
391 /**
392  * @tc.name: EmitReadVariable_test_002
393  * @tc.desc: Verify the EmitReadVariable function.
394  * @tc.type: FUNC
395  * @tc.require: #I72EZC
396  */
397 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_002, TestSize.Level1)
398 {
399     GTEST_LOG_(INFO)
400         << "CppCodeEmitterUnitTest, EmitReadVariable_test_002, TestSize.Level1";
401 
402     const String parcelName("ParcelName");
403     const String prefix("const ");
404     const std::string name("Name");
405 
406     MetaComponent mc;
407     CppCodeEmitter codeEmitter(&mc);
408 
409     StringBuilder sb;
410     MetaType mt { .kind_ = TypeKind::Boolean };
411     std::string expectStr("const Name = ParcelNameReadInt32() == 1 ? true : false;\n");
412     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
413     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
414 }
415 
416 /**
417  * @tc.name: EmitReadVariable_test_003
418  * @tc.desc: Verify the EmitReadVariable function.
419  * @tc.type: FUNC
420  * @tc.require: #I72EZC
421  */
422 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_003, TestSize.Level1)
423 {
424     GTEST_LOG_(INFO)
425         << "CppCodeEmitterUnitTest, EmitReadVariable_test_003, TestSize.Level1";
426 
427     const String parcelName("ParcelName");
428     const String prefix("const ");
429     const std::string name("Name");
430 
431     MetaComponent mc;
432     CppCodeEmitter codeEmitter(&mc);
433 
434     StringBuilder sb;
435     MetaType mt { .kind_ = TypeKind::Short };
436     std::string expectStr("const short Name = (short)ParcelNameReadInt32();\n");
437     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
438     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
439 }
440 
441 /**
442  * @tc.name: EmitReadVariable_test_004
443  * @tc.desc: Verify the EmitReadVariable function.
444  * @tc.type: FUNC
445  * @tc.require: #I72EZC
446  */
447 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_004, TestSize.Level1)
448 {
449     GTEST_LOG_(INFO)
450         << "CppCodeEmitterUnitTest, EmitReadVariable_test_004, TestSize.Level1";
451 
452     const String parcelName("ParcelName");
453     const String prefix("const ");
454     const std::string name("Name");
455 
456     MetaComponent mc;
457     CppCodeEmitter codeEmitter(&mc);
458 
459     StringBuilder sb;
460     MetaType mt { .kind_ = TypeKind::Short };
461     std::string expectStr("const Name = (short)ParcelNameReadInt32();\n");
462     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
463     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
464 }
465 
466 /**
467  * @tc.name: EmitReadVariable_test_005
468  * @tc.desc: Verify the EmitReadVariable function.
469  * @tc.type: FUNC
470  * @tc.require: #I72EZC
471  */
472 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_005, TestSize.Level1)
473 {
474     GTEST_LOG_(INFO)
475         << "CppCodeEmitterUnitTest, EmitReadVariable_test_005, TestSize.Level1";
476 
477     const String parcelName("ParcelName");
478     const String prefix("const ");
479     const std::string name("Name");
480 
481     MetaComponent mc;
482     CppCodeEmitter codeEmitter(&mc);
483 
484     StringBuilder sb;
485     MetaType mt { .kind_ = TypeKind::Integer };
486     std::string expectStr("const int32_t Name = ParcelNameReadInt32();\n");
487     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
488     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
489 }
490 
491 /**
492  * @tc.name: EmitReadVariable_test_006
493  * @tc.desc: Verify the EmitReadVariable function.
494  * @tc.type: FUNC
495  * @tc.require: #I72EZC
496  */
497 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_006, TestSize.Level1)
498 {
499     GTEST_LOG_(INFO)
500         << "CppCodeEmitterUnitTest, EmitReadVariable_test_006, TestSize.Level1";
501 
502     const String parcelName("ParcelName");
503     const String prefix("const ");
504     const std::string name("Name");
505 
506     MetaComponent mc;
507     CppCodeEmitter codeEmitter(&mc);
508 
509     StringBuilder sb;
510     MetaType mt { .kind_ = TypeKind::Integer };
511     std::string expectStr("const Name = ParcelNameReadInt32();\n");
512     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
513     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
514 }
515 
516 /**
517  * @tc.name: EmitReadVariable_test_007
518  * @tc.desc: Verify the EmitReadVariable function.
519  * @tc.type: FUNC
520  * @tc.require: #I72EZC
521  */
522 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_007, TestSize.Level1)
523 {
524     GTEST_LOG_(INFO)
525         << "CppCodeEmitterUnitTest, EmitReadVariable_test_007, TestSize.Level1";
526 
527     const String parcelName("ParcelName");
528     const String prefix("const ");
529     const std::string name("Name");
530 
531     MetaComponent mc;
532     CppCodeEmitter codeEmitter(&mc);
533 
534     StringBuilder sb;
535     MetaType mt { .kind_ = TypeKind::Long };
536     std::string expectStr("const long Name = ParcelNameReadInt64();\n");
537     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
538     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
539 }
540 
541 /**
542  * @tc.name: EmitReadVariable_test_008
543  * @tc.desc: Verify the EmitReadVariable function.
544  * @tc.type: FUNC
545  * @tc.require: #I72EZC
546  */
547 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_008, TestSize.Level1)
548 {
549     GTEST_LOG_(INFO)
550         << "CppCodeEmitterUnitTest, EmitReadVariable_test_008, TestSize.Level1";
551 
552     const String parcelName("ParcelName");
553     const String prefix("const ");
554     const std::string name("Name");
555 
556     MetaComponent mc;
557     CppCodeEmitter codeEmitter(&mc);
558 
559     StringBuilder sb;
560     MetaType mt { .kind_ = TypeKind::Long };
561     std::string expectStr("const Name = ParcelNameReadInt64();\n");
562     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
563     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
564 }
565 
566 /**
567  * @tc.name: EmitReadVariable_test_009
568  * @tc.desc: Verify the EmitReadVariable function.
569  * @tc.type: FUNC
570  * @tc.require: #I72EZC
571  */
572 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_009, TestSize.Level1)
573 {
574     GTEST_LOG_(INFO)
575         << "CppCodeEmitterUnitTest, EmitReadVariable_test_009, TestSize.Level1";
576 
577     const String parcelName("ParcelName");
578     const String prefix("const ");
579     const std::string name("Name");
580 
581     MetaComponent mc;
582     CppCodeEmitter codeEmitter(&mc);
583 
584     StringBuilder sb;
585     MetaType mt { .kind_ = TypeKind::Float };
586     std::string expectStr("const float Name = ParcelNameReadFloat();\n");
587     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
588     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
589 }
590 
591 /**
592  * @tc.name: EmitReadVariable_test_010
593  * @tc.desc: Verify the EmitReadVariable function.
594  * @tc.type: FUNC
595  * @tc.require: #I72EZC
596  */
597 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_010, TestSize.Level1)
598 {
599     GTEST_LOG_(INFO)
600         << "CppCodeEmitterUnitTest, EmitReadVariable_test_010, TestSize.Level1";
601 
602     const String parcelName("ParcelName");
603     const String prefix("const ");
604     const std::string name("Name");
605 
606     MetaComponent mc;
607     CppCodeEmitter codeEmitter(&mc);
608 
609     StringBuilder sb;
610     MetaType mt { .kind_ = TypeKind::Float };
611     std::string expectStr("const Name = ParcelNameReadFloat();\n");
612     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
613     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
614 }
615 
616 /**
617  * @tc.name: EmitReadVariable_test_011
618  * @tc.desc: Verify the EmitReadVariable function.
619  * @tc.type: FUNC
620  * @tc.require: #I72EZC
621  */
622 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_011, TestSize.Level1)
623 {
624     GTEST_LOG_(INFO)
625         << "CppCodeEmitterUnitTest, EmitReadVariable_test_011, TestSize.Level1";
626 
627     const String parcelName("ParcelName");
628     const String prefix("const ");
629     const std::string name("Name");
630 
631     MetaComponent mc;
632     CppCodeEmitter codeEmitter(&mc);
633 
634     StringBuilder sb;
635     MetaType mt { .kind_ = TypeKind::Double };
636     std::string expectStr("const double Name = ParcelNameReadDouble();\n");
637     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
638     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
639 }
640 
641 /**
642  * @tc.name: EmitReadVariable_test_012
643  * @tc.desc: Verify the EmitReadVariable function.
644  * @tc.type: FUNC
645  * @tc.require: #I72EZC
646  */
647 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_012, TestSize.Level1)
648 {
649     GTEST_LOG_(INFO)
650         << "CppCodeEmitterUnitTest, EmitReadVariable_test_012, TestSize.Level1";
651 
652     const String parcelName("ParcelName");
653     const String prefix("const ");
654     const std::string name("Name");
655 
656     MetaComponent mc;
657     CppCodeEmitter codeEmitter(&mc);
658 
659     StringBuilder sb;
660     MetaType mt { .kind_ = TypeKind::Double };
661     std::string expectStr("const Name = ParcelNameReadDouble();\n");
662     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
663     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
664 }
665 
666 /**
667  * @tc.name: EmitReadVariable_test_013
668  * @tc.desc: Verify the EmitReadVariable function.
669  * @tc.type: FUNC
670  * @tc.require: #I72EZC
671  */
672 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_013, TestSize.Level1)
673 {
674     GTEST_LOG_(INFO)
675         << "CppCodeEmitterUnitTest, EmitReadVariable_test_013, TestSize.Level1";
676 
677     const String parcelName("ParcelName");
678     const String prefix("const ");
679     const std::string name("Name");
680 
681     MetaComponent mc;
682     CppCodeEmitter codeEmitter(&mc);
683 
684     StringBuilder sb;
685     MetaType mt { .kind_ = TypeKind::String };
686     std::string expectStr("const std::string Name = Str16ToStr8(ParcelNameReadString16());\n");
687     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, true);
688     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
689 }
690 
691 /**
692  * @tc.name: EmitReadVariable_test_014
693  * @tc.desc: Verify the EmitReadVariable function.
694  * @tc.type: FUNC
695  * @tc.require: #I72EZC
696  */
697 HWTEST_F(CppCodeEmitterUnitTest, EmitReadVariable_test_014, TestSize.Level1)
698 {
699     GTEST_LOG_(INFO)
700         << "CppCodeEmitterUnitTest, EmitReadVariable_test_014, TestSize.Level1";
701 
702     const String parcelName("ParcelName");
703     const String prefix("const ");
704     const std::string name("Name");
705 
706     MetaComponent mc;
707     CppCodeEmitter codeEmitter(&mc);
708 
709     StringBuilder sb;
710     MetaType mt { .kind_ = TypeKind::String };
711     std::string expectStr("const Name = Str16ToStr8(ParcelNameReadString16());\n");
712     codeEmitter.EmitReadVariable(parcelName, name, &mt, sb, prefix, false);
713     EXPECT_STREQ(sb.buffer_, expectStr.c_str());
714 }
715 
716 /**
717  * @tc.name: ConstantName_test_001
718  * @tc.desc: Verify the ConstantName function.
719  * @tc.type: FUNC
720  * @tc.require: #I72EZC
721  */
722 HWTEST_F(CppCodeEmitterUnitTest, ConstantName_test_001, TestSize.Level1)
723 {
724     GTEST_LOG_(INFO)
725         << "CppCodeEmitterUnitTest, ConstantName_test_001, TestSize.Level1";
726 
727     MetaComponent mc;
728     CppCodeEmitter codeEmitter(&mc);
729 
730     const String emptyStr, expectStr;
731     EXPECT_EQ(codeEmitter.ConstantName(emptyStr), expectStr);
732 
733     const String inputStr3("aKxZ");
734     const String expectStr3("AKX_Z");
735     EXPECT_STREQ(codeEmitter.ConstantName(inputStr3), expectStr3);
736 }
737 
738 /**
739  * @tc.name: UnderlineAdded_test_001
740  * @tc.desc: Verify the UnderlineAdded function.
741  * @tc.type: FUNC
742  * @tc.require: #I72EZC
743  */
744 HWTEST_F(CppCodeEmitterUnitTest, UnderlineAdded_test_001, TestSize.Level1)
745 {
746     GTEST_LOG_(INFO)
747         << "CppCodeEmitterUnitTest, UnderlineAdded_test_001, TestSize.Level1";
748 
749     MetaComponent mc;
750     CppCodeEmitter codeEmitter(&mc);
751 
752     const String inputStr("origStr");
753     const std::string expectStr("_origStr");
754     EXPECT_STREQ(codeEmitter.UnderlineAdded(inputStr).c_str(), expectStr.c_str());
755 }
756 
757 /**
758  * @tc.name: EmitReturnParameter_test_001
759  * @tc.desc: Verify the EmitReturnParameter function.
760  * @tc.type: FUNC
761  * @tc.require: #I72EZC
762  */
763 HWTEST_F(CppCodeEmitterUnitTest, EmitReturnParameter_test_001, TestSize.Level1)
764 {
765     GTEST_LOG_(INFO)
766         << "CppCodeEmitterUnitTest, EmitReturnParameter_test_001, TestSize.Level1";
767 
768     MetaComponent mc;
769     CppCodeEmitter codeEmitter(&mc);
770 
771     const String name("const_string");
772     {
773         MetaType mt { .kind_ = TypeKind::Char };
774         StringBuilder sb;
775         codeEmitter.EmitReturnParameter(name, &mt, sb);
776         EXPECT_STREQ(sb.buffer_, name.string());
777     }
778     {
779         MetaType mt { .kind_ = TypeKind::Unknown };
780         StringBuilder sb;
781         codeEmitter.EmitReturnParameter(name, &mt, sb);
782         EXPECT_EQ(sb.buffer_, nullptr);
783     }
784 }
785 
786 /**
787  * @tc.name: EmitType_test_001
788  * @tc.desc: Verify the EmitType function.
789  * @tc.type: FUNC
790  * @tc.require: #I72EZC
791  */
792 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_001, TestSize.Level1)
793 {
794     GTEST_LOG_(INFO)
795         << "CppCodeEmitterUnitTest, EmitType_test_001, TestSize.Level1";
796 
797     MetaComponent mc;
798     CppCodeEmitter codeEmitter(&mc);
799 
800     MetaType mt { .kind_ = TypeKind::Char };
801     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
802     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
803 
804     EXPECT_STREQ(retStr1, String("zchar"));
805     EXPECT_STREQ(retStr2, String("zchar&"));
806 }
807 
808 /**
809  * @tc.name: EmitType_test_002
810  * @tc.desc: Verify the EmitType function.
811  * @tc.type: FUNC
812  * @tc.require: #I72EZC
813  */
814 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_002, TestSize.Level1)
815 {
816     GTEST_LOG_(INFO)
817         << "CppCodeEmitterUnitTest, EmitType_test_002, TestSize.Level1";
818 
819     MetaComponent mc;
820     CppCodeEmitter codeEmitter(&mc);
821 
822     MetaType mt { .kind_ = TypeKind::Boolean };
823     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
824     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
825 
826     EXPECT_STREQ(retStr1, String("bool"));
827     EXPECT_STREQ(retStr2, String("bool&"));
828 }
829 
830 /**
831  * @tc.name: EmitType_test_003
832  * @tc.desc: Verify the EmitType function.
833  * @tc.type: FUNC
834  * @tc.require: #I72EZC
835  */
836 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_003, TestSize.Level1)
837 {
838     GTEST_LOG_(INFO)
839         << "CppCodeEmitterUnitTest, EmitType_test_003, TestSize.Level1";
840 
841     MetaComponent mc;
842     CppCodeEmitter codeEmitter(&mc);
843 
844     MetaType mt { .kind_ = TypeKind::Byte };
845     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
846     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
847 
848     EXPECT_STREQ(retStr1, String("int8_t"));
849     EXPECT_STREQ(retStr2, String("int8_t&"));
850 }
851 
852 /**
853  * @tc.name: EmitType_test_004
854  * @tc.desc: Verify the EmitType function.
855  * @tc.type: FUNC
856  * @tc.require: #I72EZC
857  */
858 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_004, TestSize.Level1)
859 {
860     GTEST_LOG_(INFO)
861         << "CppCodeEmitterUnitTest, EmitType_test_004, TestSize.Level1";
862 
863     MetaComponent mc;
864     CppCodeEmitter codeEmitter(&mc);
865 
866     MetaType mt { .kind_ = TypeKind::Short };
867     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
868     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
869 
870     EXPECT_STREQ(retStr1, String("short"));
871     EXPECT_STREQ(retStr2, String("short&"));
872 }
873 
874 /**
875  * @tc.name: EmitType_test_005
876  * @tc.desc: Verify the EmitType function.
877  * @tc.type: FUNC
878  * @tc.require: #I72EZC
879  */
880 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_005, TestSize.Level1)
881 {
882     GTEST_LOG_(INFO)
883         << "CppCodeEmitterUnitTest, EmitType_test_006, TestSize.Level1";
884 
885     MetaComponent mc;
886     CppCodeEmitter codeEmitter(&mc);
887 
888     MetaType mt { .kind_ = TypeKind::Integer };
889     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
890     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
891 
892     EXPECT_STREQ(retStr1, String("int32_t"));
893     EXPECT_STREQ(retStr2, String("int32_t&"));
894 }
895 
896 /**
897  * @tc.name: EmitType_test_006
898  * @tc.desc: Verify the EmitType function.
899  * @tc.type: FUNC
900  * @tc.require: #I72EZC
901  */
902 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_006, TestSize.Level1)
903 {
904     GTEST_LOG_(INFO)
905         << "CppCodeEmitterUnitTest, EmitType_test_006, TestSize.Level1";
906 
907     MetaComponent mc;
908     CppCodeEmitter codeEmitter(&mc);
909 
910     MetaType mt { .kind_ = TypeKind::Long };
911     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
912     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
913 
914     EXPECT_STREQ(retStr1, String("long"));
915     EXPECT_STREQ(retStr2, String("long&"));
916 }
917 
918 /**
919  * @tc.name: EmitType_test_007
920  * @tc.desc: Verify the EmitType function.
921  * @tc.type: FUNC
922  * @tc.require: #I72EZC
923  */
924 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_007, TestSize.Level1)
925 {
926     GTEST_LOG_(INFO)
927         << "CppCodeEmitterUnitTest, EmitType_test_007, TestSize.Level1";
928 
929     MetaComponent mc;
930     CppCodeEmitter codeEmitter(&mc);
931 
932     MetaType mt { .kind_ = TypeKind::Float };
933     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
934     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
935 
936     EXPECT_STREQ(retStr1, String("float"));
937     EXPECT_STREQ(retStr2, String("float&"));
938 }
939 
940 /**
941  * @tc.name: EmitType_test_008
942  * @tc.desc: Verify the EmitType function.
943  * @tc.type: FUNC
944  * @tc.require: #I72EZC
945  */
946 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_008, TestSize.Level1)
947 {
948     GTEST_LOG_(INFO)
949         << "CppCodeEmitterUnitTest, EmitType_test_008, TestSize.Level1";
950 
951     MetaComponent mc;
952     CppCodeEmitter codeEmitter(&mc);
953 
954     MetaType mt { .kind_ = TypeKind::Double };
955     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, true);
956     String retStr2 = codeEmitter.EmitType(&mt, 0, true);
957 
958     EXPECT_STREQ(retStr1, String("double"));
959     EXPECT_STREQ(retStr2, String("double&"));
960 }
961 
962 
963 /**
964  * @tc.name: EmitType_test_009
965  * @tc.desc: Verify the EmitType function.
966  * @tc.type: FUNC
967  * @tc.require: #I72EZC
968  */
969 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_009, TestSize.Level1)
970 {
971     GTEST_LOG_(INFO)
972         << "CppCodeEmitterUnitTest, EmitType_test_009, TestSize.Level1";
973 
974     MetaComponent mc;
975     CppCodeEmitter codeEmitter(&mc);
976 
977     MetaType mt { .kind_ = TypeKind::String };
978     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN, false);
979     String retStr2 = codeEmitter.EmitType(&mt, ATTR_IN, true);
980     String retStr3 = codeEmitter.EmitType(&mt, 0, true);
981 
982     EXPECT_STREQ(retStr1, String("const std::string&"));
983     EXPECT_STREQ(retStr2, String("std::string"));
984     EXPECT_STREQ(retStr3, String("std::string&"));
985 }
986 
987 /**
988  * @tc.name: EmitType_test_010
989  * @tc.desc: Verify the EmitType function.
990  * @tc.type: FUNC
991  * @tc.require: #I72EZC
992  */
993 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_010, TestSize.Level1)
994 {
995     GTEST_LOG_(INFO)
996         << "CppCodeEmitterUnitTest, EmitType_test_010, TestSize.Level1";
997 
998     MetaComponent mc;
999     CppCodeEmitter codeEmitter(&mc);
1000 }
1001 
1002 /**
1003  * @tc.name: EmitType_test_011
1004  * @tc.desc: Verify the EmitType function.
1005  * @tc.type: FUNC
1006  * @tc.require: #I72EZC
1007  */
1008 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_011, TestSize.Level1)
1009 {
1010     GTEST_LOG_(INFO)
1011         << "CppCodeEmitterUnitTest, EmitType_test_011, TestSize.Level1";
1012 
1013     MetaComponent mc;
1014     CppCodeEmitter codeEmitter(&mc);
1015 
1016     MetaType mt { .kind_ = TypeKind::Void };
1017     String retStr = codeEmitter.EmitType(&mt, ATTR_IN, false);
1018     EXPECT_STREQ(retStr, String("void"));
1019 }
1020 
1021 /**
1022  * @tc.name: EmitType_test_012
1023  * @tc.desc: Verify the EmitType function.
1024  * @tc.type: FUNC
1025  * @tc.require: #I72EZC
1026  */
1027 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_012, TestSize.Level1)
1028 {
1029     GTEST_LOG_(INFO)
1030         << "CppCodeEmitterUnitTest, EmitType_test_012, TestSize.Level1";
1031 
1032     MetaType mt { .kind_ = TypeKind::Sequenceable, .index_ = 0 };
1033     char mseqName[] = "MetaSequenceable";
1034     MetaSequenceable mp;
1035     mp.name_ = mseqName;
1036 
1037     MetaComponent mc;
1038     mc.sequenceables_ = new MetaSequenceable*[1];
1039     mc.sequenceables_[0] = &mp;
1040     CppCodeEmitter codeEmitter(&mc);
1041 
1042     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN | ATTR_OUT, false);
1043     String retStr2 = codeEmitter.EmitType(&mt, ATTR_IN, false);
1044     String retStr3 = codeEmitter.EmitType(&mt, 0, false);
1045 
1046     EXPECT_STREQ(retStr1, String("MetaSequenceable*"));
1047     EXPECT_STREQ(retStr2, String("const MetaSequenceable&"));
1048     EXPECT_STREQ(retStr3, String("MetaSequenceable&"));
1049 
1050     delete []mc.sequenceables_;
1051 }
1052 
1053 /**
1054  * @tc.name: EmitType_test_013
1055  * @tc.desc: Verify the EmitType function.
1056  * @tc.type: FUNC
1057  * @tc.require: #I72EZC
1058  */
1059 HWTEST_F(CppCodeEmitterUnitTest, EmitType_test_013, TestSize.Level1)
1060 {
1061     GTEST_LOG_(INFO)
1062         << "CppCodeEmitterUnitTest, EmitType_test_013, TestSize.Level1";
1063 
1064     MetaType mt { .kind_ = TypeKind::Interface, .index_ = 0 };
1065     char miName[] = "MetaInterface";
1066     MetaInterface mi;
1067     mi.name_ = miName;
1068 
1069     MetaComponent mc;
1070     mc.interfaces_ = new MetaInterface*[1];
1071     mc.interfaces_[0] = &mi;
1072     CppCodeEmitter codeEmitter(&mc);
1073 
1074     String retStr1 = codeEmitter.EmitType(&mt, ATTR_IN | ATTR_OUT, false);
1075     String retStr2 = codeEmitter.EmitType(&mt, ATTR_IN, false);
1076     String retStr3 = codeEmitter.EmitType(&mt, 0, false);
1077 
1078     EXPECT_STREQ(retStr1.string(), "const sptr<MetaInterface>&");
1079     EXPECT_STREQ(retStr2.string(), "const sptr<MetaInterface>&");
1080     EXPECT_STREQ(retStr3.string(), "sptr<MetaInterface>&");
1081 
1082     delete []mc.interfaces_;
1083 }
1084 
1085 /**
1086  * @tc.name: CppFullName_test_001
1087  * @tc.desc: Verify the CppFullName function.
1088  * @tc.type: FUNC
1089  * @tc.require: #I72EZC
1090  */
1091 HWTEST_F(CppCodeEmitterUnitTest, CppFullName_test_001, TestSize.Level1)
1092 {
1093     GTEST_LOG_(INFO)
1094         << "CppCodeEmitterUnitTest, CppFullName_test_001, TestSize.Level1";
1095 
1096     MetaComponent mc;
1097     CppCodeEmitter codeEmitter(&mc);
1098 
1099     const String inputStr, expectStr;
1100     EXPECT_STREQ(codeEmitter.CppFullName(inputStr), expectStr);
1101 
1102     const String inputStr1("a.b.c.d");
1103     const String expectStr1("a::b::c::d");
1104     EXPECT_STREQ(codeEmitter.CppFullName(inputStr1).string(), expectStr1.string());
1105 }
1106 
1107 /**
1108  * @tc.name: EmitInterfaceProxyCppFile_test_001
1109  * @tc.desc: Verify the EmitInterfaceProxyCppFile function.
1110  * @tc.type: FUNC
1111  * @tc.require: #I8JQUO
1112  */
1113 HWTEST_F(CppCodeEmitterUnitTest, EmitInterfaceProxyCppFile_test_001, TestSize.Level1)
1114 {
1115     /**
1116      * @tc.steps: step1. Initialization parameters.
1117      */
1118     MetaComponent mc;
1119     CppCodeEmitter codeEmitter(&mc);
1120     char name = 'n';
1121     const String directory = "Idl";
1122     String HitraceTag = "HITRACE_TAG_DLSM";
1123     String logTag = "DISP_SEED";
1124     String domainId = "0xb0d2d4";
1125 
1126     /**
1127      * @tc.steps: step2. Initialize pointers in functions.
1128      */
1129     codeEmitter.metaInterface_ = new MetaInterface[13];
1130     ASSERT_NE(codeEmitter.metaInterface_, nullptr);
1131     codeEmitter.metaInterface_->license_ = &name;
1132     ASSERT_NE(codeEmitter.metaInterface_->license_, nullptr);
1133     codeEmitter.metaInterface_->namespace_ = &name;
1134     codeEmitter.metaInterface_->methods_ = new MetaMethod *[6];
1135     for (int j = 0; j < 6; ++j) {
1136         codeEmitter.metaInterface_->methods_[j] = new MetaMethod();
1137         ASSERT_NE(codeEmitter.metaInterface_->methods_[j], nullptr);
1138     }
1139     codeEmitter.metaInterface_->methodNumber_ = 2;
1140     codeEmitter.metaComponent_->types_ = new MetaType *[3];
1141     for (int i = 0; i < 3; ++i) {
1142         codeEmitter.metaComponent_->types_[i] = new MetaType();
1143         ASSERT_NE(codeEmitter.metaComponent_->types_[i], nullptr);
1144     }
1145 
1146     /**
1147      * @tc.steps: step3. Assigning parameters to a function.
1148      */
1149     codeEmitter.SetDirectory(directory);
1150     codeEmitter.proxyName_ = "ability_proxy";
1151     codeEmitter.SetDomainId(domainId);
1152     codeEmitter.SetHitraceTag(HitraceTag);
1153     codeEmitter.SetHitraceOn(true);
1154     codeEmitter.SetLogTag(logTag);
1155 
1156     /**
1157      * @tc.steps: step4. Execute functions that require validation.
1158      * @tc.expected: Can obtain the correct hitraceOn_.
1159      */
1160     codeEmitter.EmitInterfaceProxyCppFile();
1161     EXPECT_TRUE(codeEmitter.hitraceOn_);
1162 
1163     for (int i = 0; i < 6; i++) {
1164         delete codeEmitter.metaInterface_->methods_[i];
1165     }
1166     delete[] codeEmitter.metaInterface_->methods_;
1167     for (int j = 0; j < 3; j++) {
1168         delete codeEmitter.metaComponent_->types_[j];
1169     }
1170     delete[] codeEmitter.metaComponent_->types_;
1171     delete[] codeEmitter.metaInterface_;
1172 }
1173 
1174 /**
1175  * @tc.name: EmitInterfaceMemberVariables_test_001
1176  * @tc.desc: Verify the EmitInterfaceMemberVariables function.
1177  * @tc.type: FUNC
1178  * @tc.require: #I8JQUO
1179  */
1180 HWTEST_F(CppCodeEmitterUnitTest, EmitInterfaceMemberVariables_test_001, TestSize.Level1)
1181 {
1182     /**
1183      * @tc.steps: step1. Initialization parameters.
1184      */
1185     MetaComponent mc;
1186     CppCodeEmitter codeEmitter(&mc);
1187     String logTag = "HITRACE_TAG_ABILITY_MANAGER";
1188     String domainId = "0xb0d2d4";
1189     StringBuilder sb;
1190     String prefix = "const";
1191     codeEmitter.proxyName_ = "ability_proxy";
1192 
1193     /**
1194      * @tc.steps: step2. Set domainId and logTag.
1195      */
1196     codeEmitter.SetDomainId(domainId);
1197     codeEmitter.SetLogTag(logTag);
1198 
1199     /**
1200      * @tc.steps: step3. Execute functions that require validation.
1201      * @tc.expected: Can obtain the correct logTag_.
1202      */
1203     codeEmitter.EmitInterfaceMemberVariables(sb, prefix);
1204     std::string expectStr("HITRACE_TAG_ABILITY_MANAGER");
1205     EXPECT_STREQ(codeEmitter.logTag_, expectStr.c_str());
1206 }
1207 
1208 /**
1209  * @tc.name: EmitInterfaceDBinderInclusions_test_001
1210  * @tc.desc: Verify the EmitInterfaceDBinderInclusions function.
1211  * @tc.type: FUNC
1212  * @tc.require: #I8JQUO
1213  */
1214 HWTEST_F(CppCodeEmitterUnitTest, EmitInterfaceDBinderInclusions_test_001, TestSize.Level1)
1215 {
1216     /**
1217      * @tc.steps: step1. Initialization parameters.
1218      */
1219     MetaComponent mc;
1220     CppCodeEmitter codeEmitter(&mc);
1221     String logTag = "HITRACE_TAG_ABILITY_MANAGER";
1222     String domainId = "0xb0d2d4";
1223     StringBuilder sb;
1224 
1225     /**
1226      * @tc.steps: step2. Set domainId and logTag.
1227      */
1228     codeEmitter.SetDomainId(domainId);
1229     codeEmitter.SetLogTag(logTag);
1230 
1231     /**
1232      * @tc.steps: step3. Execute functions that require validation.
1233      * @tc.expected: Can obtain the correct logTag_.
1234      */
1235     codeEmitter.EmitInterfaceDBinderInclusions(sb);
1236     std::string expectStr("HITRACE_TAG_ABILITY_MANAGER");
1237     EXPECT_STREQ(codeEmitter.logTag_, expectStr.c_str());
1238 }
1239 
1240 /**
1241  * @tc.name: EmitInterfaceStubCppFile_test_001
1242  * @tc.desc: Verify the EmitInterfaceStubCppFile function.
1243  * @tc.type: FUNC
1244  * @tc.require: #I8JQUO
1245  */
1246 HWTEST_F(CppCodeEmitterUnitTest, EmitInterfaceStubCppFile_test_001, TestSize.Level1)
1247 {
1248     /**
1249      * @tc.steps: step1. Initialization parameters.
1250      */
1251     MetaComponent mc;
1252     CppCodeEmitter codeEmitter(&mc);
1253     String logTag = "HITRACE_TAG_ABILITY_MANAGER";
1254     String domainId = "0xb0d2d4";
1255     StringBuilder sb;
1256     char name = 'n';
1257 
1258     /**
1259      * @tc.steps: step2. Initialize pointers in functions.
1260      */
1261     codeEmitter.metaInterface_ = new MetaInterface[13];
1262     ASSERT_NE(codeEmitter.metaInterface_, nullptr);
1263     codeEmitter.metaInterface_->license_ = &name;
1264     ASSERT_NE(codeEmitter.metaInterface_->license_, nullptr);
1265     codeEmitter.metaInterface_->namespace_ = &name;
1266     ASSERT_NE(codeEmitter.metaInterface_->namespace_, nullptr);
1267     codeEmitter.metaInterface_->methods_ = new MetaMethod *[6];
1268     for (int j = 0; j < 6; ++j) {
1269         codeEmitter.metaInterface_->methods_[j] = new MetaMethod();
1270         ASSERT_NE(codeEmitter.metaInterface_->methods_[j], nullptr);
1271     }
1272     codeEmitter.metaInterface_->methodNumber_ = 2;
1273     codeEmitter.metaComponent_->types_ = new MetaType *[4];
1274     for (int i = 0; i < 4; ++i) {
1275         codeEmitter.metaComponent_->types_[i] = new MetaType();
1276         ASSERT_NE(codeEmitter.metaComponent_->types_[i], nullptr);
1277     }
1278 
1279     /**
1280      * @tc.steps: step3. Set domainId and logTag.
1281      */
1282     codeEmitter.SetDomainId(domainId);
1283     codeEmitter.SetLogTag(logTag);
1284 
1285     /**
1286      * @tc.steps: step4. Execute functions that require validation.
1287      * @tc.expected: Can obtain the correct hitraceOn_.
1288      */
1289     codeEmitter.EmitInterfaceStubCppFile();
1290     EXPECT_FALSE(codeEmitter.hitraceOn_);
1291 
1292     for (int i = 0; i < 6; i++) {
1293         delete codeEmitter.metaInterface_->methods_[i];
1294     }
1295     delete[] codeEmitter.metaInterface_->methods_;
1296     for (int j = 0; j < 4; j++) {
1297         delete codeEmitter.metaComponent_->types_[j];
1298     }
1299     delete[] codeEmitter.metaComponent_->types_;
1300     delete [] codeEmitter.metaInterface_;
1301 }
1302 
1303 /**
1304  * @tc.name: EmitWriteVariable_test_009
1305  * @tc.desc: Verify the EmitWriteVariable function.
1306  * @tc.type: FUNC
1307  * @tc.require: #I8JQUO
1308  */
1309 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_009, TestSize.Level1)
1310 {
1311     /**
1312      * @tc.steps: step1. Initialization parameters.
1313      */
1314     MetaComponent mc;
1315     CppCodeEmitter codeEmitter(&mc);
1316     String logTag = "HITRACE_TAG_ABILITY_MANAGER";
1317     String domainId = "0xb0d2d4";
1318     StringBuilder sb;
1319     String parcelName = "parcelName";
1320     std::string name = "name";
1321     String prefix = "const";
1322 
1323     /**
1324      * @tc.steps: step2. When kind_ Validate functions when taking different values.
1325      * @tc.expected: Can obtain the correct logTag_.
1326      */
1327     MetaType mt;
1328     mt.kind_ = TypeKind::Integer;
1329     codeEmitter.SetDomainId(domainId);
1330     codeEmitter.SetLogTag(logTag);
1331     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1332 
1333     mt.kind_ = TypeKind::Long;
1334     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1335 
1336     mt.kind_ = TypeKind::Float;
1337     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1338 
1339     mt.kind_ = TypeKind::Double;
1340     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1341 
1342     mt.kind_ = TypeKind::String;
1343     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1344 
1345     mt.kind_ = TypeKind::Sequenceable;
1346     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1347     std::string expectStr("HITRACE_TAG_ABILITY_MANAGER");
1348     EXPECT_STREQ(codeEmitter.logTag_, expectStr.c_str());
1349 }
1350 
1351 /**
1352  * @tc.name: EmitWriteVariable_test_0010
1353  * @tc.desc: Verify the EmitWriteVariable function.
1354  * @tc.type: FUNC
1355  * @tc.require: #I8JQUO
1356  */
1357 HWTEST_F(CppCodeEmitterUnitTest, EmitWriteVariable_test_0010, TestSize.Level1)
1358 {
1359     /**
1360      * @tc.steps: step1. Initialization parameters.
1361      */
1362     MetaComponent mc;
1363     CppCodeEmitter codeEmitter(&mc);
1364     String logTag = "HITRACE_TAG_ABILITY_MANAGER";
1365     String domainId = "0xb0d2d4";
1366     StringBuilder sb;
1367     String parcelName = "parcelName";
1368     std::string name = "name";
1369     String prefix = "const";
1370     int32_t indexes = 1;
1371 
1372     /**
1373      * @tc.steps: step2. When kind_ Validate functions when taking different values.
1374      * @tc.expected: Can obtain the correct logTag_.
1375      */
1376     MetaType mt;
1377     mt.kind_ = TypeKind::Integer;
1378     codeEmitter.SetDomainId(domainId);
1379     codeEmitter.SetLogTag(logTag);
1380     codeEmitter.metaComponent_->types_ = new MetaType *[3];
1381     for (int i = 0; i < 3; ++i) {
1382         codeEmitter.metaComponent_->types_[i] = new MetaType();
1383         ASSERT_NE(codeEmitter.metaComponent_->types_[i], nullptr);
1384     }
1385     mt.nestedTypeIndexes_ = &indexes;
1386     mt.kind_ = TypeKind::List;
1387 
1388     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1389     mt.kind_ = TypeKind::Array;
1390     codeEmitter.EmitWriteVariable(parcelName, name, &mt, sb, prefix);
1391     std::string expectStr("HITRACE_TAG_ABILITY_MANAGER");
1392     EXPECT_STREQ(codeEmitter.logTag_, expectStr.c_str());
1393 
1394     for (int j = 0; j < 3; j++) {
1395         delete codeEmitter.metaComponent_->types_[j];
1396     }
1397     delete[] codeEmitter.metaComponent_->types_;
1398 }
1399 } // namespace idl
1400 } // namespace OHOS
1401