diff --git a/src/vscode_plugin/src/parse/parsec.ts b/src/vscode_plugin/src/parse/parsec.ts index e46cd4a23350e70c59d4f71dbb569966a2bdf150..9e6adb7875ff25f94fff82d1b115aaf0db4c0d4b 100644 --- a/src/vscode_plugin/src/parse/parsec.ts +++ b/src/vscode_plugin/src/parse/parsec.ts @@ -170,6 +170,7 @@ export function parseStruct(data: string) { const alias = match[3]; // 获取成员声明 const membersString = match[2] || match[5]; + // 去注释 const comregex = /\/\/.*$/gm; const cleanedMembersString = membersString.replace(comregex, ''); const members = cleanedMembersString.split(';') @@ -208,18 +209,24 @@ 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*)\])?$/; + 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); // Logger.getInstance().info(` parseParameters match: ${JSON.stringify(match)}`); if (match) { - const type = match[2]; - const name = match[3]; + const type = match[2].trim(); + const name = match[3].trim(); // const arraySize = match[4] ? parseInt(match[4], 10) : -1; const arraySize = match[4] && match[4] !== "" ? parseInt(match[4], 10) : -1; return { type, name, arraySize }; + } else { + const type = member; + const name = ''; + // const arraySize = match[4] ? parseInt(match[4], 10) : -1; + const arraySize = -1; + return { type, name, arraySize }; } return {}; // 类型保护 @@ -240,15 +247,18 @@ export function parseMembers(members: string[]): ParamObj[] { // } // return {}; // // 类型保护 - // }).filter((m): m is ParamObj => m !== null); - const memReg = /(\w[\w\s\*]+)\s+(\w+)\s*(\s*\[\s*\d+\s*(\]\s*\[\s*\d+\s*)*\])?/; + // }).filter((m): m is ParamObj => m !== null); + const memReg = /(\w[\w\s\:\*]+)\s+(\w+)\s*(\s*\[\s*\d+\s*(\]\s*\[\s*\d+\s*)*\])?/; const pattern = /(\w+)\s*\(\s*\*([^\)]+)\s*\)\s*\(\s*([\w\s,]*)\s*\)/; + const commPattern = /([\S\,\ ]+)\s+(\w+)/; let arraySizes: string[] | null = null; return members.map(member => { + member = member.replace(/\s*private\s*:\s*/, ''); + member = member.replace(/\s*public\s*:\s*/, ''); const match = member.trim().match(memReg); if (match) { - const type = match[1]; - const name = match[2]; + const type = match[1].trim(); + const name = match[2].trim(); let arraySize = 0; // 解析数组长度 if ( match[3]) { @@ -268,8 +278,8 @@ export function parseMembers(members: string[]): ParamObj[] { } else { let funcmatch = member.trim().match(pattern); if (funcmatch) { - const type = funcmatch[1]; - const name = funcmatch[2]; + const type = funcmatch[1].trim(); + const name = funcmatch[2].trim(); let paramstr = funcmatch[3]; paramstr = paramstr.replace(/\s+/g, ''); const paramlist = paramstr.split(','); @@ -277,8 +287,27 @@ export function parseMembers(members: string[]): ParamObj[] { "type": type, "name": name, "arraySize": paramlist.length, - "arraySizeList": paramlist + "arraySizeList": paramlist.map(item => item.trim()) } + } else { + let cmatch = member.trim().match(commPattern); + if (cmatch) { + const type = cmatch[1].trim(); + const name = cmatch[2].trim(); + return { + "type": type, + "name": name, + "arraySize": -1, + "arraySizeList": [] + } + } else { + return { + "type": member, + "name": '', + "arraySize": -1, + "arraySizeList": [] + }; + } } } return {}; @@ -310,30 +339,39 @@ export function parseMethods(functions: string[]): FuncObj[] { export function parseClass(data: string) { // 使用正则表达式提取类定义 - const classRegex = /class\s+(\w+)\s*{([^}]*)}/g; + const classRegex = /class\s+(\w+)\s*{([^}]*)}\s*(\w*)\s*;/g; const classes: ClassObj[] = [] let match; while ((match = classRegex.exec(data)) !== null) { const className = match[1]; + const alias = match[3]; const classMembers = match[2] - .split(';') + // 去注释 + const comregex = /\/\/.*$/gm; + const cleanedMembersString = classMembers.replace(comregex, ''); + const memlist = cleanedMembersString.split(';') .map(member => member.trim().replace(/[\n\r]/g, '')) .filter(member => member.length > 0); const variables: string[] = []; const methods: string[] = []; - classMembers.forEach(member => { + memlist.forEach(member => { // 匹配方法声明 const methodRegex = /(\w[\w\s\*]+)\s+(\w+)\(([^)]*)\)\s*/; const variableRegex = /(\w[\w\s\*]+)\s+(\w+)\s*/; const pattern = /(\w+)\s*\(\s*\*([^\)]+)\s*\)\s*\(\s*([\w\s,]*)\s*\)/; + const comParrtern = /([\S\,\ ]+)\s+(\w+)/; if (methodRegex.test(member)) { - methods.push(member.trim().replace(/[\n\r]/g, '')); + methods.push(member.trim().replace(/[\n\r]/g, '')); } else if (variableRegex.test(member)) { - variables.push(member.trim().replace(/[\n\r]/g, '')); + variables.push(member.trim().replace(/[\n\r]/g, '')); } else if (pattern.test(member)) { variables.push(member.trim().replace(/[\n\r]/g, '')); + } else if (comParrtern.test(member)) { + variables.push(member.trim().replace(/[\n\r]/g, '')); + } else if (member.length > 0) { + variables.push(member.trim().replace(/[\n\r]/g, '')); } }); @@ -345,7 +383,7 @@ export function parseClass(data: string) { const classItem: ClassObj = { "name": className, - "alias": '', + "alias": alias, "variableList": variableList, "functionList": functionList } @@ -442,9 +480,19 @@ export function parseFunctionOld(data: string) { export function parseFunction(data: string): FuncObj[] { // const funcRegex = /^(static\s+)?(const\s+)?([\w\s\[\]*]+)\s+(\w+)\s*\(([^)]*)\);/gm; - const funcRegex = /(?:typedef\s+([\w\s\[\]*]+)\s+\(\*\s*(\w+)\)\s*\(([^)]*)\);|^(static\s+)?(const\s+)?([\w\s\[\]*]+)\s+(\w+)\s*\(([^)]*)\);)/gm + // const funcRegex = /(?:typedef\s+([\w\:\<\>\s\[\]*]+)\s+\(\*\s*(\w+)\)\s*\(([^)]*)\);|^(static\s+)?(const\s+)?([\w\:\s\[\]*]+)\s+(\w+)\s*\(([^)]*)\);)/gm + // const funcRegex = + // /(?:typedef\s+([\S\,\ ]+)\s+\(\*\s*(\w+)\)\s*\(([^)]*)\);|^(static\s+)?(const\s+)?([\S\,\ ]+)\s+(\w+)\s*\(([^)]*)\);)/gm + let funcRegLines = '(?:typedef\\s+([\\S\\,\\ ]+)\\s+\\(\\*\\s*(\\w+)\\)\\s*\\(([^)]*)\\);|' + + '^(static\\s+)?(const\\s+)?([\\S\\,\\ ]+)\\s+(\\w+)\\s*\\(([^)]*)\\);)'; + // let comfucRegex = /(static\s+)?(const\s+)?((?:[\w:]+\s*<[^<>]+>|[\w:*]+\s*)+)\s+(\w+)\s*\(\s*((?:[\w:]+\s*<[^<>]+>|[\w:*]+)\s+\w+(?:,\s*)*)*\s*\)/g; + let comfucRegex = /(static\s+)?(const\s+)?((?:[\w:]+\s*<[^<>]+>|[\w:*]+\s*)+)\s+(\w+)\s*\(\s*((?:[\w:]+\s*<[^<>]+>|[\w:*]+)\s+\w+(?:,\s*)*)*\s*\)/g; +///(static\s+)?(const\s+)?((?:\w+(?:::\w+)*(?:<[^<>]+>)?\s*)+)\s+(\w+)\s*\(\s*((?:[\w\s:<>,*]+\s+\w+\s*,?\s*)*)\s*\)/g; + // const comfucRegex = /(static\s+)?(const\s+)?((?:(?:long|short|signed|unsigned)\s+){1,3}\w+|\w+[\w:*]*(?:::\w+[\w:*<>]*)*)\s+(\w+)\s*\(\s*((?:\s*(?:[\w\s:<>,*]+)\s+\w+\s*,?)*)\s*\)/g; + const funcRegex = new RegExp(funcRegLines, 'gm'); const functions: FuncObj[] = [] let match; + let isFind = false; while ((match = funcRegex.exec(data)) !== null) { // Logger.getInstance().debug(`func match: ${JSON.stringify(match)}`) // match[3].trim(); @@ -452,17 +500,50 @@ export function parseFunction(data: string): FuncObj[] { // match[4].trim(); const name = match[2] ? match[2].trim() : match[7].trim(); // match[5].split(',').map(param => param.trim()).filter(param => param); - const params = (match[3] ? match[3] : match[8] || "").split(',').map(param => param.trim()).filter(param => param); + let paramstr = (match[3] ? match[3] : match[8] || "") + let paramreg = /([\w\s\:\*]+<[^>]*>[\s\w\:\*]+|[\*\w\s\:]+)/g; + let pmatch; + let matches = []; + + while ((pmatch = paramreg.exec(paramstr)) !== null) { + matches.push(pmatch[0].trim()); + } + let isInterface = match[0].includes('typedef'); let funcItem: FuncObj = { "type": isInterface ? "typedef" : "function", "returns": returnType, "name": name, - "parameters": parseParameters(params) + "parameters": parseParameters(matches) } - + isFind = true; functions.push(funcItem); } + + if (!isFind) { + while ((match = comfucRegex.exec(data)) !== null) { + const returnType = match[3].trim(); + const name = match[4].trim(); + let paramstr = match[5]; + + let paramreg = /([\w\s\:\*]+<[^>]*>[\s\w\:\*]+|[\*\w\s\:]+)/g; + let pmatch; + let matches = []; + + while ((pmatch = paramreg.exec(paramstr)) !== null) { + matches.push(pmatch[0].trim()); + } + + let funcItem: FuncObj = { + "type": "function", + "returns": returnType, + "name": name, + "parameters": parseParameters(matches) + } + isFind = true; + functions.push(funcItem); + } + } // Logger.getInstance().info(` return functions: ${JSON.stringify(functions)}`); return functions; } diff --git a/src/vscode_plugin/src/test/suite/parse/parsecclass.test.ts b/src/vscode_plugin/src/test/suite/parse/parsecclass.test.ts index cf95be74028be94621d20cacb6f218be78a71995..d78de258a6448190dfddcb217224781f200c4bed 100644 --- a/src/vscode_plugin/src/test/suite/parse/parsecclass.test.ts +++ b/src/vscode_plugin/src/test/suite/parse/parsecclass.test.ts @@ -26,250 +26,440 @@ suite('Parse_Class_C_Suite', () => { //1, 测试 parseClass 一般情况 test('parseClass_test_1', () => { - let testenum = `typedef class OTC { - private int len, - public char name[20], - public void contruct(int a); - public void deconstruct(); + let testclass = `typedef class OTC { + private: + int len; + public: + char name[20]; + void contruct(int a); + void deconstruct(); } OperationType;` - let enumObjList = parsec.parseClass(testenum); - assert.strictEqual(enumObjList.length, 1); - let enumItem = enumObjList[0]; - assert.strictEqual(enumItem.name, 'OTC'); - // assert.strictEqual(enumItem.alias, 'OperationType'); - // assert.strictEqual(enumItem.members.length, 3); - // assert.strictEqual(enumItem.members[0], 'NEW'); - // assert.strictEqual(enumItem.members[1], 'APPEND'); - // assert.strictEqual(enumItem.members[2], 'REPLACE'); + let classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + let classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OTC'); + assert.strictEqual(classItem.alias, 'OperationType'); + assert.strictEqual(classItem.functionList.length, 2); + assert.strictEqual(classItem.functionList[0].name, 'contruct'); + assert.strictEqual(classItem.functionList[0].returns, 'void'); + assert.strictEqual(classItem.functionList[0].parameters.length, 1); + assert.strictEqual(classItem.functionList[0].parameters[0].name, 'a'); + assert.strictEqual(classItem.functionList[0].parameters[0].type, 'int'); + assert.strictEqual(classItem.functionList[0].parameters[0].arraySize, -1); + assert.strictEqual(classItem.functionList[1].name, 'deconstruct'); + assert.strictEqual(classItem.functionList[1].returns, 'void'); + + assert.strictEqual(classItem.variableList.length, 2); + assert.strictEqual(classItem.variableList[0].name, 'len'); + assert.strictEqual(classItem.variableList[0].type, 'int'); + assert.strictEqual(classItem.variableList[0].arraySize, -1); + assert.strictEqual(classItem.variableList[1].name, 'name'); + assert.strictEqual(classItem.variableList[1].type, 'char'); + assert.strictEqual(classItem.variableList[1].arraySize, 20); }); //2, 测试边界情况 - // test('parseClass_test_2', () => { - // let testenum = `typedef enum { - // NEW, - // APPEND, - // REPLACE - // } OperationType;` - // let enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // let enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OperationType'); - // assert.strictEqual(enumItem.alias, 'OperationType'); - // // assert.strictEqual(enumItem.members.length, 3); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - // // assert.strictEqual(enumItem.members[1], 'APPEND'); - // // assert.strictEqual(enumItem.members[2], 'REPLACE'); - - // testenum = `typedef enum { NEW, APPEND, REPLACE } OperationType;` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OperationType'); - // assert.strictEqual(enumItem.alias, 'OperationType'); - // // assert.strictEqual(enumItem.members.length, 3); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - // // assert.strictEqual(enumItem.members[1], 'APPEND'); - // // assert.strictEqual(enumItem.members[2], 'REPLACE'); - - // testenum = `typedef enum { - // NEW - // } OperationType;` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OperationType'); - // assert.strictEqual(enumItem.alias, 'OperationType'); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - - // testenum = `typedef enum { NEW } OperationType;` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OperationType'); - // assert.strictEqual(enumItem.alias, 'OperationType'); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - - // testenum = `typedef enum OType { - // NEW - // } OperationType;` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OType'); - // assert.strictEqual(enumItem.alias, 'OperationType'); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - - // testenum = `typedef enum OType { NEW } OperationType;` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OType'); - // assert.strictEqual(enumItem.alias, 'OperationType'); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - - // testenum = `enum OType { - // NEW - // };` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OType'); - // // assert.strictEqual(enumItem.alias, undefined); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - - // testenum = `enum OType { NEW };` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OType'); - // // assert.strictEqual(enumItem.alias, undefined); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - - // testenum = `enum OType { NEW }; enum TOTSize1 { DTS };` - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 2); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OType'); - // // assert.strictEqual(enumItem.alias, undefined); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'NEW'); - // enumItem = enumObjList[1]; - // assert.strictEqual(enumItem.name, 'TOTSize1'); - // // assert.strictEqual(enumItem.alias, undefined); - // // assert.strictEqual(enumItem.members.length, 1); - // // assert.strictEqual(enumItem.members[0], 'DTS'); - - // testenum = `enum TEST_ENUM { - // ENUM_1 = 1, // comment - // ENUM_2 = 2 - // }`; - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'TEST_ENUM'); - // // assert.strictEqual(enumItem.alias, undefined); - // // assert.strictEqual(enumItem.members.length, 2); - // // assert.strictEqual(enumItem.members[0], 'ENUM_1=1'); - // // assert.strictEqual(enumItem.members[1], 'ENUM_2=2'); - - // // 没有分号结尾 - // testenum = `enum TEST_ENUM { - // ENUM_1, // comment - // ENUM_2 - // }`; - // enumObjList = parsec.parseClass(testenum); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'TEST_ENUM'); - // // assert.strictEqual(enumItem.alias, undefined); - // // assert.strictEqual(enumItem.members.length, 2); - // // assert.strictEqual(enumItem.members[0], 'ENUM_1'); - // // assert.strictEqual(enumItem.members[1], 'ENUM_2'); - // }); - - // //3, 测试异常情况 - // test('parseClass_test_3', () => { - // let teststr: string = ''; - // let enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = 'enum { ENUM_1 }'; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - // let enumItem = enumObjList[0]; - // // assert.strictEqual(enumItem.members[0], 'ENUM_1'); - - // teststr = `enum { - // ENUM_1, - // ENUM_2 };` - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // // assert.strictEqual(enumItem.members.length, 2); - // // assert.strictEqual(enumItem.members[0], 'ENUM_1'); - // // assert.strictEqual(enumItem.members[1], 'ENUM_2'); - - // teststr = `enum { - // ENUM_1, // comment - // ENUM_2 - // }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // // assert.strictEqual(enumItem.members.length, 2); - // // assert.strictEqual(enumItem.members[0], 'ENUM_1'); - // // assert.strictEqual(enumItem.members[1], 'ENUM_2'); - - // teststr = `enum OType { - // ENUM_1, // comment - // ENUM_2, - // };` - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // // assert.strictEqual(enumItem.members.length, 2); - // // assert.strictEqual(enumItem.members[0], 'ENUM_1'); - // // assert.strictEqual(enumItem.members[1], 'ENUM_2'); - - // teststr = `typedef enum OType { - // ENUM_1, // comment - // ENUM_2, - // };` - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - // enumItem = enumObjList[0]; - // // assert.strictEqual(enumItem.members.length, 2); - // // assert.strictEqual(enumItem.members[0], 'ENUM_1'); - // // assert.strictEqual(enumItem.members[1], 'ENUM_2'); - // }); - - // //4, 测试错误情况 - // test('parseClass_test_4', () => { - // let enumObjList = parsec.parseClass(''); - // assert.strictEqual(enumObjList.length, 0); - - // let teststr = `typedef enum OType {`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `}; typedef enum OType //{} {}`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `typedefinde enumute OType { }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `TYPEDEFfinde ENUMute OType { }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `export typedef enum OType { }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - // let enumItem = enumObjList[0]; - // assert.strictEqual(enumItem.name, 'OType'); - - // teststr = `typedef enum OType { }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - - // teststr = `typedef enum { }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - - // teststr = `typedef enum { }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - - // teststr = `typedef enum { ENUM_1 = 1, ENUM_2 = 2 }`; - // enumObjList = parsec.parseClass(teststr); - // assert.strictEqual(enumObjList.length, 1); - // }); + test('parseClass_test_2', () => { + let testclass = `typedef class testa { + private: + short snum; + short int sinum; + long slong; + long int silong; + long long llong; + long long int llinum; + char cname; + wchar_t cwname; + char16_t c16name; + char32_t c32name; + bool bflag; + float fnum; + double dnum; + long double ldnum; + std::string ssname; + std:wstring swsname; + std::u16string su16sname; + std:u32string su32sname; + std::basic_string sbsname; + + std::vector svlist; + std::deque sdlist; + std::list slist; + std::forward_list sflist; + std::array salist; + std::stack sqstack; + std::queue sqlist; + std::priority_queue spqlist; + std::pair sppair; + std::map smap; + std::multimap smmap; + std::set sset; + std::multiset smset; + std::unordered_map sumap; + std::unordered_multimap summap; + std::unordered_set suset; + std::unordered_multiset sumset; + + std::vector::iterator svlistIter; + std::deque::iterator sdlistIter; + std::list::iterator slistIter; + std::forward_list::iterator sflistIter; + std::array::iterator salistIter; + std::stack::iterator sqstackIter; + std::queue::iterator sqqueIter; + std::priority_queue::iterator spqlistIter; + std::pair::iterator sppairIter; + std::map::iterator smapIter; + std::multimap::iterator smmapIter; + std::set::iterator ssetIter; + std::multiset::iterator smsetIter; + std::unordered_map::iterator sumapIter; + std::unordered_multimap::iterator summapIter; + std::unordered_set::iterator susetIter; + std::unordered_multiset::iterator sumsetIter; + + std::function func; + std::tuple myTuple; + std::complex myComplex; + std::valarray myValarray; + std::time_t myTimet; + std::clock_t myClock; + std::tm myTm; + + } OperationType;` + + // let test = "std::pair::iterator sppairIter"; + // let regex = /([\S\,\ ]+)\s+(\w+)/; + // const matches = test.match(regex); + let classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + let classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'testa'); + assert.strictEqual(classItem.alias, 'OperationType'); + + assert.strictEqual(classItem.variableList.length, 60); + assert.strictEqual(classItem.variableList[0].name, 'snum'); + assert.strictEqual(classItem.variableList[0].type, 'short'); + assert.strictEqual(classItem.variableList[1].name, 'sinum'); + assert.strictEqual(classItem.variableList[1].type, 'short int'); + assert.strictEqual(classItem.variableList[2].name, 'slong'); + assert.strictEqual(classItem.variableList[2].type, 'long'); + assert.strictEqual(classItem.variableList[3].name, 'silong'); + assert.strictEqual(classItem.variableList[3].type, 'long int'); + assert.strictEqual(classItem.variableList[4].name, 'llong'); + assert.strictEqual(classItem.variableList[4].type, 'long long'); + assert.strictEqual(classItem.variableList[5].name, 'llinum'); + assert.strictEqual(classItem.variableList[5].type, 'long long int'); + assert.strictEqual(classItem.variableList[6].name, 'cname'); + assert.strictEqual(classItem.variableList[6].type, 'char'); + assert.strictEqual(classItem.variableList[7].name, 'cwname'); + assert.strictEqual(classItem.variableList[7].type, 'wchar_t'); + assert.strictEqual(classItem.variableList[8].name, 'c16name'); + assert.strictEqual(classItem.variableList[8].type, 'char16_t'); + assert.strictEqual(classItem.variableList[9].name, 'c32name'); + assert.strictEqual(classItem.variableList[9].type, 'char32_t'); + assert.strictEqual(classItem.variableList[10].name, 'bflag'); + assert.strictEqual(classItem.variableList[10].type, 'bool'); + assert.strictEqual(classItem.variableList[11].name, 'fnum'); + assert.strictEqual(classItem.variableList[11].type, 'float'); + assert.strictEqual(classItem.variableList[12].name, 'dnum'); + assert.strictEqual(classItem.variableList[12].type, 'double'); + assert.strictEqual(classItem.variableList[13].name, 'ldnum'); + assert.strictEqual(classItem.variableList[13].type, 'long double'); + assert.strictEqual(classItem.variableList[14].name, 'ssname'); + assert.strictEqual(classItem.variableList[14].type, 'std::string'); + assert.strictEqual(classItem.variableList[15].name, 'swsname'); + assert.strictEqual(classItem.variableList[15].type, 'std:wstring'); + assert.strictEqual(classItem.variableList[16].name, 'su16sname'); + assert.strictEqual(classItem.variableList[16].type, 'std::u16string'); + assert.strictEqual(classItem.variableList[17].name, 'su32sname'); + assert.strictEqual(classItem.variableList[17].type, 'std:u32string'); + assert.strictEqual(classItem.variableList[18].name, 'sbsname'); + assert.strictEqual(classItem.variableList[18].type, 'std::basic_string'); + assert.strictEqual(classItem.variableList[19].name, 'svlist'); + assert.strictEqual(classItem.variableList[19].type, 'std::vector'); + assert.strictEqual(classItem.variableList[20].name, 'sdlist'); + assert.strictEqual(classItem.variableList[20].type, 'std::deque'); + assert.strictEqual(classItem.variableList[21].name, 'slist'); + assert.strictEqual(classItem.variableList[21].type, 'std::list'); + assert.strictEqual(classItem.variableList[22].name, 'sflist'); + assert.strictEqual(classItem.variableList[22].type, 'std::forward_list'); + assert.strictEqual(classItem.variableList[23].name, 'salist'); + assert.strictEqual(classItem.variableList[23].type, 'std::array'); + assert.strictEqual(classItem.variableList[24].name, 'sqstack'); + assert.strictEqual(classItem.variableList[24].type, 'std::stack'); + assert.strictEqual(classItem.variableList[25].name, 'sqlist'); + assert.strictEqual(classItem.variableList[25].type, 'std::queue'); + assert.strictEqual(classItem.variableList[26].name, 'spqlist'); + assert.strictEqual(classItem.variableList[26].type, 'std::priority_queue'); + assert.strictEqual(classItem.variableList[27].name, 'sppair'); + assert.strictEqual(classItem.variableList[27].type, 'std::pair'); + assert.strictEqual(classItem.variableList[28].name, 'smap'); + assert.strictEqual(classItem.variableList[28].type, 'std::map'); + assert.strictEqual(classItem.variableList[29].name, 'smmap'); + assert.strictEqual(classItem.variableList[29].type, 'std::multimap'); + assert.strictEqual(classItem.variableList[30].name, 'sset'); + assert.strictEqual(classItem.variableList[30].type, 'std::set'); + assert.strictEqual(classItem.variableList[31].name, 'smset'); + assert.strictEqual(classItem.variableList[31].type, 'std::multiset'); + assert.strictEqual(classItem.variableList[32].name, 'sumap'); + assert.strictEqual(classItem.variableList[32].type, 'std::unordered_map'); + assert.strictEqual(classItem.variableList[33].name, 'summap'); + assert.strictEqual(classItem.variableList[33].type, 'std::unordered_multimap'); + assert.strictEqual(classItem.variableList[34].name, 'suset'); + assert.strictEqual(classItem.variableList[34].type, 'std::unordered_set'); + assert.strictEqual(classItem.variableList[35].name, 'sumset'); + assert.strictEqual(classItem.variableList[35].type, 'std::unordered_multiset'); + // assert.strictEqual(classItem.variableList[36].name, 'svlistIter'); + // assert.strictEqual(classItem.variableList[36].type, 'std::vector::iterator'); + // assert.strictEqual(classItem.variableList[37].name, 'sdlistIter'); + // assert.strictEqual(classItem.variableList[37].type, 'std::deque::iterator'); + // assert.strictEqual(classItem.variableList[38].name, 'slistIter'); + // assert.strictEqual(classItem.variableList[38].type, 'std::list::iterator'); + // assert.strictEqual(classItem.variableList[39].name, 'sflistIter'); + // assert.strictEqual(classItem.variableList[39].type, 'std::forward_list::iterator'); + // assert.strictEqual(classItem.variableList[40].name, 'salistIter'); + // assert.strictEqual(classItem.variableList[40].type, 'std::array::iterator'); + // assert.strictEqual(classItem.variableList[41].name, 'sqstackIter'); + // assert.strictEqual(classItem.variableList[41].type, 'std::stack::iterator'); + // assert.strictEqual(classItem.variableList[42].name, 'sqqueIter'); + // assert.strictEqual(classItem.variableList[42].type, 'std::queue::iterator'); + // assert.strictEqual(classItem.variableList[43].name, 'spqlistIter'); + // assert.strictEqual(classItem.variableList[43].type, 'std::priority_queue::iterator'); + // assert.strictEqual(classItem.variableList[44].name, 'sppairIter'); + // assert.strictEqual(classItem.variableList[44].type, 'std::pair::iterator'); + // assert.strictEqual(classItem.variableList[45].name, 'smapIter'); + // assert.strictEqual(classItem.variableList[45].type, 'std::map::iterator'); + // assert.strictEqual(classItem.variableList[46].name, 'smmapIter'); + // assert.strictEqual(classItem.variableList[46].type, 'std::multimap::iterator'); + // assert.strictEqual(classItem.variableList[47].name, 'ssetIter'); + // assert.strictEqual(classItem.variableList[47].type, 'std::set::iterator'); + // assert.strictEqual(classItem.variableList[48].name, 'smsetIter'); + // assert.strictEqual(classItem.variableList[48].type, 'std::multiset::iterator'); + // assert.strictEqual(classItem.variableList[49].name, 'sumapIter'); + // assert.strictEqual(classItem.variableList[49].type, 'std::unordered_map::iterator'); + // assert.strictEqual(classItem.variableList[50].name, 'summapIter'); + // assert.strictEqual(classItem.variableList[50].type, 'std::unordered_multimap::iterator'); + // assert.strictEqual(classItem.variableList[51].name, 'susetIter'); + // assert.strictEqual(classItem.variableList[51].type, 'std::unordered_set::iterator'); + // assert.strictEqual(classItem.variableList[52].name, 'sumsetIter'); + // assert.strictEqual(classItem.variableList[52].type, 'std::unordered_multiset::iterator'); + assert.strictEqual(classItem.variableList[53].name, 'func'); + assert.strictEqual(classItem.variableList[53].type, 'std::function'); + assert.strictEqual(classItem.variableList[54].name, 'myTuple'); + assert.strictEqual(classItem.variableList[54].type, 'std::tuple'); + assert.strictEqual(classItem.variableList[55].name, 'myComplex'); + assert.strictEqual(classItem.variableList[55].type, 'std::complex'); + assert.strictEqual(classItem.variableList[56].name, 'myValarray'); + assert.strictEqual(classItem.variableList[56].type, 'std::valarray'); + assert.strictEqual(classItem.variableList[57].name, 'myTimet'); + assert.strictEqual(classItem.variableList[57].type, 'std::time_t'); + assert.strictEqual(classItem.variableList[58].name, 'myClock'); + assert.strictEqual(classItem.variableList[58].type, 'std::clock_t'); + assert.strictEqual(classItem.variableList[59].name, 'myTm'); + assert.strictEqual(classItem.variableList[59].type, 'std::tm'); + // assert.strictEqual(classItem.members[1], 'APPEND'); + // assert.strictEqual(classItem.members[2], 'REPLACE'); + + testclass = `typedef class testa { NEW; APPEND; REPLACE } OperationType;` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'testa'); + assert.strictEqual(classItem.alias, 'OperationType'); + assert.strictEqual(classItem.variableList.length, 3); + assert.strictEqual(classItem.variableList[0].type, 'NEW'); + assert.strictEqual(classItem.variableList[1].type, 'APPEND'); + assert.strictEqual(classItem.variableList[2].type, 'REPLACE'); + + // no class name + testclass = `typedef class { + NEW; + } OperationType;` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 0); + classItem = classObjList[0]; + + testclass = `typedef class { NEW } OperationType;` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 0); + + testclass = `typedef class OType { + NEW + } OperationType;` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + assert.strictEqual(classItem.alias, 'OperationType'); + assert.strictEqual(classItem.variableList.length, 1); + assert.strictEqual(classItem.variableList[0].type, 'NEW'); + + testclass = `typedef class OType { NEW } OperationType;` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + assert.strictEqual(classItem.alias, 'OperationType'); + assert.strictEqual(classItem.variableList.length, 1); + assert.strictEqual(classItem.variableList[0].type, 'NEW'); + + testclass = `class OType { + NEW + };` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + assert.strictEqual(classItem.variableList.length, 1); + assert.strictEqual(classItem.variableList[0].type, 'NEW'); + + testclass = `class OType { NEW };` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + assert.strictEqual(classItem.variableList.length, 1); + assert.strictEqual(classItem.variableList[0].type, 'NEW'); + + testclass = `class OType { NEW }; class TOTSize1 { DTS };` + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 2); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + assert.strictEqual(classItem.variableList.length, 1); + assert.strictEqual(classItem.variableList[0].type, 'NEW'); + classItem = classObjList[1]; + assert.strictEqual(classItem.name, 'TOTSize1'); + assert.strictEqual(classItem.variableList.length, 1); + assert.strictEqual(classItem.variableList[0].type, 'DTS'); + + testclass = `class TEST_ENUM { + int a; // comment + float b; + };`; + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'TEST_ENUM'); + assert.strictEqual(classItem.variableList.length, 2); + assert.strictEqual(classItem.variableList[0].name, 'a'); + assert.strictEqual(classItem.variableList[0].type, 'int'); + assert.strictEqual(classItem.variableList[1].name, 'b'); + assert.strictEqual(classItem.variableList[1].type, 'float'); + + // 分号结尾 + testclass = `class TEST_ENUM { + ENUM_1; // comment + ENUM_2; + };`; + classObjList = parsec.parseClass(testclass); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'TEST_ENUM'); + assert.strictEqual(classItem.variableList.length, 2); + assert.strictEqual(classItem.variableList[0].type, 'ENUM_1'); + assert.strictEqual(classItem.variableList[1].type, 'ENUM_2'); + }); + + //3, 测试异常情况 + test('parseClass_test_3', () => { + let teststr: string = ''; + let classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + + teststr = 'class { ENUM_1 }'; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + let classItem = classObjList[0]; + // assert.strictEqual(classItem.members[0], 'ENUM_1'); + + teststr = `class { + ENUM_1, + ENUM_2 };` + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + classItem = classObjList[0]; + // assert.strictEqual(classItem.members.length, 2); + // assert.strictEqual(classItem.members[0], 'ENUM_1'); + // assert.strictEqual(classItem.members[1], 'ENUM_2'); + + teststr = `class { + ENUM_1, // comment + ENUM_2 + }`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + classItem = classObjList[0]; + // assert.strictEqual(classItem.members.length, 2); + // assert.strictEqual(classItem.members[0], 'ENUM_1'); + // assert.strictEqual(classItem.members[1], 'ENUM_2'); + + teststr = `class OType { + ENUM_1, // comment + ENUM_2, + };` + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + assert.strictEqual(classItem.variableList.length, 1); + assert.strictEqual(classItem.variableList[0].name, 'ENUM_2'); + + teststr = `typedef class OType { + ENUM_1, // comment + ENUM_2, + };` + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + assert.strictEqual(classItem.variableList.length, 1); + }); + + //4, 测试错误情况 + test('parseClass_test_4', () => { + let classObjList = parsec.parseClass(''); + assert.strictEqual(classObjList.length, 0); + + let teststr = `typedef class OType {`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + + teststr = `}; typedef class OType //{} {}`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + + teststr = `typedefinde enumute OType { }`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + + teststr = `TYPEDEFfinde ENUMute OType { }`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + + teststr = `export typedef class OType { };`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 1); + let classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + + teststr = `typedef class OType { };`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 1); + classItem = classObjList[0]; + assert.strictEqual(classItem.name, 'OType'); + + teststr = `typedef class { }`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + + teststr = `typedef class { }`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + + teststr = `typedef class { ENUM_1 = 1, ENUM_2 = 2 }`; + classObjList = parsec.parseClass(teststr); + assert.strictEqual(classObjList.length, 0); + }); }); diff --git a/src/vscode_plugin/src/test/suite/parse/parsecfunc.test.ts b/src/vscode_plugin/src/test/suite/parse/parsecfunc.test.ts index 7b27149ba7f75ab83e087e58cedb62aa89465fd5..5801a3d80b01afd4f3a98e43286a7052cbd250c6 100644 --- a/src/vscode_plugin/src/test/suite/parse/parsecfunc.test.ts +++ b/src/vscode_plugin/src/test/suite/parse/parsecfunc.test.ts @@ -19,6 +19,7 @@ import * as assert from 'assert'; // as well as import your extension to test it import * as vscode from 'vscode'; import * as parsec from '../../../parse/parsec' +import G = require('glob'); // import * as myExtension from '../../extension'; suite('Parse_C_Func_Suite', () => { @@ -27,9 +28,9 @@ suite('Parse_C_Func_Suite', () => { //1, 测试 parseEnum 一般情况 test('parseFunction_test_1', () => { let testenum = `int add(int a,int b);` - let enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - let funcItem = enumObjList[0]; + let funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + let funcItem = funcObjList[0]; assert.strictEqual(funcItem.name, 'add'); assert.strictEqual(funcItem.returns, 'int'); assert.strictEqual(funcItem.type, 'function'); @@ -39,240 +40,902 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[1].name, 'b'); assert.strictEqual(funcItem.parameters[1].type, 'int'); - // assert.strictEqual(funcItem.alias, 'OperationType'); - // assert.strictEqual(funcItem.members.length, 3); - // assert.strictEqual(funcItem.members[0], 'NEW'); - // assert.strictEqual(funcItem.members[1], 'APPEND'); - // assert.strictEqual(funcItem.members[2], 'REPLACE'); }); //2, 测试边界情况 - // test('parseFunction_test_2', () => { - // let testenum = `typedef enum { - // NEW, - // APPEND, - // REPLACE - // } OperationType;` - // let enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // let funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OperationType'); - // // assert.strictEqual(funcItem.alias, 'OperationType'); - // // assert.strictEqual(funcItem.members.length, 3); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - // // assert.strictEqual(funcItem.members[1], 'APPEND'); - // // assert.strictEqual(funcItem.members[2], 'REPLACE'); - - // testenum = `typedef enum { NEW, APPEND, REPLACE } OperationType;` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OperationType'); - // // assert.strictEqual(funcItem.alias, 'OperationType'); - // // assert.strictEqual(funcItem.members.length, 3); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - // // assert.strictEqual(funcItem.members[1], 'APPEND'); - // // assert.strictEqual(funcItem.members[2], 'REPLACE'); - - // testenum = `typedef enum { - // NEW - // } OperationType;` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OperationType'); - // // assert.strictEqual(funcItem.alias, 'OperationType'); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - - // testenum = `typedef enum { NEW } OperationType;` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OperationType'); - // // assert.strictEqual(funcItem.alias, 'OperationType'); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - - // testenum = `typedef enum OType { - // NEW - // } OperationType;` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OType'); - // // assert.strictEqual(funcItem.alias, 'OperationType'); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - - // testenum = `typedef enum OType { NEW } OperationType;` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OType'); - // // assert.strictEqual(funcItem.alias, 'OperationType'); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - - // testenum = `enum OType { - // NEW - // };` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OType'); - // // assert.strictEqual(funcItem.alias, undefined); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - - // testenum = `enum OType { NEW };` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OType'); - // // assert.strictEqual(funcItem.alias, undefined); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - - // testenum = `enum OType { NEW }; enum TOTSize1 { DTS };` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 2); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OType'); - // // assert.strictEqual(funcItem.alias, undefined); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'NEW'); - // funcItem = enumObjList[1]; - // assert.strictEqual(funcItem.name, 'TOTSize1'); - // // assert.strictEqual(funcItem.alias, undefined); - // // assert.strictEqual(funcItem.members.length, 1); - // // assert.strictEqual(funcItem.members[0], 'DTS'); - - // testenum = `enum TEST_ENUM { - // ENUM_1 = 1, // comment - // ENUM_2 = 2 - // }`; - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'TEST_ENUM'); - // // assert.strictEqual(funcItem.alias, undefined); - // // assert.strictEqual(funcItem.members.length, 2); - // // assert.strictEqual(funcItem.members[0], 'ENUM_1=1'); - // // assert.strictEqual(funcItem.members[1], 'ENUM_2=2'); - - // // 没有分号结尾 - // testenum = `enum TEST_ENUM { - // ENUM_1, // comment - // ENUM_2 - // }`; - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'TEST_ENUM'); - // // assert.strictEqual(funcItem.alias, undefined); - // // assert.strictEqual(funcItem.members.length, 2); - // // assert.strictEqual(funcItem.members[0], 'ENUM_1'); - // // assert.strictEqual(funcItem.members[1], 'ENUM_2'); - // }); - - // //3, 测试异常情况 - // test('parseFunction_test_3', () => { - // let teststr: string = ''; - // let enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = 'enum { ENUM_1 }'; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - // let funcItem = enumObjList[0]; - // // assert.strictEqual(funcItem.members[0], 'ENUM_1'); - - // teststr = `enum { - // ENUM_1, - // ENUM_2 };` - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // // assert.strictEqual(funcItem.members.length, 2); - // // assert.strictEqual(funcItem.members[0], 'ENUM_1'); - // // assert.strictEqual(funcItem.members[1], 'ENUM_2'); - - // teststr = `enum { - // ENUM_1, // comment - // ENUM_2 - // }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // // assert.strictEqual(funcItem.members.length, 2); - // // assert.strictEqual(funcItem.members[0], 'ENUM_1'); - // // assert.strictEqual(funcItem.members[1], 'ENUM_2'); - - // teststr = `enum OType { - // ENUM_1, // comment - // ENUM_2, - // };` - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // // assert.strictEqual(funcItem.members.length, 2); - // // assert.strictEqual(funcItem.members[0], 'ENUM_1'); - // // assert.strictEqual(funcItem.members[1], 'ENUM_2'); - - // teststr = `typedef enum OType { - // ENUM_1, // comment - // ENUM_2, - // };` - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[0]; - // // assert.strictEqual(funcItem.members.length, 2); - // // assert.strictEqual(funcItem.members[0], 'ENUM_1'); - // // assert.strictEqual(funcItem.members[1], 'ENUM_2'); - // }); - - // //4, 测试错误情况 - // test('parseFunction_test_4', () => { - // let enumObjList = parsec.parseFunction(''); - // assert.strictEqual(enumObjList.length, 0); - - // let teststr = `typedef enum OType {`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `}; typedef enum OType //{} {}`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `typedefinde enumute OType { }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `TYPEDEFfinde ENUMute OType { }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 0); - - // teststr = `export typedef enum OType { }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - // let funcItem = enumObjList[0]; - // assert.strictEqual(funcItem.name, 'OType'); - - // teststr = `typedef enum OType { }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - - // teststr = `typedef enum { }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - - // teststr = `typedef enum { }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - - // teststr = `typedef enum { ENUM_1 = 1, ENUM_2 = 2 }`; - // enumObjList = parsec.parseFunction(teststr); - // assert.strictEqual(enumObjList.length, 1); - // }); + test('parseFunction_test_2', () => { + // let paramstr = 'int a,test alen, test blen, test clen, test dlen'; + // let paramreg = /(\w+<[^>]*>\s+\w+|\w+\s+\w+)/g; + // let match; + // let matches = []; + + // while ((match = paramreg.exec(paramstr)) !== null) { + // matches.push(match[0]); + // } + + // let match: RegExpExecArray | null; + // let declarations: string[] = []; + // while ((match = paramreg.exec(paramstr)) != null) { + // declarations.push(match[1]); + // }; + + let testenum = `int add_T(int a,int b);` + let funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + let funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'add_T'); + assert.strictEqual(funcItem.returns, 'int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'int'); + assert.strictEqual(funcItem.parameters[1].name, 'b'); + assert.strictEqual(funcItem.parameters[1].type, 'int'); + + testenum = `const int add_T(int a,int b);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'add_T'); + assert.strictEqual(funcItem.returns, 'int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'int'); + assert.strictEqual(funcItem.parameters[1].name, 'b'); + assert.strictEqual(funcItem.parameters[1].type, 'int'); + + testenum = `int add_T(const int a, int b);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'add_T'); + assert.strictEqual(funcItem.returns, 'int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'int'); + assert.strictEqual(funcItem.parameters[1].name, 'b'); + assert.strictEqual(funcItem.parameters[1].type, 'int'); + + testenum = `int add_T(TEST a, int b);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'add_T'); + assert.strictEqual(funcItem.returns, 'int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'TEST'); + assert.strictEqual(funcItem.parameters[1].name, 'b'); + assert.strictEqual(funcItem.parameters[1].type, 'int'); + + testenum = `int _ADD_T(TEST a, int b);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, '_ADD_T'); + assert.strictEqual(funcItem.returns, 'int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'TEST'); + assert.strictEqual(funcItem.parameters[1].name, 'b'); + assert.strictEqual(funcItem.parameters[1].type, 'int'); + + testenum = `int _ADD_T(long long a, int b);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, '_ADD_T'); + assert.strictEqual(funcItem.returns, 'int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'long long'); + assert.strictEqual(funcItem.parameters[1].name, 'b'); + assert.strictEqual(funcItem.parameters[1].type, 'int'); + + testenum = `std::string tfunc(std::string a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::string'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::string'); + + testenum = `std::wstring tfunc(std::wstring a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::wstring'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::wstring'); + + testenum = `std::u16string tfunc(std::u16string a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::u16string'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::u16string'); + + testenum = `std::u32string tfunc(std::u32string a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::u32string'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::u32string'); + + testenum = `std::basic_string tfunc(std::basic_string a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::basic_string'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::basic_string'); + + testenum = `std::basic_string tfunc(std::basic_string a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::basic_string'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::basic_string'); + + testenum = `short tfunc(short a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'short'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'short'); + + testenum = `short int tfunc(short int a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'short int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'short int'); + + testenum = `long tfunc(long a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'long'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'long'); + + testenum = `long int tfunc(long int a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'long int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'long int'); + + testenum = `long long tfunc(long long a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'long long'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'long long'); + + testenum = `long long int tfunc(long long int a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'long long int'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'long long int'); + + testenum = `char tfunc(char a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'char'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'char'); + + testenum = `wchar_t tfunc(wchar_t a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'wchar_t'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'wchar_t'); + + testenum = `char16_t tfunc(char16_t a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'char16_t'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'char16_t'); + + testenum = `char32_t tfunc(char32_t a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'char32_t'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'char32_t'); + + testenum = `bool tfunc(bool a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'bool'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'bool'); + + testenum = `float tfunc(float a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'float'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'float'); + + testenum = `double tfunc(double a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'double'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'double'); + + testenum = `long double tfunc(long double a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'long double'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'long double'); + + testenum = `std::vector tfunc(std::vector a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::vector'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::vector'); + + testenum = `std::deque tfunc(std::deque a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::deque'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::deque'); + + testenum = `std::list tfunc(std::list a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::list'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::list'); + + testenum = `std::forward_list tfunc(std::forward_list a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::forward_list'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::forward_list'); + + testenum = `std::array tfunc(std::array a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::array'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::array'); + + testenum = `std::stack tfunc(std::stack a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::stack'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::stack'); + + testenum = `std::queue tfunc(std::queue a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::queue'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::queue'); + + testenum = `std::priority_queue tfunc(std::priority_queue a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::priority_queue'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::priority_queue'); + + testenum = `std::pair tfunc(std::pair a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::pair'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::pair'); + + testenum = `std::map tfunc(std::map a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::map'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::map'); + + testenum = `std::multimap tfunc(std::multimap a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::multimap'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::multimap'); + + testenum = `std::set tfunc(std::set a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::set'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::set'); + + testenum = `std::multiset tfunc(std::multiset a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::multiset'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::multiset'); + + testenum = `std::unordered_map tfunc(std::unordered_map a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_map'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_map'); + + testenum = `std::unordered_multimap tfunc(std::unordered_multimap a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_multimap'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multimap'); + + testenum = `std::unordered_set tfunc(std::unordered_set a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_set'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_set'); + + testenum = `std::unordered_multiset tfunc(std::unordered_multiset a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_multiset'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multiset'); + + testenum = `std::vector::iterator tfunc(std::vector::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::vector::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::vector::iterator'); + + testenum = `std::deque::iterator tfunc(std::deque::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::deque::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::deque::iterator'); + + testenum = `std::list::iterator tfunc(std::list::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::list::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::list::iterator'); + + testenum = `std::forward_list::iterator tfunc(std::forward_list::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::forward_list::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::forward_list::iterator'); + + testenum = `std::array::iterator tfunc(std::array::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::array::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::array::iterator'); + + testenum = `std::stack::iterator tfunc(std::stack::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::stack::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::stack::iterator'); + + testenum = `std::queue::iterator tfunc(std::queue::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::queue::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::queue::iterator'); + + testenum = `std::priority_queue::iterator tfunc(std::priority_queue::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::priority_queue::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::priority_queue::iterator'); + + testenum = `std::pair::iterator tfunc(std::pair::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::pair::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::pair::iterator'); + + testenum = `std::map::iterator tfunc(std::map::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::map::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::map::iterator'); + + testenum = `std::multimap::iterator tfunc(std::multimap::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::multimap::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::multimap::iterator'); + + testenum = `std::set::iterator tfunc(std::set::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::set::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::set::iterator'); + + testenum = `std::multiset::iterator tfunc(std::multiset::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::multiset::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::multiset::iterator'); + + testenum = `std::unordered_map::iterator tfunc(std::unordered_map::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_map::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_map::iterator'); + + testenum = `std::unordered_multimap::iterator tfunc(std::unordered_multimap::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_multimap::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multimap::iterator'); + + testenum = `std::unordered_set::iterator tfunc(std::unordered_set::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_set::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_set::iterator'); + + testenum = `std::unordered_multiset::iterator tfunc(std::unordered_multiset::iterator a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::unordered_multiset::iterator'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multiset::iterator'); + + testenum = `std::tuple tfunc(std::tuple a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::tuple'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::tuple'); + + testenum = `std::complex tfunc(std::complex a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::complex'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::complex'); + + testenum = `std::valarray tfunc(std::valarray a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::valarray'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::valarray'); + + testenum = `std::time_t tfunc(std::time_t a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::time_t'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::time_t'); + + testenum = `std::clock_t tfunc(std::clock_t a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::clock_t'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::clock_t'); + + testenum = `std::tm tfunc(std::tm a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::tm'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::tm'); + + testenum = `wchar_t* tfunc(wchar_t* a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'wchar_t*'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'wchar_t*'); + }); + + test('parseFunction_test_21', () => { + let testenum = `std::function tfunc(int a);` + let funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + let funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::function'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'int'); + + + testenum = `std::function tfunc(std::function a);` + funcObjList = parsec.parseFunction(testenum); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'tfunc'); + assert.strictEqual(funcItem.returns, 'std::function'); + assert.strictEqual(funcItem.type, 'function'); + assert.strictEqual(funcItem.parameters.length, 1); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'std::function'); + }) + + //3, 测试异常情况 + test('parseFunction_test_3', () => { + let teststr: string = ''; + let funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 0); + + teststr = 'void test(ENUM_1)'; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 0); + let funcItem = funcObjList[0]; + // assert.strictEqual(funcItem.members[0], 'ENUM_1'); + + teststr = `void test(ENUM_1, ENUM_2);` + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.name, 'test'); + assert.strictEqual(funcItem.returns, 'void'); + assert.strictEqual(funcItem.parameters[0].type, 'ENUM_1'); + assert.strictEqual(funcItem.parameters[1].type, 'ENUM_2'); + + teststr = `int test(ENUM_1, ENUM_2);`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.name, 'test'); + assert.strictEqual(funcItem.returns, 'int'); + assert.strictEqual(funcItem.parameters[0].type, 'ENUM_1'); + assert.strictEqual(funcItem.parameters[1].type, 'ENUM_2'); + + teststr = `void testa ( + ENUM_1, // comment + ENUM_2, + );` + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'testa'); + assert.strictEqual(funcItem.returns, 'void'); + // assert.strictEqual(funcItem.members.length, 2); + // assert.strictEqual(funcItem.members[0], 'ENUM_1'); + // assert.strictEqual(funcItem.members[1], 'ENUM_2'); + + teststr = `typedef void test(int a, float b);` + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 1); + funcItem = funcObjList[0]; + assert.strictEqual(funcItem.name, 'test'); + assert.strictEqual(funcItem.returns, 'typedef void'); + assert.strictEqual(funcItem.parameters.length, 2); + assert.strictEqual(funcItem.parameters[0].name, 'a'); + assert.strictEqual(funcItem.parameters[0].type, 'int'); + assert.strictEqual(funcItem.parameters[1].name, 'b'); + assert.strictEqual(funcItem.parameters[1].type, 'float'); + }); + + //4, 测试错误情况 + test('parseFunction_test_4', () => { + let funcObjList = parsec.parseFunction(''); + assert.strictEqual(funcObjList.length, 0); + + let teststr = `typedef void OType ()`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 1); + let funcaItem = funcObjList[0]; + assert.strictEqual(funcaItem.name, 'OType'); + assert.strictEqual(funcaItem.returns, 'typedef void'); + + teststr = `}; typedef int OType //() ()`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 0); + + teststr = `typedefinde bigint OType ( )`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 1); + funcaItem = funcObjList[0]; + assert.strictEqual(funcaItem.name, 'OType'); + assert.strictEqual(funcaItem.returns, 'typedefinde bigint'); + + teststr = `TYPEDEFfinde ENUMute OType ({ })`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 0); + + teststr = `export typedef char_t OType ({ })`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 0); + + teststr = `typedef inline OType ({ })`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 0); + + teststr = `typedef test ( )`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 1); + funcaItem = funcObjList[0]; + assert.strictEqual(funcaItem.name, 'test'); + assert.strictEqual(funcaItem.returns, 'typedef'); + + teststr = `typedef test ( ENUM_1 = 1, ENUM_2 = 2 )`; + funcObjList = parsec.parseFunction(teststr); + assert.strictEqual(funcObjList.length, 0); + }); });