1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstring>
17 #include <fstream>
18 #include <gtest/gtest.h>
19 #include "idl_common.h"
20
21 using namespace testing::ext;
22 using namespace OHOS::Idl::TestCommon;
23 namespace OHOS {
24 namespace Idl {
25 namespace UnitTest {
26 class TsCodeEmitterProxyTest : public testing::Test, public IdlCommon {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void TsCodeEmitterProxyTest::SetUpTestCase(void)
35 {}
TearDownTestCase(void)36 void TsCodeEmitterProxyTest::TearDownTestCase(void)
37 {}
SetUp()38 void TsCodeEmitterProxyTest::SetUp()
39 {}
TearDown()40 void TsCodeEmitterProxyTest::TearDown()
41 {
42 tsCodeGen_ = nullptr;
43 }
44
45 /*
46 * Feature: idl
47 * Function: EmitWriteArrayVariable
48 * SubFunction: NA
49 * FunctionPoints: EmitWriteArrayVariable validates the array type
50 * EnvConditions: NA
51 * CaseDescription: Array type keyword generated successfully.
52 */
53 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteArrayVariable_001, TestSize.Level1)
54 {
55 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
56 int argc = 6;
57 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
58 ParameterArgv parameters(argvArray, argc);
59 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
60 EXPECT_NE(tsCodeGen_, nullptr);
61 StringBuilder stringBuilder;
62 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
63 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
64 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
65 MetaParameter* mp = metaMethod->parameters_[j];
66 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
67 if (mt->kind_ == TypeKind::Array && (mp->attributes_ & ATTR_IN) != 0) {
68 MetaType* innerType = tsCodeGen_->metaComponent_->types_[mt->nestedTypeIndexes_[0]];
69 tsCodeGen_->EmitWriteArrayVariable("data", mp->name_, innerType,
70 stringBuilder, CodeEmitter::TAB);
71 }
72 }
73 }
74 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
75 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
76 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
77 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
78 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
79 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
80 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
81 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
82 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
83 EXPECT_TRUE(stringBuilder.ToString().IsEmpty());
84 }
85
86 /*
87 * Feature: idl
88 * Function: EmitWriteArrayVariable
89 * SubFunction: NA
90 * FunctionPoints: EmitWriteArrayVariable validates the array type
91 * EnvConditions: NA
92 * CaseDescription: Array type keyword generated successfully.
93 */
94 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteArrayVariable_002, TestSize.Level1)
95 {
96 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
97 int argc = 6;
98 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
99 ParameterArgv parameters(argvArray, argc);
100 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
101 EXPECT_NE(tsCodeGen_, nullptr);
102 StringBuilder stringBuilder;
103 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
104 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
105 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
106 MetaParameter* mp = metaMethod->parameters_[j];
107 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
108 if (mt->kind_ == TypeKind::Array && (mp->attributes_ & ATTR_IN) != 0) {
109 MetaType* innerType = tsCodeGen_->metaComponent_->types_[mt->nestedTypeIndexes_[0]];
110 tsCodeGen_->EmitWriteArrayVariable("data", mp->name_, innerType,
111 stringBuilder, CodeEmitter::TAB);
112 }
113 }
114 }
115 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
116 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
117 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
118 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
119 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
120 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
121 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
122 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
123 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
124 }
125
126 /*
127 * Feature: idl
128 * Function: EmitWriteArrayVariable
129 * SubFunction: NA
130 * FunctionPoints: EmitWriteArrayVariable validates the array type
131 * EnvConditions: NA
132 * CaseDescription: Array type keyword generated successfully.
133 */
134 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteArrayVariable_003, TestSize.Level1)
135 {
136 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
137 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
138 int argc = 6;
139 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
140 ParameterArgv parameters(argvArray, argc);
141 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
142 EXPECT_NE(tsCodeGen_, nullptr);
143 StringBuilder stringBuilder;
144 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
145 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
146 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
147 MetaParameter* mp = metaMethod->parameters_[j];
148 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
149 if (mt->kind_ == TypeKind::Array && (mp->attributes_ & ATTR_IN) != 0) {
150 MetaType* innerType = tsCodeGen_->metaComponent_->types_[mt->nestedTypeIndexes_[0]];
151 tsCodeGen_->EmitWriteArrayVariable("data", mp->name_, innerType,
152 stringBuilder, CodeEmitter::TAB);
153 }
154 }
155 }
156 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
157 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
158 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
159 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
160 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
161 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
162 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
163 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
164 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
165 }
166
167 /*
168 * Feature: idl
169 * Function: EmitWriteArrayVariable
170 * SubFunction: NA
171 * FunctionPoints: EmitWriteArrayVariable validates the array type
172 * EnvConditions: NA
173 * CaseDescription: Array type keyword generated successfully.
174 */
175 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteArrayVariable_004, TestSize.Level1)
176 {
177 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
178 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
179 int argc = 6;
180 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
181 ParameterArgv parameters(argvArray, argc);
182 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
183 EXPECT_NE(tsCodeGen_, nullptr);
184 StringBuilder stringBuilder;
185 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
186 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
187 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
188 MetaParameter* mp = metaMethod->parameters_[j];
189 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
190 if (mt->kind_ == TypeKind::Array && (mp->attributes_ & ATTR_IN) != 0) {
191 MetaType* innerType = tsCodeGen_->metaComponent_->types_[mt->nestedTypeIndexes_[0]];
192 tsCodeGen_->EmitWriteArrayVariable("data", mp->name_, innerType,
193 stringBuilder, CodeEmitter::TAB);
194 }
195 }
196 }
197 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
198 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
199 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
200 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
201 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
202 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
203 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
204 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
205 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
206 EXPECT_TRUE(stringBuilder.ToString().IsEmpty());
207 }
208
209 /*
210 * Feature: idl
211 * Function: EmitWriteArrayVariable
212 * SubFunction: NA
213 * FunctionPoints: EmitWriteArrayVariable validates the array type
214 * EnvConditions: NA
215 * CaseDescription: Array type keyword generated successfully.
216 */
217 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteArrayVariable_005, TestSize.Level1)
218 {
219 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
220 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
221 int argc = 6;
222 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
223 ParameterArgv parameters(argvArray, argc);
224 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
225 EXPECT_NE(tsCodeGen_, nullptr);
226 StringBuilder stringBuilder;
227 int count = 0;
228 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
229 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
230 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
231 MetaParameter* mp = metaMethod->parameters_[j];
232 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
233 if (mt->kind_ == TypeKind::Array && (mp->attributes_ & ATTR_IN) != 0) {
234 count++;
235 MetaType* innerType = tsCodeGen_->metaComponent_->types_[mt->nestedTypeIndexes_[0]];
236 tsCodeGen_->EmitWriteArrayVariable("data", mp->name_, innerType,
237 stringBuilder, CodeEmitter::TAB);
238 }
239 }
240 }
241 const int size = 18;
242 EXPECT_TRUE(count == size);
243 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
244 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
245 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
246 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
247 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
248 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
249 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
250 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
251 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
252 }
253
254 /*
255 * Feature: idl
256 * Function: EmitReadOutArrayVariable
257 * SubFunction: NA
258 * FunctionPoints: EmitReadOutArrayVariable validates the array type
259 * EnvConditions: NA
260 * CaseDescription: Array type keyword generated successfully.
261 */
262 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutArrayVariable_001, TestSize.Level1)
263 {
264 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
265 int argc = 6;
266 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
267 ParameterArgv parameters(argvArray, argc);
268 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
269 EXPECT_NE(tsCodeGen_, nullptr);
270 StringBuilder stringBuilder;
271 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
272 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
273 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
274 MetaParameter* mp = metaMethod->parameters_[j];
275 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
276 if (mt->kind_ == TypeKind::Array && (mp->attributes_ & ATTR_MASK) == ATTR_OUT) {
277 tsCodeGen_->EmitReadOutArrayVariable("data", mp->name_, mt,
278 stringBuilder, CodeEmitter::TAB);
279 }
280 }
281 }
282 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
283 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
284 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
285 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
286 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
287 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
288 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
289 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
290 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
291 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
292 }
293
294 /*
295 * Feature: idl
296 * Function: EmitReadOutArrayVariable
297 * SubFunction: NA
298 * FunctionPoints: EmitReadOutArrayVariable validates the array type
299 * EnvConditions: NA
300 * CaseDescription: Array type keyword generated successfully.
301 */
302 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutArrayVariable_002, TestSize.Level1)
303 {
304 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
305 int argc = 6;
306 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
307 ParameterArgv parameters(argvArray, argc);
308 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
309 EXPECT_NE(tsCodeGen_, nullptr);
310 StringBuilder stringBuilder;
311 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
312 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
313 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
314 MetaParameter* mp = metaMethod->parameters_[j];
315 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
316 if (mt->kind_ == TypeKind::Array && (mp->attributes_ & ATTR_MASK) == ATTR_OUT) {
317 tsCodeGen_->EmitReadOutArrayVariable("data", mp->name_, mt,
318 stringBuilder, CodeEmitter::TAB);
319 }
320 }
321 }
322 EXPECT_EQ(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
323 EXPECT_EQ(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
324 EXPECT_EQ(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
325 EXPECT_EQ(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
326 EXPECT_EQ(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
327 EXPECT_EQ(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
328 EXPECT_EQ(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
329 EXPECT_EQ(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
330 EXPECT_EQ(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
331 EXPECT_TRUE(stringBuilder.ToString().IsEmpty());
332 }
333
334 /*
335 * Feature: idl
336 * Function: EmitReadOutArrayVariable
337 * SubFunction: NA
338 * FunctionPoints: EmitReadOutArrayVariable validates the array type
339 * EnvConditions: NA
340 * CaseDescription: Array type keyword generated successfully.
341 */
342 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutArrayVariable_003, TestSize.Level1)
343 {
344 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
345 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
346 int argc = 6;
347 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
348 ParameterArgv parameters(argvArray, argc);
349 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
350 EXPECT_NE(tsCodeGen_, nullptr);
351 StringBuilder stringBuilder;
352 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
353 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
354 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
355 MetaParameter* mp = metaMethod->parameters_[j];
356 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
357 if (mt->kind_ == TypeKind::Array) {
358 tsCodeGen_->EmitReadOutArrayVariable("data", mp->name_, mt,
359 stringBuilder, CodeEmitter::TAB);
360 }
361 }
362 }
363 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
364 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
365 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
366 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
367 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
368 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
369 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
370 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
371 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
372 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
373 }
374
375 /*
376 * Feature: idl
377 * Function: EmitReadOutArrayVariable
378 * SubFunction: NA
379 * FunctionPoints: EmitReadOutArrayVariable validates the array type
380 * EnvConditions: NA
381 * CaseDescription: Array type keyword generated successfully.
382 */
383 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutArrayVariable_004, TestSize.Level1)
384 {
385 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
386 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
387 int argc = 6;
388 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
389 ParameterArgv parameters(argvArray, argc);
390 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
391 EXPECT_NE(tsCodeGen_, nullptr);
392 StringBuilder stringBuilder;
393 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
394 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
395 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
396 MetaParameter* mp = metaMethod->parameters_[j];
397 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
398 if (mt->kind_ == TypeKind::Array) {
399 tsCodeGen_->EmitReadOutArrayVariable("data", mp->name_, mt,
400 stringBuilder, CodeEmitter::TAB);
401 }
402 }
403 }
404 EXPECT_EQ(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
405 EXPECT_EQ(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
406 EXPECT_EQ(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
407 EXPECT_EQ(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
408 EXPECT_EQ(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
409 EXPECT_EQ(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
410 EXPECT_EQ(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
411 EXPECT_EQ(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
412 EXPECT_EQ(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
413 EXPECT_TRUE(stringBuilder.ToString().IsEmpty());
414 }
415
416 /*
417 * Feature: idl
418 * Function: EmitReadOutArrayVariable
419 * SubFunction: NA
420 * FunctionPoints: EmitReadOutArrayVariable validates the array type
421 * EnvConditions: NA
422 * CaseDescription: Array type keyword generated successfully.
423 */
424 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutArrayVariable_005, TestSize.Level1)
425 {
426 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
427 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
428 int argc = 6;
429 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
430 ParameterArgv parameters(argvArray, argc);
431 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
432 EXPECT_NE(tsCodeGen_, nullptr);
433 StringBuilder stringBuilder;
434 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
435 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
436 for (int j = 0; j < metaMethod->parameterNumber_; j++) {
437 MetaParameter* mp = metaMethod->parameters_[j];
438 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
439 if (mt->kind_ == TypeKind::Array) {
440 tsCodeGen_->EmitReadOutArrayVariable("data", mp->name_, mt,
441 stringBuilder, CodeEmitter::TAB);
442 }
443 }
444 }
445 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
446 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
447 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
448 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
449 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
450 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
451 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
452 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
453 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
454 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
455 }
456
457 /*
458 * Feature: idl
459 * Function: EmitWriteMethodParameter
460 * SubFunction: NA
461 * FunctionPoints: EmitWriteMethodParameter validates the array type
462 * EnvConditions: NA
463 * CaseDescription: Array type keyword generated successfully
464 */
465 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteMethodParameter_001, TestSize.Level1)
466 {
467 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
468 int argc = 6;
469 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
470 ParameterArgv parameters(argvArray, argc);
471 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
472 EXPECT_NE(tsCodeGen_, nullptr);
473 StringBuilder stringBuilder;
474 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
475 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
476 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
477 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
478 if ((mp->attributes_ & ATTR_IN) != 0) {
479 tsCodeGen_->EmitWriteMethodParameter(mp, "reply", stringBuilder, CodeEmitter::TAB);
480 }
481 }
482 }
483 std::string data(stringBuilder.ToString().string());
484 EXPECT_TRUE(data.length());
485 EXPECT_NE(data.find("writeInt"), std::string::npos);
486 EXPECT_NE(data.find("writeLong"), std::string::npos);
487 EXPECT_NE(data.find("writeFloat"), std::string::npos);
488 EXPECT_NE(data.find("writeDouble"), std::string::npos);
489 EXPECT_NE(data.find("writeString"), std::string::npos);
490 EXPECT_NE(data.find("writeSequenceable"), std::string::npos);
491 EXPECT_NE(data.find("writeRemoteObject"), std::string::npos);
492 }
493
494 /*
495 * Feature: idl
496 * Function: EmitWriteMethodParameter
497 * SubFunction: NA
498 * FunctionPoints: EmitWriteMethodParameter validates the array type
499 * EnvConditions: NA
500 * CaseDescription: Array type keyword generated successfully
501 */
502 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteMethodParameter_002, TestSize.Level1)
503 {
504 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
505 int argc = 6;
506 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
507 ParameterArgv parameters(argvArray, argc);
508 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
509 EXPECT_NE(tsCodeGen_, nullptr);
510 StringBuilder stringBuilder;
511 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
512 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
513 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
514 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
515 if ((mp->attributes_ & ATTR_OUT) != 0) {
516 tsCodeGen_->EmitWriteMethodParameter(mp, "reply", stringBuilder, CodeEmitter::TAB);
517 }
518 }
519 }
520 std::string data(stringBuilder.ToString().string());
521 EXPECT_TRUE(data.length());
522 EXPECT_NE(data.find("writeInt"), std::string::npos);
523 EXPECT_NE(data.find("writeLong"), std::string::npos);
524 EXPECT_NE(data.find("writeFloat"), std::string::npos);
525 EXPECT_NE(data.find("writeDouble"), std::string::npos);
526 EXPECT_NE(data.find("writeString"), std::string::npos);
527 EXPECT_NE(data.find("writeSequenceable"), std::string::npos);
528 EXPECT_NE(data.find("writeRemoteObject"), std::string::npos);
529 }
530
531 /*
532 * Feature: idl
533 * Function: EmitWriteMethodParameter
534 * SubFunction: NA
535 * FunctionPoints: EmitWriteMethodParameter validates the array type
536 * EnvConditions: NA
537 * CaseDescription: Array type keyword generated successfully
538 */
539 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteMethodParameter_003, TestSize.Level1)
540 {
541 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
542 int argc = 6;
543 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
544 ParameterArgv parameters(argvArray, argc);
545 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
546 EXPECT_NE(tsCodeGen_, nullptr);
547 StringBuilder stringBuilder;
548 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
549 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
550 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
551 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
552 if ((mp->attributes_ & ATTR_OUT) != 0) {
553 tsCodeGen_->EmitWriteMethodParameter(mp, "reply", stringBuilder, CodeEmitter::TAB);
554 }
555 }
556 }
557 std::string data(stringBuilder.ToString().string());
558 EXPECT_TRUE(data.length());
559 EXPECT_NE(data.find("writeInt"), std::string::npos);
560 EXPECT_NE(data.find("writeLong"), std::string::npos);
561 EXPECT_NE(data.find("writeFloat"), std::string::npos);
562 EXPECT_NE(data.find("writeDouble"), std::string::npos);
563 EXPECT_NE(data.find("writeString"), std::string::npos);
564 EXPECT_NE(data.find("writeSequenceable"), std::string::npos);
565 EXPECT_NE(data.find("writeRemoteObject"), std::string::npos);
566 }
567
568 /*
569 * Feature: idl
570 * Function: EmitWriteMethodParameter
571 * SubFunction: NA
572 * FunctionPoints: EmitWriteMethodParameter validates the array type
573 * EnvConditions: NA
574 * CaseDescription: Array type keyword generated successfully
575 */
576 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteMethodParameter_004, TestSize.Level1)
577 {
578 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
579 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
580 int argc = 6;
581 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
582 ParameterArgv parameters(argvArray, argc);
583 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
584 EXPECT_NE(tsCodeGen_, nullptr);
585 StringBuilder stringBuilder;
586 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
587 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
588 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
589 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
590 if ((mp->attributes_ & ATTR_OUT) != 0) {
591 tsCodeGen_->EmitWriteMethodParameter(mp, "reply", stringBuilder, CodeEmitter::TAB);
592 }
593 }
594 }
595 EXPECT_TRUE(stringBuilder.ToString().IsEmpty());
596 }
597
598 /*
599 * Feature: idl
600 * Function: EmitWriteMethodParameter
601 * SubFunction: NA
602 * FunctionPoints: EmitWriteMethodParameter validates the array type
603 * EnvConditions: NA
604 * CaseDescription: Array type keyword generated successfully
605 */
606 HWTEST_F(TsCodeEmitterProxyTest, EmitWriteMethodParameter_005, TestSize.Level1)
607 {
608 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
609 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
610 int argc = 6;
611 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
612 ParameterArgv parameters(argvArray, argc);
613 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
614 EXPECT_NE(tsCodeGen_, nullptr);
615 StringBuilder stringBuilder;
616 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
617 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
618 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
619 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
620 if ((mp->attributes_ & ATTR_OUT) != 0) {
621 tsCodeGen_->EmitWriteMethodParameter(mp, "reply", stringBuilder, CodeEmitter::TAB);
622 }
623 }
624 }
625 std::string data(stringBuilder.ToString().string());
626 EXPECT_TRUE(data.length());
627 EXPECT_NE(data.find("writeInt"), std::string::npos);
628 EXPECT_NE(data.find("writeLong"), std::string::npos);
629 EXPECT_NE(data.find("writeFloat"), std::string::npos);
630 EXPECT_NE(data.find("writeDouble"), std::string::npos);
631 EXPECT_NE(data.find("writeString"), std::string::npos);
632 EXPECT_NE(data.find("writeSequenceable"), std::string::npos);
633 }
634
635 /*
636 * Feature: idl
637 * Function: EmitReadMethodParameter
638 * SubFunction: NA
639 * FunctionPoints: EmitReadMethodParameter validates the array type
640 * EnvConditions: NA
641 * CaseDescription: Array type keyword generated successfully
642 */
643 HWTEST_F(TsCodeEmitterProxyTest, EmitReadMethodParameter_001, TestSize.Level1)
644 {
645 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
646 int argc = 6;
647 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
648 ParameterArgv parameters(argvArray, argc);
649 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
650 EXPECT_NE(tsCodeGen_, nullptr);
651 StringBuilder stringBuilder;
652 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
653 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
654 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
655 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
656 if ((mp->attributes_ & ATTR_IN) != 0) {
657 tsCodeGen_->EmitReadMethodParameter(mp, "result.reply", stringBuilder, CodeEmitter::TAB);
658 }
659 }
660 }
661 std::string data(stringBuilder.ToString().string());
662 EXPECT_TRUE(data.length());
663 EXPECT_NE(data.find("readInt"), std::string::npos);
664 EXPECT_NE(data.find("readLong"), std::string::npos);
665 EXPECT_NE(data.find("readFloat"), std::string::npos);
666 EXPECT_NE(data.find("readDouble"), std::string::npos);
667 EXPECT_NE(data.find("readString"), std::string::npos);
668 EXPECT_NE(data.find("readSequenceable"), std::string::npos);
669 EXPECT_NE(data.find("readRemoteObject"), std::string::npos);
670 EXPECT_NE(data.find("new Map()"), std::string::npos);
671 }
672
673 /*
674 * Feature: idl
675 * Function: EmitReadMethodParameter
676 * SubFunction: NA
677 * FunctionPoints: EmitReadMethodParameter validates the array type
678 * EnvConditions: NA
679 * CaseDescription: Array type keyword generated successfully
680 */
681 HWTEST_F(TsCodeEmitterProxyTest, EmitReadMethodParameter_002, TestSize.Level1)
682 {
683 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
684 int argc = 6;
685 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
686 ParameterArgv parameters(argvArray, argc);
687 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
688 EXPECT_NE(tsCodeGen_, nullptr);
689 StringBuilder stringBuilder;
690 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
691 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
692 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
693 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
694 if ((mp->attributes_ & ATTR_OUT) != 0) {
695 tsCodeGen_->EmitReadMethodParameter(mp, "result.reply", stringBuilder, CodeEmitter::TAB);
696 }
697 }
698 }
699 std::string data(stringBuilder.ToString().string());
700 EXPECT_TRUE(data.length());
701 EXPECT_NE(data.find("readInt"), std::string::npos);
702 EXPECT_NE(data.find("readLong"), std::string::npos);
703 EXPECT_NE(data.find("readFloat"), std::string::npos);
704 EXPECT_NE(data.find("readDouble"), std::string::npos);
705 EXPECT_NE(data.find("readString"), std::string::npos);
706 EXPECT_NE(data.find("readSequenceable"), std::string::npos);
707 EXPECT_NE(data.find("readRemoteObject"), std::string::npos);
708 EXPECT_NE(data.find("new Map()"), std::string::npos);
709 }
710
711 /*
712 * Feature: idl
713 * Function: EmitReadMethodParameter
714 * SubFunction: NA
715 * FunctionPoints: EmitReadMethodParameter validates the array type
716 * EnvConditions: NA
717 * CaseDescription: Array type keyword generated successfully
718 */
719 HWTEST_F(TsCodeEmitterProxyTest, EmitReadMethodParameter_003, TestSize.Level1)
720 {
721 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
722 int argc = 6;
723 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
724 ParameterArgv parameters(argvArray, argc);
725 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
726 EXPECT_NE(tsCodeGen_, nullptr);
727 StringBuilder stringBuilder;
728 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
729 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
730 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
731 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
732 if ((mp->attributes_ & ATTR_OUT) != 0) {
733 tsCodeGen_->EmitReadMethodParameter(mp, "result.reply", stringBuilder, CodeEmitter::TAB);
734 }
735 }
736 }
737 std::string data(stringBuilder.ToString().string());
738 EXPECT_TRUE(data.length());
739 EXPECT_NE(data.find("readInt"), std::string::npos);
740 EXPECT_NE(data.find("readLong"), std::string::npos);
741 EXPECT_NE(data.find("readFloat"), std::string::npos);
742 EXPECT_NE(data.find("readDouble"), std::string::npos);
743 EXPECT_NE(data.find("readString"), std::string::npos);
744 EXPECT_NE(data.find("readSequenceable"), std::string::npos);
745 EXPECT_NE(data.find("readRemoteObject"), std::string::npos);
746 EXPECT_NE(data.find("new Map()"), std::string::npos);
747 }
748
749 /*
750 * Feature: idl
751 * Function: EmitReadMethodParameter
752 * SubFunction: NA
753 * FunctionPoints: EmitReadMethodParameter validates the array type
754 * EnvConditions: NA
755 * CaseDescription: Array type keyword generated successfully
756 */
757 HWTEST_F(TsCodeEmitterProxyTest, EmitReadMethodParameter_004, TestSize.Level1)
758 {
759 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
760 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
761 int argc = 6;
762 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
763 ParameterArgv parameters(argvArray, argc);
764 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
765 EXPECT_NE(tsCodeGen_, nullptr);
766 StringBuilder stringBuilder;
767 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
768 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
769 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
770 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
771 if ((mp->attributes_ & ATTR_OUT) != 0) {
772 tsCodeGen_->EmitReadMethodParameter(mp, "result.reply", stringBuilder, CodeEmitter::TAB);
773 }
774 }
775 }
776 EXPECT_TRUE(stringBuilder.ToString().IsEmpty());
777 }
778
779 /*
780 * Feature: idl
781 * Function: EmitReadMethodParameter
782 * SubFunction: NA
783 * FunctionPoints: EmitReadMethodParameter validates the array type
784 * EnvConditions: NA
785 * CaseDescription: Array type keyword generated successfully
786 */
787 HWTEST_F(TsCodeEmitterProxyTest, EmitReadMethodParameter_005, TestSize.Level1)
788 {
789 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
790 NORMAL_TYPE_COMBINATION_IDL_CONTENT2.c_str()), ERR_OK);
791 int argc = 6;
792 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
793 ParameterArgv parameters(argvArray, argc);
794 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
795 EXPECT_NE(tsCodeGen_, nullptr);
796 StringBuilder stringBuilder;
797 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
798 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
799 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
800 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
801 if ((mp->attributes_ & ATTR_OUT) != 0) {
802 tsCodeGen_->EmitReadMethodParameter(mp, "result.reply", stringBuilder, CodeEmitter::TAB);
803 }
804 }
805 }
806 std::string data(stringBuilder.ToString().string());
807 EXPECT_TRUE(data.length());
808 EXPECT_NE(data.find("readIntArray"), std::string::npos);
809 EXPECT_NE(data.find("readLongArray"), std::string::npos);
810 EXPECT_NE(data.find("readFloatArray"), std::string::npos);
811 EXPECT_NE(data.find("readStringArray"), std::string::npos);
812 }
813
814 /*
815 * Feature: idl
816 * Function: EmitReadOutVariable
817 * SubFunction: NA
818 * FunctionPoints: EmitReadOutVariable validates the array type
819 * EnvConditions: NA
820 * CaseDescription: Array type keyword generated successfully
821 */
822 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutVariable_001, TestSize.Level1)
823 {
824 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
825 int argc = 6;
826 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
827 ParameterArgv parameters(argvArray, argc);
828 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
829 EXPECT_NE(tsCodeGen_, nullptr);
830 StringBuilder stringBuilder;
831 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
832 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
833 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
834 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
835 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
836 if ((mp->attributes_ & ATTR_IN) != 0) {
837 tsCodeGen_->EmitReadOutVariable("result.reply", mp->name_, mt, stringBuilder, CodeEmitter::TAB);
838 }
839 }
840 }
841 std::string data(stringBuilder.ToString().string());
842 EXPECT_TRUE(data.length());
843 EXPECT_NE(data.find("readInt"), std::string::npos);
844 EXPECT_NE(data.find("readLong"), std::string::npos);
845 EXPECT_NE(data.find("readFloat"), std::string::npos);
846 EXPECT_NE(data.find("readDouble"), std::string::npos);
847 EXPECT_NE(data.find("readString"), std::string::npos);
848 EXPECT_NE(data.find("readSequenceable"), std::string::npos);
849 EXPECT_NE(data.find("readRemoteObject"), std::string::npos);
850 EXPECT_NE(data.find("new Map()"), std::string::npos);
851 }
852
853 /*
854 * Feature: idl
855 * Function: EmitReadOutVariable
856 * SubFunction: NA
857 * FunctionPoints: EmitReadOutVariable validates the array type
858 * EnvConditions: NA
859 * CaseDescription: Array type keyword generated successfully
860 */
861 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutVariable_002, TestSize.Level1)
862 {
863 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
864 int argc = 6;
865 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
866 ParameterArgv parameters(argvArray, argc);
867 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
868 EXPECT_NE(tsCodeGen_, nullptr);
869 StringBuilder stringBuilder;
870 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
871 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
872 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
873 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
874 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
875 if ((mp->attributes_ & ATTR_OUT) != 0) {
876 tsCodeGen_->EmitReadOutVariable("result.reply", mp->name_, mt, stringBuilder, CodeEmitter::TAB);
877 }
878 }
879 }
880 std::string data(stringBuilder.ToString().string());
881 EXPECT_TRUE(data.length());
882 EXPECT_NE(data.find("readInt"), std::string::npos);
883 EXPECT_NE(data.find("readLong"), std::string::npos);
884 EXPECT_NE(data.find("readFloat"), std::string::npos);
885 EXPECT_NE(data.find("readDouble"), std::string::npos);
886 EXPECT_NE(data.find("readString"), std::string::npos);
887 EXPECT_NE(data.find("readSequenceable"), std::string::npos);
888 EXPECT_NE(data.find("readRemoteObject"), std::string::npos);
889 EXPECT_NE(data.find("new Map()"), std::string::npos);
890 }
891
892 /*
893 * Feature: idl
894 * Function: EmitReadOutVariable
895 * SubFunction: NA
896 * FunctionPoints: EmitReadOutVariable validates the array type
897 * EnvConditions: NA
898 * CaseDescription: Array type keyword generated successfully
899 */
900 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutVariable_003, TestSize.Level1)
901 {
902 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
903 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
904 int argc = 6;
905 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
906 ParameterArgv parameters(argvArray, argc);
907 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
908 EXPECT_NE(tsCodeGen_, nullptr);
909 StringBuilder stringBuilder;
910 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
911 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
912 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
913 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
914 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
915 if ((mp->attributes_ & ATTR_OUT) != 0) {
916 tsCodeGen_->EmitReadOutVariable("result.reply", mp->name_, mt, stringBuilder, CodeEmitter::TAB);
917 }
918 }
919 }
920 std::string data(stringBuilder.ToString().string());
921 EXPECT_TRUE(data.length());
922 EXPECT_NE(data.find("readInt"), std::string::npos);
923 EXPECT_NE(data.find("readLong"), std::string::npos);
924 EXPECT_NE(data.find("readFloat"), std::string::npos);
925 EXPECT_NE(data.find("readDouble"), std::string::npos);
926 EXPECT_NE(data.find("readString"), std::string::npos);
927 EXPECT_NE(data.find("readSequenceable"), std::string::npos);
928 EXPECT_NE(data.find("readRemoteObject"), std::string::npos);
929 EXPECT_NE(data.find("new Map()"), std::string::npos);
930 }
931
932 /*
933 * Feature: idl
934 * Function: EmitReadOutVariable
935 * SubFunction: NA
936 * FunctionPoints: EmitReadOutVariable validates the array type
937 * EnvConditions: NA
938 * CaseDescription: Array type keyword generated successfully
939 */
940 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutVariable_004, TestSize.Level1)
941 {
942 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
943 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
944 int argc = 6;
945 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
946 ParameterArgv parameters(argvArray, argc);
947 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
948 EXPECT_NE(tsCodeGen_, nullptr);
949 StringBuilder stringBuilder;
950 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
951 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
952 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
953 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
954 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
955 if ((mp->attributes_ & ATTR_OUT) != 0) {
956 tsCodeGen_->EmitReadOutVariable("result.reply", mp->name_, mt, stringBuilder, CodeEmitter::TAB);
957 }
958 }
959 }
960 EXPECT_TRUE(stringBuilder.ToString().IsEmpty());
961 }
962
963 /*
964 * Feature: idl
965 * Function: EmitReadOutVariable
966 * SubFunction: NA
967 * FunctionPoints: EmitReadOutVariable validates the array type
968 * EnvConditions: NA
969 * CaseDescription: Array type keyword generated successfully
970 */
971 HWTEST_F(TsCodeEmitterProxyTest, EmitReadOutVariable_005, TestSize.Level1)
972 {
973 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
974 NORMAL_TYPE_COMBINATION_IDL_CONTENT2.c_str()), ERR_OK);
975 int argc = 6;
976 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
977 ParameterArgv parameters(argvArray, argc);
978 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
979 EXPECT_NE(tsCodeGen_, nullptr);
980 StringBuilder stringBuilder;
981 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
982 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
983 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
984 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
985 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
986 if ((mp->attributes_ & ATTR_OUT) != 0) {
987 tsCodeGen_->EmitReadOutVariable("result.reply", mp->name_, mt, stringBuilder, CodeEmitter::TAB);
988 }
989 }
990 }
991 std::string data(stringBuilder.ToString().string());
992 EXPECT_TRUE(data.length());
993 EXPECT_NE(data.find("readIntArray"), std::string::npos);
994 EXPECT_NE(data.find("readLongArray"), std::string::npos);
995 EXPECT_NE(data.find("readFloatArray"), std::string::npos);
996 EXPECT_NE(data.find("readStringArray"), std::string::npos);
997 }
998
999 /*
1000 * Feature: idl
1001 * Function: EmitLicense
1002 * SubFunction: NA
1003 * FunctionPoints: TsCodeEmitter EmitLicense
1004 * EnvConditions: NA
1005 * CaseDescription: Incoming normal license, stringBuilder appended the license.
1006 */
1007 HWTEST_F(TsCodeEmitterProxyTest, EmitLicense_001, TestSize.Level1)
1008 {
1009 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1010 int argc = 6;
1011 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1012 ParameterArgv parameters(argvArray, argc);
1013 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1014 EXPECT_NE(tsCodeGen_, nullptr);
1015 StringBuilder stringBuilder;
1016 tsCodeGen_->EmitLicense(stringBuilder);
1017
1018 std::string data(stringBuilder.ToString().string());
1019 EXPECT_TRUE(data.length());
1020 EXPECT_NE(data.find("Ltd."), std::string::npos);
1021 }
1022
1023 /*
1024 * Feature: idl
1025 * Function: EmitLicense
1026 * SubFunction: NA
1027 * FunctionPoints: TsCodeEmitter EmitLicense
1028 * EnvConditions: NA
1029 * CaseDescription: Incoming null license, stringBuilder not have content.
1030 */
1031 HWTEST_F(TsCodeEmitterProxyTest, EmitLicense_002, TestSize.Level1)
1032 {
1033 std::string fileLicense;
1034 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1035 NORMAL_TYPE_IN_IDL_CONTENT.c_str(), fileLicense), ERR_OK);
1036 int argc = 6;
1037 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1038 ParameterArgv parameters(argvArray, argc);
1039 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1040 EXPECT_NE(tsCodeGen_, nullptr);
1041 StringBuilder stringBuilder;
1042 tsCodeGen_->EmitLicense(stringBuilder);
1043
1044 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1045 std::string data(stringBuilder.ToString().string());
1046 std::string value = "\n";
1047 EXPECT_EQ(data, value);
1048 }
1049
1050 /*
1051 * Feature: idl
1052 * Function: EmitType
1053 * SubFunction: NA
1054 * FunctionPoints: TsCodeEmitter EmitType
1055 * EnvConditions: NA
1056 * CaseDescription: Incoming differernt metaType, return expected data type.
1057 */
1058 HWTEST_F(TsCodeEmitterProxyTest, EmitType_001, TestSize.Level1)
1059 {
1060 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1061 NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1062 int argc = 6;
1063 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1064 ParameterArgv parameters(argvArray, argc);
1065 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1066 EXPECT_NE(tsCodeGen_, nullptr);
1067 StringBuilder stringBuilder;
1068 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1069 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1070 for (int parameterIndex = 0; parameterIndex < metaMethod->parameterNumber_; parameterIndex++) {
1071 MetaParameter* mp = metaMethod->parameters_[parameterIndex];
1072 MetaType* mt = tsCodeGen_->metaComponent_->types_[mp->typeIndex_];
1073 String result = tsCodeGen_->EmitType(mt);
1074 stringBuilder.Append(result.string());
1075 }
1076 }
1077 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1078 std::string data = stringBuilder.ToString().string();
1079 EXPECT_TRUE(data.length());
1080 EXPECT_NE(data.find("void"), std::string::npos);
1081 EXPECT_NE(data.find("number"), std::string::npos);
1082 EXPECT_NE(data.find("string"), std::string::npos);
1083 EXPECT_NE(data.find("MySequenceable"), std::string::npos);
1084 EXPECT_NE(data.find("IInterfaceDeclare"), std::string::npos);
1085 EXPECT_NE(data.find("boolean[]"), std::string::npos);
1086 EXPECT_NE(data.find("string[]"), std::string::npos);
1087 EXPECT_NE(data.find("number[]"), std::string::npos);
1088 EXPECT_NE(data.find("MySequenceable[]"), std::string::npos);
1089 }
1090
1091 /*
1092 * Feature: idl
1093 * Function: FileName
1094 * SubFunction: NA
1095 * FunctionPoints: TsCodeEmitter EmitType
1096 * EnvConditions: NA
1097 * CaseDescription: Incoming differernt filename, return expected filename.
1098 */
1099 HWTEST_F(TsCodeEmitterProxyTest, FileName_001, TestSize.Level1)
1100 {
1101 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1102 int argc = 6;
1103 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1104 ParameterArgv parameters(argvArray, argc);
1105 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1106 EXPECT_NE(tsCodeGen_, nullptr);
1107 String param1;
1108 EXPECT_TRUE(tsCodeGen_->FileName(param1).Equals(param1));
1109 String param2("testFileName");
1110 EXPECT_TRUE(tsCodeGen_->FileName(param2).Equals("test_file_name"));
1111 String param3("app.data.testFileName");
1112 EXPECT_TRUE(tsCodeGen_->FileName(param3).Equals("app/data/test_file_name"));
1113 String param4("testfile");
1114 EXPECT_TRUE(tsCodeGen_->FileName(param4).Equals("testfile"));
1115 }
1116
1117 /*
1118 * Feature: idl
1119 * Function: EmitWriteArrayVariable
1120 * SubFunction: NA
1121 * FunctionPoints: Generate proxy code.
1122 * EnvConditions: NA
1123 * CaseDescription: Verify key strings in proxy code.
1124 */
1125 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyImpl_001, TestSize.Level1)
1126 {
1127 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
1128 int argc = 6;
1129 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1130 ParameterArgv parameters(argvArray, argc);
1131 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1132 EXPECT_NE(tsCodeGen_, nullptr);
1133 StringBuilder stringBuilder;
1134 tsCodeGen_->EmitInterface();
1135 tsCodeGen_->EmitInterfaceProxyImpl(stringBuilder);
1136 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1137 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1138 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1139 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1140 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1141 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1142 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1143 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1144 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1145 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1146 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1147 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
1148 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
1149 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
1150 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1151 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
1152 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1153 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1154 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1155 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1156 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1157 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1158 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1159 }
1160
1161 /*
1162 * Feature: idl
1163 * Function: EmitWriteArrayVariable
1164 * SubFunction: NA
1165 * FunctionPoints: Generate proxy code.
1166 * EnvConditions: NA
1167 * CaseDescription: Verify key strings in proxy code.
1168 */
1169 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyImpl_002, TestSize.Level1)
1170 {
1171 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1172 int argc = 6;
1173 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1174 ParameterArgv parameters(argvArray, argc);
1175 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1176 EXPECT_NE(tsCodeGen_, nullptr);
1177 StringBuilder stringBuilder;
1178 tsCodeGen_->EmitInterface();
1179 tsCodeGen_->EmitInterfaceProxyImpl(stringBuilder);
1180 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1181 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1182 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1183 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1184 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1185 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1186 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1187 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1188 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1189 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
1190 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
1191 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
1192 EXPECT_EQ(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1193 EXPECT_EQ(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1194 EXPECT_EQ(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1195 EXPECT_EQ(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1196 EXPECT_EQ(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1197 EXPECT_EQ(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1198 EXPECT_EQ(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1199 EXPECT_EQ(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1200 EXPECT_EQ(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1201 }
1202
1203 /*
1204 * Feature: idl
1205 * Function: EmitWriteArrayVariable
1206 * SubFunction: NA
1207 * FunctionPoints: Generate proxy code.
1208 * EnvConditions: NA
1209 * CaseDescription: Verify key strings in proxy code.
1210 */
1211 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyImpl_003, TestSize.Level1)
1212 {
1213 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1214 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
1215 int argc = 6;
1216 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1217 ParameterArgv parameters(argvArray, argc);
1218 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1219 EXPECT_NE(tsCodeGen_, nullptr);
1220 StringBuilder stringBuilder;
1221 tsCodeGen_->EmitInterface();
1222 tsCodeGen_->EmitInterfaceProxyImpl(stringBuilder);
1223 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1224 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1225 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1226 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1227 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1228 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1229 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1230 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1231 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1232 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1233 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
1234 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
1235 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
1236 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1237 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1238 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1239 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1240 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1241 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1242 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1243 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1244 }
1245
1246 /*
1247 * Feature: idl
1248 * Function: EmitWriteArrayVariable
1249 * SubFunction: NA
1250 * FunctionPoints: Generate proxy code.
1251 * EnvConditions: NA
1252 * CaseDescription: Verify key strings in proxy code.
1253 */
1254 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyImpl_004, TestSize.Level1)
1255 {
1256 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1257 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
1258 int argc = 6;
1259 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1260 ParameterArgv parameters(argvArray, argc);
1261 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1262 EXPECT_NE(tsCodeGen_, nullptr);
1263 StringBuilder stringBuilder;
1264 tsCodeGen_->EmitInterface();
1265 tsCodeGen_->EmitInterfaceProxyImpl(stringBuilder);
1266 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1267 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1268 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1269 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1270 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1271 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1272 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1273 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1274 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1275 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1276 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1277 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
1278 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
1279 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
1280 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1281 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
1282 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1283 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1284 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1285 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1286 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1287 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1288 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1289 }
1290
1291 /*
1292 * Feature: idl
1293 * Function: EmitWriteArrayVariable
1294 * SubFunction: NA
1295 * FunctionPoints: Generate proxy code.
1296 * EnvConditions: NA
1297 * CaseDescription: Verify key strings in proxy code.
1298 */
1299 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyImpl_005, TestSize.Level1)
1300 {
1301 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1302 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
1303 int argc = 6;
1304 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1305 ParameterArgv parameters(argvArray, argc);
1306 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1307 EXPECT_NE(tsCodeGen_, nullptr);
1308 StringBuilder stringBuilder;
1309 tsCodeGen_->EmitInterface();
1310 tsCodeGen_->EmitInterfaceProxyImpl(stringBuilder);
1311 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1312 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1313 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1314 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1315 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1316 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1317 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1318 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1319 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1320 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1321 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
1322 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
1323 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
1324 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1325 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1326 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1327 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1328 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1329 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1330 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1331 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1332 }
1333
1334 /*
1335 * Feature: idl
1336 * Function: EmitInterfaceProxyConstructor
1337 * SubFunction: NA
1338 * FunctionPoints: Proxy Constructor.
1339 * EnvConditions: NA
1340 * CaseDescription: Verify Proxy Constructor.
1341 */
1342 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyConstructor_001, TestSize.Level1)
1343 {
1344 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
1345 int argc = 6;
1346 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1347 ParameterArgv parameters(argvArray, argc);
1348 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1349 EXPECT_NE(tsCodeGen_, nullptr);
1350 StringBuilder stringBuilder;
1351 tsCodeGen_->EmitInterfaceProxyConstructor(stringBuilder, CodeEmitter::TAB);
1352 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1353 EXPECT_NE(stringBuilder.ToString().IndexOf("constructor("), ERR_FAIL);
1354 }
1355
1356 /*
1357 * Feature: idl
1358 * Function: EmitInterfaceProxyConstructor
1359 * SubFunction: NA
1360 * FunctionPoints: Proxy Constructor.
1361 * EnvConditions: NA
1362 * CaseDescription: Verify Proxy Constructor.
1363 */
1364 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyConstructor_002, TestSize.Level1)
1365 {
1366 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1367 int argc = 6;
1368 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1369 ParameterArgv parameters(argvArray, argc);
1370 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1371 EXPECT_NE(tsCodeGen_, nullptr);
1372 StringBuilder stringBuilder;
1373 tsCodeGen_->EmitInterfaceProxyConstructor(stringBuilder, CodeEmitter::TAB);
1374 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1375 EXPECT_NE(stringBuilder.ToString().IndexOf("constructor("), ERR_FAIL);
1376 }
1377
1378 /*
1379 * Feature: idl
1380 * Function: EmitInterfaceProxyConstructor
1381 * SubFunction: NA
1382 * FunctionPoints: Proxy Constructor.
1383 * EnvConditions: NA
1384 * CaseDescription: Verify Proxy Constructor.
1385 */
1386 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyConstructor_003, TestSize.Level1)
1387 {
1388 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1389 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
1390 int argc = 6;
1391 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1392 ParameterArgv parameters(argvArray, argc);
1393 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1394 EXPECT_NE(tsCodeGen_, nullptr);
1395 StringBuilder stringBuilder;
1396 tsCodeGen_->EmitInterfaceProxyConstructor(stringBuilder, CodeEmitter::TAB);
1397 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1398 EXPECT_NE(stringBuilder.ToString().IndexOf("constructor("), ERR_FAIL);
1399 }
1400
1401 /*
1402 * Feature: idl
1403 * Function: EmitInterfaceProxyConstructor
1404 * SubFunction: NA
1405 * FunctionPoints: Proxy Constructor.
1406 * EnvConditions: NA
1407 * CaseDescription: Verify Proxy Constructor.
1408 */
1409 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyConstructor_004, TestSize.Level1)
1410 {
1411 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1412 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
1413 int argc = 6;
1414 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1415 ParameterArgv parameters(argvArray, argc);
1416 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1417 EXPECT_NE(tsCodeGen_, nullptr);
1418 StringBuilder stringBuilder;
1419 tsCodeGen_->EmitInterfaceProxyConstructor(stringBuilder, CodeEmitter::TAB);
1420 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1421 EXPECT_NE(stringBuilder.ToString().IndexOf("constructor("), ERR_FAIL);
1422 }
1423
1424 /*
1425 * Feature: idl
1426 * Function: EmitInterfaceProxyConstructor
1427 * SubFunction: NA
1428 * FunctionPoints: Proxy Constructor.
1429 * EnvConditions: NA
1430 * CaseDescription: Verify Proxy Constructor.
1431 */
1432 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyConstructor_005, TestSize.Level1)
1433 {
1434 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1435 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
1436 int argc = 6;
1437 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1438 ParameterArgv parameters(argvArray, argc);
1439 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1440 EXPECT_NE(tsCodeGen_, nullptr);
1441 StringBuilder stringBuilder;
1442 tsCodeGen_->EmitInterfaceProxyConstructor(stringBuilder, CodeEmitter::TAB);
1443 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1444 EXPECT_NE(stringBuilder.ToString().IndexOf("constructor("), ERR_FAIL);
1445 }
1446
1447 /*
1448 * Feature: idl
1449 * Function: EmitInterfaceProxyMethodImpls
1450 * SubFunction: NA
1451 * FunctionPoints: Generate proxy Method Impls.
1452 * EnvConditions: NA
1453 * CaseDescription: Verify key strings in proxy code.
1454 */
1455 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpls_001, TestSize.Level1)
1456 {
1457 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
1458 int argc = 6;
1459 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1460 ParameterArgv parameters(argvArray, argc);
1461 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1462 EXPECT_NE(tsCodeGen_, nullptr);
1463 StringBuilder stringBuilder;
1464 tsCodeGen_->EmitInterface();
1465 tsCodeGen_->EmitInterfaceProxyMethodImpls(stringBuilder, CodeEmitter::TAB);
1466 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1467 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1468 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1469 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1470 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1471 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1472 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1473 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1474 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1475 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1476 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1477 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1478 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
1479 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1480 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1481 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1482 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1483 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1484 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1485 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1486 }
1487
1488 /*
1489 * Feature: idl
1490 * Function: EmitInterfaceProxyMethodImpls
1491 * SubFunction: NA
1492 * FunctionPoints: Generate proxy Method Impls.
1493 * EnvConditions: NA
1494 * CaseDescription: Verify key strings in proxy code.
1495 */
1496 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpls_002, TestSize.Level1)
1497 {
1498 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1499 int argc = 6;
1500 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1501 ParameterArgv parameters(argvArray, argc);
1502 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1503 EXPECT_NE(tsCodeGen_, nullptr);
1504 StringBuilder stringBuilder;
1505 tsCodeGen_->EmitInterface();
1506 tsCodeGen_->EmitInterfaceProxyMethodImpls(stringBuilder, CodeEmitter::TAB);
1507 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1508 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1509 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1510 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1511 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1512 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1513 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1514 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1515 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1516 EXPECT_EQ(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1517 EXPECT_EQ(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1518 EXPECT_EQ(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1519 EXPECT_EQ(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1520 EXPECT_EQ(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1521 EXPECT_EQ(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1522 EXPECT_EQ(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1523 EXPECT_EQ(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1524 EXPECT_EQ(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1525 }
1526
1527 /*
1528 * Feature: idl
1529 * Function: EmitInterfaceProxyMethodImpls
1530 * SubFunction: NA
1531 * FunctionPoints: Generate proxy Method Impls.
1532 * EnvConditions: NA
1533 * CaseDescription: Verify key strings in proxy code.
1534 */
1535 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpls_003, TestSize.Level1)
1536 {
1537 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1538 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
1539 int argc = 6;
1540 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1541 ParameterArgv parameters(argvArray, argc);
1542 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1543 EXPECT_NE(tsCodeGen_, nullptr);
1544 StringBuilder stringBuilder;
1545 tsCodeGen_->EmitInterface();
1546 tsCodeGen_->EmitInterfaceProxyMethodImpls(stringBuilder, CodeEmitter::TAB);
1547 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1548 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1549 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1550 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1551 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1552 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1553 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1554 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1555 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1556 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1557 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1558 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1559 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1560 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1561 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1562 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1563 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1564 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1565 }
1566
1567 /*
1568 * Feature: idl
1569 * Function: EmitInterfaceProxyMethodImpls
1570 * SubFunction: NA
1571 * FunctionPoints: Generate proxy Method Impls.
1572 * EnvConditions: NA
1573 * CaseDescription: Verify key strings in proxy code.
1574 */
1575 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpls_004, TestSize.Level1)
1576 {
1577 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1578 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
1579 int argc = 6;
1580 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1581 ParameterArgv parameters(argvArray, argc);
1582 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1583 EXPECT_NE(tsCodeGen_, nullptr);
1584 StringBuilder stringBuilder;
1585 tsCodeGen_->EmitInterface();
1586 tsCodeGen_->EmitInterfaceProxyMethodImpls(stringBuilder, CodeEmitter::TAB);
1587 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1588 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1589 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1590 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1591 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1592 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1593 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1594 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1595 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1596 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1597 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1598 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1599 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
1600 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1601 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1602 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1603 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1604 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1605 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1606 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1607 }
1608
1609 /*
1610 * Feature: idl
1611 * Function: EmitInterfaceProxyMethodImpls
1612 * SubFunction: NA
1613 * FunctionPoints: Generate proxy Method Impls.
1614 * EnvConditions: NA
1615 * CaseDescription: Verify key strings in proxy code.
1616 */
1617 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpls_005, TestSize.Level1)
1618 {
1619 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1620 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
1621 int argc = 6;
1622 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1623 ParameterArgv parameters(argvArray, argc);
1624 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1625 EXPECT_NE(tsCodeGen_, nullptr);
1626 StringBuilder stringBuilder;
1627 tsCodeGen_->EmitInterface();
1628 tsCodeGen_->EmitInterfaceProxyMethodImpls(stringBuilder, CodeEmitter::TAB);
1629 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1630 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1631 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1632 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1633 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1634 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1635 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1636 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1637 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1638 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1639 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1640 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1641 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1642 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1643 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1644 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1645 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1646 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1647 }
1648
1649 /*
1650 * Feature: idl
1651 * Function: EmitInterfaceProxyMethodImpl
1652 * SubFunction: NA
1653 * FunctionPoints: Generate proxy Method Impl.
1654 * EnvConditions: NA
1655 * CaseDescription: Verify key strings in proxy code.
1656 */
1657 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpl_001, TestSize.Level1)
1658 {
1659 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
1660 int argc = 6;
1661 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1662 ParameterArgv parameters(argvArray, argc);
1663 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1664 EXPECT_NE(tsCodeGen_, nullptr);
1665 StringBuilder stringBuilder;
1666 tsCodeGen_->EmitInterface();
1667 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1668 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1669 tsCodeGen_->EmitInterfaceProxyMethodImpl(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1670 }
1671 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1672 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1673 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1674 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1675 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1676 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1677 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1678 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1679 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1680 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1681 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1682 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1683 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
1684 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1685 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1686 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1687 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1688 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1689 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1690 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1691 }
1692
1693 /*
1694 * Feature: idl
1695 * Function: EmitInterfaceProxyMethodImpl
1696 * SubFunction: NA
1697 * FunctionPoints: Generate proxy Method Impl.
1698 * EnvConditions: NA
1699 * CaseDescription: Verify key strings in proxy code.
1700 */
1701 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpl_002, TestSize.Level1)
1702 {
1703 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1704 int argc = 6;
1705 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1706 ParameterArgv parameters(argvArray, argc);
1707 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1708 EXPECT_NE(tsCodeGen_, nullptr);
1709 StringBuilder stringBuilder;
1710 tsCodeGen_->EmitInterface();
1711 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1712 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1713 tsCodeGen_->EmitInterfaceProxyMethodImpl(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1714 }
1715 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1716 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1717 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1718 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1719 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1720 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1721 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1722 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1723 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1724 EXPECT_EQ(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1725 EXPECT_EQ(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1726 EXPECT_EQ(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1727 EXPECT_EQ(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1728 EXPECT_EQ(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1729 EXPECT_EQ(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1730 EXPECT_EQ(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1731 EXPECT_EQ(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1732 EXPECT_EQ(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1733 }
1734
1735 /*
1736 * Feature: idl
1737 * Function: EmitInterfaceProxyMethodImpl
1738 * SubFunction: NA
1739 * FunctionPoints: Generate proxy Method Impl.
1740 * EnvConditions: NA
1741 * CaseDescription: Verify key strings in proxy code.
1742 */
1743 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpl_003, TestSize.Level1)
1744 {
1745 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1746 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
1747 int argc = 6;
1748 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1749 ParameterArgv parameters(argvArray, argc);
1750 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1751 EXPECT_NE(tsCodeGen_, nullptr);
1752 StringBuilder stringBuilder;
1753 tsCodeGen_->EmitInterface();
1754 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1755 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1756 tsCodeGen_->EmitInterfaceProxyMethodImpl(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1757 }
1758 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1759 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1760 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1761 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1762 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1763 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1764 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1765 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1766 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1767 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1768 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1769 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1770 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1771 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1772 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1773 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1774 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1775 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1776 }
1777
1778 /*
1779 * Feature: idl
1780 * Function: EmitInterfaceProxyMethodImpl
1781 * SubFunction: NA
1782 * FunctionPoints: Generate proxy Method Impl.
1783 * EnvConditions: NA
1784 * CaseDescription: Verify key strings in proxy code.
1785 */
1786 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpl_004, TestSize.Level1)
1787 {
1788 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1789 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
1790 int argc = 6;
1791 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1792 ParameterArgv parameters(argvArray, argc);
1793 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1794 EXPECT_NE(tsCodeGen_, nullptr);
1795 StringBuilder stringBuilder;
1796 tsCodeGen_->EmitInterface();
1797 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1798 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1799 tsCodeGen_->EmitInterfaceProxyMethodImpl(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1800 }
1801 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1802 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1803 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1804 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1805 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1806 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1807 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1808 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1809 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1810 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1811 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1812 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1813 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
1814 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1815 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1816 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1817 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1818 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1819 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1820 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1821 }
1822
1823 /*
1824 * Feature: idl
1825 * Function: EmitInterfaceProxyMethodImpl
1826 * SubFunction: NA
1827 * FunctionPoints: Generate proxy Method Impl.
1828 * EnvConditions: NA
1829 * CaseDescription: Verify key strings in proxy code.
1830 */
1831 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodImpl_005, TestSize.Level1)
1832 {
1833 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1834 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
1835 int argc = 6;
1836 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1837 ParameterArgv parameters(argvArray, argc);
1838 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1839 EXPECT_NE(tsCodeGen_, nullptr);
1840 StringBuilder stringBuilder;
1841 tsCodeGen_->EmitInterface();
1842 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1843 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1844 tsCodeGen_->EmitInterfaceProxyMethodImpl(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1845 }
1846 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1847 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1848 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1849 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1850 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1851 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1852 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1853 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1854 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1855 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1856 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1857 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1858 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1859 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1860 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1861 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1862 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1863 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1864 }
1865
1866 /*
1867 * Feature: idl
1868 * Function: EmitInterfaceProxyMethodBody
1869 * SubFunction: NA
1870 * FunctionPoints: Generate proxy Method Body.
1871 * EnvConditions: NA
1872 * CaseDescription: Verify key strings in proxy code.
1873 */
1874 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodBody_001, TestSize.Level1)
1875 {
1876 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
1877 int argc = 6;
1878 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1879 ParameterArgv parameters(argvArray, argc);
1880 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1881 EXPECT_NE(tsCodeGen_, nullptr);
1882 StringBuilder stringBuilder;
1883 tsCodeGen_->EmitInterface();
1884 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1885 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1886 tsCodeGen_->EmitInterfaceProxyMethodBody(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1887 }
1888 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1889 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1890 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1891 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1892 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1893 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1894 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1895 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1896 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1897 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1898 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1899 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1900 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
1901 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1902 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1903 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1904 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1905 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1906 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1907 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1908 }
1909
1910 /*
1911 * Feature: idl
1912 * Function: EmitInterfaceProxyMethodBody
1913 * SubFunction: NA
1914 * FunctionPoints: Generate proxy Method Body.
1915 * EnvConditions: NA
1916 * CaseDescription: Verify key strings in proxy code.
1917 */
1918 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodBody_002, TestSize.Level1)
1919 {
1920 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
1921 int argc = 6;
1922 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1923 ParameterArgv parameters(argvArray, argc);
1924 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1925 EXPECT_NE(tsCodeGen_, nullptr);
1926 StringBuilder stringBuilder;
1927 tsCodeGen_->EmitInterface();
1928 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1929 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1930 tsCodeGen_->EmitInterfaceProxyMethodBody(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1931 }
1932 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
1933 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1934 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1935 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1936 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1937 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1938 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1939 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1940 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1941 EXPECT_EQ(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1942 EXPECT_EQ(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1943 EXPECT_EQ(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1944 EXPECT_EQ(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1945 EXPECT_EQ(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1946 EXPECT_EQ(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1947 EXPECT_EQ(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1948 EXPECT_EQ(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1949 EXPECT_EQ(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1950 }
1951
1952 /*
1953 * Feature: idl
1954 * Function: EmitInterfaceProxyMethodBody
1955 * SubFunction: NA
1956 * FunctionPoints: Generate proxy Method Body.
1957 * EnvConditions: NA
1958 * CaseDescription: Verify key strings in proxy code.
1959 */
1960 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodBody_003, TestSize.Level1)
1961 {
1962 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
1963 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
1964 int argc = 6;
1965 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
1966 ParameterArgv parameters(argvArray, argc);
1967 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
1968 EXPECT_NE(tsCodeGen_, nullptr);
1969 StringBuilder stringBuilder;
1970 tsCodeGen_->EmitInterface();
1971 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
1972 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
1973 tsCodeGen_->EmitInterfaceProxyMethodBody(metaMethod, index, stringBuilder, CodeEmitter::TAB);
1974 }
1975 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
1976 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
1977 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
1978 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
1979 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
1980 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
1981 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
1982 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
1983 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
1984 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
1985 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
1986 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
1987 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
1988 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
1989 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
1990 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
1991 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
1992 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
1993 }
1994
1995 /*
1996 * Feature: idl
1997 * Function: EmitInterfaceProxyMethodBody
1998 * SubFunction: NA
1999 * FunctionPoints: Generate proxy Method Body.
2000 * EnvConditions: NA
2001 * CaseDescription: Verify key strings in proxy code.
2002 */
2003 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodBody_004, TestSize.Level1)
2004 {
2005 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
2006 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
2007 int argc = 6;
2008 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2009 ParameterArgv parameters(argvArray, argc);
2010 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2011 EXPECT_NE(tsCodeGen_, nullptr);
2012 StringBuilder stringBuilder;
2013 tsCodeGen_->EmitInterface();
2014 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
2015 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
2016 tsCodeGen_->EmitInterfaceProxyMethodBody(metaMethod, index, stringBuilder, CodeEmitter::TAB);
2017 }
2018 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
2019 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
2020 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
2021 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
2022 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
2023 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
2024 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
2025 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
2026 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
2027 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
2028 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
2029 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
2030 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
2031 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
2032 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
2033 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
2034 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
2035 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
2036 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
2037 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
2038 }
2039
2040 /*
2041 * Feature: idl
2042 * Function: EmitInterfaceProxyMethodBody
2043 * SubFunction: NA
2044 * FunctionPoints: Generate proxy Method Body.
2045 * EnvConditions: NA
2046 * CaseDescription: Verify key strings in proxy code.
2047 */
2048 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxyMethodBody_005, TestSize.Level1)
2049 {
2050 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
2051 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
2052 int argc = 6;
2053 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2054 ParameterArgv parameters(argvArray, argc);
2055 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2056 EXPECT_NE(tsCodeGen_, nullptr);
2057 StringBuilder stringBuilder;
2058 tsCodeGen_->EmitInterface();
2059 for (int index = 0; index < tsCodeGen_->metaInterface_->methodNumber_; index++) {
2060 MetaMethod* metaMethod = tsCodeGen_->metaInterface_->methods_[index];
2061 tsCodeGen_->EmitInterfaceProxyMethodBody(metaMethod, index, stringBuilder, CodeEmitter::TAB);
2062 }
2063 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
2064 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
2065 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
2066 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
2067 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
2068 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
2069 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
2070 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
2071 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
2072 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
2073 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
2074 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
2075 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
2076 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
2077 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
2078 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
2079 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
2080 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
2081 }
2082
2083
2084 /*
2085 * Feature: idl
2086 * Function: EmitWriteArrayVariable
2087 * SubFunction: NA
2088 * FunctionPoints: Generate proxy code.
2089 * EnvConditions: NA
2090 * CaseDescription: Verify key strings in proxy code.
2091 */
2092 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxy_001, TestSize.Level1)
2093 {
2094 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2095 int argc = 6;
2096 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2097 ParameterArgv parameters(argvArray, argc);
2098 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2099 EXPECT_NE(tsCodeGen_, nullptr);
2100 StringBuilder stringBuilder;
2101 tsCodeGen_->EmitInterface();
2102 tsCodeGen_->EmitInterfaceProxy();
2103 String filePath = String::Format("%s/%s", "./", "idl_test_proxy.ts");
2104 File file(filePath, File::READ);
2105 MetaComponent header;
2106 EXPECT_TRUE(file.ReadData((void*)&header, sizeof(MetaComponent)));
2107 EXPECT_TRUE(file.Reset());
2108 char* fileData = new char[header.size_];
2109 file.ReadData(static_cast<void*>(fileData), header.size_);
2110 stringBuilder.Append(fileData);
2111 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
2112 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
2113 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
2114 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
2115 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
2116 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
2117 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
2118 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
2119 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
2120 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
2121 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
2122 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
2123 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
2124 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
2125 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
2126 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
2127 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
2128 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
2129 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
2130 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
2131 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
2132 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
2133 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
2134 delete[] fileData;
2135 }
2136
2137 /*
2138 * Feature: idl
2139 * Function: EmitWriteArrayVariable
2140 * SubFunction: NA
2141 * FunctionPoints: Generate proxy code.
2142 * EnvConditions: NA
2143 * CaseDescription: Verify key strings in proxy code.
2144 */
2145 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxy_002, TestSize.Level1)
2146 {
2147 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_IN_IDL_CONTENT.c_str()), ERR_OK);
2148 int argc = 6;
2149 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2150 ParameterArgv parameters(argvArray, argc);
2151 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2152 EXPECT_NE(tsCodeGen_, nullptr);
2153 StringBuilder stringBuilder;
2154 tsCodeGen_->EmitInterface();
2155 tsCodeGen_->EmitInterfaceProxy();
2156 std::string tsProxyStr;
2157 std::ifstream tsProxyInputStream;
2158 tsProxyInputStream.open("idl_test_proxy.ts");
2159 std::stringstream tsProxyStrStream;
2160 tsProxyStrStream << tsProxyInputStream.rdbuf();
2161 tsProxyInputStream.close();
2162 tsProxyStr = tsProxyStrStream.str();
2163 tsProxyStrStream.clear();
2164 tsProxyStrStream.str("");
2165 const char* fileData = tsProxyStr.data();
2166 stringBuilder.Append(fileData);
2167 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
2168 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
2169 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
2170 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
2171 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
2172 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
2173 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
2174 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
2175 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
2176 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
2177 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
2178 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
2179 EXPECT_EQ(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
2180 EXPECT_EQ(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
2181 EXPECT_EQ(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
2182 EXPECT_EQ(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
2183 EXPECT_EQ(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
2184 EXPECT_EQ(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
2185 EXPECT_EQ(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
2186 EXPECT_EQ(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
2187 EXPECT_EQ(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
2188 }
2189
2190 /*
2191 * Feature: idl
2192 * Function: EmitWriteArrayVariable
2193 * SubFunction: NA
2194 * FunctionPoints: Generate proxy code.
2195 * EnvConditions: NA
2196 * CaseDescription: Verify key strings in proxy code.
2197 */
2198 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxy_003, TestSize.Level1)
2199 {
2200 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
2201 NORMAL_TYPE_IN_AND_OUT_IDL_CONTENT.c_str()), ERR_OK);
2202 int argc = 6;
2203 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2204 ParameterArgv parameters(argvArray, argc);
2205 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2206 EXPECT_NE(tsCodeGen_, nullptr);
2207 StringBuilder stringBuilder;
2208 tsCodeGen_->EmitInterface();
2209 tsCodeGen_->EmitInterfaceProxy();
2210 String filePath = String::Format("%s/%s", "./", "idl_test_proxy.ts");
2211 File file(filePath, File::READ);
2212 MetaComponent header;
2213 EXPECT_TRUE(file.ReadData((void*)&header, sizeof(MetaComponent)));
2214 EXPECT_TRUE(file.Reset());
2215 char* fileData = new char[header.size_];
2216 file.ReadData(static_cast<void*>(fileData), header.size_);
2217 stringBuilder.Append(fileData);
2218 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
2219 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
2220 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
2221 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
2222 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
2223 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
2224 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
2225 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
2226 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
2227 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
2228 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
2229 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
2230 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
2231 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
2232 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
2233 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
2234 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
2235 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
2236 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
2237 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
2238 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
2239 delete[] fileData;
2240 }
2241
2242 /*
2243 * Feature: idl
2244 * Function: EmitWriteArrayVariable
2245 * SubFunction: NA
2246 * FunctionPoints: Generate proxy code.
2247 * EnvConditions: NA
2248 * CaseDescription: Verify key strings in proxy code.
2249 */
2250 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxy_004, TestSize.Level1)
2251 {
2252 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
2253 NORMAL_TYPE_RETURN_IDL_CONTENT.c_str()), ERR_OK);
2254 int argc = 6;
2255 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2256 ParameterArgv parameters(argvArray, argc);
2257 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2258 EXPECT_NE(tsCodeGen_, nullptr);
2259 StringBuilder stringBuilder;
2260 tsCodeGen_->EmitInterface();
2261 tsCodeGen_->EmitInterfaceProxy();
2262 std::string tsProxyStr;
2263 std::ifstream tsProxyInputStream;
2264 tsProxyInputStream.open("idl_test_proxy.ts");
2265 std::stringstream tsProxyStrStream;
2266 tsProxyStrStream << tsProxyInputStream.rdbuf();
2267 tsProxyInputStream.close();
2268 tsProxyStr = tsProxyStrStream.str();
2269 tsProxyStrStream.clear();
2270 tsProxyStrStream.str("");
2271 const char* fileData = tsProxyStr.data();
2272 stringBuilder.Append(fileData);
2273 EXPECT_FALSE(stringBuilder.ToString().IsEmpty());
2274 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
2275 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
2276 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
2277 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
2278 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
2279 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
2280 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
2281 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
2282 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
2283 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
2284 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
2285 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
2286 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
2287 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
2288 EXPECT_EQ(stringBuilder.ToString().IndexOf("Int8Array"), ERR_FAIL);
2289 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
2290 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
2291 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
2292 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
2293 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
2294 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
2295 EXPECT_EQ(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
2296 }
2297
2298 /*
2299 * Feature: idl
2300 * Function: EmitWriteArrayVariable
2301 * SubFunction: NA
2302 * FunctionPoints: Generate proxy code.
2303 * EnvConditions: NA
2304 * CaseDescription: Verify key strings in proxy code.
2305 */
2306 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxy_005, TestSize.Level1)
2307 {
2308 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(),
2309 NORMAL_TYPE_COMBINATION_IDL_CONTENT.c_str()), ERR_OK);
2310 int argc = 6;
2311 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2312 ParameterArgv parameters(argvArray, argc);
2313 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2314 EXPECT_NE(tsCodeGen_, nullptr);
2315 StringBuilder stringBuilder;
2316 tsCodeGen_->EmitInterface();
2317 tsCodeGen_->EmitInterfaceProxy();
2318 String filePath = String::Format("%s/%s", "./", "idl_test_proxy.ts");
2319 File file(filePath, File::READ);
2320 MetaComponent header;
2321 EXPECT_TRUE(file.ReadData((void*)&header, sizeof(MetaComponent)));
2322 EXPECT_TRUE(file.Reset());
2323 char* fileData = new char[header.size_];
2324 file.ReadData(static_cast<void*>(fileData), header.size_);
2325 stringBuilder.Append(fileData);
2326 EXPECT_NE(stringBuilder.ToString().IndexOf("readBooleanArray"), ERR_FAIL);
2327 EXPECT_NE(stringBuilder.ToString().IndexOf("readByteArray"), ERR_FAIL);
2328 EXPECT_NE(stringBuilder.ToString().IndexOf("readShortArray"), ERR_FAIL);
2329 EXPECT_NE(stringBuilder.ToString().IndexOf("readIntArray"), ERR_FAIL);
2330 EXPECT_NE(stringBuilder.ToString().IndexOf("readLongArray"), ERR_FAIL);
2331 EXPECT_NE(stringBuilder.ToString().IndexOf("readFloatArray"), ERR_FAIL);
2332 EXPECT_NE(stringBuilder.ToString().IndexOf("readDoubleArray"), ERR_FAIL);
2333 EXPECT_NE(stringBuilder.ToString().IndexOf("readStringArray"), ERR_FAIL);
2334 EXPECT_NE(stringBuilder.ToString().IndexOf("readSequenceable"), ERR_FAIL);
2335 EXPECT_NE(stringBuilder.ToString().IndexOf("new Map()"), ERR_FAIL);
2336 EXPECT_NE(stringBuilder.ToString().IndexOf("export default class"), ERR_FAIL);
2337 EXPECT_NE(stringBuilder.ToString().IndexOf("static readonly"), ERR_FAIL);
2338 EXPECT_NE(stringBuilder.ToString().IndexOf("private proxy"), ERR_FAIL);
2339 EXPECT_NE(stringBuilder.ToString().IndexOf("writeBooleanArray"), ERR_FAIL);
2340 EXPECT_NE(stringBuilder.ToString().IndexOf("writeShortArray"), ERR_FAIL);
2341 EXPECT_NE(stringBuilder.ToString().IndexOf("writeIntArray"), ERR_FAIL);
2342 EXPECT_NE(stringBuilder.ToString().IndexOf("writeLongArray"), ERR_FAIL);
2343 EXPECT_NE(stringBuilder.ToString().IndexOf("writeFloatArray"), ERR_FAIL);
2344 EXPECT_NE(stringBuilder.ToString().IndexOf("writeDoubleArray"), ERR_FAIL);
2345 EXPECT_NE(stringBuilder.ToString().IndexOf("writeStringArray"), ERR_FAIL);
2346 EXPECT_NE(stringBuilder.ToString().IndexOf("writeSequenceable"), ERR_FAIL);
2347 delete[] fileData;
2348 }
2349
2350 /*
2351 * Feature: idl
2352 * Function: EmitInterfaceProxy
2353 * SubFunction: NA
2354 * FunctionPoints: EmitInterfaceProxy validates the interface name
2355 * EnvConditions: NA
2356 * CaseDescription: Content interface name not start with "I"
2357 */
2358 HWTEST_F(TsCodeEmitterProxyTest, EmitInterfaceProxy_006, TestSize.Level1)
2359 {
2360 EXPECT_EQ(PrepareIdlFile(INTERFACE_SPECIAL_NAME_IDL_NAME.c_str(),
2361 INTERFACE_SPECIAL_NAME_IDL_CONTENT.c_str()),
2362 ERR_OK);
2363 int argc = 6;
2364 const char* argvArray[] = {"./idl", "-c", INTERFACE_SPECIAL_NAME_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2365 ParameterArgv parameters(argvArray, argc);
2366 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2367 EXPECT_NE(tsCodeGen_, nullptr);
2368 tsCodeGen_->EmitInterface();
2369 tsCodeGen_->EmitInterfaceProxy();
2370
2371 String filePath = String::Format("%s/%s", "./", "special_name_test_proxy.ts");
2372 File file(filePath, File::READ);
2373 MetaComponent header;
2374 EXPECT_TRUE(file.ReadData((void*)&header, sizeof(MetaComponent)));
2375 EXPECT_TRUE(file.Reset());
2376 void* fileData = malloc(header.size_);
2377 file.ReadData(fileData, header.size_);
2378 std::string data((char*)fileData);
2379
2380 EXPECT_TRUE(data.length());
2381 EXPECT_NE(data.find("Copyright"), std::string::npos);
2382 EXPECT_NE(data.find("import SpecialNameTest"), std::string::npos);
2383 EXPECT_NE(data.find("class SpecialNameTestProxy implements SpecialNameTest"), std::string::npos);
2384 EXPECT_NE(data.find("voidParameterTypeShort"), std::string::npos);
2385 EXPECT_NE(data.find("this.proxy.sendMessageRequest"), std::string::npos);
2386 free(fileData);
2387 }
2388
2389 /*
2390 * Feature: idl
2391 * Function: MethodName
2392 * SubFunction: NA
2393 * FunctionPoints: Method Name.
2394 * EnvConditions: NA
2395 * CaseDescription: Verify Method Name.
2396 */
2397 HWTEST_F(TsCodeEmitterProxyTest, MethodName_001, TestSize.Level1)
2398 {
2399 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2400 int argc = 6;
2401 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2402 ParameterArgv parameters(argvArray, argc);
2403 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2404 EXPECT_NE(tsCodeGen_, nullptr);
2405 const String inPutString("voidOrderReturnMap");
2406 String relustString = tsCodeGen_->MethodName(inPutString);
2407 EXPECT_EQ(std::string(relustString.string()), std::string(inPutString.string()));
2408 }
2409
2410 /*
2411 * Feature: idl
2412 * Function: MethodName
2413 * SubFunction: NA
2414 * FunctionPoints: Method Name.
2415 * EnvConditions: NA
2416 * CaseDescription: Verify Method Name.
2417 */
2418 HWTEST_F(TsCodeEmitterProxyTest, MethodName_002, TestSize.Level1)
2419 {
2420 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2421 int argc = 6;
2422 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2423 ParameterArgv parameters(argvArray, argc);
2424 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2425 EXPECT_NE(tsCodeGen_, nullptr);
2426 const String inPutString("VoidOrderReturnMap");
2427 const String expectString("voidOrderReturnMap");
2428 String relustString = tsCodeGen_->MethodName(inPutString);
2429 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2430 }
2431
2432 /*
2433 * Feature: idl
2434 * Function: MethodName
2435 * SubFunction: NA
2436 * FunctionPoints: Method Name.
2437 * EnvConditions: NA
2438 * CaseDescription: Verify Method Name.
2439 */
2440 HWTEST_F(TsCodeEmitterProxyTest, MethodName_003, TestSize.Level1)
2441 {
2442 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2443 int argc = 6;
2444 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2445 ParameterArgv parameters(argvArray, argc);
2446 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2447 EXPECT_NE(tsCodeGen_, nullptr);
2448 const String inPutString("VVidOrderReturnMap");
2449 const String expectString("vVidOrderReturnMap");
2450 String relustString = tsCodeGen_->MethodName(inPutString);
2451 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2452 }
2453
2454 /*
2455 * Feature: idl
2456 * Function: MethodName
2457 * SubFunction: NA
2458 * FunctionPoints: Method Name.
2459 * EnvConditions: NA
2460 * CaseDescription: Verify Method Name.
2461 */
2462 HWTEST_F(TsCodeEmitterProxyTest, MethodName_004, TestSize.Level1)
2463 {
2464 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2465 int argc = 6;
2466 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2467 ParameterArgv parameters(argvArray, argc);
2468 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2469 EXPECT_NE(tsCodeGen_, nullptr);
2470 const String inPutString("VVid1254789");
2471 const String expectString("vVid1254789");
2472 String relustString = tsCodeGen_->MethodName(inPutString);
2473 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2474 }
2475
2476 /*
2477 * Feature: idl
2478 * Function: ConstantName
2479 * SubFunction: NA
2480 * FunctionPoints: Constant Name.
2481 * EnvConditions: NA
2482 * CaseDescription: Verify Constant Name.
2483 */
2484 HWTEST_F(TsCodeEmitterProxyTest, ConstantName_001, TestSize.Level1)
2485 {
2486 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2487 int argc = 6;
2488 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2489 ParameterArgv parameters(argvArray, argc);
2490 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2491 EXPECT_NE(tsCodeGen_, nullptr);
2492 const String inPutString("VVid1254789");
2493 const String expectString("VVID1254789");
2494 String relustString = tsCodeGen_->ConstantName(inPutString);
2495 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2496 }
2497
2498 /*
2499 * Feature: idl
2500 * Function: ConstantName
2501 * SubFunction: NA
2502 * FunctionPoints: Constant Name.
2503 * EnvConditions: NA
2504 * CaseDescription: Verify Constant Name.
2505 */
2506 HWTEST_F(TsCodeEmitterProxyTest, ConstantName_002, TestSize.Level1)
2507 {
2508 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2509 int argc = 6;
2510 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2511 ParameterArgv parameters(argvArray, argc);
2512 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2513 EXPECT_NE(tsCodeGen_, nullptr);
2514 const String inPutString("VVidVide");
2515 const String expectString("VVID_VIDE");
2516 String relustString = tsCodeGen_->ConstantName(inPutString);
2517 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2518 }
2519
2520 /*
2521 * Feature: idl
2522 * Function: ConstantName
2523 * SubFunction: NA
2524 * FunctionPoints: Constant Name.
2525 * EnvConditions: NA
2526 * CaseDescription: Verify Constant Name.
2527 */
2528 HWTEST_F(TsCodeEmitterProxyTest, ConstantName_003, TestSize.Level1)
2529 {
2530 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2531 int argc = 6;
2532 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2533 ParameterArgv parameters(argvArray, argc);
2534 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2535 EXPECT_NE(tsCodeGen_, nullptr);
2536 const String inPutString("vvidVide_V");
2537 const String expectString("VVID_VIDE__V");
2538 String relustString = tsCodeGen_->ConstantName(inPutString);
2539 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2540 }
2541
2542 /*
2543 * Feature: idl
2544 * Function: StubName
2545 * SubFunction: NA
2546 * FunctionPoints: Stub Name.
2547 * EnvConditions: NA
2548 * CaseDescription: Verify Stub Name.
2549 */
2550 HWTEST_F(TsCodeEmitterProxyTest, StubName_001, TestSize.Level1)
2551 {
2552 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2553 int argc = 6;
2554 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2555 ParameterArgv parameters(argvArray, argc);
2556 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2557 EXPECT_NE(tsCodeGen_, nullptr);
2558 const String inPutString("IVid1254789");
2559 const String expectString("Vid1254789Stub");
2560 String relustString = tsCodeGen_->StubName(inPutString);
2561 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2562 }
2563
2564 /*
2565 * Feature: idl
2566 * Function: StubName
2567 * SubFunction: NA
2568 * FunctionPoints: Stub Name.
2569 * EnvConditions: NA
2570 * CaseDescription: Verify Stub Name.
2571 */
2572 HWTEST_F(TsCodeEmitterProxyTest, StubName_002, TestSize.Level1)
2573 {
2574 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2575 int argc = 6;
2576 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2577 ParameterArgv parameters(argvArray, argc);
2578 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2579 EXPECT_NE(tsCodeGen_, nullptr);
2580 const String inPutString("iVid1254789");
2581 const String expectString("iVid1254789Stub");
2582 String relustString = tsCodeGen_->StubName(inPutString);
2583 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2584 }
2585
2586 /*
2587 * Feature: idl
2588 * Function: StubName
2589 * SubFunction: NA
2590 * FunctionPoints: Stub Name.
2591 * EnvConditions: NA
2592 * CaseDescription: Verify Stub Name.
2593 */
2594 HWTEST_F(TsCodeEmitterProxyTest, StubName_003, TestSize.Level1)
2595 {
2596 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2597 int argc = 6;
2598 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2599 ParameterArgv parameters(argvArray, argc);
2600 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2601 EXPECT_NE(tsCodeGen_, nullptr);
2602 const String inPutString("Vid1254789");
2603 const String expectString("Vid1254789Stub");
2604 String relustString = tsCodeGen_->StubName(inPutString);
2605 EXPECT_EQ(std::string(relustString.string()), std::string(expectString.string()));
2606 }
2607
2608 /*
2609 * Feature: idl
2610 * Function: UnderlineAdded
2611 * SubFunction: NA
2612 * FunctionPoints: UnderlineAdded Name.
2613 * EnvConditions: NA
2614 * CaseDescription: Verify UnderlineAdded.
2615 */
2616 HWTEST_F(TsCodeEmitterProxyTest, UnderlineAdded_001, TestSize.Level1)
2617 {
2618 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2619 int argc = 6;
2620 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2621 ParameterArgv parameters(argvArray, argc);
2622 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2623 EXPECT_NE(tsCodeGen_, nullptr);
2624 const String inPutString("Vid1254789");
2625 const String expectString("_Vid1254789");
2626 std::string relustString = tsCodeGen_->UnderlineAdded(inPutString);
2627 EXPECT_EQ(relustString, std::string(expectString.string()));
2628 }
2629
2630 /*
2631 * Feature: idl
2632 * Function: UnderlineAdded
2633 * SubFunction: NA
2634 * FunctionPoints: UnderlineAdded Name.
2635 * EnvConditions: NA
2636 * CaseDescription: Verify UnderlineAdded.
2637 */
2638 HWTEST_F(TsCodeEmitterProxyTest, UnderlineAdded_002, TestSize.Level1)
2639 {
2640 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2641 int argc = 6;
2642 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2643 ParameterArgv parameters(argvArray, argc);
2644 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2645 EXPECT_NE(tsCodeGen_, nullptr);
2646 const String inPutString("iVid1254789");
2647 const String expectString("_iVid1254789");
2648 std::string relustString = tsCodeGen_->UnderlineAdded(inPutString);
2649 EXPECT_EQ(relustString, std::string(expectString.string()));
2650 }
2651
2652 /*
2653 * Feature: idl
2654 * Function: UnderlineAdded
2655 * SubFunction: NA
2656 * FunctionPoints: UnderlineAdded Name.
2657 * EnvConditions: NA
2658 * CaseDescription: Verify UnderlineAdded.
2659 */
2660 HWTEST_F(TsCodeEmitterProxyTest, UnderlineAdded_003, TestSize.Level1)
2661 {
2662 EXPECT_EQ(PrepareIdlFile(UNKNOW_TYPE_IDL_NAME.c_str(), NORMAL_TYPE_OUT_IDL_CONTENT.c_str()), ERR_OK);
2663 int argc = 6;
2664 const char* argvArray[] = {"./idl", "-c", UNKNOW_TYPE_IDL_NAME.c_str(), "-gen-ts", "-d", "."};
2665 ParameterArgv parameters(argvArray, argc);
2666 EXPECT_EQ(Ready(argc, parameters.GetArgv()), ERR_OK);
2667 EXPECT_NE(tsCodeGen_, nullptr);
2668 const String inPutString("_Vid1254789");
2669 const String expectString("__Vid1254789");
2670 std::string relustString = tsCodeGen_->UnderlineAdded(inPutString);
2671 EXPECT_EQ(relustString, std::string(expectString.string()));
2672 }
2673 }
2674 }
2675 }
2676