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] = ∓
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