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/"
16
17const { analyzeFile } = require(genDir + "analyze");
18var assert = require("assert");
19const re = require(genDir + "/tools/re");
20const { info, Console } = require("console");
21const { JsxEmit } = require("typescript");
22const { readFile } = require(genDir + "tools/FileRW");
23const { generateEnum } = require(genDir + "generate/enum");
24const { jsToC, jsToCEnum, paramGenerate, paramGenerateArray, anyTempleteFunc,
25  objectTempleteFunc, unionTempleteFunc } = require(genDir + "generate/param_generate");
26const { paramGenerateMap, mapTempleteFunc, paramGenerateCommon, paramGenerateUnion, paramGenerateCallBack,
27  paramGenerateAny, paramGenerateObject } = require(genDir + "generate/param_generate");
28const { cToJs, cToJsForInterface, cToJsForType, returnGenerate,
29  objectTempleteFuncReturn } = require(genDir + "generate/return_generate");
30const { generateInterface, generateVariable, anyTypeString,
31  getHDefineOfVariable } = require(genDir + "generate/interface");
32const { mapTypeString, connectResult } = require(genDir + "generate/interface");
33const { generateNamespace, formatMiddleInit } = require(genDir + "generate/namespace");
34const { generateEnumResult, generateFunction } = require(genDir + "generate/namespace");
35const { generateFunctionAsync } = require(genDir + "generate/function_async");
36const { generateFunctionDirect } = require(genDir + "generate/function_direct");
37const { generateFunctionSync } = require(genDir + "generate/function_sync");
38const { generateFunctionOnOff } = require(genDir + "generate/function_onoff");
39const { generateThreadsafeFunc } = require(genDir + "generate/function_threadsafe");
40
41var correctResult
42
43function before() {
44    let data = readFile("test/unittest/result.json")
45
46    if (data) {
47        correctResult = JSON.parse(data)
48    }
49
50    result = analyzeFile("test/unittest/@ohos.input_sample.d.ts")
51}
52
53describe('Generate', function () {
54    before(function () {
55        before()
56    });
57
58    partOfEnum();
59
60    it('test gen/generate/function_async generateFunctionAsync', function () {
61        let retJson = funcAsyncAssert();
62        let struct = retJson.substring(retJson.indexOf("{"),retJson.indexOf("}")+1)
63        assert.strictEqual(struct,"{\\n    void *data_ptr = data;\\n    if_async_value_struct *vio = static_cast<if_async_value_struct *>(data_ptr);\\n    TestClass1 *pInstance = (TestClass1 *)pxt->GetAsyncInstance();\\n    pInstance->if_async(vio->in0, vio->outErrCode, vio->out);\\n}")
64
65        let execute = retJson.substring(retJson.indexOf("if_async_execute"),retJson.indexOf("*data")+6)
66        assert.strictEqual(execute,"if_async_execute(XNapiTool *pxt, DataPtr data)\\n{\\n    void *data_")
67        let complete = retJson.substring(retJson.indexOf("if_async_complete"),retJson.lastIndexOf("*data")+6)
68        assert.strictEqual(complete,"if_async_complete(XNapiTool *pxt, DataPtr data)\\n{\\n    void *data_")
69        let middle = retJson.substring(retJson.indexOf("if_async_middle"),retJson.indexOf("info)")+5)
70        assert.strictEqual(middle,"if_async_middle(napi_env env, napi_callback_info info)")
71    });
72
73    it('test gen/generate/function_direct generateFunctionDirect', function () {
74        let retJson = funcDirectAssert();
75        let struct = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1)
76        assert.strictEqual(struct, "{\\n    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\\n    if (pxt->IsFailed()) {\\n        napi_value err = pxt->GetError();\\n        delete pxt;\\n        return err;\\n    }")
77        let middle = retJson.substring(retJson.indexOf("if_direct_middle"), retJson.indexOf("info)") + 5)
78        assert.strictEqual(middle, "if_direct_middle(napi_env env, napi_callback_info info)")
79    });
80
81    it('test gen/generate/function_direct generateFunctionStaticDirect', function () {
82        let retJson = funcStaticDirectAssert();
83        let struct = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1);
84        assert.strictEqual(struct, "{\\n    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\\n    if (pxt->IsFailed()) {\\n        napi_value err = pxt->GetError();\\n        delete pxt;\\n        return err;\\n    }");
85        let middle = retJson.substring(retJson.indexOf("if_direct_middle"), retJson.indexOf("info)") + 5);
86        assert.strictEqual(middle, "if_direct_middle(napi_env env, napi_callback_info info)");
87        let implH = retJson.search("static bool if_direct");
88        assert.strictEqual(implH > 0, true);
89    });
90
91    it('test gen/generate/function_sync generateFunctionSync', function () {
92        let retJson = funcSyncAssert();
93        let struct = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1)
94        assert.strictEqual(struct, "{\\n    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\\n    if (pxt->IsFailed()) {\\n        napi_value err = pxt->GetError();\\n        delete pxt;\\n        return err;\\n    }")
95        let middle = retJson.substring(retJson.indexOf("if_callback_middle"), retJson.indexOf("info)") + 5)
96        assert.strictEqual(middle, "if_callback_middle(napi_env env, napi_callback_info info)")
97    });
98
99    partOfFuncOnOff();
100
101    partOfFuncThread();
102
103    partOfInterface(correctResult);
104
105    partOfTest();
106
107    partOfNamespace(correctResult)
108
109    partofParamGenerate(correctResult)
110
111});
112
113function funcAsyncAssert() {
114    let valueFi = { name: 'v1', type: 'string' };
115    let value1Se = { name: 'cb', type: 'AsyncCallback<string>' };
116    let funParam = { name: 'if_async', type: 4, value: [valueFi, value1Se], ret: 'string' }
117    let data = {
118        class: [],
119        const: [],
120        enum: [],
121        exports: [],
122        function: [{ name: 'if_async', type: 4, value: [valueFi, value1Se], ret: 'string' }],
123        interface: [],
124        namespace: [],
125        type: [],
126    }
127    let ret = generateFunctionAsync(funParam, data, 'TestClass1');
128    let retJson = JSON.stringify(ret);
129    return retJson
130}
131
132function funcDirectAssert() {
133    let valueFi = [{ name: 'v1', type: 'string', optional: false }, {name: 'v2', type: 'boolean', optional: true}];
134    let funParam = { name: 'if_direct', type: 1, value: valueFi, ret: 'string', isStatic: false };
135    let data = {
136        class: [],
137        const: [],
138        enum: [],
139        exports: [],
140        function: [{ name: 'if_direct', type: 1, value: [valueFi], ret: 'string', isStatic: false }],
141        interface: [],
142        namespace: [],
143        type: [],
144    }
145    let ret = generateFunctionDirect(funParam, data, 'TestClass1');
146    let retJson = JSON.stringify(ret);
147    return retJson
148}
149
150function funcStaticDirectAssert() {
151  let valueFi = { name: 'v1', type: 'string', optional: false };
152  let funParam = { name: 'if_direct', type: 1, value: [valueFi], ret: 'string', isStatic: true };
153  let data = {
154      class: [],
155      const: [],
156      enum: [],
157      exports: [],
158      function: [{ name: 'if_direct', type: 1, value: [valueFi], ret: 'string', isStatic: true }],
159      interface: [],
160      namespace: [],
161      type: [],
162  }
163  let ret = generateFunctionDirect(funParam, data, 'TestClass1');
164  let retJson = JSON.stringify(ret);
165  return retJson
166}
167
168function funcSyncAssert() {
169    let valueFi = { name: 'v1', type: 'string' };
170    let value1Se = { name: 'cb', type: 'Callback<string>' };
171    let funParam = { name: 'if_callback', type: 2, value: [valueFi, value1Se], ret: 'string' };
172    let data = {
173        class: [],
174        const: [],
175        enum: [],
176        exports: [],
177        function: [{ name: 'if_callback', type: 2, value: [valueFi, value1Se], ret: 'string' }],
178        interface: [],
179        namespace: [],
180        type: [],
181    }
182    let ret = generateFunctionSync(funParam, data, 'TestClass1');
183    let retJson = JSON.stringify(ret);
184    return retJson
185}
186
187function funcOnOffAssert(funcName) {
188  let valueFi = { name: 'v1', type: 'string', optional: false };
189  let value1Se = { name: 'cb', type: 'Callback<string>', optional: false };
190  let funParam = { name: funcName, type: 2, value: [valueFi, value1Se], ret: 'void' };
191  let data = {
192      class: [],
193      const: [],
194      enum: [],
195      exports: [],
196      function: [{ name: funcName, type: 2, value: [valueFi, value1Se], ret: 'string' }],
197      interface: [],
198      namespace: [],
199      type: [],
200  }
201  let ret = generateFunctionOnOff(funParam, data, 'TestClass1');
202  let retJson = JSON.stringify(ret);
203  return retJson;
204}
205
206function funcRegistUnregistAssert(funcName, type, retVal) {
207  let funParam = {
208    isParentMember: false,
209    isStatic: false,
210    name: funcName,
211    ret: retVal,
212    value: [{name: 'cb', optional: false, realType: type, type: type}]
213  }
214  let data = {
215    allProperties: {
216      functions: [{isParentMember: false, isStatic: false, name: funcName, ret: retVal, type: 2,
217        value: [{name: 'cb', optional: false, realType: type, type: type}]}],
218      values: []
219    },
220    childList: [],
221    function: [{isParentMember: false, isStatic: false, name: funcName, ret: retVal, type: 2,
222      value: [{name: 'cb', optional: false, realType: type, type: type}]}],
223    parentList: [],
224    parentNameList: [],
225    value: []
226  }
227  let ret = generateFunctionOnOff(funParam, data, 'TestClass1');
228
229  return ret
230}
231
232function partOfEnum() {
233    it('test gen/generate/enum generateEnum', function () {
234        let data = {
235            element: [{ name: "STATUS0", value: "0", type: "NUMBER_TYPE_1" }],
236            function: [],
237            enumValueType: 0
238        }
239        let ret = generateEnum('GrantStatus', data);
240        let retJson = JSON.stringify(ret);
241        let qiepianEnd = retJson.search('\"implCpp\":\"\"') - 1;
242        let actualResult = retJson.substring(1, qiepianEnd);
243        let expectresult = '"implH":"\\nenum class GrantStatus {\\n    STATUS0 = 0,\\n};\\n"';
244        assert.strictEqual(actualResult, expectresult);
245
246        let data2 = {
247            element: [{ name: "ACTION_HOME", value: "ohos.want.action.home", type: "string" }],
248            function: [],
249            enumValueType: 1
250        }
251        let ret2 = generateEnum('Action', data2);
252        let retJson2 = JSON.stringify(ret2);
253        let qiepianEnd2 = retJson2.search('\"implCpp\":') - 1;
254        let actualResult2 = retJson2.substring(1, qiepianEnd2);
255        let expectresult2 =
256          '"implH":"\\nclass Action {\\npublic:\\n    static const std::string ACTION_HOME;\\n};\\n"';
257        assert.strictEqual(actualResult2, expectresult2);
258    });
259}
260
261function funcThreadsafeAssert(funcName) {
262  let func = {
263    isParentMember: false,
264    isStatic: false,
265    name: funcName,
266    ret: 'void',
267    type: 1,
268    value: [{name: 'name', optional: false, realType: 'string', type: 'string'},
269      {name: 'callback', optional: false, realType: '(value', type: '(value'}]
270  }
271
272  let data = {
273    allProperties: {
274      functions: [{
275        isParentMember: false,
276        isStatic: false,
277        name: funcName,
278        ret: 'void',
279        type: 1,
280        value: [{name: 'name', optional: false, realType: 'string', type: 'string'},
281          {name: 'callback', optionalz: false, realType: 'string', type: 'string'}]
282      }],
283      values: [],
284    },
285    childList: [],
286    function: [{
287      isParentMember: false,
288      isStatic: false,
289      name: funcName,
290      ret: 'void',
291      type: 1,
292      value: [{name: 'name', optional: false, realType: 'string', type: 'string'},
293        {name: 'callback', optional: false, realType: 'string', type: 'string'}]
294    }],
295    parentList: [],
296    parentNameList: [],
297    value: []
298  }
299  let ret = generateThreadsafeFunc(func, data, 'TestClass1');
300  return ret;
301}
302
303function partOfFuncThread() {
304  it('test gen/generate/function_threadsafe generateThreadsafeFunc', function () {
305    let ret = funcThreadsafeAssert('createThreadSafeFuncClass1');
306    let middleCppRet = JSON.stringify(ret[0]);
307    let implHRet = JSON.stringify(ret[1]);
308    let implCppRet = JSON.stringify(ret[2]);
309    let middleHRet = JSON.stringify(ret[3]);
310    assert.strictEqual(implHRet, '""');
311    assert.strictEqual(implCppRet, '""');
312    assert.strictEqual(middleHRet, '"\\nstruct createThreadSafeFuncClass1_value_struct {\\n    std::string eventName;\\n};\\n\\nstatic  napi_value createThreadSafeFuncClass1_middle(napi_env env, napi_callback_info info);\\n"')
313    let index = middleCppRet.indexOf('status = napi_create_threadsafe_function(env, pxt->GetArgv(argc - 1), nullptr,')
314    assert.strictEqual(index > 0, true);
315    let indexRegisterFunc = middleCppRet.indexOf('pxt->RegistThreadsafeFunc(vio->eventName, threadsafeFunc);')
316    assert.strictEqual(indexRegisterFunc > 0, true);
317  });
318}
319
320function partOfFuncOnOff() {
321    // on/off test
322    it('test gen/generate/function_onoff generateFunctionOnOff on/off', function () {
323        let retJson = funcOnOffAssert('on');
324        let struct = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1)
325        assert.strictEqual(struct, "{\\n    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\\n    if (pxt->IsFailed()) {\\n        napi_value err = pxt->GetError();\\n        delete pxt;\\n        return err;\\n    }")
326        let middle = retJson.substring(retJson.indexOf("on_middle"), retJson.indexOf("info)") + 5)
327        assert.strictEqual(middle, "on_middle(napi_env env, napi_callback_info info)")
328
329        let retJson2 = funcOnOffAssert('off');
330        let struct2 = retJson2.substring(retJson2.indexOf("{"), retJson2.indexOf("}") + 1)
331        assert.strictEqual(struct2, "{\\n    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\\n    if (pxt->IsFailed()) {\\n        napi_value err = pxt->GetError();\\n        delete pxt;\\n        return err;\\n    }")
332        let middle2 = retJson2.substring(retJson2.indexOf("off_middle"), retJson2.indexOf("info)") + 5)
333        assert.strictEqual(middle2, "off_middle(napi_env env, napi_callback_info info)")
334    });
335
336    // registerXXX/UnregisterXXX test
337    partOfFuncRegistUnregist();
338}
339function partOfFuncRegistUnregist() {
340    // registerXXX test Function
341    it('test gen/generate/function_onoff generateFunctionOnOff registerXXX', function () {
342        let ret = funcRegistUnregistAssert('registerTestfunc11', 'Function', 'void');
343        let middleCppRet = ret[0];
344        let implHRet = ret[1];
345        let implCppRet = ret[2];
346        let middleHRet = ret[3];
347        let indexImplH = implHRet.indexOf('void Testfunc11Callback();');
348        assert.strictEqual(indexImplH >= 0, true);
349        let indexImplCpp = implCppRet.indexOf('ptr->Testfunc11CallbackMiddle(eventName);');
350        assert.strictEqual(indexImplCpp > 0, true);
351        let indexMiddleH = middleHRet.indexOf('struct registerTestfunc11_value_struct {');
352        assert.strictEqual(indexMiddleH >= 0, true);
353        let indexMiddleCpp = middleCppRet.indexOf('pxt->RegistOnOffFunc(vio->eventName, pxt->GetArgv(XNapiTool::ZERO));');
354        assert.strictEqual(indexMiddleCpp > 0, true);
355    });
356
357    // unRegisterXXX test Function
358    it('test gen/generate/function_onoff generateFunctionOnOff unRegisterXXX', function () {
359        let ret = funcRegistUnregistAssert('unRegisterTestfunc11', 'Function', 'void');
360        let middleCppRet = ret[0];
361        let implHRet = ret[1];
362        let implCppRet = ret[2];
363        let middleHRet = ret[3];
364        assert.strictEqual(JSON.stringify(implHRet), '""');
365        assert.strictEqual(JSON.stringify(implCppRet), '""');
366        let indexMiddleH = middleHRet.indexOf('struct unRegisterTestfunc11_value_struct {');
367        assert.strictEqual(indexMiddleH >= 0, true);
368        let indexMiddleCpp = middleCppRet.indexOf('pxt->UnregistOnOffFunc(vio->eventName);');
369        assert.strictEqual(indexMiddleCpp > 0, true);
370    });
371
372    // registerXXX/unRegisterXXX test Callback<boolean>
373    partOfFuncRegistUnregist2();
374}
375
376function partOfFuncRegistUnregist2() {
377  // registerXXX test Callback<boolean>
378  it('test gen/generate/function_onoff generateFunctionOnOff registerXXX', function () {
379    let ret = funcRegistUnregistAssert('registerTestfunc13', 'Callback<boolean>', 'void');
380    let middleCppRet = ret[0];
381    let implHRet = ret[1];
382    let implCppRet = ret[2];
383    let middleHRet = ret[3];
384    let indexImplH = implHRet.indexOf('void Testfunc13Callback(bool &valueIn);');
385    assert.strictEqual(indexImplH >= 0, true);
386    let indexImplCpp = implCppRet.indexOf('ptr->Testfunc13CallbackMiddle(eventName, valueIn);');
387    assert.strictEqual(indexImplCpp > 0, true);
388    let indexMiddleH = middleHRet.indexOf('struct registerTestfunc13_value_struct {');
389    assert.strictEqual(indexMiddleH >= 0, true);
390    let indexMiddleCpp = middleCppRet.indexOf('pxt->RegistOnOffFunc(vio->eventName, pxt->GetArgv(XNapiTool::ZERO));');
391    assert.strictEqual(indexMiddleCpp > 0, true);
392  });
393
394  // unRegisterXXX test Callback<boolean>
395  it('test gen/generate/function_onoff generateFunctionOnOff unRegisterXXX', function () {
396    let ret = funcRegistUnregistAssert('unRegisterTestfunc13', 'Callback<boolean>', 'void');
397    let middleCppRet = ret[0];
398    let implHRet = ret[1];
399    let implCppRet = ret[2];
400    let middleHRet = ret[3];
401    assert.strictEqual(JSON.stringify(implHRet), '""');
402    assert.strictEqual(JSON.stringify(implCppRet), '""');
403    let indexMiddleH = middleHRet.indexOf('struct unRegisterTestfunc13_value_struct {');
404    assert.strictEqual(indexMiddleH >= 0, true);
405    let indexMiddleCpp = middleCppRet.indexOf('pxt->UnregistOnOffFunc(vio->eventName);');
406    assert.strictEqual(indexMiddleCpp > 0, true);
407  });
408}
409
410function partOfInterface() {
411    partOfInterfaceOne();
412
413    it('test gen/generate/interface anyTypeString', function () {
414      let ret = anyTypeString("any", "v");
415      let result = "\n    std::string v_type;\n    std::any v;";
416      assert.strictEqual(JSON.stringify(ret), JSON.stringify(result));
417    });
418
419    partOfInterfaceFour();
420
421    it('test gen/generate/interface generateInterface', function () {
422        let data = {
423            function: [],
424            value: [{ name: "disable", type: "boolean" }, { name: "map1", type: "Map<string,string>" }]
425        }
426        let ret = generateInterface('ConfigOption', data, 'napitest::');
427        let retJson = JSON.stringify(ret).substring(1, JSON.stringify(ret).length);
428        let configOption = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1);
429        let configResult = "{\\npublic:\\n    bool disable;\\n    std::map<std::string, std::string> map1;\\n\\n}";
430        assert.strictEqual(configOption, configResult);
431        assert.strictEqual(retJson.search("ConfigOption_middle") > 0, true)
432        assert.strictEqual(retJson.search("middleInit") > 0, true)
433    });
434
435    partOfInterfaceTwo();
436    partOfInterfaceThree();
437}
438
439function partOfInterfaceFour() {
440    it('test gen/generate/interface mapTypeString', function () {
441        let ret = mapTypeString("Map<string,string>", "map1");
442        let result = "\n    std::map<std::string, std::string> map1;";
443        assert.strictEqual(JSON.stringify(ret), JSON.stringify(result));
444
445        let ret2 = mapTypeString("Map<string,NUMBER_TYPE_1>", "map1");
446        let result2 = "\n    std::map<std::string, NUMBER_TYPE_1> map1;";
447        assert.strictEqual(JSON.stringify(ret2), JSON.stringify(result2));
448
449        let ret3 = mapTypeString("Map<string,boolean>", "map1");
450        let result3 = "\n    std::map<std::string, bool> map1;";
451        assert.strictEqual(JSON.stringify(ret3), JSON.stringify(result3));
452
453        let ret4 = mapTypeString("{[key:string]:string}", "map1");
454        let result4 = "\n    std::map<std::string, std::string> map1;";
455        assert.strictEqual(JSON.stringify(ret4), JSON.stringify(result4));
456
457        let ret5 = mapTypeString("{[key:string]:NUMBER_TYPE_1}", "map1");
458        let result5 = "\n    std::map<std::string, NUMBER_TYPE_1> map1;";
459        assert.strictEqual(JSON.stringify(ret5), JSON.stringify(result5));
460
461        let ret6 = mapTypeString("{[key:string]:boolean}", "map1");
462        let result6 = "\n    std::map<std::string, bool> map1;";
463        assert.strictEqual(JSON.stringify(ret6), JSON.stringify(result6));
464
465        let ret7 = mapTypeString("Map<string,Map<string,string>>", "map1");
466        let result7 = "\n    std::map<std::string, std::map<std::string, std::string>> map1;";
467        assert.strictEqual(JSON.stringify(ret7), JSON.stringify(result7));
468
469        let ret8 = mapTypeString("{[key:string]:{[key:string]:string}}", "map1");
470        let result8 = "\n    std::map<std::string, std::map<std::string, std::string>> map1;";
471        assert.strictEqual(JSON.stringify(ret8), JSON.stringify(result8));
472
473        let ret9 = mapTypeString("Map<string,string[]>", "map1");
474        let result9 = "\n    std::map<std::string, std::vector<std::string>> map1;";
475        assert.strictEqual(JSON.stringify(ret9), JSON.stringify(result9));
476
477        let ret10 = mapTypeString("Map<string,Array<string>>", "map1");
478        let result10 = "\n    std::map<std::string, std::vector<std::string>> map1;";
479        assert.strictEqual(JSON.stringify(ret10), JSON.stringify(result10));
480    });
481}
482
483function partOfInterfaceOne() {
484    it('test gen/generate/interface generateVariable', function () {
485        // test basic type
486        let retBool = generateVariableAsset("boolean");
487        let ex = JSON.stringify(variableMiddleBoolValue())
488        assert.strictEqual(retBool, ex);
489
490        // test Array
491        let retArrStr = generateVariableAsset("Array<string>");
492        retArrStr = re.replaceAll(retArrStr, "tt[0-9]+", "tt");
493        retArrStr = re.replaceAll(retArrStr, "tnv[0-9]+", "tnv");
494        retArrStr = re.replaceAll(retArrStr, "outLen[0-9]+", "outLen");
495        retArrStr = re.replaceAll(retArrStr, "len[0-9]+", "len");
496        retArrStr = re.replaceAll(retArrStr, "i[0-9]+", "i");
497        let resultArrStr = JSON.stringify(variableMiddleArrStrValue());
498        assert.strictEqual(retArrStr, resultArrStr);
499
500        let retArrStr2 = generateVariableAsset("string[]");
501        retArrStr2 = re.replaceAll(retArrStr2, "tt[0-9]+", "tt");
502        retArrStr2 = re.replaceAll(retArrStr2, "tnv[0-9]+", "tnv");
503        retArrStr2 = re.replaceAll(retArrStr2, "outLen[0-9]+", "outLen");
504        retArrStr2 = re.replaceAll(retArrStr2, "len[0-9]+", "len");
505        retArrStr2 = re.replaceAll(retArrStr2, "i[0-9]+", "i");
506        assert.strictEqual(retArrStr2, resultArrStr);
507
508        // test Map
509        let retMapStr = generateVariableAsset("Map<string, string>");
510        let resultMapStr = JSON.stringify(variableMiddleMapStrValue());
511        retMapStr = re.replaceAll(retMapStr, "tt[0-9]+", "tt");
512        retMapStr = re.replaceAll(retMapStr, "tnv[0-9]+", "tnv");
513        retMapStr = re.replaceAll(retMapStr, "len[0-9]+", "len");
514        retMapStr = re.replaceAll(retMapStr, "i[0-9]+", "i");
515        assert.strictEqual(retMapStr, resultMapStr);
516
517        let retMapStr2 = generateVariableAsset("{[key:string]: string}");
518        let resultMapStr2 = JSON.stringify(variableMiddleMapStrValue());
519        retMapStr2 = re.replaceAll(retMapStr2, "tt[0-9]+", "tt");
520        retMapStr2 = re.replaceAll(retMapStr2, "tnv[0-9]+", "tnv");
521        retMapStr2 = re.replaceAll(retMapStr2, "len[0-9]+", "len");
522        retMapStr2 = re.replaceAll(retMapStr2, "i[0-9]+", "i");
523        assert.strictEqual(retMapStr2, resultMapStr2);
524    });
525}
526
527function generateVariableAsset(valType) {
528    let variable = {
529        hDefine: "",
530        middleValue: "",
531    };
532    let value = {
533        name: "disable",
534        type: valType,
535    }
536    generateVariable(value, variable, 'ConfigOption');
537    let ret = JSON.stringify(variable.middleValue);
538    return ret;
539}
540
541function partOfInterfaceThree() {
542    it('test gen/generate/interface getHDefineOfVariable', function () {
543        let retStr = getHDefineOfVariableAsset("string");
544        let resultStr = "\"\\n    std::string vName;\"";
545        assert.strictEqual(retStr, resultStr);
546
547        let retBool = getHDefineOfVariableAsset("boolean");
548        let resultBool = "\"\\n    bool vName;\"";
549        assert.strictEqual(retBool, resultBool);
550
551        let retNum = getHDefineOfVariableAsset("NUMBER_TYPE_1");
552        let resultNum = "\"\\n    NUMBER_TYPE_1 vName;\"";
553        assert.strictEqual(retNum, resultNum);
554
555        let retArrStr1 = getHDefineOfVariableAsset("Array<string>");
556        let resultArrStr1 = "\"\\n    std::vector<std::string> vName;\"";
557        assert.strictEqual(retArrStr1, resultArrStr1);
558
559        let retArrAny1 = getHDefineOfVariableAsset("Array<any>");
560        let resultArrAny1 = "\"\\n    std::string vName_type; \\n    std::any vName;\"";
561        assert.strictEqual(retArrAny1, resultArrAny1);
562
563        let retArrStr2 = getHDefineOfVariableAsset("string[]");
564        let resultArrStr2 = "\"\\n    std::vector<std::string> vName;\"";
565        assert.strictEqual(retArrStr2, resultArrStr2);
566
567        let retArrAny2 = getHDefineOfVariableAsset("any[]");
568        let resultArrAny2 = "\"\\n    std::string vName_type;\\n    std::any vName;\"";
569        assert.strictEqual(retArrAny2, resultArrAny2);
570
571        let retObject = getHDefineOfVariableAsset("Object");
572        let resultObject= "\"\\n    std::map<std::string, std::any> vName;\"";
573        assert.strictEqual(retObject, resultObject);
574    });
575}
576
577function getHDefineOfVariableAsset(valType) {
578    let variable = {
579        hDefine: "",
580        middleValue: ""
581    }
582    getHDefineOfVariable("vName", valType, variable);
583    let ret = variable.hDefine;
584    return JSON.stringify(ret);
585}
586
587function partOfInterfaceTwo() {
588    it('test gen/generate/interface connectResult', function () {
589        let data = {
590            function: [],
591            value: [{ name: "disable", type: "boolean" }, { name: "map1", type: "Map<string,string>" }]
592        }
593        let ret = connectResult(data, 'napitest::', 'ConfigOption');
594        let retJson = JSON.stringify(ret);
595        let getDisable = retJson.search("static napi_value getvalue_disable");
596        assert.strictEqual(getDisable > 0, true)
597        let setDisable = retJson.search("static napi_value setvalue_disable");
598        assert.strictEqual(setDisable > 0, true)
599        let getMap1 = retJson.search("static napi_value getvalue_map1");
600        assert.strictEqual(getMap1 > 0, true)
601        let setMap1 = retJson.search("static napi_value setvalue_map1");
602        assert.strictEqual(setMap1 > 0, true)
603    });
604}
605
606function partOfTest() {
607    it('test gen/generate/param_generate jsToC', function () {
608        assert.strictEqual(jsToC("a", "b", "string"), "pxt->SwapJs2CUtf8(b, a);");
609
610        assert.strictEqual(jsToC("a", "b", "NUMBER_TYPE_1"), "NUMBER_JS_2_C(b, NUMBER_TYPE_1, a);");
611
612        assert.strictEqual(jsToC("a", "b", "boolean"), "BOOLEAN_JS_2_C(b, bool, a);\n");
613
614        let retJsToC = JSON.stringify(jsToC("a", "b", "Array<string>"));
615        retJsToC = re.replaceAll(retJsToC, "len[0-9]*", "len");
616        retJsToC = re.replaceAll(retJsToC, "i[0-9]*", "i");
617        retJsToC = re.replaceAll(retJsToC, "tt[0-9]*", "tt");
618        assert.strictEqual(retJsToC, JSON.stringify(jsToCParam()));
619
620        let retJsToC1 = JSON.stringify(jsToC("a", "b", "string[]"));
621        retJsToC1 = re.replaceAll(retJsToC1, "len[0-9]*", "len");
622        retJsToC1 = re.replaceAll(retJsToC1, "i[0-9]*", "i");
623        retJsToC1 = re.replaceAll(retJsToC1, "tt[0-9]*", "tt");
624        assert.strictEqual(retJsToC1, JSON.stringify(jsToCParamArray()));
625
626        let retJsToC2 = JSON.stringify(jsToC("a", "b", "{[key:string]:boolean}"));
627        retJsToC2 = re.replaceAll(retJsToC2, "len[0-9]*", "len");
628        retJsToC2 = re.replaceAll(retJsToC2, "i[0-9]*", "i");
629        retQiepian = retJsToC2.substring(retJsToC2.indexOf("tt"), retJsToC2.indexOf("tt") + 3)
630        retJsToC2 = re.replaceAll(retJsToC2, retQiepian, "tt");
631        retJsToC2 = re.replaceAll(retJsToC2, "tt[0-9]+", "tt1");
632        assert.strictEqual(retJsToC2, JSON.stringify(jsToCParamMap()));
633
634        let retJsToC3 = JSON.stringify(jsToC("a", "b", "Map<string,number>"));
635        retJsToC3 = re.replaceAll(retJsToC3, "len[0-9]*", "len");
636        retJsToC3 = re.replaceAll(retJsToC3, "i[0-9]*", "i");
637        retQiepian = retJsToC3.substring(retJsToC3.indexOf("tt"), retJsToC3.indexOf("tt") + 3)
638        retJsToC3 = re.replaceAll(retJsToC3, retQiepian, "tt");
639        retJsToC3 = re.replaceAll(retJsToC3, "tt[1-9]+", "tt1");
640        assert.strictEqual(retJsToC3, JSON.stringify(jsToCParamMap1()));
641    });
642
643    it('test gen/generate/param_generate jsToCEnum', function () {
644        let ret = jsToCEnum('string', 'vio->in0', 'pxt->GetArgv(0)')
645        let retJson = JSON.stringify(ret)
646        assert.strictEqual(retJson, 'null')
647    });
648
649    partOfTestTwo()
650}
651
652function partOfTestTwo(){
653    it('test gen/generate/return_generate cToJs', function () {
654        assert.strictEqual(cToJs("a", "string", "b", 1), "b = pxt->SwapC2JsUtf8(a.c_str());\n")
655
656        ret = cToJs("a", "NUMBER_TYPE_1", "b", 1)
657        assert.strictEqual(ret, "b = NUMBER_C_2_JS(pxt, a);\n")
658
659        ret1 = cToJs("a", "boolean", "b", 1)
660        assert.strictEqual(ret1, "b = pxt->SwapC2JsBool(a);\n")
661
662        ret2 = cToJs("a", "void", "b", 1)
663        assert.strictEqual(ret2, "b = pxt->UndefinedValue();\n")
664
665        ret3 = cToJs("a", "any", "b", 1)
666        assert.strictEqual(ret3, "pxt->GetAnyValue(a_type, result, a);")
667
668        let retcToJs = JSON.stringify(cToJs("a", "Array<string>", "b", 1))
669        retcToJs = re.replaceAll(retcToJs, "len[0-9]*", "len")
670        retcToJs = re.replaceAll(retcToJs, "i[0-9]*", "i")
671        retcToJs = re.replaceAll(retcToJs, "tnv[0-9]*", "tnv")
672        assert.strictEqual(retcToJs, JSON.stringify(cToJsParamArray()))
673
674        let retcToJs1 = JSON.stringify(cToJs("a", "string[]", "b", 1))
675        retcToJs1 = re.replaceAll(retcToJs1, "len[0-9]*", "len")
676        retcToJs1 = re.replaceAll(retcToJs1, "i[0-9]*", "i")
677        retcToJs1 = re.replaceAll(retcToJs1, "tnv[0-9]*", "tnv")
678        assert.strictEqual(retcToJs1, JSON.stringify(cToJsParamArray()))
679
680        let retcToJs2 = JSON.stringify(cToJs("a", "Map<string,string>", "b", 1))
681        retcToJs2 = re.replaceAll(retcToJs2, "i[0-9]*", "i")
682        retQiepian = retcToJs2.substring(retcToJs2.indexOf("tnv"), retcToJs2.indexOf("tnv") + 4)
683        retcToJs2 = re.replaceAll(retcToJs2, retQiepian, "tnv")
684        retcToJs2 = re.replaceAll(retcToJs2, "tnv[0-9]+", "tnv1")
685        assert.strictEqual(retcToJs2, JSON.stringify(cToJsParamMap()))
686
687        let retcToJs3 = JSON.stringify(cToJs("a", "{[key:string]:string}", "b", 1))
688        retcToJs3 = re.replaceAll(retcToJs3, "i[0-9]*", "i")
689        retQiepian = retcToJs3.substring(retcToJs3.indexOf("tnv"), retcToJs3.indexOf("tnv") + 4)
690        retcToJs3 = re.replaceAll(retcToJs3, retQiepian, "tnv")
691        retcToJs3 = re.replaceAll(retcToJs3, "tnv[0-9]+", "tnv1")
692        assert.strictEqual(retcToJs3, JSON.stringify(cToJsParamMap1()))
693    });
694
695    partOfTestTwo2();
696}
697
698function partOfTestTwo2() {
699    it('test gen/generate/return_generate cToJsForInterface', function () {
700        let ret = cToJsForInterface('vio->out', 'ConfigOption', 'result', 1)
701        let retJson = JSON.stringify(ret)
702        assert.strictEqual(retJson, '""')
703    });
704
705    it('test gen/generate/return_generate cToJsForType', function () {
706        let ret = cToJsForType('vio->out', 'ConfigOption', 'result', 1)
707        let retJson = JSON.stringify(ret)
708        assert.strictEqual(retJson, '""')
709    });
710
711    it('test gen/generate/return_generate objectTempleteFuncReturn', function () {
712        let ret = objectTempleteFuncReturn('vio->out');
713        let retJson = JSON.stringify(ret)
714        assert.strictEqual(retJson, '"pxt->GetObjectValue(result, vio->out);"')
715    });
716}
717
718function variableMiddleBoolValue() {
719    let variableMidVal = '\n      ' +
720    '    napi_value ConfigOption_middle::getvalue_disable(napi_env env, napi_callback_info info)\n    ' +
721    '    {\n        ' +
722    '    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\n        ' +
723    '    void *instPtr = pxt->UnWarpInstance();\n        ' +
724    '    ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n        ' +
725    '    napi_value result = nullptr;\n          ' +
726    '    result = pxt->SwapC2JsBool(p->disable);\n\n        ' +
727    '    delete pxt;\n        ' +
728    '    return result;\n    ' +
729    '    }\n      ' +
730    '    napi_value ConfigOption_middle::setvalue_disable(napi_env env, napi_callback_info info)\n    ' +
731    '    {\n        ' +
732    '    std::shared_ptr<XNapiTool> pxt = std::make_shared<XNapiTool>(env, info);\n        ' +
733    '    void *instPtr = pxt->UnWarpInstance();\n        ' +
734    '    ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n          ' +
735    '    BOOLEAN_JS_2_C(pxt->GetArgv(XNapiTool::ZERO), bool, p->disable);\n\n        ' +
736    '    return nullptr;\n    ' +
737    '    }'
738    return  variableMidVal
739}
740
741function variableMiddleArrStrValue() {
742    let variableMidVal = '\n      ' +
743        '    napi_value ConfigOption_middle::getvalue_disable(napi_env env, napi_callback_info info)\n    ' +
744        '    {\n        ' +
745        '    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\n        ' +
746        '    void *instPtr = pxt->UnWarpInstance();\n        ' +
747        '    ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n        ' +
748        '    napi_value result = nullptr;\n          ' +
749        '    pxt->CreateArray(result);\n' +
750        '    uint32_t outLen = p->disable.size();\n' +
751        '    for (uint32_t i = 0; i < outLen; i++) {\n    ' +
752        '    napi_value tnv = nullptr;\n    ' +
753        '    tnv = pxt->SwapC2JsUtf8(p->disable[i].c_str());\n    ' +
754        '    pxt->SetArrayElement(result, i, tnv);\n    }\n        ' +
755        '    delete pxt;\n        ' +
756        '    return result;\n    ' +
757        '    }\n      ' +
758        '    napi_value ConfigOption_middle::setvalue_disable(napi_env env, napi_callback_info info)\n    ' +
759        '    {\n        ' +
760        '    std::shared_ptr<XNapiTool> pxt = std::make_shared<XNapiTool>(env, info);\n        ' +
761        '    void *instPtr = pxt->UnWarpInstance();\n        ' +
762        '    ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n              ' +
763        '    uint32_t len = pxt->GetArrayLength(pxt->GetArgv(XNapiTool::ZERO));\n' +
764        '    for (uint32_t i = 0; i < len; i++) {\n    ' +
765        '    std::string tt;\n    ' +
766        '    pxt->SwapJs2CUtf8(pxt->GetArrayElement(pxt->GetArgv(XNapiTool::ZERO), i), tt);\n    ' +
767        '    p->disable.push_back(tt);\n    }\n\n        ' +
768        '    return nullptr;\n    ' +
769        '    }'
770    return variableMidVal;
771}
772
773function variableMiddleMapStrValue() {
774    // let variableMidVal = '\n      ' +
775    //     '    static napi_value getvalue_disable(napi_env env, napi_callback_info info)\n    {\n    ' +
776    //     '    XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\n    ' +
777    //     '    void *instPtr = pxt->UnWarpInstance();\n    ' +
778    //     '    ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n    ' +
779    //     '    napi_value result = nullptr;\n    ' +
780    //     '    result = nullptr;\n' +
781    //     '    for (auto i = p->disable.begin(); i != p->disable.end(); i++) {\n    ' +
782    //     '    const char * tnv;\n    ' +
783    //     '    napi_value tnv = nullptr;\n    ' +
784    //     '    tnv = (i -> first).c_str();\n    ' +
785    //     '    tnv = pxt->SwapC2JsUtf8(i->second.c_str());\n    ' +
786    //     '    pxt->SetMapElement(result, tnv, tnv);\n    }\n    ' +
787    //     '    delete pxt;\n    ' +
788    //     '    return result;\n    }\n' +
789    //     '    static napi_value setvalue_disable(napi_env env, napi_callback_info info)\n    {\n    ' +
790    //     '    std::shared_ptr<XNapiTool> pxt = std::make_shared<XNapiTool>(env, info);\n    ' +
791    //     '    void *instPtr = pxt->UnWarpInstance();\n    ' +
792    //     '    ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n    ' +
793    //     '    uint32_t len = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO));\n' +
794    //     'for (uint32_t i = 0; i < len; i++) {\n' +
795    //     '    std::string tt;\n' +
796    //     '    std::string tt;\n' +
797    //     '    pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i), tt);\n    ' +
798    //     '    pxt->SwapJs2CUtf8(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt.c_str()), tt);\n\n' +
799    //     '    p->disable.insert(std::make_pair(tt, tt));\n}\n    ' +
800    //     '    return nullptr;\n    }'
801
802    let variableMidVal = "\n          napi_value ConfigOption_middle::getvalue_disable(napi_env env, napi_callback_info info)\n        {\n            XNapiTool *pxt = std::make_unique<XNapiTool>(env, info).release();\n            void *instPtr = pxt->UnWarpInstance();\n            ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n            napi_value result = nullptr;\n              result = nullptr;\n    for (auto i = p->disable.begin(); i != p->disable.end(); i++) {\n        const char * tnv;\n        napi_value tnv = nullptr;\n        tnv = (i -> first).c_str();\n        tnv = pxt->SwapC2JsUtf8(i->second.c_str());\n        pxt->SetMapElement(result, tnv, tnv);\n    }\n            delete pxt;\n            return result;\n        }\n          napi_value ConfigOption_middle::setvalue_disable(napi_env env, napi_callback_info info)\n        {\n            std::shared_ptr<XNapiTool> pxt = std::make_shared<XNapiTool>(env, info);\n            void *instPtr = pxt->UnWarpInstance();\n            ConfigOption *p = static_cast<ConfigOption *>(instPtr);\n              uint32_t len = pxt->GetMapLength(pxt->GetArgv(XNapiTool::ZERO));\nfor (uint32_t i = 0; i < len; i++) {\n    std::string tt;\n    std::string tt;\n    pxt->SwapJs2CUtf8(pxt->GetMapElementName(pxt->GetArgv(XNapiTool::ZERO), i), tt);\n        pxt->SwapJs2CUtf8(pxt->GetMapElementValue(pxt->GetArgv(XNapiTool::ZERO), tt.c_str()), tt);\n\n    p->disable.insert(std::make_pair(tt, tt));\n}\n            return nullptr;\n        }"
803    return variableMidVal;
804}
805
806function cToJsParamArray() {
807    let value = 'pxt->CreateArray(b);\n' +
808    '    uint32_t outLen1 = a.size();\n' +
809    '    for (uint32_t i = 0; i < outLen1; i++) {\n' +
810    '        napi_value tnv = nullptr;\n' +
811    '        tnv = pxt->SwapC2JsUtf8(a[i].c_str());\n' +
812    '        pxt->SetArrayElement(b, i, tnv);\n' +
813    '    }'
814    return value
815}
816
817function cToJsParamMap() {
818    let value = 'result = nullptr;\n' +
819        '    for (auto i = a.begin(); i != a.end(); i++) {\n' +
820        '        const char * tnv;\n' +
821        '        napi_value tnv1 = nullptr;\n' +
822        '        tnv = (i -> first).c_str();\n' +
823        '        tnv1 = pxt->SwapC2JsUtf8(i->second.c_str());\n' +
824        '        pxt->SetMapElement(b, tnv, tnv1);\n' +
825        '    }'
826    return value
827}
828
829function cToJsParamMap1() {
830    let value = 'result = nullptr;\n' +
831        '    for (auto i = a.begin(); i != a.end(); i++) {\n' +
832        '        const char * tnv;\n' +
833        '        napi_value tnv1 = nullptr;\n' +
834        '        tnv = (i -> first).c_str();\n' +
835        '        tnv1 = pxt->SwapC2JsUtf8(i->second.c_str());\n' +
836        '        pxt->SetMapElement(b, tnv, tnv1);\n' +
837        '    }'
838    return value
839}
840
841function jsToCParam() {
842    let value = '    uint32_t len = pxt->GetArrayLength(b);\n' +
843        '    for (uint32_t i = 0; i < len; i++) {\n' +
844        '        std::string tt;\n' +
845        '        pxt->SwapJs2CUtf8(pxt->GetArrayElement(b, i), tt);\n' +
846        '        a.push_back(tt);\n' +
847        '    }\n'
848    return value
849}
850
851function jsToCParamArray() {
852    let value = '    uint32_t len = pxt->GetArrayLength(b);\n' +
853        '    for (uint32_t i = 0; i < len; i++) {\n' +
854        '        std::string tt;\n' +
855        '        pxt->SwapJs2CUtf8(pxt->GetArrayElement(b, i), tt);\n' +
856        '        a.push_back(tt);\n' +
857        '    }\n'
858    return value
859}
860
861function jsToCParamMap() {
862    let value = 'uint32_t len = pxt->GetMapLength(b);\n' +
863        'for (uint32_t i = 0; i < len; i++) {\n' +
864        '    std::string tt1;\n' +
865        '    bool tt1;\n' +
866        '    pxt->SwapJs2CUtf8(pxt->GetMapElementName(b, i), tt1);\n' +
867        '        tt1 = pxt->SwapJs2CBool(pxt->GetMapElementValue(b, tt1.c_str()));\n' +
868        '\n' +
869        '    a.insert(std::make_pair(tt1, tt1));\n' +
870        '}'
871    return value
872}
873
874function jsToCParamMap1() {
875    // let value = 'uint32_t len = pxt->GetMapLength(b);\n' +
876    //     'for (uint32_t i = 0; i < len; i++) {\n' +
877    //     '    std::string tt;\n' +
878    //     '    number tt1;\n' +
879    //     '    [replace_swap]\n' +
880    //     '    a.insert(std::make_pair(tt, tt1));\n' +
881    //     '}'
882    // let value = "uint32_t len = pxt->GetMapLength(b);\nfor (uint32_t i = 0; i < len; i++) {\n    std::string tt0;\n    number tt1;\n    [replace_swap]\n    a.insert(std::make_pair(tt0, tt1));\n}"
883    let value = "uint32_t len = pxt->GetMapLength(b);\nfor (uint32_t i = 0; i < len; i++) {\n    std::string tt1;\n    number tt1;\n    [replace_swap]\n    a.insert(std::make_pair(tt1, tt1));\n}"
884    return value
885}
886
887function partOfNamespace(correctResult) {
888    it('test gen/generate/namespace generateNamespace', function () {
889        let enumElement = [{ name: "name", value: "", type: "string" }];
890        let interfaceBody = { function: [], value: [{ name: "age", type: "NUMBER_TYPE_1" }] }
891        let data = {
892            class: [],
893            const: [],
894            enum: [{ name: "TestEnum", body: { element: enumElement, function: [], enumValueType: 0 } }],
895            export: [],
896            function: [{ name: "fun1", type: 1, value: [{ name: "v", type: "Array<string>" }], ret: "string" }],
897            interface: [{ name: "TestInterface", body: interfaceBody }],
898            namespace: []
899        };
900        let retJson = JSON.stringify(generateNamespace('napitest', data, inNamespace = ""));
901        retJson = re.replaceAll(retJson, " ", "")
902        retJson = re.replaceAll(retJson, "\\n", "")
903        retJson = re.replaceAll(retJson, "len[0-9]+", "len")
904        retJson = re.replaceAll(retJson, "i[0-9]+", "i")
905        retJson = re.replaceAll(retJson, "tt[0-9]+", "tt")
906        assert.strictEqual(retJson, correctResult['Generate']['generateNamespace']);
907    });
908
909    it('test gen/generate/namespace generateEnumResult', function () {
910        let data = {
911            "exports": ["GrantStatus"],
912            "enum": [{
913                "name": "GrantStatus",
914                "body": {
915                    "element": [
916                        { "name": "PERMISSION_DEFAULT", "value": "", "type": "string" }],
917                    "function": [],
918                    "enumValueType": 1
919                }
920            }],
921            "const": [],
922            "type": [],
923            "function": [],
924            "interface": [],
925            "class": [],
926            "namespace": []
927        };
928        let retJson = JSON.stringify(generateEnumResult(data));
929        let actualResult = retJson.substring(1,retJson.indexOf("implCpp") - 2);
930        let expectresult1 = "\"implH\":\"\\nclass GrantStatus {\\npublic:\\n    ";
931        let expectresult2 = "static const std::string PERMISSION_DEFAULT;\\n};\\n\"";
932        assert.strictEqual(actualResult, expectresult1 + expectresult2);
933    });
934
935    partOfNamespaceTwo();
936}
937function partOfNamespaceTwo(){
938    it('test gen/generate/namespace generateFunction', function () {
939        let func = { name: "fun1", type: 4, value: [{ name: "cb", type: "AsyncCallback<string>" }] };
940        let funcValue = [{ name: "cb", type: "AsyncCallback<string>" }]
941        let data = {
942            class: [],
943            const: [],
944            enum: [],
945            export: [],
946            function: [{ name: "fun1", type: 4, value: funcValue, ret: "string" }],
947            interface: [],
948            namespace: []
949        };
950        let retJson = JSON.stringify(generateFunction(func, data));
951        retJson = re.replaceAll(retJson, "  ", "")
952        assert.strictEqual(retJson, correctResult['Generate']['generateFunction']);
953    });
954
955    it('test gen/generate/namespace formatMiddleInit', function () {
956        let ret = formatMiddleInit('', 'napitest');
957        assert.strictEqual(JSON.stringify(ret), '""');
958    })
959}
960
961function partofParamGenerate(correctResult) {
962    partofParamGenerateArr(correctResult);
963
964    partofParamGenerateMap(correctResult);
965
966    partofParamGenerateCommon(correctResult);
967
968    partofParamGenerateUnion(correctResult);
969
970    partofParamGenerateCallBack(correctResult);
971
972    partofParamGenerateAny(correctResult);
973
974    partofParamGenerateObject(correctResult);
975
976    partmapTempleteFunc()
977
978    partunionTempleteFunc()
979
980    partanyTempleteFunc()
981
982    partobjectTempleteFunc()
983
984    it('test gen/generate/param_generate ParamGenerate', function () {
985        paramGenerateResult(correctResult);
986    });
987
988    it('test gen/generate/return_generate returnGenerate', function () {
989        returnGenerateParam(correctResult);
990    });
991}
992
993function partofParamGenerateArr(correctResult) {
994    it('test gen/generate/param_generate paramGenerateArray', function () {
995        let param = {
996            valueCheckout: '',
997            valueDefine: '',
998            valueFill: '',
999            valueIn: '',
1000            valueOut: '',
1001            valuePackage: ''
1002        }
1003        let funcValue = { name: 'v', type: 'Array<string>' }
1004        paramGenerateArray('0', funcValue, param);
1005        let retParam = JSON.stringify(param);
1006        retParam = re.replaceAll(retParam,"  ","");
1007        retParam = re.replaceAll(retParam,"len[0-9]+","len")
1008        retParam = re.replaceAll(retParam,"i[0-9]+","i")
1009        retParam = re.replaceAll(retParam,"tt[0-9]+","tt")
1010        assert.strictEqual(retParam, correctResult['Generate']['paramGenerateArray'])
1011    });
1012}
1013
1014function partofParamGenerateMap(correctResult) {
1015    it('test gen/generate/param_generate paramGenerateMap', function () {
1016        let param1 = {
1017            optionalParamDestory: '',
1018            valueCheckout: '',
1019            valueDefine: '',
1020            valueFill: '',
1021            valueIn: '',
1022            valueOut: '',
1023            valuePackage: ''
1024        }
1025        let funcVlaue = { name: 'v', type: '{[key:string]:string}', optional: false };
1026        paramGenerateMap(funcVlaue, param1, '0');
1027        let retParam1 = JSON.stringify(param1);
1028        retParam1 = re.replaceAll(retParam1,"  ","");
1029        retParam1 = re.replaceAll(retParam1,"len[0-9]+","len")
1030        retParam1 = re.replaceAll(retParam1,"i[0-9]+","i")
1031        let parmQiepian = retParam1.substring(retParam1.indexOf("tt"),retParam1.indexOf("tt")+3)
1032        retParam1 = re.replaceAll(retParam1,parmQiepian,"tt")
1033        retParam1 = re.replaceAll(retParam1,"tt[0-9]+","tt")
1034        assert.strictEqual(retParam1, correctResult['Generate']['paramGenerateMap'])
1035    });
1036}
1037
1038function partofParamGenerateCommon(correctResult) {
1039    it('test gen/generate/param_generate paramGenerateCommon', function () {
1040        let param1 = {
1041            optionalParamDestory: '',
1042            valueCheckout: '',
1043            valueDefine: '',
1044            valueFill: '',
1045            valueIn: '',
1046            valueOut: '',
1047            valuePackage: ''
1048        }
1049        let funcVlaue = { name: 'v', type: 'string', optional: false };
1050        paramGenerateCommon('0', 'std::string', funcVlaue, param1, '&', 'vio->in0');
1051        let retParam1 = JSON.stringify(param1);
1052        retParam1 = re.replaceAll(retParam1,"  ","");
1053        retParam1 = re.replaceAll(retParam1,"len[0-9]+","len")
1054        retParam1 = re.replaceAll(retParam1,"i[0-9]+","i")
1055        retParam1 = re.replaceAll(retParam1,"tt[0-9]+","tt")
1056        assert.strictEqual(retParam1, correctResult['Generate']['paramGenerateCommon'])
1057    });
1058}
1059
1060function partofParamGenerateUnion(correctResult) {
1061    it('test gen/generate/param_generate paramGenerateUnion', function () {
1062        let param1 = {
1063            optionalParamDestory: '',
1064            valueCheckout: '',
1065            valueDefine: '',
1066            valueFill: '',
1067            valueIn: '',
1068            valueOut: '',
1069            valuePackage: ''
1070        }
1071        paramGenerateUnion('string|NUMBER_TYPE_1|boolean', param1, '0', 'v');
1072        let retParam1 = JSON.stringify(param1);
1073        retParam1 = re.replaceAll(retParam1,"  ","");
1074        assert.strictEqual(retParam1, correctResult['Generate']['paramGenerateUnion'])
1075    });
1076}
1077
1078function partofParamGenerateCallBack(correctResult) {
1079    it('test gen/generate/param_generate paramGenerateCallBack', function () {
1080        let data = {
1081            class: [],
1082            const: [],
1083            enum:  [],
1084            exports: [],
1085            function: [
1086                {isStatic: false,
1087                name: 't1',
1088                type: 2,
1089                value: [{name: 'v1', type: 'string', optional: false},
1090                        {name: 'cb', type: 'Callback<string>', optional: false}],
1091                ret: 'void'}],
1092            interface: [],
1093            namespace: []
1094        }
1095        let param1 = {
1096            optionalParamDestory: '',
1097            valueCheckout: '',
1098            valueDefine: '',
1099            valueFill: '',
1100            valueIn: '',
1101            valueOut: '',
1102            valuePackage: ''
1103        }
1104        let funcVlaue = { name: 'cb', type: 'Callback<string>', optional: false };
1105        paramGenerateCallBack(data, funcVlaue, param1, '1');
1106        let retParam1 = JSON.stringify(param1);
1107        retParam1 = re.replaceAll(retParam1,"  ","");
1108        assert.strictEqual(retParam1, correctResult['Generate']['paramGenerateCallBack'])
1109    });
1110}
1111
1112function partofParamGenerateAny(correctResult) {
1113    it('test gen/generate/param_generate paramGenerateAny', function () {
1114        let param1 = {
1115            optionalParamDestory: '',
1116            valueCheckout: '',
1117            valueDefine: '',
1118            valueFill: '',
1119            valueIn: '',
1120            valueOut: '',
1121            valuePackage: ''
1122        }
1123        paramGenerateAny('0', 'v', 'any', param1);
1124        let retParam1 = JSON.stringify(param1);
1125        retParam1 = re.replaceAll(retParam1,"  ","");
1126        assert.strictEqual(retParam1, correctResult['Generate']['paramGenerateAny'])
1127    });
1128}
1129
1130function partofParamGenerateObject(correctResult) {
1131    it('test gen/generate/param_generate paramGenerateObject', function () {
1132        let param1 = {
1133            optionalParamDestory: '',
1134            valueCheckout: '',
1135            valueDefine: '',
1136            valueFill: '',
1137            valueIn: '',
1138            valueOut: '',
1139            valuePackage: ''
1140        }
1141        let funcVlaue = { name: 'v', type: 'Object', optional: false };
1142        paramGenerateObject('0', funcVlaue, param1);
1143        let retParam1 = JSON.stringify(param1);
1144        retParam1 = re.replaceAll(retParam1,"  ","");
1145        retParam1 = re.replaceAll(retParam1,"len[0-9]+","len");
1146        retParam1 = re.replaceAll(retParam1,"i[0-9]+","i");
1147        retParam1 = re.replaceAll(retParam1,"tt[0-9]+","tt");
1148        retParam1 = re.replaceAll(retParam1,"NUMBER_TYPE_[0-9]+","NUMBER_TYPE_");
1149        assert.strictEqual(retParam1, correctResult['Generate']['paramGenerateObject'])
1150    });
1151}
1152
1153function partmapTempleteFunc() {
1154    it('test gen/generate/param_generate mapTempleteFunc', function () {
1155        let ret = mapTempleteFunc('vio->in0', 'pxt->GetArgv(0)', '{[key:string]:string}')
1156        let retJson = JSON.stringify(ret)
1157        retJson = re.replaceAll(retJson,"  ","");
1158        retJson = re.replaceAll(retJson,"len[0-9]+","len");
1159        retJson = re.replaceAll(retJson,"i[0-9]+","i");
1160        let parmQiepian = retJson.substring(retJson.indexOf("tt"),retJson.indexOf("tt")+4)
1161        retJson = re.replaceAll(retJson,parmQiepian,"kk1");
1162        retJson = re.replaceAll(retJson,"tt[0-9]+","kk2");
1163        retJson = re.replaceAll(retJson,"\n","")
1164        assert.strictEqual(retJson, correctResult['Generate']['mapTempleteFunc'])
1165    })
1166}
1167
1168function partunionTempleteFunc(){
1169  it('test gen/generate/param_generate unionTempleteFunc', function () {
1170      let ret = unionTempleteFunc('vio->in0', 'pxt->GetArgv(XNapiTool::ZERO)', 'string|NUMBER_TYPE_1|boolean')
1171      let retJson = JSON.stringify(ret)
1172      retJson = re.replaceAll(retJson,"  ","");
1173      retJson = re.replaceAll(retJson,"\n","")
1174      assert.strictEqual(retJson, correctResult['Generate']['unionTempleteFunc'])
1175  })
1176}
1177
1178function partanyTempleteFunc(){
1179  it('test gen/generate/param_generate anyTempleteFunc', function () {
1180      let ret = anyTempleteFunc('vio->in0');
1181      let retJson = JSON.stringify(ret);
1182      retJson = re.replaceAll(retJson,"  ","");
1183      retJson = re.replaceAll(retJson,"\n","");
1184      assert.strictEqual(retJson, correctResult['Generate']['anyTempleteFunc']);
1185  })
1186}
1187
1188function partobjectTempleteFunc(){
1189  it('test gen/generate/param_generate objectTempleteFunc', function () {
1190      let ret = objectTempleteFunc('vio->in0', 'pxt->GetArgv(XNapiTool::ZERO)')
1191      let retJson = JSON.stringify(ret)
1192      retJson = re.replaceAll(retJson,"  ","");
1193      retJson = re.replaceAll(retJson,"len[0-9]+","len");
1194      retJson = re.replaceAll(retJson,"i[0-9]+","i");
1195      retJson = re.replaceAll(retJson,"tt[0-9]+","tt");
1196      retJson = re.replaceAll(retJson,"NUMBER_TYPE_[0-9]+","NUMBER_TYPE_");
1197      retJson = re.replaceAll(retJson,"\n","")
1198      assert.strictEqual(retJson, correctResult['Generate']['objectTempleteFunc'])
1199  })
1200}
1201
1202function returnGenerateParam(correctResult) {
1203    let retJson = returnGenerateAndAssert("string")
1204    retJson = re.replaceAll(retJson,"  ","")
1205
1206    assert.strictEqual(retJson, correctResult['Generate']['returnGenerate'])
1207
1208    let retJson1 = returnGenerateAndAssert("NUMBER_TYPE_1")
1209    retJson1 = re.replaceAll(retJson1,"  ","")
1210
1211    assert.strictEqual(retJson1, correctResult['Generate']['returnGenerate1'])
1212
1213    let retJson2 = returnGenerateAndAssert("boolean")
1214    retJson2 = re.replaceAll(retJson2,"  ","")
1215    assert.strictEqual(retJson2, correctResult['Generate']['returnGenerate2'])
1216
1217    let retJson3 = returnGenerateAndAssert("Array<string>")
1218    retJson3 = re.replaceAll(retJson3,"  ","")
1219    retJson3 = re.replaceAll(retJson3,"len[0-9]*","len")
1220    retJson3 = re.replaceAll(retJson3,"i[0-9]*","i")
1221    retJson3 = re.replaceAll(retJson3,"tnv[0-9]*","tnv")
1222
1223    assert.strictEqual(retJson3, correctResult['Generate']['returnGenerate3'])
1224
1225    let retJson4 = returnGenerateAndAssert("Array<NUMBER_TYPE_1>")
1226    retJson4 = re.replaceAll(retJson4,"  ","")
1227    retJson4 = re.replaceAll(retJson4,"len[0-9]*","len")
1228    retJson4 = re.replaceAll(retJson4,"i[0-9]*","i")
1229    retJson4 = re.replaceAll(retJson4,"tnv[0-9]*","tnv")
1230    assert.strictEqual(retJson4, correctResult['Generate']['returnGenerate4'])
1231
1232    let retJson5 = returnGenerateAndAssert("Array<boolean>")
1233    retJson5 = re.replaceAll(retJson5,"  ","")
1234    retJson5 = re.replaceAll(retJson5,"len[0-9]*","len")
1235    retJson5 = re.replaceAll(retJson5,"i[0-9]*","i")
1236    retJson5 = re.replaceAll(retJson5,"tnv[0-9]*","tnv")
1237    assert.strictEqual(retJson5, correctResult['Generate']['returnGenerate5'])
1238
1239    returnGenerateParamTwo(correctResult);
1240
1241    returnGenerateParamThree(correctResult);
1242}
1243
1244function returnGenerateParamTwo(correctResult){
1245    let retJson6 = returnGenerateAndAssert("string[]")
1246    retJson6 = re.replaceAll(retJson6,"  ","")
1247    retJson6 = re.replaceAll(retJson6,"len[0-9]*","len")
1248    retJson6 = re.replaceAll(retJson6,"i[0-9]*","i")
1249    retJson6 = re.replaceAll(retJson6,"tnv[0-9]*","tnv")
1250    assert.strictEqual(retJson6, correctResult['Generate']['returnGenerate6'])
1251
1252    let retJson7 = returnGenerateAndAssert("boolean[]")
1253    retJson7 = re.replaceAll(retJson7,"  ","")
1254    retJson7 = re.replaceAll(retJson7,"len[0-9]*","len")
1255    retJson7 = re.replaceAll(retJson7,"i[0-9]*","i")
1256    retJson7 = re.replaceAll(retJson7,"tnv[0-9]*","tnv")
1257    assert.strictEqual(retJson7, correctResult['Generate']['returnGenerate7'])
1258
1259    let retJson8 = returnGenerateAndAssert("NUMBER_TYPE_1[]")
1260    retJson8 = re.replaceAll(retJson8,"  ","")
1261    retJson8 = re.replaceAll(retJson8,"len[0-9]*","len")
1262    retJson8 = re.replaceAll(retJson8,"i[0-9]*","i")
1263    retJson8 = re.replaceAll(retJson8,"tnv[0-9]*","tnv")
1264    assert.strictEqual(retJson8, correctResult['Generate']['returnGenerate8'])
1265}
1266
1267function returnGenerateParamThree(correctResult){
1268  let retJson9 = returnGenerateAndAssert("Map<string, string>")
1269  retJson9 = re.replaceAll(retJson9,"  ","")
1270  retJson9 = re.replaceAll(retJson9,"len[0-9]*","len")
1271  retJson9 = re.replaceAll(retJson9,"i[0-9]*","i")
1272  retJson9 = re.replaceAll(retJson9,"tnv[0-9]*","tnv")
1273  assert.strictEqual(retJson9, correctResult['Generate']['returnGenerate9'])
1274
1275  let retJson10 = returnGenerateAndAssert("{[key:string]: string}")
1276  retJson10 = re.replaceAll(retJson10,"  ","")
1277  retJson10 = re.replaceAll(retJson10,"len[0-9]*","len")
1278  retJson10 = re.replaceAll(retJson10,"i[0-9]*","i")
1279  retJson10 = re.replaceAll(retJson10,"tnv[0-9]*","tnv")
1280  assert.strictEqual(retJson10, correctResult['Generate']['returnGenerate9'])
1281
1282  let retJson11 = returnGenerateAndAssert("Map<string, NUMBER_TYPE_1>")
1283  retJson11 = re.replaceAll(retJson11,"  ","")
1284  retJson11 = re.replaceAll(retJson11,"len[0-9]*","len")
1285  retJson11 = re.replaceAll(retJson11,"i[0-9]*","i")
1286  retJson11 = re.replaceAll(retJson11,"tnv[0-9]*","tnv")
1287  assert.strictEqual(retJson11, correctResult['Generate']['returnGenerate10'])
1288
1289  let retJson12 = returnGenerateAndAssert("{[key:string]: NUMBER_TYPE_1}")
1290  retJson12 = re.replaceAll(retJson12,"  ","")
1291  retJson12 = re.replaceAll(retJson12,"len[0-9]*","len")
1292  retJson12 = re.replaceAll(retJson12,"i[0-9]*","i")
1293  retJson12 = re.replaceAll(retJson12,"tnv[0-9]*","tnv")
1294  assert.strictEqual(retJson12, correctResult['Generate']['returnGenerate10'])
1295
1296  let retJson13 = returnGenerateAndAssert("Map<string, boolean>")
1297  retJson13 = re.replaceAll(retJson13,"  ","")
1298  retJson13 = re.replaceAll(retJson13,"len[0-9]*","len")
1299  retJson13 = re.replaceAll(retJson13,"i[0-9]*","i")
1300  retJson13 = re.replaceAll(retJson13,"tnv[0-9]*","tnv")
1301  assert.strictEqual(retJson13, correctResult['Generate']['returnGenerate11'])
1302
1303  let retJson14 = returnGenerateAndAssert("{[key:string]: boolean}")
1304  retJson14 = re.replaceAll(retJson14,"  ","")
1305  retJson14 = re.replaceAll(retJson14,"len[0-9]*","len")
1306  retJson14 = re.replaceAll(retJson14,"i[0-9]*","i")
1307  retJson14 = re.replaceAll(retJson14,"tnv[0-9]*","tnv")
1308  assert.strictEqual(retJson14, correctResult['Generate']['returnGenerate11'])
1309}
1310
1311function returnGenerateAndAssert(dataType) {
1312    param = {
1313        optionalParamDestory:'',
1314        valueCheckout:'',
1315        valueDefine:'',
1316        valueFill:'',
1317        valueIn:'',
1318        valueOut:'',
1319        valuePackage:''
1320    }
1321    data = {
1322        class: [],
1323        const: [],
1324        enum:  [],
1325        exports: [],
1326        function: [{name: 'fun1', type: 1, value: [], ret: dataType}],
1327        interface: [],
1328        namespace: []
1329    }
1330    let returnInfo = { type: dataType, optional: false }
1331    if (null != data) {
1332        returnGenerate(returnInfo, param, data)
1333    } else {
1334        returnGenerate(returnInfo, param)
1335    }
1336    let result = JSON.stringify(param);
1337    return result
1338}
1339
1340function paramGenerateResult(correctResult) {
1341    let retJson = JSON.stringify(paramGenerateAndAssert("string"))
1342    retJson = re.replaceAll(retJson,"  ", "")
1343    assert.strictEqual(retJson, correctResult['Generate']['ParamGenerate'])
1344
1345    let retJson1 = JSON.stringify(paramGenerateAndAssert("NUMBER_TYPE_1"));
1346    retJson1 = re.replaceAll(retJson1,"  ","")
1347    let qiepian = retJson1.substring(retJson1.indexOf("NUMBER_TYPE_"),retJson1.indexOf("NUMBER_TYPE_")+13);
1348    retJson1 = re.replaceAll(retJson1,qiepian,"NUMBER_TYPE_1")
1349    assert.strictEqual(retJson1, correctResult['Generate']['ParamGenerate1'])
1350
1351    let retJson2 = JSON.stringify(paramGenerateAndAssert("boolean"))
1352    retJson2 = re.replaceAll(retJson2,"  ","")
1353    assert.strictEqual(retJson2, correctResult['Generate']['ParamGenerate2'])
1354
1355    let retJson3 = JSON.stringify(paramGenerateAndAssert("Array<string>"))
1356    retJson3 = re.replaceAll(retJson3,"  ","")
1357    retJson3 = re.replaceAll(retJson3,"i[0-9]+","i")
1358    retJson3 = re.replaceAll(retJson3,"len[0-9]+","len")
1359    retJson3 = re.replaceAll(retJson3,"tt[0-9]+","tt")
1360    assert.strictEqual(retJson3, correctResult['Generate']['ParamGenerate3'])
1361
1362    let retJson4 = JSON.stringify(paramGenerateAndAssert("Array<boolean>"))
1363    retJson4 = re.replaceAll(retJson4,"  ","")
1364    retJson4 = re.replaceAll(retJson4,"i[0-9]+","i")
1365    retJson4 = re.replaceAll(retJson4,"len[0-9]+","len")
1366    retJson4 = re.replaceAll(retJson4,"tt[0-9]+","tt")
1367    assert.strictEqual(retJson4, correctResult['Generate']['ParamGenerate4'])
1368
1369    paramGenerateResultTwo(correctResult)
1370
1371    paramGenerateResultThree(correctResult)
1372}
1373
1374function paramGenerateResultTwo(correctResult){
1375    let retJson5 = JSON.stringify(paramGenerateAndAssert("Array<number>"));
1376    retJson5 = re.replaceAll(retJson5,"  ","")
1377    retJson5 = re.replaceAll(retJson5,"i[0-9]+","i")
1378    retJson5 = re.replaceAll(retJson5,"len[0-9]+","len")
1379    retJson5 = re.replaceAll(retJson5,"tt[0-9]+","tt")
1380    assert.strictEqual(retJson5, correctResult['Generate']['ParamGenerate5'])
1381
1382    let retJson6 = JSON.stringify(paramGenerateAndAssert("string[]"))
1383    retJson6 = re.replaceAll(retJson6,"  ","")
1384    retJson6 = re.replaceAll(retJson6,"i[0-9]+","i")
1385    retJson6 = re.replaceAll(retJson6,"len[0-9]+","len")
1386    retJson6 = re.replaceAll(retJson6,"tt[0-9]+","tt")
1387    assert.strictEqual(retJson6, correctResult['Generate']['ParamGenerate6'])
1388
1389    let retJson7 = JSON.stringify(paramGenerateAndAssert("boolean[]"));
1390    retJson7 = re.replaceAll(retJson7,"  ","")
1391    retJson7 = re.replaceAll(retJson7,"i[0-9]+","i")
1392    retJson7 = re.replaceAll(retJson7,"len[0-9]+","len")
1393    retJson7 = re.replaceAll(retJson7,"tt[0-9]+","tt")
1394    assert.strictEqual(retJson7, correctResult['Generate']['ParamGenerate7'])
1395
1396    let retJson8 = JSON.stringify(paramGenerateAndAssert("number[]"))
1397    retJson8 = re.replaceAll(retJson8,"  ","")
1398    retJson8 = re.replaceAll(retJson8,"i[0-9]+","i")
1399    retJson8 = re.replaceAll(retJson8,"len[0-9]+","len")
1400    retJson8 = re.replaceAll(retJson8,"tt[0-9]+","tt")
1401    assert.strictEqual(retJson8, correctResult['Generate']['ParamGenerate8'])
1402}
1403
1404function paramGenerateResultThree(correctResult){
1405    let retJson9 = paramGenerateAndAssert("Map<string, string>")
1406    retJson9 = re.replaceAll(retJson9,"  ","")
1407    retJson9 = re.replaceAll(retJson9,"len[0-9]*","len")
1408    retJson9 = re.replaceAll(retJson9,"i[0-9]*","i")
1409    retJson9 = re.replaceAll(retJson9,"tt[0-9]+","tt")
1410    assert.strictEqual(retJson9, correctResult['Generate']['ParamGenerate9'])
1411
1412    let retJson10 = paramGenerateAndAssert("{[key:string]: string}")
1413    retJson10 = re.replaceAll(retJson10,"  ","")
1414    retJson10 = re.replaceAll(retJson10,"len[0-9]*","len")
1415    retJson10 = re.replaceAll(retJson10,"i[0-9]*","i")
1416    retJson10 = re.replaceAll(retJson10,"tt[0-9]+","tt")
1417    assert.strictEqual(retJson10, correctResult['Generate']['ParamGenerate9'])
1418
1419    let retJson11 = paramGenerateAndAssert("Map<string, NUMBER_TYPE_1>")
1420    retJson11 = re.replaceAll(retJson11,"  ","")
1421    retJson11 = re.replaceAll(retJson11,"len[0-9]*","len")
1422    retJson11 = re.replaceAll(retJson11,"i[0-9]*","i")
1423    retJson11 = re.replaceAll(retJson11,"tt[0-9]+","tt")
1424    assert.strictEqual(retJson11, correctResult['Generate']['ParamGenerate10'])
1425
1426    let retJson12 = paramGenerateAndAssert("{[key:string]: NUMBER_TYPE_1}")
1427    retJson12 = re.replaceAll(retJson12,"  ","")
1428    retJson12 = re.replaceAll(retJson12,"len[0-9]*","len")
1429    retJson12 = re.replaceAll(retJson12,"i[0-9]*","i")
1430    retJson12 = re.replaceAll(retJson12,"tt[0-9]+","tt")
1431    assert.strictEqual(retJson12, correctResult['Generate']['ParamGenerate10'])
1432
1433    let retJson13 = paramGenerateAndAssert("Map<string, boolean>")
1434    retJson13 = re.replaceAll(retJson13,"  ","")
1435    retJson13 = re.replaceAll(retJson13,"len[0-9]*","len")
1436    retJson13 = re.replaceAll(retJson13,"i[0-9]*","i")
1437    retJson13 = re.replaceAll(retJson13,"tt[0-9]+","tt")
1438    assert.strictEqual(retJson13, correctResult['Generate']['ParamGenerate11'])
1439
1440    let retJson14 = paramGenerateAndAssert("{[key:string]: boolean}")
1441    retJson14 = re.replaceAll(retJson14,"  ","")
1442    retJson14 = re.replaceAll(retJson14,"len[0-9]*","len")
1443    retJson14 = re.replaceAll(retJson14,"i[0-9]*","i")
1444    retJson14 = re.replaceAll(retJson14,"tt[0-9]+","tt")
1445    assert.strictEqual(retJson14, correctResult['Generate']['ParamGenerate11'])
1446}
1447
1448function paramGenerateAndAssert(dataType) {
1449    param = {
1450        optionalParamDestory:'',
1451        valueCheckout:'',
1452        valueDefine:'',
1453        valueFill:'',
1454        valueIn:'',
1455        valueOut:'',
1456        valuePackage:''
1457    }
1458    data = {
1459        class: [],
1460        const: [],
1461        enum:  [],
1462        exports: [],
1463        function: [
1464            {name: 'fun1',
1465             type: 1,
1466             value: [{name: 'v', type: dataType, optional: false}],
1467             ret: 'void'}],
1468        interface: [],
1469        namespace: []
1470    }
1471    let funcValue = { name: "v", type: dataType, optional: false, realType: dataType }
1472    if (null != data) {
1473        paramGenerate(0, funcValue, param, data)
1474    } else {
1475        paramGenerate(0, funcValue, param)
1476    }
1477    let result = JSON.stringify(param);
1478    return result
1479}