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