• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2* Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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*/
15let genDir = "../../src/gen/"
16const re = require(genDir + "tools/re");
17const { analyzeFile } = require(genDir + "analyze");
18const { analyzeEnum, analyzeEnumResult } = require(genDir + "analyze/enum");
19const { analyzeFunction, analyzeSubInterface, getFuncParaType, analyzeFuncNoNameInterface,
20  analyseSubReturn } = require(genDir + "analyze/function");
21const { analyzeInterface } = require(genDir + "analyze/interface");
22const { analyzeType, analyzeType2 } = require(genDir + "analyze/type");
23const { analyzeNamespace, parseNamespace } = require(genDir + "analyze/namespace");
24const { parseEnum, parseFunction, parseInterface, parseClass, parseType } = require(genDir + "analyze/namespace");
25const { analyzeParams } = require(genDir + "analyze/params");
26const { analyzeReturn } = require(genDir + "analyze/return");
27const { readFile } = require("../../src/gen/tools/FileRW");
28
29var assert = require("assert");
30var correctResult;
31function before() {
32    let data = readFile("test/unittest/result.json")
33    if (data) {
34        correctResult = JSON.parse(data);
35    }
36}
37
38describe('Analyze', function () {
39    before(function () {
40        before();
41    });
42
43    it('test gen/analyze analyzeFile', function () {
44        let structOfTs = analyzeFile("test/unittest/@ohos.input_sample.d.ts");
45        let retJson = JSON.stringify(structOfTs)
46        let retNameSpace = retJson.search("\"name\":\"napitest\"");
47        assert.strictEqual(retNameSpace > 0, true);
48        let retLicense = retJson.search("Copyright");
49        assert.strictEqual(retLicense > 0, true);
50    });
51
52    partOfEnum();
53
54    partOfFunction(correctResult);
55
56    partOfInterface(correctResult);
57
58    partOfType();
59
60    partOfNamespace(correctResult);
61
62    partOfParam();
63
64    it('test gen/analyze/return analyzeReturn', function () {
65        let ret = analyzeReturn("string");
66        assert.strictEqual(ret[0], 'string');
67        assert.strictEqual(ret[1], false);
68        let ret2 = analyzeReturn("boolean");
69        assert.strictEqual(ret2[0], 'boolean');
70        assert.strictEqual(ret2[1], false);
71    });
72
73    it('test gen/analyze/return analyzeReturn', function () {
74        let ret = analyzeReturn("Promise<string>");
75        assert.strictEqual(ret[0], 'Promise<string>');
76        assert.strictEqual(ret[1], true);
77        let ret2 = analyzeReturn("Promise<boolean>");
78        assert.strictEqual(ret2[0], 'Promise<boolean>');
79        assert.strictEqual(ret2[1], true);
80    });
81});
82
83function partOfEnum() {
84    it('test gen/analyze/enum analyzeStringEnum', function () {
85        let data = '\nDENIED = "-1"';
86        let retJson = JSON.stringify(analyzeEnum(data));
87        let enumValueType = retJson.search("\"enumValueType\":1");
88        assert.strictEqual(enumValueType > 0, true);
89        let element = retJson.search("\"name\":\"DENIED\",\"value\":\"-1\",\"type\":\"string\"");
90        assert.strictEqual(element > 0, true);
91    });
92
93    it('test gen/analyze/enum analyzeNumberEnum', function () {
94        let data = '\nFAULT = 1,\nSTATISTIC = 2,\nSECURITY = 3,\nBEHAVIOR = 4,\n';
95        let retJson = JSON.stringify(analyzeEnum(data));
96        let enumValueType = retJson.search("\"enumValueType\":0");
97        assert.strictEqual(enumValueType > 0, true);
98        let element = retJson.search("\"name\":\"FAULT\",\"value\":\"1\",\"type\":\"NUMBER_TYPE_");
99        assert.strictEqual(element > 0, true);
100        let retFunc = retJson.substring(retJson.search("function") - 1, retJson.search("function") + 12);
101        assert.strictEqual(retFunc, "\"function\":[]");
102    });
103
104    it('test gen/analyze/enum analyzeEnumStringResult', function () {
105        let result = {
106            element: [{ name: "STATUS0", value: "0", type: "string" }],
107            function: [],
108            enumValueType: 0
109        }
110        let retJson = JSON.stringify(analyzeEnumResult(result, 'STATUS0 = "1"', '0'))
111        let enumValueType = retJson.search("\"enumValueType\":1");
112        assert.strictEqual(enumValueType > 0, true);
113    });
114
115    it('test gen/analyze/enum analyzeEnumNumberResult', function () {
116      let result = {
117          element: [{ name: "STATUS1", value: "0", type: "NUMBER_TYPE_1" }],
118          function: [],
119          enumValueType: 0
120      }
121      let retJson = JSON.stringify(analyzeEnumResult(result, 'STATUS1 = 1', '0'))
122      let enumValueType = retJson.search("\"enumValueType\":0");
123      assert.strictEqual(enumValueType > 0, true);
124  });
125}
126
127function partOfFunction(correctResult) {
128    partOfFunctionOne(correctResult);
129
130    it('test gen/analyze/function analyzeFuncNoNameInterface', function () {
131        let data = {
132            exports: [],
133            enum: [],
134            const: [],
135            type: [],
136            function: [],
137            interface: [],
138            class: [],
139            namespace: [],
140        }
141        let values = "fp3: {nm: string, isTrue: boolean}";
142        let retJson = JSON.stringify(analyzeFuncNoNameInterface(data, values));
143        retJson = re.replaceAll(retJson,"AUTO_INTERFACE_[0-9]+","AUTO_INTERFACE")
144        assert.strictEqual(retJson, "{\"interfaceName\":\"AUTO_INTERFACE\",\"values\":\"fp3:AUTO_INTERFACE\"}");
145    });
146
147    it('test gen/analyze/function analyseSubReturn', function () {
148        let data = {
149            exports: [],
150            enum: [],
151            const: [],
152            type: [],
153            function: [],
154            interface: [],
155            class: [],
156            namespace: [],
157        }
158        let ret = "{read:number;written:number}";
159        let retJson = JSON.stringify(analyseSubReturn(ret, data));
160        retJson = re.replaceAll(retJson,"AUTO_INTERFACE_[0-9]+","AUTO_INTERFACE")
161        assert.strictEqual(retJson, "\"AUTO_INTERFACE\"");
162    });
163
164    it('test gen/analyze/function getFuncParaType', function () {
165        let data = 'if_direct(v1: string, v2: boolean): string;';
166        let v = { name: 'v1', type: 'string' };
167        let retJson = JSON.stringify(getFuncParaType(v, '', data))
168        assert.strictEqual(retJson, "{\"name\":\"v1\",\"type\":\"string\"}");
169    });
170
171    partOfFunctionTwo();
172}
173
174function partOfFunctionOne(correctResult) {
175    it('test gen/analyze/function analyzeSubInterface', function () {
176        let data = correctResult['ParamIn']['analyzeSubInterface'];
177        let retJson = JSON.stringify(analyzeSubInterface(data))
178        let retNum = retJson.search("{\"name\":\"num1\",\"type\":\"NUMBER_TYPE_");
179        assert.strictEqual(retNum > 0, true);
180        let retString = retJson.search("{\"name\":\"str1\",\"type\":\"string\"}");
181        assert.strictEqual(retString > 0, true);
182        let retBoolean = retJson.search("{\"name\":\"bool1\",\"type\":\"boolean\"}");
183        assert.strictEqual(retBoolean > 0, true);
184        let retArrayNum = retJson.search("{\"name\":\"nums\",\"type\":\"Array<NUMBER_TYPE_");
185        assert.strictEqual(retArrayNum > 0, true);
186        let retArrayString = retJson.search("{\"name\":\"strs\",\"type\":\"Array<string>\"}");
187        assert.strictEqual(retArrayString > 0, true);
188        let retArrayBoolean = retJson.search("{\"name\":\"bools\",\"type\":\"Array<boolean>\"}");
189        assert.strictEqual(retArrayBoolean > 0, true);
190        let retMapNumber = retJson.search("{\"name\":\"mapNum\",\"type\":\"Map<string, NUMBER_TYPE_");
191        assert.strictEqual(retMapNumber > 0, true);
192        let retMapString = retJson.search("{\"name\":\"mapStr\",\"type\":\"Map<string, string>\"}");
193        assert.strictEqual(retMapString > 0, true);
194        let retMapBoolean = retJson.search("{\"name\":\"mapBool\",\"type\":\"Map<string, boolean>\"}");
195        assert.strictEqual(retMapBoolean > 0, true);
196        let retMapNumber2 = retJson.indexOf("\"name\":\"mapNum2\",\"type\":\"{[key: string]: NUMBER_TYPE_");
197        assert.strictEqual(retMapNumber2 > 0, true);
198        let strictEqual = retJson.indexOf("\"name\":\"mapStr2\",\"type\":\"{[key: string]: string}");
199        assert.strictEqual(strictEqual > 0, true);
200        let retMapBoolean2 = retJson.indexOf("\"name\":\"mapBool2\",\"type\":\"{[key: string]: boolean}");
201        assert.strictEqual(retMapBoolean2 > 0, true);
202    });
203}
204
205function partOfFunctionTwo() {
206    it('test gen/analyze/function analyzeDirectFunction', function () {
207        let data = "if_direct(v1: string, v2: boolean): string;";
208        let ret = analyzeFunction(data, false, `if_direct`, "v1: string, v2: boolean", "asdfgh");
209        let retJson = JSON.stringify(ret);
210        let str1 = "{\"name\":\"v1\",\"type\":\"string\",\"optional\":false},";
211        let str2 = "{\"name\":\"v2\",\"type\":\"boolean\",\"optional\":false}";
212        let retValue = retJson.search(str1 + str2)
213        assert.strictEqual(retValue > 0, true);
214        let retName = retJson.search("\"name\":\"if_direct\"");
215        assert.strictEqual(retName > 0, true);
216        let retType = retJson.search("\"type\":1");
217        assert.strictEqual(retType > 0, true);
218    });
219
220    it('test gen/analyze/function analyzeAsyncFunction', function () {
221        let data = "if_async(v1: string, cb: AsyncCallback<string>): string;";
222        let ret = analyzeFunction(data, false, `if_async`, "v1: string, cb: AsyncCallback<string>", "qwerty");
223        let retJson = JSON.stringify(ret)
224        let str1 = "{\"name\":\"v1\",\"type\":\"string\",\"optional\":false},";
225        let str2 = "{\"name\":\"cb\",\"type\":\"AsyncCallback<string>\",\"optional\":false}";
226        let retValue = retJson.search(str1 + str2)
227        assert.strictEqual(retValue > 0, true);
228        let retName = retJson.search("\"name\":\"if_async\"")
229        assert.strictEqual(retName > 0, true);
230        let retType = retJson.search("\"type\":4")
231        assert.strictEqual(retType > 0, true);
232    });
233
234    it('test gen/analyze/function analyzeSyncFunction', function () {
235        let data = "if_callback(v1: string, cb: Callback<Array<string>>): string;";
236        let ret = analyzeFunction(data, false, `if_callback`, "v1: string, cb: Callback<Array<string>>", "zxcvbn");
237        let retJson = JSON.stringify(ret)
238        let retType = retJson.search("\"type\":2")
239        assert.strictEqual(retType > 0, true);
240    });
241
242    it('test gen/analyze/function analyzePromiseFunction', function () {
243        let data = "if_promise(v1: Array<number>): Promise<boolean>;";
244        let ret = analyzeFunction(data, false, `if_promise`, "v1: Array<number>", "Promise<boolean>");
245        let retJson = JSON.stringify(ret)
246        let retType = retJson.search("\"type\":4")
247        assert.strictEqual(retType > 0, true);
248        let retReturn = retJson.search('\"ret\":\"void\"')
249        assert.strictEqual(retReturn > 0, true);
250    });
251}
252
253function partOfInterface(correctResult) {
254    it('test gen/analyze/interface analyzeInterface', function () {
255        let ret = analyzeInterface(correctResult['ParamIn']['analyzeInterface']);
256        let retJson = JSON.stringify(ret)
257        let valueArray = retJson.substring(retJson.indexOf("\[") + 1, retJson.indexOf("\]")).split("}");
258        let numContain = valueArray[0].indexOf("\"name\":\"num1\",\"type\":\"NUMBER_TYPE_");
259        assert.strictEqual(numContain > 0, true);
260        assert.strictEqual(valueArray[1], ",{\"name\":\"str1\",\"type\":\"string\"");
261        assert.strictEqual(valueArray[2], ",{\"name\":\"bool1\",\"type\":\"boolean\"");
262        let numArrayCon = valueArray[3].indexOf("\"name\":\"nums\",\"type\":\"Array<NUMBER_TYPE_");
263        assert.strictEqual(numArrayCon > 0, true);
264        assert.strictEqual(valueArray[4], ",{\"name\":\"strs\",\"type\":\"Array<string>\"");
265        assert.strictEqual(valueArray[5], ",{\"name\":\"bools\",\"type\":\"Array<boolean>\"");
266        let numMapCon = valueArray[6].indexOf("\"name\":\"mapNum\",\"type\":\"Map<string,NUMBER_TYPE_");
267        assert.strictEqual(numMapCon > 0, true);
268        assert.strictEqual(valueArray[7], ",{\"name\":\"mapStr\",\"type\":\"Map<string,string>\"");
269        assert.strictEqual(valueArray[8], ",{\"name\":\"mapBool\",\"type\":\"Map<string,boolean>\"");
270        let mapNumCon = retJson.indexOf("\"name\":\"mapNum2\",\"type\":\"{[key:string]:NUMBER_TYPE_");
271        assert.strictEqual(mapNumCon > 0, true);
272        let mapStrCon = retJson.indexOf("\"name\":\"mapStr2\",\"type\":\"{[key:string]:string}");
273        assert.strictEqual(mapStrCon > 0, true);
274        let mapBoolCon = retJson.indexOf("\"name\":\"mapBool2\",\"type\":\"{[key:string]:boolean}");
275        assert.strictEqual(mapBoolCon > 0, true);
276        let asyncExit = retJson.search("\"name\":\"if_async\",\"type\":4")
277        assert.strictEqual(asyncExit > 0, true);
278        let asyncArray = retJson.substring(retJson.lastIndexOf("\[") + 1, retJson.lastIndexOf("\]")).split("}");
279        assert.strictEqual(asyncArray[0], "{\"name\":\"v1\",\"type\":\"string\",\"optional\":false");
280        assert.strictEqual(asyncArray[1], ",{\"name\":\"cb\",\"type\":\"AsyncCallback<string>\",\"optional\":false");
281        assert.strictEqual(asyncArray[2], "],\"ret\":\"string\",\"isStatic\":false");
282    });
283}
284
285function partOfType() {
286    it('test gen/analyze/type analyzeType', function () {
287        let retJson = JSON.stringify(analyzeType("tomato: string;\ntomatoTag: boolean;"));
288        let value0 = retJson.search("\"name\":\"tomato\",\"type\":\"string\"");
289        assert.strictEqual(value0 > 0, true);
290        let value1 = retJson.search("\"name\":\"tomatoTag\",\"type\":\"boolean\"");
291        assert.strictEqual(value1 > 0, true);
292    });
293
294    it('test gen/analyze/type analyzeType2', function () {
295        let retJson = JSON.stringify(analyzeType2("aaa' | 'bbb' | 'ccc"));
296        let enumValueType = retJson.search("\"enumValueType\":1");
297        assert.strictEqual(enumValueType > 0, true);
298        let element0 = retJson.search("\"name\":\"NAME_AAA\",\"value\":\"aaa\",\"type\":\"string\"");
299        assert.strictEqual(element0 > 0, true);
300        let element1 = retJson.search("\"name\":\"NAME_BBB\",\"value\":\"bbb\",\"type\":\"string\"");
301        assert.strictEqual(element1 > 0, true);
302        let element2 = retJson.search("\"name\":\"NAME_CCC\",\"value\":\"ccc\",\"type\":\"string\"");
303        assert.strictEqual(element2 > 0, true);
304    });
305}
306
307function partOfNamespace(correctResult) {
308    it('test gen/analyze/namespace analyzeNamespace', function () {
309        let ret = analyzeNamespace(correctResult['ParamIn']['analyzeNamespace']);
310        let retJson = JSON.stringify(ret);
311        let nameResult = retJson.substring(retJson.search("namespace") - 1, retJson.length - 1);
312        let searchExport = nameResult.search("\"exports\"")
313        let exportResult = nameResult.substring(searchExport, nameResult.search("\"exports\"") + 20);
314        assert.strictEqual(exportResult, "\"exports\":[\"Entity\"]")
315        let enumResult = nameResult.substring(nameResult.search("\"enum\""), nameResult.indexOf("\"const\"") - 1);
316        assert.strictEqual(enumResult.search("\"name\":\"Entity\"") > 0, true);
317        assert.strictEqual(enumResult.search("\"enumValueType\":1") > 0, true);
318        let searchInte = nameResult.indexOf("\"interface\"")
319        let interResult = nameResult.substring(searchInte, nameResult.indexOf("\"class\"") - 1);
320        assert.strictEqual(interResult.search("{\"name\":\"animal\",\"type\":\"string\"}") > 0, true);
321        let qiePianStart = interResult.lastIndexOf("function") - 1;
322        let qiepianEnd = interResult.lastIndexOf("parentNameList")-2;
323        let interFun = interResult.substring(qiePianStart, qiepianEnd);
324        let interValue = "\"value\":[{\"name\":\"v1\",\"type\":\"string\",\"optional\":false}],";
325        let interRet = "\"ret\":\"string\","
326        let interIsStatic = "\"isStatic\":false\}]"
327        let funcResult = "\"function\":[{\"name\":\"fix\",\"type\":1," + interValue + interRet + interIsStatic;
328        assert.strictEqual(interFun, funcResult);
329    });
330
331    it('test gen/analyze/namespace analyzeNamespaceClass', function () {
332        let ret = analyzeNamespace('\nnamespace Space3 {\nclass TestClass {\nstatic $fun1(v:string):boolean;\n}\n}\n');
333        let retJson = JSON.stringify(ret);
334        let nameResult = retJson.substring(retJson.search("namespace"), retJson.length - 2)
335        let interResult = nameResult.substring(nameResult.search("\"interface\"") - 1,nameResult.length)
336        let classResult = interResult.substring(interResult.search("\"function\"") - 1, interResult.length)
337        assert.strictEqual(classResult.search("\"isStatic\":true") > 0, true)
338    });
339
340    it('test gen/analyze/namespace analyzeNamespaceFunction', function () {
341        let ret = analyzeNamespace('\nnamespace Space3 {\nfunction fun1(v: string): boolean;\n}\n');
342        let retJson = JSON.stringify(ret);
343        let nameResult = retJson.substring(retJson.search("namespace"), retJson.length - 2)
344        let qiePianStart = nameResult.lastIndexOf("\"function\"");
345        let funcResult = nameResult.substring(qiePianStart, nameResult.lastIndexOf("\"interface\"") - 2);
346        assert.strictEqual(funcResult.search("\"name\":\"fun1\",\"type\":1") > 0, true)
347        assert.strictEqual(funcResult.search("{\"name\":\"v\",\"type\":\"string\",\"optional\":false}") > 0, true)
348    });
349
350    partOfNamespaceTwo(correctResult);
351
352    partOfNamespaceThree(correctResult);
353
354    partOfNamespaceFour(correctResult);
355}
356
357function partOfNamespaceTwo(correctResult) {
358    it('test gen/analyze/namespace parseNamespace', function () {
359        let data = correctResult['ParamIn']['parseNamespace'];
360        let matchs = re.match(" *\n*", data)
361        let result = {
362            exports: [],
363            enum: [],
364            const: [],
365            type: [],
366            function: [],
367            interface: [],
368            class: [],
369            namespace: [],
370        }
371        let ret = parseNamespace(matchs, data, result);
372        let retJson = JSON.stringify(ret)
373        assert.strictEqual(retJson, "\"\\n\"");
374    });
375
376    it('test gen/analyze/namespace parseEnum', function () {
377        let data = correctResult['ParamIn']['parseEnum']
378        let matchs = re.match(" *\n*", data)
379        let result = {
380            exports: [],
381            enum: [],
382            const: [],
383            type: [],
384            function: [],
385            interface: [],
386            class: [],
387            namespace: [],
388        }
389        let ret = parseEnum(matchs, data, result);
390        let retJson = JSON.stringify(ret)
391        assert.strictEqual(retJson, "\"\\n\"");
392    })
393}
394
395function partOfNamespaceThree(correctResult) {
396    it('test gen/analyze/namespace parseFunction', function () {
397        let data = 'function fun1(name: string, flags: number): boolean;\n';
398        let matchs = re.match(" *\n*", data)
399        let result = {
400            exports: [],
401            enum: [],
402            const: [],
403            type: [],
404            function: [],
405            interface: [],
406            class: [],
407            namespace: [],
408        }
409        let ret = parseFunction(matchs, data, result);
410        let retJson = JSON.stringify(ret)
411        assert.strictEqual(retJson, "\"\"");
412    });
413
414    it('test gen/analyze/namespace parseInterface', function () {
415        let data = correctResult['ParamIn']['parseInterface']
416        let matchs = re.match(" *\n*", data)
417        let result = {
418            exports: [],
419            enum: [],
420            const: [],
421            type: [],
422            function: [],
423            interface: [],
424            class: [],
425            namespace: [],
426        }
427        let ret = parseInterface(matchs, data, result);
428        let retJson = JSON.stringify(ret)
429        assert.strictEqual(retJson, "\"\\nfunction fun1(v: ConfigOption): void\\n\"");
430    });
431}
432
433function partOfNamespaceFour(correctResult) {
434    it('test gen/analyze/namespace parseClass', function () {
435        let data = correctResult['ParamIn']['parseClass']
436        let matchs = re.match(" *\n*", data)
437        let result = {
438            exports: [],
439            enum: [],
440            const: [],
441            type: [],
442            function: [],
443            interface: [],
444            class: [],
445            namespace: [],
446        }
447        let ret = parseClass(matchs, data, result);
448        let retJson = JSON.stringify(ret);
449        assert.strictEqual(retJson, correctResult['ParamOut']['parseClass']);
450    });
451
452    it('test gen/analyze/namespace parseType', function () {
453      let data = correctResult['ParamIn']['parseType']
454      let matchs = re.match(" *\n*", data)
455      let result = {
456          exports: [],
457          enum: [],
458          const: [],
459          type: [],
460          function: [],
461          interface: [],
462          class: [],
463          namespace: [],
464      }
465      let ret = parseType(matchs, data, result);
466      let retJson = JSON.stringify(ret)
467      assert.strictEqual(retJson, correctResult['ParamOut']['parseType']);
468    });
469}
470
471function partOfParam() {
472    it('test gen/analyze/params analyzeDirectParams', function () {
473        let ret = analyzeParams('', 'v1:string,v2:boolean');
474        let retJson = JSON.stringify(ret);
475        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
476        assert.strictEqual(retJsonpian[0].indexOf("\"name\":\"v1\",\"type\":\"string\",\"optional\":false") > 0, true);
477        assert.strictEqual(retJsonpian[1].indexOf("\"name\":\"v2\",\"type\":\"boolean\",\"optional\":false") > 0, true);
478        assert.strictEqual(ret[1], 1);
479    });
480
481    it('test gen/analyze/params analyzeOptionalParams', function () {
482        let ret = analyzeParams('', 'v1:string,v2?:boolean');
483        let retJson = JSON.stringify(ret);
484        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
485        assert.strictEqual(retJsonpian[0].indexOf("\"name\":\"v1\",\"type\":\"string\",\"optional\":false") > 0, true);
486        assert.strictEqual(retJsonpian[1].indexOf("\"name\":\"v2\",\"type\":\"boolean\",\"optional\":true") > 0, true);
487        assert.strictEqual(ret[1], 1);
488    });
489
490
491    it('test gen/analyze/params analyzeAsynctParams', function () {
492        let ret = analyzeParams('', 'v2:string,cb:AsyncCallback<string>');
493        let retJson = JSON.stringify(ret);
494        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
495        assert.strictEqual(retJsonpian[0].indexOf("\"name\":\"v2\",\"type\":\"string\",\"optional\":false") > 0, true);
496        let flag = retJsonpian[1].indexOf("\"name\":\"cb\",\"type\":\"AsyncCallback<string>\",\"optional\":false") > 0
497        assert.strictEqual(flag, true);
498        assert.strictEqual(ret[1], 4);
499    });
500
501    it('test gen/analyze/params analyzeSynctParams', function () {
502        let ret = analyzeParams('', 'v2:boolean,cb:Callback<boolean>');
503        let retJson = JSON.stringify(ret);
504        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
505        assert.strictEqual(retJsonpian[0].indexOf("\"name\":\"v2\",\"type\":\"boolean\",\"optional\":false") > 0, true);
506        let flag = retJsonpian[1].indexOf("\"name\":\"cb\",\"type\":\"Callback<boolean>\",\"optional\":false") > 0
507        assert.strictEqual(flag, true);
508        assert.strictEqual(ret[1], 2);
509    });
510
511    it('test gen/analyze/params analyzeArrayParams', function () {
512        let ret = analyzeParams('', "v1: Array<number>,v2:Map<string,boolean>");
513        let retJson = JSON.stringify(ret);
514        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
515        let flagArray = retJsonpian[0].indexOf("\"name\":\"v1\",\"type\":\"Array<number>\",\"optional\":false") > 0
516        assert.strictEqual(flagArray, true);
517        let flag = retJsonpian[1].indexOf("\"name\":\"v2\",\"type\":\"Map<string,boolean>\",\"optional\":false") > 0
518        assert.strictEqual(flag, true);
519    });
520
521    partOfParamTwo();
522}
523
524function partOfParamTwo() {
525    it('test gen/analyze/params analyzeMapParams', function () {
526        let ret = analyzeParams('', "v1: string[],v2:{[key:string]:boolean}");
527        let retJson = JSON.stringify(ret);
528        let retJsonpian = retJson.substring(2, retJson.length - 4);
529        assert.strictEqual(retJsonpian.indexOf("\"name\":\"v2\",\"type\":\"{\[key:string\]:boolean}\"") > 0, true);
530        assert.strictEqual(retJsonpian.indexOf("\"name\":\"v1\",\"type\":\"string[]\",\"optional\":false") > 0, true);
531    });
532
533    it('test gen/analyze/params analyzeInterfaceParams', function () {
534        let ret = analyzeParams('', "v: Human");
535        let retJson = JSON.stringify(ret);
536        let retJsonpian = retJson.substring(2, retJson.length - 4);
537        assert.strictEqual(retJsonpian.indexOf("\"name\":\"v\",\"type\":\"Human\"") > 0, true);
538    });
539
540    it('test gen/analyze/params analyzeInterfaceParams', function () {
541        let ret = analyzeParams('', "v: any");
542        let retJson = JSON.stringify(ret);
543        let retJsonpian = retJson.substring(2, retJson.length - 4);
544        assert.strictEqual(retJsonpian.indexOf("\"name\":\"v\",\"type\":\"any\"") > 0, true);
545    });
546
547    it('test gen/analyze/params analyzeInterfaceParams', function () {
548        let ret = analyzeParams('', "v: string|number|boolean");
549        let retJson = JSON.stringify(ret);
550        let retJsonpian = retJson.substring(2, retJson.length - 4);
551        assert.strictEqual(retJsonpian.indexOf("\"name\":\"v\",\"type\":\"string|number|boolean\"") > 0, true);
552    });
553}
554
555