From 6815374a2316da366c05af4447c9e0c0410db593 Mon Sep 17 00:00:00 2001 From: wangshi Date: Tue, 18 Feb 2025 18:28:13 +0800 Subject: [PATCH 1/4] update cclass test case Signed-off-by: wangshi --- .../src/test/suite/parse/parsecclass.test.ts | 674 +++++++++++------- 1 file changed, 432 insertions(+), 242 deletions(-) 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 cf95be74..d78de258 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); + }); }); -- Gitee From 4f9488e5bc0026388d197b15dc2f7e43ea8e7f28 Mon Sep 17 00:00:00 2001 From: wangshi Date: Tue, 18 Feb 2025 18:28:32 +0800 Subject: [PATCH 2/4] update cfunc test case Signed-off-by: wangshi --- .../src/test/suite/parse/parsecfunc.test.ts | 897 +++++++++++++++--- 1 file changed, 770 insertions(+), 127 deletions(-) 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 7b27149b..0b5db8fc 100644 --- a/src/vscode_plugin/src/test/suite/parse/parsecfunc.test.ts +++ b/src/vscode_plugin/src/test/suite/parse/parsecfunc.test.ts @@ -39,142 +39,785 @@ 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'); + 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 enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + let funcItem = enumObjList[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 = `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 = `const int add_T(int a,int b);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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 = `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 = `int add_T(const int a, int b);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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 = `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 = `int add_T(TEST a, int b);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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 = `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 = `int _ADD_T(TEST a, int b);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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 = `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 = `int _ADD_T(long long a, int b);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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 = `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'); - // }); + testenum = `std::string tfunc(std::string a);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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::function tfunc(std::function a);` + // enumObjList = parsec.parseFunction(testenum); + // assert.strictEqual(enumObjList.length, 1); + // funcItem = enumObjList[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'); + + testenum = `std::tuple tfunc(std::tuple a);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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);` + enumObjList = parsec.parseFunction(testenum); + assert.strictEqual(enumObjList.length, 1); + funcItem = enumObjList[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*'); + }); // //3, 测试异常情况 // test('parseFunction_test_3', () => { -- Gitee From 91cb68626c80c48a2a42484c66bf7ec90938a21c Mon Sep 17 00:00:00 2001 From: wangshi Date: Tue, 18 Feb 2025 18:28:52 +0800 Subject: [PATCH 3/4] update parsec Signed-off-by: wangshi --- src/vscode_plugin/src/parse/parsec.ts | 81 ++++++++++++++++++++------- 1 file changed, 62 insertions(+), 19 deletions(-) diff --git a/src/vscode_plugin/src/parse/parsec.ts b/src/vscode_plugin/src/parse/parsec.ts index 7f0c6eea..7d410ddb 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,14 +209,14 @@ 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*)\])?$/; // 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 }; @@ -239,15 +240,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]) { @@ -267,8 +271,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(','); @@ -276,8 +280,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 {}; @@ -309,30 +332,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, '')); } }); @@ -344,7 +376,7 @@ export function parseClass(data: string) { const classItem: ClassObj = { "name": className, - "alias": '', + "alias": alias, "variableList": variableList, "functionList": functionList } @@ -441,7 +473,8 @@ 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 const functions: FuncObj[] = [] let match; while ((match = funcRegex.exec(data)) !== null) { @@ -451,13 +484,23 @@ 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]); + } + // const params = (match[3] ? match[3] : match[8] || "") + // .split(',').map(param => param.trim()).filter(param => param); + let isInterface = match[0].includes('typedef'); let funcItem: FuncObj = { "type": isInterface ? "typedef" : "function", "returns": returnType, "name": name, - "parameters": parseParameters(params) + "parameters": parseParameters(matches) } functions.push(funcItem); -- Gitee From 88cee7f8933fa6b5eb32e5b70fa3bb6a52a7a464 Mon Sep 17 00:00:00 2001 From: wangshi Date: Wed, 19 Feb 2025 16:07:26 +0800 Subject: [PATCH 4/4] update parsec func Signed-off-by: wangshi --- src/vscode_plugin/src/parse/parsec.ts | 51 +- .../src/test/suite/parse/parsecfunc.test.ts | 648 +++++++++--------- 2 files changed, 379 insertions(+), 320 deletions(-) diff --git a/src/vscode_plugin/src/parse/parsec.ts b/src/vscode_plugin/src/parse/parsec.ts index 7d410ddb..9e6adb78 100644 --- a/src/vscode_plugin/src/parse/parsec.ts +++ b/src/vscode_plugin/src/parse/parsec.ts @@ -209,7 +209,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); @@ -220,6 +221,12 @@ export function parseParameters(members: string[]): ParamObj[] { // 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 {}; // 类型保护 @@ -474,9 +481,18 @@ 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+([\S\,\ ]+)\s+\(\*\s*(\w+)\)\s*\(([^)]*)\);|^(static\s+)?(const\s+)?([\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(); @@ -490,10 +506,8 @@ export function parseFunction(data: string): FuncObj[] { let matches = []; while ((pmatch = paramreg.exec(paramstr)) !== null) { - matches.push(pmatch[0]); + matches.push(pmatch[0].trim()); } - // const params = (match[3] ? match[3] : match[8] || "") - // .split(',').map(param => param.trim()).filter(param => param); let isInterface = match[0].includes('typedef'); let funcItem: FuncObj = { @@ -502,9 +516,34 @@ export function parseFunction(data: string): FuncObj[] { "name": name, "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/parsecfunc.test.ts b/src/vscode_plugin/src/test/suite/parse/parsecfunc.test.ts index 0b5db8fc..5801a3d8 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'); @@ -59,9 +60,9 @@ suite('Parse_C_Func_Suite', () => { // }; let testenum = `int add_T(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_T'); assert.strictEqual(funcItem.returns, 'int'); assert.strictEqual(funcItem.type, 'function'); @@ -72,9 +73,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[1].type, 'int'); testenum = `const int add_T(int a,int b);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -85,9 +86,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[1].type, 'int'); testenum = `int add_T(const int a, int b);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -98,9 +99,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[1].type, 'int'); testenum = `int add_T(TEST a, int b);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -111,9 +112,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[1].type, 'int'); testenum = `int _ADD_T(TEST a, int b);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -124,9 +125,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[1].type, 'int'); testenum = `int _ADD_T(long long a, int b);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -137,9 +138,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[1].type, 'int'); testenum = `std::string tfunc(std::string a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -148,9 +149,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::string'); testenum = `std::wstring tfunc(std::wstring a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -159,9 +160,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::wstring'); testenum = `std::u16string tfunc(std::u16string a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -170,9 +171,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::u16string'); testenum = `std::u32string tfunc(std::u32string a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -181,9 +182,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::u32string'); testenum = `std::basic_string tfunc(std::basic_string a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -192,9 +193,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::basic_string'); testenum = `std::basic_string tfunc(std::basic_string a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -203,9 +204,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::basic_string'); testenum = `short tfunc(short a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -214,9 +215,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'short'); testenum = `short int tfunc(short int a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -225,9 +226,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'short int'); testenum = `long tfunc(long a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -236,9 +237,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'long'); testenum = `long int tfunc(long int a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -247,9 +248,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'long int'); testenum = `long long tfunc(long long a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -258,9 +259,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'long long'); testenum = `long long int tfunc(long long int a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -269,9 +270,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'long long int'); testenum = `char tfunc(char a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -280,9 +281,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'char'); testenum = `wchar_t tfunc(wchar_t a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -291,9 +292,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'wchar_t'); testenum = `char16_t tfunc(char16_t a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -302,9 +303,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'char16_t'); testenum = `char32_t tfunc(char32_t a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -313,9 +314,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'char32_t'); testenum = `bool tfunc(bool a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -324,9 +325,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'bool'); testenum = `float tfunc(float a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -335,9 +336,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'float'); testenum = `double tfunc(double a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -346,9 +347,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'double'); testenum = `long double tfunc(long double a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -357,9 +358,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'long double'); testenum = `std::vector tfunc(std::vector a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -368,9 +369,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::vector'); testenum = `std::deque tfunc(std::deque a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -379,9 +380,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::deque'); testenum = `std::list tfunc(std::list a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -390,9 +391,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::list'); testenum = `std::forward_list tfunc(std::forward_list a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -401,9 +402,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::forward_list'); testenum = `std::array tfunc(std::array a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -412,9 +413,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::array'); testenum = `std::stack tfunc(std::stack a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -423,9 +424,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::stack'); testenum = `std::queue tfunc(std::queue a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -434,9 +435,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::queue'); testenum = `std::priority_queue tfunc(std::priority_queue a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -445,9 +446,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::priority_queue'); testenum = `std::pair tfunc(std::pair a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -456,9 +457,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::pair'); testenum = `std::map tfunc(std::map a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -467,9 +468,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::map'); testenum = `std::multimap tfunc(std::multimap a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -478,9 +479,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::multimap'); testenum = `std::set tfunc(std::set a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -489,9 +490,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::set'); testenum = `std::multiset tfunc(std::multiset a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -500,9 +501,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::multiset'); testenum = `std::unordered_map tfunc(std::unordered_map a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -511,9 +512,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_map'); testenum = `std::unordered_multimap tfunc(std::unordered_multimap a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -522,9 +523,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multimap'); testenum = `std::unordered_set tfunc(std::unordered_set a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -533,9 +534,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_set'); testenum = `std::unordered_multiset tfunc(std::unordered_multiset a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -544,9 +545,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multiset'); testenum = `std::vector::iterator tfunc(std::vector::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -555,9 +556,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::vector::iterator'); testenum = `std::deque::iterator tfunc(std::deque::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -566,9 +567,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::deque::iterator'); testenum = `std::list::iterator tfunc(std::list::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -577,9 +578,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::list::iterator'); testenum = `std::forward_list::iterator tfunc(std::forward_list::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -588,9 +589,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::forward_list::iterator'); testenum = `std::array::iterator tfunc(std::array::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -599,9 +600,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::array::iterator'); testenum = `std::stack::iterator tfunc(std::stack::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -610,9 +611,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::stack::iterator'); testenum = `std::queue::iterator tfunc(std::queue::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -621,9 +622,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::queue::iterator'); testenum = `std::priority_queue::iterator tfunc(std::priority_queue::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -632,9 +633,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::priority_queue::iterator'); testenum = `std::pair::iterator tfunc(std::pair::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -643,9 +644,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::pair::iterator'); testenum = `std::map::iterator tfunc(std::map::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -654,9 +655,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::map::iterator'); testenum = `std::multimap::iterator tfunc(std::multimap::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -665,9 +666,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::multimap::iterator'); testenum = `std::set::iterator tfunc(std::set::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -676,9 +677,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::set::iterator'); testenum = `std::multiset::iterator tfunc(std::multiset::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -687,9 +688,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::multiset::iterator'); testenum = `std::unordered_map::iterator tfunc(std::unordered_map::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -698,9 +699,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_map::iterator'); testenum = `std::unordered_multimap::iterator tfunc(std::unordered_multimap::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -709,9 +710,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multimap::iterator'); testenum = `std::unordered_set::iterator tfunc(std::unordered_set::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -720,9 +721,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_set::iterator'); testenum = `std::unordered_multiset::iterator tfunc(std::unordered_multiset::iterator a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -730,21 +731,10 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].name, 'a'); assert.strictEqual(funcItem.parameters[0].type, 'std::unordered_multiset::iterator'); - // testenum = `std::function tfunc(std::function a);` - // enumObjList = parsec.parseFunction(testenum); - // assert.strictEqual(enumObjList.length, 1); - // funcItem = enumObjList[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'); - testenum = `std::tuple tfunc(std::tuple a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -753,9 +743,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::tuple'); testenum = `std::complex tfunc(std::complex a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -764,9 +754,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::complex'); testenum = `std::valarray tfunc(std::valarray a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -775,9 +765,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::valarray'); testenum = `std::time_t tfunc(std::time_t a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -786,9 +776,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::time_t'); testenum = `std::clock_t tfunc(std::clock_t a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -797,9 +787,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::clock_t'); testenum = `std::tm tfunc(std::tm a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -808,9 +798,9 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'std::tm'); testenum = `wchar_t* tfunc(wchar_t* a);` - enumObjList = parsec.parseFunction(testenum); - assert.strictEqual(enumObjList.length, 1); - funcItem = enumObjList[0]; + 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'); @@ -819,103 +809,133 @@ suite('Parse_C_Func_Suite', () => { assert.strictEqual(funcItem.parameters[0].type, 'wchar_t*'); }); - // //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_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); + }); }); -- Gitee