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