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