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,\'realType\':\'string\'},';
211        let str2 = '{\'name\':\'v2\',\'type\':\'boolean\',\'optional\':false,\'realType\':\'boolean\'}';
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,\'realType\':\'string\'},';
225        let str2 = '{\'name\':\'cb\',\'type\':\'AsyncCallback<string>\',\'optional\':false,\'realType\':\'AsyncCallback<string>\'}';
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 data = correctResultParamIn.analyzeInterface;
256        let ret = analyzeInterface(data);
257        let retJson = JSON.stringify(ret);
258        let valueArray = retJson.substring(retJson.indexOf('\[') + 1, retJson.indexOf('\]')).split('}');
259        let numContain = valueArray[0].indexOf('\'name\':\'num1\',\'type\':\'NUMBER_TYPE_');
260        assert.strictEqual(numContain > 0, true);
261        assert.strictEqual(valueArray[1], ',{\'name\':\'str1\',\'type\':\'string\',\'realType\':\'string\',\'optional\':false');
262        assert.strictEqual(valueArray[2], ',{\'name\':\'bool1\',\'type\':\'boolean\',\'realType\':\'boolean\',\'optional\':false');
263        let numArrayCon = valueArray[3].indexOf('\'name\':\'nums\',\'type\':\'Array<NUMBER_TYPE_');
264        assert.strictEqual(numArrayCon > 0, true);
265        assert.strictEqual(valueArray[4], ',{\'name\':\'strs\',\'type\':\'Array<string>\',\'realType\':\'Array<string>\',\'optional\':false');
266        assert.strictEqual(valueArray[5], ',{\'name\':\'bools\',\'type\':\'Array<boolean>\',\'realType\':\'Array<boolean>\',\'optional\':false');
267        let numMapCon = valueArray[6].indexOf('\'name\':\'mapNum\',\'type\':\'Map<string,NUMBER_TYPE_');
268        assert.strictEqual(numMapCon > 0, true);
269        assert.strictEqual(valueArray[7], ',{\'name\':\'mapStr\',\'type\':\'Map<string,string>\',\'realType\':\'Map<string,string>\',\'optional\':false');
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,\'realType\':\'string\'');
280        assert.strictEqual(asyncArray[1], ',{\'name\':\'cb\',\'type\':\'AsyncCallback<string>\',\'optional\':false,\'realType\':\'AsyncCallback<string>\'');
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, false);
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,\'realType\':\'string\'}],';
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,\'realType\':\'string\'}') > 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}