diff --git a/src/vscode_plugin/src/gen/datatype.ts b/src/vscode_plugin/src/gen/datatype.ts
index bccf41364c56e696d2605183c363a0b9900222f5..12378a8d30e4ae3ba963044b66185fab0035c1cf 100644
--- a/src/vscode_plugin/src/gen/datatype.ts
+++ b/src/vscode_plugin/src/gen/datatype.ts
@@ -118,7 +118,6 @@ export interface FuncInfo {
   name: string,
   params: ParamObj[],
   retType: string,
-  genName: string,
 }
 
 // 保存 typedefine int cJSON_bool
diff --git a/src/vscode_plugin/src/gen/gencpp.ts b/src/vscode_plugin/src/gen/gencpp.ts
index 1572f7390d83af0289ace89696fc7cc843d65523..71fcf8b7dda3d15b85b7203d73caa62b00e06cbc 100644
--- a/src/vscode_plugin/src/gen/gencpp.ts
+++ b/src/vscode_plugin/src/gen/gencpp.ts
@@ -48,7 +48,7 @@ export function generateDirectFunction(funcInfo: FuncInfo, rawFileName: string,
       let returnType = funcInfo.retType === 'std::string' ? 'const char *' : funcInfo.retType;
       returnType = returnType === 'size_t' ? 'int64_t' : returnType;
       let funcReturnReplace = replaceAll(napiFuncRetTemplate, '[return_name]', retObjInfo.objName);
-      funcReturnReplace = replaceAll(funcReturnReplace, '[func_name_replace]', funcInfo.genName);
+      funcReturnReplace = replaceAll(funcReturnReplace, '[func_name_replace]', funcInfo.name);
       funcReturnReplace = replaceAll(funcReturnReplace, '[return_replace]', retGenResult);
       bodyReplace = replaceAll(bodyReplace, '[func_return_replace]', funcReturnReplace);
   } else {
@@ -62,8 +62,8 @@ export function generateDirectFunction(funcInfo: FuncInfo, rawFileName: string,
 
 export function getReplaceInfo(funcInfo: FuncInfo, hFileName: string) {
   let funcInfoParams = genFuncInfoParams(funcInfo);
-  let bodyReplace = replaceAll(napiFuncCppTemplate, '[func_name_replace]', funcInfo.genName);
-  bodyReplace = replaceAll(bodyReplace, '[get_error_msg_tag]', funcInfo.genName);
+  let bodyReplace = replaceAll(napiFuncCppTemplate, '[func_name_replace]', funcInfo.name);
+  bodyReplace = replaceAll(bodyReplace, '[get_error_msg_tag]', funcInfo.name);
   bodyReplace = replaceAll(bodyReplace, '[file_introduce_replace]', hFileName);
   bodyReplace = replaceAll(bodyReplace, '[func_introduce_replace]', funcInfo.name);
   bodyReplace = replaceAll(bodyReplace, '[input_introduce_replace]', funcInfoParams === '' ? 'void' : funcInfoParams);
@@ -82,7 +82,7 @@ export function getBodyReplace2(funcInfo: FuncInfo, bodyReplace: string, genPara
 
 export function getGenParamReplace(funcInfo: FuncInfo, paramGenResult: string) {
   let genParamReplace = replaceAll(funcGetParamTemplate, '[param_length]', 'PARAMS' + funcInfo.params.length);
-  genParamReplace = replaceAll(genParamReplace, '[func_name_replace]', funcInfo.genName);
+  genParamReplace = replaceAll(genParamReplace, '[func_name_replace]', funcInfo.name);
   genParamReplace = replaceAll(genParamReplace, '[getAllParam_replace]', paramGenResult);
   return genParamReplace;
 }
diff --git a/src/vscode_plugin/src/gen/gendts.ts b/src/vscode_plugin/src/gen/gendts.ts
index 55528f44abe31fd22826d6c732dec4b2c215f66d..2fbca3c13659ad0aafd69f888a3ad8aae8269764 100644
--- a/src/vscode_plugin/src/gen/gendts.ts
+++ b/src/vscode_plugin/src/gen/gendts.ts
@@ -23,29 +23,6 @@ import util = require('util');
 import re = require('../common/re');
 import { dtsFuncTemplate } from '../template/func_template';
 
-const MIN_RANDOM = 100;
-const MAX_RANDOM = 999
-
-export function isStringType(cType: string) {
-  switch (cType) {
-      case 'string':
-      case 'std::string':
-      case 'char':
-      case 'wchar_t':
-      case 'char16_t':
-      case 'char32_t':
-          return true;
-      default:
-          return false;
-  }
-}
-
-export function isBoolType(cType: string) {
-  if (cType === 'bool') {
-      return true;
-  }
-  return false;
-}
 
 export function genTsFunction(func: FuncInfo, rawFileName: string) {
   let funcParams = '';
@@ -56,50 +33,13 @@ export function genTsFunction(func: FuncInfo, rawFileName: string) {
   let funcContent = replaceAll(dtsFuncTemplate, '[file_introduce_replace]', rawFileName);
   funcContent = replaceAll(funcContent, '[func_introduce_replace]', func.name);
   funcContent = replaceAll(funcContent, '[input_introduce_replace]', funcParams === '' ? 'void' : funcParams);
-  funcContent = replaceAll(funcContent, '[func_name_replace]', func.genName);
+  funcContent = replaceAll(funcContent, '[func_name_replace]', func.name);
   funcContent = replaceAll(funcContent, '[func_param_replace]', funcParams);
   funcContent = replaceAll(funcContent, '[func_return_replace]', func.retType);
 
   return funcContent;
 }
 
-export function isNumberType(cType: string) {
-  switch (cType) {
-      case 'short':
-      case 'int':
-      case 'uint32_t':
-      case 'size_t':
-      case 'long':
-      case 'long long':
-      case 'float':
-      case 'double':
-      case 'long double':
-      case 'int16_t':
-      case 'uint16_t':
-      case 'int32_t':
-      case 'int64_t':
-      case 'uint64_t':
-      case 'double_t':
-      case 'float_t':
-          return true;
-      default:
-          return false;
-  }
-}
-
-export function basicC2js(cType: string) {
-  let jsType = '';
-  if (isStringType(cType)) {
-      jsType = 'string';
-  } else if (isBoolType(cType)) {
-      jsType = 'boolean';
-  } else if (isNumberType(cType)) {
-      jsType = 'number';
-  } else {
-      jsType = cType;
-  }
-  return jsType;
-}
 
 export function getInterFuncRetType(str: string) {
   let strArr = str.split(' ');
@@ -112,42 +52,6 @@ export function getInterFuncName(str: string) {
   return replaceAll(strArr[1], '*', '');
 }
 
-export function getJsTypeFromC(cType: string) {
-  if (!cType) {
-    return '';
-  }
-  let basicCtype = cType;
-  let matchs = re.match('(std::)?vector<([\x21-\x7e ]+)>', basicCtype);
-  let isArray = 0;
-  if (matchs) {
-      basicCtype = re.getReg(basicCtype, matchs.regs[2]).trim();
-      isArray = 1;
-  }
-
-  let unsignedIdx = basicCtype.indexOf('unsigned');
-  if (unsignedIdx >= 0) {
-      // cut off the keywords 'unsigned'
-      basicCtype = basicCtype.substring(unsignedIdx + 8, basicCtype.length).trim();
-  }
-  let jsType = basicC2js(basicCtype);
-  if (isArray) {
-      jsType = util.format('Array<%s>', jsType);
-  }
-  // 去掉const
-  jsType = replaceAll(jsType, 'const', '');
-  // struct cJson * 的情况
-  let matchStruct = re.match('(struct)?[A-Z_a-z0-9 *]+', basicCtype);
-  if (matchStruct) {
-      let index = basicCtype.indexOf('struct');
-      // 去掉struct和*
-      if (index >= 0) {
-        jsType = jsType.substring(index + 6, basicCtype.length);
-      }
-      jsType = replaceAll(jsType, '*', '').trim();
-  }
-  jsType = basicC2js(jsType);
-  return jsType;
-}
 
 export function getInterFuncParams(str: string, paramObj: ParamObj[]) {
   let paramsStr = '';
@@ -164,7 +68,7 @@ export function getInterFuncParams(str: string, paramObj: ParamObj[]) {
     paramObject.name = paramVal;
     paramObject.type = paramType;
     paramObj.push(paramObject);
-    let rawType = getJsTypeFromC(paramType);
+    let rawType = transTskey2Ckey(paramType);
     paramsStr += paramVal + ': ' + rawType;
     if (i !== paramArr.length - 1) {
       paramsStr += ', ';
@@ -209,7 +113,7 @@ export function createParam(parseParamInfo: ParamObj) {
   tsParam.name = replaceAll(parseParamInfo.name, '*', '');
   cppParam.name = tsParam.name;
   cppParam.type = removeMarco(parseParamInfo.type);
-  let rawType = getJsTypeFromC(parseParamInfo.type);
+  let rawType = transTskey2Ckey(parseParamInfo.type);
   tsParam.type = removeMarco(rawType);
   return [tsParam, cppParam];
 }
@@ -219,19 +123,15 @@ export function createFuncInfo(parseFuncInfo: FuncObj) {
       name: '',
       params: [],
       retType: '',
-      genName: ''
   };
 
   let cppFuncInfo: FuncInfo = {
     name: '',
     params: [],
     retType: '',
-    genName: ''
   }
   funcInfo.name = parseFuncInfo.name;
   cppFuncInfo.name = parseFuncInfo.name;
-  funcInfo.genName = util.format('KH%s_%s', generateRandomInteger(MIN_RANDOM, MAX_RANDOM), funcInfo.name);
-  cppFuncInfo.genName = funcInfo.genName;
   let parseParams = parseFuncInfo.parameters;
   for (let i = 0; i < parseParams.length; ++i) {
       let paramsRes = createParam(parseParams[i]);
@@ -246,7 +146,7 @@ export function createFuncInfo(parseFuncInfo: FuncObj) {
   let retType = parseFuncInfo.returns === '' ? 'void' : parseFuncInfo.returns;
   retType = removeMarco(retType);
   cppFuncInfo.retType = retType;
-  funcInfo.retType = getJsTypeFromC(retType);
+  funcInfo.retType = transTskey2Ckey(retType);
   return [funcInfo, cppFuncInfo];
 }
 
@@ -315,7 +215,6 @@ export function genDtsInterface(path: string, typeList: TypeList[], interfaceLis
           let interFuncParams: ParamObj[] = []
           let returnType = getInterFuncRetType(match[0]);
           let funcName = getInterFuncName(match[1]);
-          funcName = util.format('KH%s_%s', generateRandomInteger(MIN_RANDOM, MAX_RANDOM), funcName);
           let params = getInterFuncParams(match[2], interFuncParams);
           interDefine += util.format('  %s:(%s) => %s;\n',funcName, params, returnType);
           let funcObj: FuncObj = {
@@ -329,7 +228,6 @@ export function genDtsInterface(path: string, typeList: TypeList[], interfaceLis
           let interFuncParams: ParamObj[] = []
           let returnType = getInterFuncRetType(match2[1]);
           let funcName = match2[2];
-          funcName = util.format('KH%s_%s', generateRandomInteger(MIN_RANDOM, MAX_RANDOM), funcName);
           let params = getInterFuncParams(match2[3], interFuncParams);
           interDefine += util.format('  %s:(%s) => %s;\n',funcName, params, returnType);
           let funcObj: FuncObj = {
@@ -343,7 +241,7 @@ export function genDtsInterface(path: string, typeList: TypeList[], interfaceLis
           let lastTabIndex = paramStr.lastIndexOf(' ');
           const variableName = paramStr.substring(lastTabIndex + 1, paramStr.length).replace('*', '')
           const variabletype = paramStr.substring(0, lastTabIndex);
-          let rawType = getJsTypeFromC(variabletype);
+          let rawType = transTskey2Ckey(variabletype);
           if (!isJsBasicType(rawType)) {
             rawType += ' | null';
           }
@@ -372,7 +270,7 @@ export function genDtsInterface(path: string, typeList: TypeList[], interfaceLis
         // 输出匹配的基本类型定义
         Logger.getInstance().debug('Basic type typedef match:' + basicTypeMatch[0]); 
         let matchs = basicTypeMatch[index].split(' ');
-        let rawType = getJsTypeFromC(matchs[1].trim());
+        let rawType = transTskey2Ckey(matchs[1].trim());
         let defineType = matchs[2].split(';')
         let typedefine = 'type ' + defineType[0] + ' = ' + rawType + ';\n';
         interfaceListDef += typedefine;
@@ -411,6 +309,10 @@ export function transTskey2Ckey(key: string) {
   for(const keyItem of dts2cpp_key) {
     for(const str of keyItem.keys) {
       if (key.includes(str)) {
+        const match = key.match(/(std::)?vector<([\w\s*::<>]+)>/);
+        if (match) {
+          return 'Array<' + keyItem.value + '>';
+        }
         return keyItem.value;
       }
     }
diff --git a/src/vscode_plugin/src/gen/gendtscpp.ts b/src/vscode_plugin/src/gen/gendtscpp.ts
index 69421cadf2c020cadba1886190c375da16d3b8cb..7df239c8a472d5f461fbb528fb42f8771aad2a91 100644
--- a/src/vscode_plugin/src/gen/gendtscpp.ts
+++ b/src/vscode_plugin/src/gen/gendtscpp.ts
@@ -45,7 +45,7 @@ export function genHFunction(func: FuncInfo, rawFileName: string) {
   let hContent = replaceAll(napiFuncHTemplate, '[file_introduce_replace]', rawFileName);
   hContent = replaceAll(hContent, '[func_introduce_replace]', func.name);
   hContent = replaceAll(hContent, '[input_introduce_replace]', funcParams === '' ? 'void' : funcParams);
-  hContent = replaceAll(hContent, '[func_name_replace]', func.genName);
+  hContent = replaceAll(hContent, '[func_name_replace]', func.name);
   hContent = replaceAll(hContent, '[func_param_replace]', funcParams);
   hContent = replaceAll(hContent, '[func_return_replace]', func.retType === ''? 'void': func.retType);
 
@@ -120,7 +120,7 @@ export function generateFuncCode(rootInfo: DtscppRootInfo) {
     // gen dts function
     tsFuncContent += genTsFunction(tsfunctions[i], rawFileName);
     // 每个napi方法的init
-    genResult.napiInitContent += replaceAll(napiFuncInitTemplate, '[func_name_replace]', tsfunctions[i].genName);
+    genResult.napiInitContent += replaceAll(napiFuncInitTemplate, '[func_name_replace]', tsfunctions[i].name);
     // 每个napi方法的h声明
     genResult.napiHContent += genHFunction(cppfunctions[i], rawFileName);
     // 每个Napi方法的cpp说明
@@ -167,7 +167,7 @@ export function generateFunctions(parseObj: ParseObj, tsFilePath: string) {
   let rawFileName = path.basename(tsFilePath);
   for (let i = 0; i < cppfunctions.length; i++) {
     // 每个napi方法的init
-    genResult.napiInitContent += replaceAll(napiFuncInitTemplate, '[func_name_replace]', cppfunctions[i].genName);
+    genResult.napiInitContent += replaceAll(napiFuncInitTemplate, '[func_name_replace]', cppfunctions[i].name);
     // 每个napi方法的h声明
     genResult.napiHContent += genHFunction(cppfunctions[i], rawFileName);
     // 每个Napi方法的cpp说明
@@ -226,10 +226,8 @@ export function getFunctions(parseObj: ParseObj) {
       name: '',
       params: [],
       retType: '',
-      genName: ''
     };
     cppFuncInfo.name = parseObj.funcs[i].name;
-    cppFuncInfo.genName = parseObj.funcs[i].name;
     let parseParams = parseObj.funcs[i].parameters;
     for (let i = 0; i < parseParams.length; ++i) {
       let paramsRes = createFuncParam(parseParams[i]);
diff --git a/src/vscode_plugin/src/gen/gentest.ts b/src/vscode_plugin/src/gen/gentest.ts
index 77374daf096b39bcef828a1d5fa8bafa35d3e27e..a78ec5db9b5109a9087306e45311d1b93d5a5c24 100644
--- a/src/vscode_plugin/src/gen/gentest.ts
+++ b/src/vscode_plugin/src/gen/gentest.ts
@@ -16,9 +16,10 @@
 import util = require('util');
 import { replaceAll } from "../common/tool";
 import { FuncInfo, InterfaceList, ParamObj, TypeList } from "./datatype";
-import { getInterfaceBody, getJsTypeFromC, getTypeBody, isBoolType, isNumberType, isStringType } from './gendts';
+import { getInterfaceBody, getTypeBody, transTskey2Ckey } from './gendts';
 import { testAbilityFuncTemplate } from "../template/func_template";
 import { Logger } from '../common/log';
+import { dts2cpp_key } from '../template/dtscpp/dts2cpp_key';
 
 const INTVALUE = 5;
 const FLOATVALUE = 2.5;
@@ -35,15 +36,15 @@ export function generateFuncTestCase(funcInfo: FuncInfo, rawFileName: string,  t
   if (getJsType(funcInfo.retType) !== 'void') {
     callFunc = util.format('let result: %s = testNapi.%s(%s)\n    ', getJsType(funcInfo.retType), funcInfo.genName, funcParamUse);
     // 加 hilog 打印
-    hilogContent = util.format('hilog.info(0x0000, "testTag", "Test NAPI %s: ", JSON.stringify(result));\n    ', funcInfo.genName);
-    hilogContent += util.format('Logger.getInstance().info("testTag", "Test NAPI %s: ", JSON.stringify(result));\n    ', funcInfo.genName);
+    hilogContent = util.format('hilog.info(0x0000, "testTag", "Test NAPI %s: ", JSON.stringify(result));\n    ', funcInfo.name);
+    hilogContent += util.format('Logger.getInstance().info("testTag", "Test NAPI %s: ", JSON.stringify(result));\n    ', funcInfo.name);
   } else {
-    callFunc = util.format('testNapi.%s(%s)\n    ', funcInfo.genName, funcParamUse);
+    callFunc = util.format('testNapi.%s(%s)\n    ', funcInfo.name, funcParamUse);
   }
   let funcTestReplace = funcParamDefine + callFunc + hilogContent;
   // 替换test_case_name
   let funcTestContent = replaceAll(testAbilityFuncTemplate, '[func_direct_testCase]', funcTestReplace);
-  funcTestContent = replaceAll(funcTestContent, '[test_case_name]', funcInfo.genName);
+  funcTestContent = replaceAll(funcTestContent, '[test_case_name]', funcInfo.name);
   funcTestContent = replaceAll(funcTestContent, '[file_introduce_replace]', rawFileName);
   funcTestContent = replaceAll(funcTestContent, '[func_introduce_replace]', funcInfo.name);
   funcTestContent = replaceAll(funcTestContent, '[input_introduce_replace]', funcInfoParams === '' ? 'void' : funcInfoParams);
@@ -90,7 +91,7 @@ export function genInitTestfunc(funcInfo: FuncInfo, typeList: TypeList[], interf
 
 export function getTypeDefine(testType: string, funcParamDefine: string, funcInfo: FuncInfo, i: number, funcParamUse: string, typeList: TypeList[]) {
   let cTypeDefine = getTypeBody(testType, typeList);
-  let typeDefType = getJsTypeFromC(cTypeDefine as string);
+  let typeDefType = transTskey2Ckey(cTypeDefine as string);
   // genType
   if (typeDefType === 'number') {
     funcParamDefine += util.format('let %s = %s\n    ', funcInfo.params[i].name, INTVALUE);
@@ -108,7 +109,7 @@ export function getTypeDefine(testType: string, funcParamDefine: string, funcInf
 export function genInterFuncParamStr(param: ParamObj[]) {
   let paramsStr = '';
   for(let i = 0; i < param.length; i++) {
-    let rawType = getJsTypeFromC(param[i].type);
+    let rawType = transTskey2Ckey(param[i].type);
     paramsStr += param[i].name + ': ' + rawType;
     if (i !== param.length - 1) {
       paramsStr += ', ';
@@ -124,7 +125,7 @@ export function getInterfaceDefine(testType: string, funcParamDefine: string, fu
   let interFuncs = objValue!.funcs;
   // 成员变量赋值
   for (let j = 0; j < interParams.length; j++) {
-    let paramType = getJsTypeFromC(interParams[j].type);
+    let paramType = transTskey2Ckey(interParams[j].type);
     if (paramType === 'number') {
       objTestData += util.format('%s: %s, ', interParams[j].name, INTVALUE);
     } else if (paramType === 'string') {
@@ -140,7 +141,7 @@ export function getInterfaceDefine(testType: string, funcParamDefine: string, fu
   for (let j = 0; j < interFuncs.length; j++) {
     let paramStr = genInterFuncParamStr(interFuncs[j].parameters);
     let initInterFunc = util.format('%s:(%s) => ',interFuncs[j].name, paramStr);
-    let interFuncRetType = getJsTypeFromC(interFuncs[j].returns);
+    let interFuncRetType = transTskey2Ckey(interFuncs[j].returns);
     if (interFuncRetType === 'void') {
       let interfaceFuncRetDefine = initInterFunc + '{}';
       objTestData += util.format('%s, ', interfaceFuncRetDefine);
@@ -187,10 +188,13 @@ export function getTestType(type: string) {
 
 export function getJsType(type: string) {
     type = replaceAll(type,'const', '');
-    type = replaceAll(type, '*', '').trim();
-    if (isNumberType(type) || isStringType(type) || isBoolType(type) || type === 'void') {
-      return getJsTypeFromC(type);
-    } else {
-      return 'testNapi.' + type.replace('*', '').trim();
-    }  
+    type = replaceAll(type, '*', '').trim(); 
+    for(const keyItem of dts2cpp_key) {
+      for(const str of keyItem.keys) {
+        if (type.includes(str)) {
+          return transTskey2Ckey(type);
+        }
+      }
+    }
+    return 'testNapi.' + type.replace('*', '').trim();
 }
\ No newline at end of file
diff --git a/src/vscode_plugin/src/parse/parsec.ts b/src/vscode_plugin/src/parse/parsec.ts
index d656e8bab392f5ac2169f6ed87465bc7787b3cc7..7847073bc06d8fc21381b9f2b2abde6b6b3db895 100644
--- a/src/vscode_plugin/src/parse/parsec.ts
+++ b/src/vscode_plugin/src/parse/parsec.ts
@@ -172,7 +172,8 @@ export function parseStruct(data: string) {
 // /^(const\s+)?([\w\s*]+)\s+(\w+)(?:\[(\d+)\])?$/
 export function parseParameters(members: string[]): ParamObj[] {
   // const memberRegex = /^(const\s+)?([\w\s*]+)\s+(\w+)(?:\[(\d+)\])?$/;
-  const memberRegex = /^(const\s+)?([\w\s*]+)\s+(\w+)(?:\[(\d*)\])?$/;
+  // const memberRegex = /^(const\s+)?([\w\s*]+)\s+(\w+)(?:\[(\d*)\])?$/;
+  const memberRegex = /^(const\s+)?([\w\s*::<>]+)\s+(\w+)(?:\[(\d*)\])?$/;
   // Logger.getInstance().info(` parseParameters members: ${JSON.stringify(members)}`);
   return members.map(member => {
       const match = member.trim().match(memberRegex);
diff --git a/src/vscode_plugin/src/template/dtscpp/dts2cpp_key.ts b/src/vscode_plugin/src/template/dtscpp/dts2cpp_key.ts
index 49826842777f8df1c7609ae84e564e4e4b8fcb4d..8b4e81404190bfb304f0307ced3e39e09ea51eea 100644
--- a/src/vscode_plugin/src/template/dtscpp/dts2cpp_key.ts
+++ b/src/vscode_plugin/src/template/dtscpp/dts2cpp_key.ts
@@ -19,11 +19,15 @@ export let dts2cpp_key = [
         value: 'string'
     },
     {
-        keys: ['size_t', 'int', 'short', 'long', 'double', 'float'],
-        value: 'number'
+      keys: ['size_t', 'int', 'short', 'long', 'double', 'float', 'unsigned'],
+      value: 'number'
     },
     {
         keys: ['bool'],
         value: 'boolean'
+    },
+    {
+        keys: ['void'],
+        value: 'void'
     }
 ]
\ No newline at end of file
diff --git a/src/vscode_plugin/src/test/suite/gen/gendts.test.ts b/src/vscode_plugin/src/test/suite/gen/gendts.test.ts
index d6c5dc6be2bac8944e7b7d90a385ef429a431ee6..152efbf1497c0caa5df42343ef8e786ef7200493 100644
--- a/src/vscode_plugin/src/test/suite/gen/gendts.test.ts
+++ b/src/vscode_plugin/src/test/suite/gen/gendts.test.ts
@@ -38,24 +38,110 @@ suite('Gendts_transTskey2Ckey_Suite', () => {
     assert.strictEqual(resStr, 'number');
     resStr = genDts.transTskey2Ckey('long');
     assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('uint8_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('uint16_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('uint32_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('uint64_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('int8_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('int16_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('int32_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('int64_t');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('unsigned');
+    assert.strictEqual(resStr, 'number');
     resStr = genDts.transTskey2Ckey('bool');
     assert.strictEqual(resStr, 'boolean');
     resStr = genDts.transTskey2Ckey('char');
     assert.strictEqual(resStr, 'string');
-    resStr = genDts.transTskey2Ckey('string');
+    resStr = genDts.transTskey2Ckey('wchar_t');
     assert.strictEqual(resStr, 'string');
+    resStr = genDts.transTskey2Ckey('char8_t');
+    assert.strictEqual(resStr, 'string');
+    resStr = genDts.transTskey2Ckey('char16_t');
+    assert.strictEqual(resStr, 'string');
+    resStr = genDts.transTskey2Ckey('char32_t');
+    assert.strictEqual(resStr, 'string');
+    resStr = genDts.transTskey2Ckey('std::vector<int>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<size_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<double>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<float>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<long>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<short>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<uint8_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<uint16_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<uint32_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<uint64_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<int8_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<int16_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<int32_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<int64_t>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<unsigned>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<bool>');
+    assert.strictEqual(resStr, 'Array<boolean>');
+    resStr = genDts.transTskey2Ckey('std::vector<char>');
+    assert.strictEqual(resStr, 'Array<string>');
+    resStr = genDts.transTskey2Ckey('std::vector<wchar_t>');
+    assert.strictEqual(resStr, 'Array<string>');
+    resStr = genDts.transTskey2Ckey('std::vector<char8_t>');
+    assert.strictEqual(resStr, 'Array<string>');
+    resStr = genDts.transTskey2Ckey('std::vector<char16_t>');
+    assert.strictEqual(resStr, 'Array<string>');
+    resStr = genDts.transTskey2Ckey('std::vector<char32_t>');
+    assert.strictEqual(resStr, 'Array<string>');
   });
 
   //2, 测试边界情况
   test('transTskey2Ckey_test_2', () => {
     let resStr = genDts.transTskey2Ckey('std::string');
     assert.strictEqual(resStr, 'string');
+    resStr = genDts.transTskey2Ckey('std::vector<std::string>');
+    assert.strictEqual(resStr, 'Array<string>');
     resStr = genDts.transTskey2Ckey('char *');
     assert.strictEqual(resStr, 'string');
     resStr = genDts.transTskey2Ckey('');
     assert.strictEqual(resStr, '');
     resStr = genDts.transTskey2Ckey('char   *');
     assert.strictEqual(resStr, resStr);
+    resStr = genDts.transTskey2Ckey('long long');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('unsigned short');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('unsigned long');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('unsigned long long');
+    assert.strictEqual(resStr, 'number');
+    resStr = genDts.transTskey2Ckey('std::vector<long long>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<unsigned short>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<unsigned long>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('std::vector<unsigned long long>');
+    assert.strictEqual(resStr, 'Array<number>');
+    resStr = genDts.transTskey2Ckey('int *');
+    assert.strictEqual(resStr, 'number');
   });
 
   //3, 测试异常情况