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 } = require(genDir + "generate/param_generate"); 25const { paramGenerateMap, mapTempleteFunc } = require(genDir + "generate/param_generate"); 26const { cToJs, cToJsForInterface, returnGenerate } = require(genDir + "generate/return_generate"); 27const { generateInterface, generateVariable } = require(genDir + "generate/interface"); 28const { mapTypeString, connectResult } = require(genDir + "generate/interface"); 29const { generateNamespace, formatMiddleInit } = require(genDir + "generate/namespace"); 30const { generateEnumResult, generateFunction } = require(genDir + "generate/namespace"); 31const { generateFunctionAsync } = require(genDir + "generate/function_async"); 32const { generateFunctionDirect } = require(genDir + "generate/function_direct"); 33const { generateFunctionSync } = require(genDir + "generate/function_sync"); 34 35var correctResult 36 37function before() { 38 let data = readFile("test/unittest/result.json") 39 40 if (data) { 41 correctResult = JSON.parse(data) 42 } 43 44 result = analyzeFile("test/unittest/@ohos.input_sample.d.ts") 45} 46 47describe('Generate', function () { 48 before(function () { 49 before() 50 }); 51 52 it('test gen/generate/enum generateEnum', function () { 53 let data = { 54 element: [{ name: "STATUS0", value: "0", type: "NUMBER_TYPE_1" }], 55 function: [], 56 enumValueType: 0 57 } 58 let ret = generateEnum('GrantStatus', data); 59 let retJson = JSON.stringify(ret); 60 let result = { "implH": "\nenum GrantStatus {\n STATUS0 = 0,\n};\n", "implCpp": "" }; 61 assert.strictEqual(retJson, JSON.stringify(result)); 62 }); 63 64 it('test gen/generate/function_async generateFunctionAsync', function () { 65 let retJson = funcAsyncAssert(); 66 let struct = retJson.substring(retJson.indexOf("{"),retJson.indexOf("}")+1) 67 assert.strictEqual(struct,"{\\n std::string in0;\\n uint32_t outErrCode = 0;\\n std::string out;\\n}") 68 let execute = retJson.substring(retJson.indexOf("if_async_execute"),retJson.indexOf("*data")+6) 69 assert.strictEqual(execute,"if_async_execute(XNapiTool *pxt, void *data)") 70 let complete = retJson.substring(retJson.indexOf("if_async_complete"),retJson.lastIndexOf("*data")+6) 71 assert.strictEqual(complete,"if_async_complete(XNapiTool *pxt, void *data)") 72 let middle = retJson.substring(retJson.indexOf("if_async_middle"),retJson.indexOf("info)")+5) 73 assert.strictEqual(middle,"if_async_middle(napi_env env, napi_callback_info info)") 74 }); 75 76 it('test gen/generate/function_direct generateFunctionDirect', function () { 77 let retJson = funcDirectAssert(); 78 let struct = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1) 79 assert.strictEqual(struct, "{\\n std::string in0;\\n \\n std::string out;\\n}") 80 let middle = retJson.substring(retJson.indexOf("if_direct_middle"), retJson.indexOf("info)") + 5) 81 assert.strictEqual(middle, "if_direct_middle(napi_env env, napi_callback_info info)") 82 }); 83 84 it('test gen/generate/function_sync generateFunctionSync', function () { 85 let retJson = funcSyncAssert(); 86 let struct = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1) 87 assert.strictEqual(struct, "{\\n std::string in0;\\n \\n std::string out;\\n}") 88 let middle = retJson.substring(retJson.indexOf("if_callback_middle"), retJson.indexOf("info)") + 5) 89 assert.strictEqual(middle, "if_callback_middle(napi_env env, napi_callback_info info)") 90 }); 91 92 partOfInterface(correctResult); 93 94 partOfTest(); 95 96 partOfNamespace(correctResult) 97 98 partofParamGenerate(correctResult) 99 100}); 101 102function funcAsyncAssert() { 103 let valueFi = { name: 'v1', type: 'string' }; 104 let value1Se = { name: 'cb', type: 'AsyncCallback<string>' }; 105 let funParam = { name: 'if_async', type: 4, value: [valueFi, value1Se], ret: 'string' } 106 let data = { 107 class: [], 108 const: [], 109 enum: [], 110 exports: [], 111 function: [{ name: 'if_async', type: 4, value: [valueFi, value1Se], ret: 'string' }], 112 interface: [], 113 namespace: [], 114 type: [], 115 } 116 let ret = generateFunctionAsync(funParam, data, 'TestClass1'); 117 let retJson = JSON.stringify(ret); 118 return retJson 119} 120 121 122function funcDirectAssert() { 123 let valueFi = { name: 'v1', type: 'string' }; 124 let funParam = { name: 'if_direct', type: 1, value: [valueFi], ret: 'string' }; 125 let data = { 126 class: [], 127 const: [], 128 enum: [], 129 exports: [], 130 function: [{ name: 'if_direct', type: 1, value: [valueFi], ret: 'string' }], 131 interface: [], 132 namespace: [], 133 type: [], 134 } 135 let ret = generateFunctionDirect(funParam, data, 'TestClass1'); 136 let retJson = JSON.stringify(ret); 137 return retJson 138} 139 140function funcSyncAssert() { 141 let valueFi = { name: 'v1', type: 'string' }; 142 let value1Se = { name: 'cb', type: 'Callback<string>' }; 143 let funParam = { name: 'if_callback', type: 2, value: [valueFi, value1Se], ret: 'string' }; 144 let data = { 145 class: [], 146 const: [], 147 enum: [], 148 exports: [], 149 function: [{ name: 'if_callback', type: 2, value: [valueFi, value1Se], ret: 'string' }], 150 interface: [], 151 namespace: [], 152 type: [], 153 } 154 let ret = generateFunctionSync(funParam, data, 'TestClass1'); 155 let retJson = JSON.stringify(ret); 156 return retJson 157} 158 159function partOfInterface() { 160 161 it('test gen/generate/interface generateVariable', function () { 162 variable = { 163 hDefine: '', 164 middleValue: '' 165 }; 166 let ret = generateVariable('disable', 'boolean', variable, 'ConfigOption'); 167 assert.strictEqual(JSON.stringify(ret), undefined); 168 }); 169 170 it('test gen/generate/interface mapTypeString', function () { 171 let ret = mapTypeString("Map<string,string>", "map1"); 172 let result = "\n std::map<std::string,std::string> map1;"; 173 assert.strictEqual(JSON.stringify(ret), JSON.stringify(result)); 174 }); 175 176 it('test gen/generate/interface generateInterface', function () { 177 let data = { 178 function: [], 179 value: [{ name: "disable", type: "boolean" }, { name: "map1", type: "Map<string,string>" }] 180 } 181 let ret = generateInterface('ConfigOption', data, 'napitest::'); 182 let retJson = JSON.stringify(ret).substring(1, JSON.stringify(ret).length); 183 let configOption = retJson.substring(retJson.indexOf("{"), retJson.indexOf("}") + 1); 184 let configResult = "{\\npublic:\\n bool disable;\\n std::map<std::string,std::string> map1;\\n}"; 185 assert.strictEqual(configOption, configResult); 186 assert.strictEqual(retJson.search("ConfigOption_middle") > 0, true) 187 assert.strictEqual(retJson.search("middleInit") > 0, true) 188 }); 189 190 191 it('test gen/generate/interface connectResult', function () { 192 let data = { 193 function: [], 194 value: [{ name: "disable", type: "boolean" }, { name: "map1", type: "Map<string,string>" }] 195 } 196 let ret = connectResult(data, 'napitest::', 'ConfigOption'); 197 let retJson = JSON.stringify(ret); 198 let getDisable = retJson.search("static napi_value getvalue_disable"); 199 assert.strictEqual(getDisable > 0, true) 200 let setDisable = retJson.search("static napi_value setvalue_disable"); 201 assert.strictEqual(setDisable > 0, true) 202 let getMap1 = retJson.search("static napi_value getvalue_map1"); 203 assert.strictEqual(getMap1 > 0, true) 204 let setMap1 = retJson.search("static napi_value setvalue_map1"); 205 assert.strictEqual(setMap1 > 0, true) 206 }); 207} 208 209function partOfTest() { 210 it('test gen/generate/param_generate jsToC', function () { 211 assert.strictEqual(jsToC("a", "b", "string"), "pxt->SwapJs2CUtf8(b, a);"); 212 213 assert.strictEqual(jsToC("a", "b", "NUMBER_TYPE_1"), "NUMBER_JS_2_C(b,NUMBER_TYPE_1,a);"); 214 215 assert.strictEqual(jsToC("a", "b", "boolean"), "BOOLEAN_JS_2_C(b,bool,a);"); 216 217 let retJsToC = JSON.stringify(jsToC("a", "b", "Array<string>")); 218 retJsToC = re.replaceAll(retJsToC, "len[0-9]*", "len"); 219 retJsToC = re.replaceAll(retJsToC, "i[0-9]*", "i"); 220 retJsToC = re.replaceAll(retJsToC, "tt[0-9]*", "tt"); 221 assert.strictEqual(retJsToC, JSON.stringify(jsToCParam())); 222 223 let retJsToC1 = JSON.stringify(jsToC("a", "b", "string[]")); 224 retJsToC1 = re.replaceAll(retJsToC1, "len[0-9]*", "len"); 225 retJsToC1 = re.replaceAll(retJsToC1, "i[0-9]*", "i"); 226 retJsToC1 = re.replaceAll(retJsToC1, "tt[0-9]*", "tt"); 227 assert.strictEqual(retJsToC1, JSON.stringify(jsToCParamArray())); 228 229 let retJsToC2 = JSON.stringify(jsToC("a", "b", "{[key:string]:boolean}")); 230 retJsToC2 = re.replaceAll(retJsToC2, "len[0-9]*", "len"); 231 retJsToC2 = re.replaceAll(retJsToC2, "i[0-9]*", "i"); 232 retQiepian = retJsToC2.substring(retJsToC2.indexOf("tt"), retJsToC2.indexOf("tt") + 3) 233 retJsToC2 = re.replaceAll(retJsToC2, retQiepian, "tt"); 234 retJsToC2 = re.replaceAll(retJsToC2, "tt[0-9]+", "tt1"); 235 assert.strictEqual(retJsToC2, JSON.stringify(jsToCParamMap())); 236 237 let retJsToC3 = JSON.stringify(jsToC("a", "b", "Map<string,number>")); 238 retJsToC3 = re.replaceAll(retJsToC3, "len[0-9]*", "len"); 239 retJsToC3 = re.replaceAll(retJsToC3, "i[0-9]*", "i"); 240 retQiepian = retJsToC3.substring(retJsToC3.indexOf("tt"), retJsToC3.indexOf("tt") + 3) 241 retJsToC3 = re.replaceAll(retJsToC3, retQiepian, "tt"); 242 retJsToC3 = re.replaceAll(retJsToC3, "tt[0-9]+", "tt1"); 243 assert.strictEqual(retJsToC3, JSON.stringify(jsToCParamMap1())); 244 }); 245 246 it('test gen/generate/param_generate jsToCEnum', function () { 247 let ret = jsToCEnum('string', 'vio->in0', 'pxt->GetArgv(0)') 248 let retJson = JSON.stringify(ret) 249 assert.strictEqual(retJson, '""') 250 }); 251 252 partOfTestTwo() 253} 254 255function partOfTestTwo(){ 256 257 it('test gen/generate/return_generate cToJs', function () { 258 assert.strictEqual(cToJs("a", "string", "b", 1), "b = pxt->SwapC2JsUtf8(a.c_str());") 259 260 ret = cToJs("a", "NUMBER_TYPE_1", "b", 1) 261 assert.strictEqual(ret, "b = NUMBER_C_2_JS(pxt, a);") 262 263 ret1 = cToJs("a", "boolean", "b", 1) 264 assert.strictEqual(ret1, "b = pxt->SwapC2JsBool(a);") 265 266 let retcToJs = JSON.stringify(cToJs("a", "Array<string>", "b", 1)) 267 retcToJs = re.replaceAll(retcToJs, "len[0-9]*", "len") 268 retcToJs = re.replaceAll(retcToJs, "i[0-9]*", "i") 269 retcToJs = re.replaceAll(retcToJs, "tnv[0-9]*", "tnv") 270 assert.strictEqual(retcToJs, JSON.stringify(cToJsParam())) 271 272 let retcToJs1 = JSON.stringify(cToJs("a", "string[]", "b", 1)) 273 retcToJs1 = re.replaceAll(retcToJs1, "len[0-9]*", "len") 274 retcToJs1 = re.replaceAll(retcToJs1, "i[0-9]*", "i") 275 retcToJs1 = re.replaceAll(retcToJs1, "tnv[0-9]*", "tnv") 276 assert.strictEqual(retcToJs1, JSON.stringify(cToJsParamArray())) 277 278 let retcToJs2 = JSON.stringify(cToJs("a", "Map<string,string>", "b", 1)) 279 retcToJs2 = re.replaceAll(retcToJs2, "i[0-9]*", "i") 280 retQiepian = retcToJs2.substring(retcToJs2.indexOf("tnv"), retcToJs2.indexOf("tnv") + 4) 281 retcToJs2 = re.replaceAll(retcToJs2, retQiepian, "tnv") 282 retcToJs2 = re.replaceAll(retcToJs2, "tnv[0-9]+", "tnv1") 283 assert.strictEqual(retcToJs2, JSON.stringify(cToJsParamMap())) 284 285 let retcToJs3 = JSON.stringify(cToJs("a", "{[key:string]:string}", "b", 1)) 286 retcToJs3 = re.replaceAll(retcToJs3, "i[0-9]*", "i") 287 retQiepian = retcToJs3.substring(retcToJs3.indexOf("tnv"), retcToJs3.indexOf("tnv") + 4) 288 retcToJs3 = re.replaceAll(retcToJs3, retQiepian, "tnv") 289 retcToJs3 = re.replaceAll(retcToJs3, "tnv[0-9]+", "tnv1") 290 assert.strictEqual(retcToJs3, JSON.stringify(cToJsParamMap1())) 291 }); 292 293 it('test gen/generate/return_generate cToJsForInterface', function () { 294 let ret = cToJsForInterface('vio->out', 'ConfigOption', 'result', 1) 295 let retJson = JSON.stringify(ret) 296 assert.strictEqual(retJson, '""') 297 }); 298} 299 300function cToJsParam() { 301 let value = 'uint32_t len=a.size();\n' + 302 ' for(uint32_t i=0;i<len;i++) {\n' + 303 ' napi_value tnv = nullptr;\n' + 304 ' tnv = pxt->SwapC2JsUtf8(a[i].c_str());\n' + 305 ' pxt->SetArrayElement(b, i, tnv);\n' + 306 ' }' 307 return value 308} 309 310function cToJsParamArray() { 311 let value = 'uint32_t len=a.size();\n' + 312 ' for(uint32_t i=0;i<len;i++) {\n' + 313 ' napi_value tnv = nullptr;\n' + 314 ' tnv = pxt->SwapC2JsUtf8(a[i].c_str());\n' + 315 ' pxt->SetArrayElement(b, i, tnv);\n' + 316 ' }' 317 return value 318} 319 320function cToJsParamMap() { 321 let value = 'result = nullptr;\n' + 322 ' for (auto i = a.begin(); i != a.end(); i++)\n' + 323 ' {\n' + 324 ' const char * tnv;\n' + 325 ' napi_value tnv1 = nullptr;\n' + 326 ' tnv = (i -> first).c_str();\n' + 327 ' tnv1 = pxt->SwapC2JsUtf8(i->second.c_str());\n' + 328 ' pxt->SetMapElement(b, tnv, tnv1);\n' + 329 ' }' 330 return value 331} 332 333function cToJsParamMap1() { 334 let value = 'result = nullptr;\n' + 335 ' for (auto i = a.begin(); i != a.end(); i++)\n' + 336 ' {\n' + 337 ' const char * tnv;\n' + 338 ' napi_value tnv1 = nullptr;\n' + 339 ' tnv = (i -> first).c_str();\n' + 340 ' tnv1 = pxt->SwapC2JsUtf8(i->second.c_str());\n' + 341 ' pxt->SetMapElement(b, tnv, tnv1);\n' + 342 ' }' 343 return value 344} 345 346function jsToCParam() { 347 let value = ' uint32_t len=pxt->GetArrayLength(b);\n' + 348 ' for(uint32_t i=0;i<len;i++) {\n' + 349 ' std::string tt;\n' + 350 ' pxt->SwapJs2CUtf8(pxt->GetArrayElement(b,i), tt);\n' + 351 ' a.push_back(tt);\n' + 352 '\n' + 353 ' }\n' 354 return value 355} 356 357function jsToCParamArray() { 358 let value = ' uint32_t len=pxt->GetArrayLength(b);\n' + 359 ' for(uint32_t i=0;i<len;i++) {\n' + 360 ' std::string tt;\n' + 361 ' pxt->SwapJs2CUtf8(pxt->GetArrayElement(b,i), tt);\n' + 362 ' a.push_back(tt);\n' + 363 '\n' + 364 ' }\n' 365 return value 366} 367 368function jsToCParamMap() { 369 let value = 'uint32_t len=pxt->GetMapLength(b);\n' + 370 'for(uint32_t i=0;i<len;i++) {\n' + 371 ' std::string tt;\n' + 372 ' bool tt1;\n' + 373 ' pxt->SwapJs2CUtf8(pxt->GetMapElementName(b,i), tt);\n' + 374 ' tt1 = pxt->SwapJs2CBool(pxt->GetMapElementValue(b,tt.c_str()));\n' + 375 ' a.insert(std::make_pair(tt, tt1));\n' + 376 '}' 377 return value 378} 379 380function jsToCParamMap1() { 381 let value = 'uint32_t len=pxt->GetMapLength(b);\n' + 382 'for(uint32_t i=0;i<len;i++) {\n' + 383 ' std::string tt;\n' + 384 ' number tt1;\n' + 385 ' [replace_swap]\n' + 386 ' a.insert(std::make_pair(tt, tt1));\n' + 387 '}' 388 return value 389} 390 391function partOfNamespace(correctResult) { 392 393 it('test gen/generate/namespace generateNamespace', function () { 394 let enumElement = [{ name: "name", value: "", type: "string" }]; 395 let interfaceBody = { function: [], value: [{ name: "age", type: "NUMBER_TYPE_1" }] } 396 let data = { 397 class: [], 398 const: [], 399 enum: [{ name: "TestEnum", body: { element: enumElement, function: [], enumValueType: 0 } }], 400 export: [], 401 function: [{ name: "fun1", type: 1, value: [{ name: "v", type: "Array<string>" }], ret: "string" }], 402 interface: [{ name: "TestInterface", body: interfaceBody }], 403 namespace: [] 404 }; 405 let retJson = JSON.stringify(generateNamespace('napitest', data, inNamespace = "")); 406 retJson = re.replaceAll(retJson, " ", "") 407 retJson = re.replaceAll(retJson, "\\n", "") 408 assert.strictEqual(retJson, correctResult['Generate']['generateNamespace']); 409 }); 410 411 it('test gen/generate/namespace generateEnumResult', function () { 412 let data = { 413 "exports": ["GrantStatus"], 414 "enum": [{ 415 "name": "GrantStatus", 416 "body": { 417 "element": [ 418 { "name": "PERMISSION_DEFAULT", "value": "", "type": "string" }], 419 "function": [], 420 "enumValueType": 1 421 } 422 }], 423 "const": [], 424 "type": [], 425 "function": [], 426 "interface": [], 427 "class": [], 428 "namespace": [] 429 }; 430 let retJson = JSON.stringify(generateEnumResult(data)); 431 let result = "{\"implH\":\"\\nenum GrantStatus {\\n PERMISSION_DEFAULT = 0,\\n};\\n\",\"implCpp\":\"\"}"; 432 assert.strictEqual(retJson, result); 433 }); 434 435 partOfNamespaceTwo(); 436} 437function partOfNamespaceTwo(){ 438 it('test gen/generate/namespace generateFunction', function () { 439 let func = { name: "fun1", type: 4, value: [{ name: "cb", type: "AsyncCallback<string>" }] }; 440 let funcValue = [{ name: "cb", type: "AsyncCallback<string>" }] 441 let data = { 442 class: [], 443 const: [], 444 enum: [], 445 export: [], 446 function: [{ name: "fun1", type: 4, value: funcValue, ret: "string" }], 447 interface: [], 448 namespace: [] 449 }; 450 let retJson = JSON.stringify(generateFunction(func, data)); 451 retJson = re.replaceAll(retJson, " ", "") 452 assert.strictEqual(retJson, correctResult['Generate']['generateFunction']); 453 }); 454 455 it('test gen/generate/namespace formatMiddleInit', function () { 456 let ret = formatMiddleInit('', 'napitest'); 457 assert.strictEqual(JSON.stringify(ret), '""'); 458 }) 459} 460 461function partofParamGenerate(correctResult) { 462 463 it('test gen/generate/param_generate paramGenerateArray', function () { 464 let param = { 465 valueCheckout: '', 466 valueDefine: '', 467 valueFill: '', 468 valueIn: '', 469 valueOut: '', 470 valuePackage: '' 471 } 472 let funcValue = { name: 'v', type: 'Array<string>' } 473 paramGenerateArray('0', funcValue, param); 474 let retParam = JSON.stringify(param); 475 retParam = re.replaceAll(retParam," ",""); 476 retParam = re.replaceAll(retParam,"len[0-9]+","len") 477 retParam = re.replaceAll(retParam,"i[0-9]+","i") 478 retParam = re.replaceAll(retParam,"tt[0-9]+","tt") 479 assert.strictEqual(retParam, correctResult['Generate']['paramGenerateArray']) 480 }); 481 482 it('test gen/generate/param_generate paramGenerateMap', function () { 483 let param1 = { 484 optionalParamDestory: '', 485 valueCheckout: '', 486 valueDefine: '', 487 valueFill: '', 488 valueIn: '', 489 valueOut: '', 490 valuePackage: '' 491 } 492 let funcVlaue = { name: 'v', type: '{[key:string]:string}', optional: false }; 493 paramGenerateMap(funcVlaue, param1, '0'); 494 let retParam1 = JSON.stringify(param1); 495 retParam1 = re.replaceAll(retParam1," ",""); 496 retParam1 = re.replaceAll(retParam1,"len[0-9]+","len") 497 retParam1 = re.replaceAll(retParam1,"i[0-9]+","i") 498 let parmQiepian = retParam1.substring(retParam1.indexOf("tt"),retParam1.indexOf("tt")+3) 499 retParam1 = re.replaceAll(retParam1,parmQiepian,"tt") 500 retParam1 = re.replaceAll(retParam1,"tt[0-9]+","tt1") 501 assert.strictEqual(retParam1, correctResult['Generate']['paramGenerateMap']) 502 }); 503 504 partmapTempleteFunc() 505 506 it('test gen/generate/param_generate ParamGenerate', function () { 507 paramGenerateResult(correctResult); 508 }); 509 510 it('test gen/generate/return_generate returnGenerate', function () { 511 returnGenerateParam(correctResult); 512 }); 513} 514function partmapTempleteFunc(){ 515 it('test gen/generate/param_generate mapTempleteFunc', function () { 516 let ret = mapTempleteFunc('vio->in0', 'pxt->GetArgv(0)', '{[key:string]:string}') 517 let retJson = JSON.stringify(ret) 518 retJson = re.replaceAll(retJson," ",""); 519 retJson = re.replaceAll(retJson,"len[0-9]+","len"); 520 retJson = re.replaceAll(retJson,"i[0-9]+","i"); 521 let parmQiepian = retJson.substring(retJson.indexOf("tt"),retJson.indexOf("tt")+4) 522 retJson = re.replaceAll(retJson,parmQiepian,"kk1"); 523 retJson = re.replaceAll(retJson,"tt[0-9]+","kk2"); 524 retJson = re.replaceAll(retJson,"\n","") 525 assert.strictEqual(retJson, correctResult['Generate']['mapTempleteFunc']) 526 }) 527} 528 529function returnGenerateParam(correctResult) { 530 let retJson = returnGenerateAndAssert("string") 531 retJson = re.replaceAll(retJson," ","") 532 533 assert.strictEqual(retJson, correctResult['Generate']['returnGenerate']) 534 535 let retJson1 = returnGenerateAndAssert("NUMBER_TYPE_1") 536 retJson1 = re.replaceAll(retJson1," ","") 537 538 assert.strictEqual(retJson1, correctResult['Generate']['returnGenerate1']) 539 540 let retJson2 = returnGenerateAndAssert("boolean") 541 retJson2 = re.replaceAll(retJson2," ","") 542 assert.strictEqual(retJson2, correctResult['Generate']['returnGenerate2']) 543 544 let retJson3 = returnGenerateAndAssert("Array<string>") 545 retJson3 = re.replaceAll(retJson3," ","") 546 retJson3 = re.replaceAll(retJson3,"len[0-9]*","len") 547 retJson3 = re.replaceAll(retJson3,"i[0-9]*","i") 548 retJson3 = re.replaceAll(retJson3,"tnv[0-9]*","tnv") 549 550 assert.strictEqual(retJson3, correctResult['Generate']['returnGenerate3']) 551 552 let retJson4 = returnGenerateAndAssert("Array<NUMBER_TYPE_1>") 553 retJson4 = re.replaceAll(retJson4," ","") 554 retJson4 = re.replaceAll(retJson4,"len[0-9]*","len") 555 retJson4 = re.replaceAll(retJson4,"i[0-9]*","i") 556 retJson4 = re.replaceAll(retJson4,"tnv[0-9]*","tnv") 557 assert.strictEqual(retJson4, correctResult['Generate']['returnGenerate4']) 558 559 let retJson5 = returnGenerateAndAssert("Array<boolean>") 560 retJson5 = re.replaceAll(retJson5," ","") 561 retJson5 = re.replaceAll(retJson5,"len[0-9]*","len") 562 retJson5 = re.replaceAll(retJson5,"i[0-9]*","i") 563 retJson5 = re.replaceAll(retJson5,"tnv[0-9]*","tnv") 564 assert.strictEqual(retJson5, correctResult['Generate']['returnGenerate5']) 565 566 returnGenerateParamTwo(correctResult); 567} 568 569function returnGenerateParamTwo(correctResult){ 570 571 let retJson6 = returnGenerateAndAssert("string[]") 572 retJson6 = re.replaceAll(retJson6," ","") 573 retJson6 = re.replaceAll(retJson6,"len[0-9]*","len") 574 retJson6 = re.replaceAll(retJson6,"i[0-9]*","i") 575 retJson6 = re.replaceAll(retJson6,"tnv[0-9]*","tnv") 576 assert.strictEqual(retJson6, correctResult['Generate']['returnGenerate6']) 577 578 let retJson7 = returnGenerateAndAssert("boolean[]") 579 retJson7 = re.replaceAll(retJson7," ","") 580 retJson7 = re.replaceAll(retJson7,"len[0-9]*","len") 581 retJson7 = re.replaceAll(retJson7,"i[0-9]*","i") 582 retJson7 = re.replaceAll(retJson7,"tnv[0-9]*","tnv") 583 assert.strictEqual(retJson7, correctResult['Generate']['returnGenerate7']) 584 585 let retJson8 = returnGenerateAndAssert("NUMBER_TYPE_1[]") 586 retJson8 = re.replaceAll(retJson8," ","") 587 retJson8 = re.replaceAll(retJson8,"len[0-9]*","len") 588 retJson8 = re.replaceAll(retJson8,"i[0-9]*","i") 589 retJson8 = re.replaceAll(retJson8,"tnv[0-9]*","tnv") 590 assert.strictEqual(retJson8, correctResult['Generate']['returnGenerate8']) 591} 592 593function returnGenerateAndAssert(dataType) { 594 param = { 595 optionalParamDestory:'', 596 valueCheckout:'', 597 valueDefine:'', 598 valueFill:'', 599 valueIn:'', 600 valueOut:'', 601 valuePackage:'' 602 } 603 data = { 604 class: [], 605 const: [], 606 enum: [], 607 exports: [], 608 function: [{name: 'fun1', type: 1, value: [], ret: dataType}], 609 interface: [], 610 namespace: [] 611 } 612 let returnInfo = { type: dataType, optional: false } 613 if (null != data) { 614 returnGenerate(returnInfo, param, data) 615 } else { 616 returnGenerate(returnInfo, param) 617 } 618 let result = JSON.stringify(param); 619 return result 620} 621function paramGenerateResult(correctResult) { 622 let retJson = JSON.stringify(paramGenerateAndAssert("string")) 623 retJson = re.replaceAll(retJson," ", "") 624 assert.strictEqual(retJson, correctResult['Generate']['ParamGenerate']) 625 626 let retJson1 = JSON.stringify(paramGenerateAndAssert("NUMBER_TYPE_1")); 627 retJson1 = re.replaceAll(retJson1," ","") 628 let qiepian = retJson1.substring(retJson1.indexOf("NUMBER_TYPE_"),retJson1.indexOf("NUMBER_TYPE_")+13); 629 retJson1 = re.replaceAll(retJson1,qiepian,"NUMBER_TYPE_1") 630 assert.strictEqual(retJson1, correctResult['Generate']['ParamGenerate1']) 631 632 let retJson2 = JSON.stringify(paramGenerateAndAssert("boolean")) 633 retJson2 = re.replaceAll(retJson2," ","") 634 assert.strictEqual(retJson2, correctResult['Generate']['ParamGenerate2']) 635 636 let retJson3 = JSON.stringify(paramGenerateAndAssert("Array<string>")) 637 retJson3 = re.replaceAll(retJson3," ","") 638 retJson3 = re.replaceAll(retJson3,"i[0-9]+","i") 639 retJson3 = re.replaceAll(retJson3,"len[0-9]+","len") 640 retJson3 = re.replaceAll(retJson3,"tt[0-9]+","tt") 641 assert.strictEqual(retJson3, correctResult['Generate']['ParamGenerate3']) 642 643 let retJson4 = JSON.stringify(paramGenerateAndAssert("Array<boolean>")) 644 retJson4 = re.replaceAll(retJson4," ","") 645 retJson4 = re.replaceAll(retJson4,"i[0-9]+","i") 646 retJson4 = re.replaceAll(retJson4,"len[0-9]+","len") 647 retJson4 = re.replaceAll(retJson4,"tt[0-9]+","tt") 648 assert.strictEqual(retJson4, correctResult['Generate']['ParamGenerate4']) 649 650 paramGenerateResultTwo(correctResult) 651} 652 653function paramGenerateResultTwo(correctResult){ 654 let retJson5 = JSON.stringify(paramGenerateAndAssert("Array<number>")); 655 retJson5 = re.replaceAll(retJson5," ","") 656 retJson5 = re.replaceAll(retJson5,"i[0-9]+","i") 657 retJson5 = re.replaceAll(retJson5,"len[0-9]+","len") 658 retJson5 = re.replaceAll(retJson5,"tt[0-9]+","tt") 659 assert.strictEqual(retJson5, correctResult['Generate']['ParamGenerate5']) 660 661 let retJson6 = JSON.stringify(paramGenerateAndAssert("string[]")) 662 retJson6 = re.replaceAll(retJson6," ","") 663 retJson6 = re.replaceAll(retJson6,"i[0-9]+","i") 664 retJson6 = re.replaceAll(retJson6,"len[0-9]+","len") 665 retJson6 = re.replaceAll(retJson6,"tt[0-9]+","tt") 666 assert.strictEqual(retJson6, correctResult['Generate']['ParamGenerate6']) 667 668 let retJson7 = JSON.stringify(paramGenerateAndAssert("boolean[]")); 669 retJson7 = re.replaceAll(retJson7," ","") 670 retJson7 = re.replaceAll(retJson7,"i[0-9]+","i") 671 retJson7 = re.replaceAll(retJson7,"len[0-9]+","len") 672 retJson7 = re.replaceAll(retJson7,"tt[0-9]+","tt") 673 assert.strictEqual(retJson7, correctResult['Generate']['ParamGenerate7']) 674 675 let retJson8 = JSON.stringify(paramGenerateAndAssert("number[]")) 676 retJson8 = re.replaceAll(retJson8," ","") 677 retJson8 = re.replaceAll(retJson8,"i[0-9]+","i") 678 retJson8 = re.replaceAll(retJson8,"len[0-9]+","len") 679 retJson8 = re.replaceAll(retJson8,"tt[0-9]+","tt") 680 assert.strictEqual(retJson8, correctResult['Generate']['ParamGenerate8']) 681} 682 683function paramGenerateAndAssert(dataType) { 684 param = { 685 optionalParamDestory:'', 686 valueCheckout:'', 687 valueDefine:'', 688 valueFill:'', 689 valueIn:'', 690 valueOut:'', 691 valuePackage:'' 692 } 693 data = { 694 class: [], 695 const: [], 696 enum: [], 697 exports: [], 698 function: [ 699 {name: 'fun1', 700 type: 1, 701 value: [{name: 'v', type: dataType, optional: false}], 702 ret: 'void'}], 703 interface: [], 704 namespace: [] 705 } 706 let funcValue = { name: "v", type: dataType, optional: false } 707 if (null != data) { 708 paramGenerate(0, funcValue, param, data) 709 } else { 710 paramGenerate(0, funcValue, param) 711 } 712 let result = JSON.stringify(param); 713 return result 714}