diff --git a/src/vscode_plugin/src/parse/parsec.ts b/src/vscode_plugin/src/parse/parsec.ts
index e79ea201fe80d4101df8ea522a521a47ffd39a6e..d656e8bab392f5ac2169f6ed87465bc7787b3cc7 100644
--- a/src/vscode_plugin/src/parse/parsec.ts
+++ b/src/vscode_plugin/src/parse/parsec.ts
@@ -20,23 +20,55 @@ import { ParamObj, FuncObj, StructObj, ClassObj, EnumObj, UnionObj, ParseObj } f
 import { Logger } from '../common/log';
 import fs = require('fs');
 
+export function doParseEnum(data: string) {
+  // const enumRegex = /typedef\s+enum\s+(\w*)\s*\{\s*([a-zA-Z0-9 _,]+)\}\s*(\w*)/g;
+  const enumRegex = /enum\s+(\w*)\s*{([^}]*)}/g;
+  const enums: EnumObj[] = [];
+  let match;
+  while ((match = enumRegex.exec(data)) !== null) {
+    const enumName = match[1] || match[3] || match[4];
+    const aliasName = match[3];
+    const membersString = match[2] || match[5];
+    const comregex = /,\s*\/\/.*$/gm;
+    const cleanedEnumString = membersString.replace(comregex, '');
+
+    const enumMembers = cleanedEnumString.split('\n')
+      .map(member => member.trim().replace(/[,\n\r\s]/g, ''))
+      .filter(member => member);
+
+    let enumItem = {
+      "name": enumName,
+      "alias": aliasName,
+      "members": enumMembers
+    };
+    enums.push(enumItem);
+  }
+  Logger.getInstance().info(` return enums: ${JSON.stringify(enums)}`);
+  return enums;
+}
+
+
 export function parseEnum(data: string) {
   // 使用正则表达式提取枚举定义
-  const enumRegex = /typedef\s+enum\s+(\w*)\s*{([^}]*)}\s*(\w+);|enum\s+(\w+)\s*{([^}]*)}\s*;/g;
+  const enumRegex = /typedef\s+enum\s+(\w*)\s*{([^}]*)}\s*(\w+)|enum\s+(\w*)\s*{([^}]*)}/g;
   const enums: EnumObj[] = [];
   let match;
   while ((match = enumRegex.exec(data)) !== null) {
-    const enumName = match[1] ||match[3] || match[4];
+    const enumName = match[1] || match[3] || match[4];
     const aliasName = match[3];
     const membersString = match[2] || match[5];
-    const members = membersString.split(',')
-        .map(member => member.trim().replace(/[\n\r\s]/g, ''))
-        .filter(member => member.length > 0);
+    const comregex = /\/\/.*$/gm;
+    const cleanedEnumString = membersString.replace(comregex, '');
+
+    const enumMembers = cleanedEnumString.split(',')
+      .map(member => member.trim().replace(/[,\n\r\s]/g, ''))
+      .filter(member => member);
+
     let enumItem = {
       "name": enumName,
       "alias": aliasName,
-      "members": members
-    }
+      "members": enumMembers
+    };
     enums.push(enumItem);
   }
   Logger.getInstance().info(` return enums: ${JSON.stringify(enums)}`);
diff --git a/src/vscode_plugin/src/test/suite/common/file.test.ts b/src/vscode_plugin/src/test/suite/common/file.test.ts
index f8cbd0edac82f9e747c5ddb3e37ee3fecb6908b3..0db980c43e689e4d155b7072cb6db43658e6901e 100644
--- a/src/vscode_plugin/src/test/suite/common/file.test.ts
+++ b/src/vscode_plugin/src/test/suite/common/file.test.ts
@@ -21,6 +21,7 @@ import * as vscode from 'vscode';
 import * as fs from 'fs';
 import * as files from '../../../common/file'
 import { GEN_TYPE } from '../../../common/conf';
+import { Logger } from '../../../common/log';
 // import * as myExtension from '../../extension';
 
 suite('Common_File_Test_Suite', () => {
@@ -97,6 +98,85 @@ suite('Common_File_Test_Suite', () => {
 			}
     });
 
+    //1, 测试一般情况
+    test('mkdirSync_new_test_1', () => {
+      let fPath = './testdir';
+      if (fs.existsSync(fPath)) {
+        fs.rmdirSync(fPath);
+      }
+      files.Filer.getInstance().mkdirSync(fPath);
+      let isExist = fs.existsSync(fPath);
+      assert.strictEqual(isExist, true);
+      if (fs.existsSync(fPath)) {
+        fs.rmdirSync(fPath);
+      }
+    });
+
+    //2, 测试边界情况
+    test('mkdirSync_new_test_2', () => {
+        // 短文件名
+        let fPath = './1';
+        let filer = files.Filer.getInstance();
+        filer.mkdirSync(fPath);
+        let isExist = fs.existsSync(fPath);
+        assert.strictEqual(isExist, true);
+        fs.rmdirSync(fPath);
+
+        // 长文件名
+        fPath = './1';
+        for (let i=0;i<100;i++) {
+            fPath = './1' + i;
+        }
+        fPath = fPath;
+        filer.mkdirSync(fPath);
+        isExist = fs.existsSync(fPath);
+        assert.strictEqual(isExist, true);
+        fs.rmdirSync(fPath);
+
+        // 中文文件名
+        fPath = './测试中文';
+        filer.mkdirSync(fPath);
+        isExist = fs.existsSync(fPath);
+        assert.strictEqual(isExist, true);
+        fs.rmdirSync(fPath);
+    });
+
+    //3, 测试异常情况
+    test('mkdirSync_new_test_3', () => {
+			let resultStr = ''
+			let fPath = './d1.txt';
+      if (fs.existsSync(fPath) && fs.lstatSync(fPath).isDirectory()) {
+        fs.rmdirSync(fPath);
+      }
+      let filer = files.Filer.getInstance();
+			filer.mkdirSync(fPath);
+			let isExist = fs.existsSync(fPath) && fs.lstatSync(fPath).isDirectory();
+			assert.strictEqual(isExist, true);
+      fs.rmdirSync(fPath);
+      
+      fPath = './{'
+			filer.mkdirSync(fPath);
+			isExist = fs.existsSync(fPath);
+			assert.strictEqual(isExist, true);
+      fs.rmdirSync(fPath);
+    });
+
+    //4, 测试错误情况
+    test('mkdirSync_new_test_4', () => {
+			let fPath = './';
+      let filer = files.Filer.getInstance();
+			try {
+				filer.mkdirSync(fPath);
+			} catch (e) {
+				let isError = true;
+				assert.strictEqual(isError, true);
+				let emsg = JSON.stringify(e);
+        Logger.getInstance().error(emsg);
+        let isLike = emsg.includes('EISDIR');
+				assert.strictEqual(isLike, true);
+			}
+    });
+
     //1, 测试一般情况
     test('saveFileSync_append_test_1', () => {
       files.Filer.getInstance().setGenType(GEN_TYPE.GEN_APPEND);
@@ -126,7 +206,7 @@ suite('Common_File_Test_Suite', () => {
     test('saveFileSync_append_test_2', () => {
       // 短文件名
       let fPath = './1.txt';
-      if (fs.existsSync(fPath)) {
+      if (fs.existsSync(fPath) && fs.lstatSync(fPath).isFile()) {
         fs.unlinkSync(fPath);
       }
       let filer = files.Filer.getInstance();
@@ -179,7 +259,7 @@ suite('Common_File_Test_Suite', () => {
     //3, 测试异常情况
     test('saveFileSync_append_test_3', () => {
 			let fPath = './1.txt';
-      if (fs.existsSync(fPath)) {
+      if (fs.existsSync(fPath) && fs.lstatSync(fPath).isFile()) {
         fs.unlinkSync(fPath);
       }
 
diff --git a/src/vscode_plugin/src/test/suite/common/log.test.ts b/src/vscode_plugin/src/test/suite/common/log.test.ts
index 436ff2de68ed8563bf6eb74c59d283db4420c932..f054f730643768344352dcf529dc3c76252071d3 100644
--- a/src/vscode_plugin/src/test/suite/common/log.test.ts
+++ b/src/vscode_plugin/src/test/suite/common/log.test.ts
@@ -25,7 +25,6 @@ import * as logs from '../../../common/log'
 
 suite('Common_Log_Test_Suite', () => {
     vscode.window.showInformationMessage('Start all tests.');
-
     //1, 测试debug一般情况
     test('debug_test_1', () => {
       let logger = logs.Logger.getInstance();
@@ -61,7 +60,7 @@ suite('Common_Log_Test_Suite', () => {
       let fsize = fstat.size;
       let fflag = (fsize > 1048000 && fsize < 1049000) ? true : false;
       assert.strictEqual(fflag, true);
-      // fs.unlinkSync(logFilePath);
+      fs.unlinkSync(logFilePath);
     });
 
     //1, 测试info一般情况
@@ -152,7 +151,7 @@ suite('Common_Log_Test_Suite', () => {
         if (ditem.isFile()) {
           const { name, ext } = path.parse(ditem.name);
           if (name.includes('dmesg') && ext.includes('.log')) {
-
+            fs.unlinkSync(ditem.name);
           }
         }
       }
diff --git a/src/vscode_plugin/src/test/suite/index.ts b/src/vscode_plugin/src/test/suite/index.ts
index 2a02101e7b5c8d5136ead9318f695797c501d3af..e1af31beb01457eec6e3019c171f9f7b75e01339 100644
--- a/src/vscode_plugin/src/test/suite/index.ts
+++ b/src/vscode_plugin/src/test/suite/index.ts
@@ -25,7 +25,8 @@ export function run(): Promise<void> {
 		ui: 'tdd'
 	});
 	mocha.useColors(true);
-
+	mocha.timeout(10000);
+	mocha.enableTimeouts(true);
 	let reportTestResult = getReportConf();
 	if (reportTestResult) {
 		let outpath = getOutputPath();
diff --git a/src/vscode_plugin/src/test/suite/parse/parsec.test.ts b/src/vscode_plugin/src/test/suite/parse/parsec.test.ts
index 45a2ec551f5e43ecf61b86c55f7773d75b4fab7b..555d1a9fbf7c118a9faea70dc8b0dda746b5a192 100644
--- a/src/vscode_plugin/src/test/suite/parse/parsec.test.ts
+++ b/src/vscode_plugin/src/test/suite/parse/parsec.test.ts
@@ -26,20 +26,150 @@ suite('Parse_C_Suite', () => {
 
     //1, 测试 parseEnum 一般情况
     test('parseEnum_test_1', () => {
-        let enumObjList = parsec.parseEnum('hello_world');
-        assert.strictEqual(enumObjList.length, 0);
+        let testenum = `typedef enum {
+            NEW,
+            APPEND,
+            REPLACE
+        } OperationType;`
+        let enumObjList = parsec.parseEnum(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');
     });
 
     //2, 测试边界情况
     test('parseEnum_test_2', () => {
-        let enumObjList = parsec.parseEnum('enum { ENUM_1 }');
-        assert.strictEqual(enumObjList.length, 0);
+        let testenum = `typedef enum {
+            NEW,
+            APPEND,
+            REPLACE
+        } OperationType;`
+        let enumObjList = parsec.parseEnum(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');
 
-        enumObjList = parsec.parseEnum('enum { ENUM_1, ENUM_2 }');
-        assert.strictEqual(enumObjList.length, 0);
+        testenum = `typedef enum { NEW, APPEND, REPLACE } OperationType;`
+        enumObjList = parsec.parseEnum(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');
 
-        enumObjList = parsec.parseEnum('enum { ENUM_1, ENUM_2 }; enum { ENUM_10, ENUM_20 };');
-        assert.strictEqual(enumObjList.length, 0);
+        testenum = `typedef enum {
+            NEW
+        } OperationType;`
+        enumObjList = parsec.parseEnum(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.parseEnum(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.parseEnum(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.parseEnum(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.parseEnum(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.parseEnum(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.parseEnum(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.parseEnum(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.parseEnum(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, 测试异常情况
@@ -48,16 +178,97 @@ suite('Parse_C_Suite', () => {
         let enumObjList = parsec.parseEnum(teststr);
         assert.strictEqual(enumObjList.length, 0);
 
-        enumObjList = parsec.parseEnum('enum');
-        assert.strictEqual(enumObjList.length, 0);
+        teststr = 'enum { ENUM_1 }';
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 1);
+        let enumItem = enumObjList[0];
+        assert.strictEqual(enumItem.members[0], 'ENUM_1');
 
-        enumObjList = parsec.parseEnum('enum { ENUM_1, ENUM_1 }');
-        assert.strictEqual(enumObjList.length, 0);
+        teststr = `enum { 
+            ENUM_1, 
+            ENUM_2 };`
+        enumObjList = parsec.parseEnum(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.parseEnum(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.parseEnum(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.parseEnum(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('replaceall_test_4', () => {
+    test('parseEnum_test_4', () => {
         let enumObjList = parsec.parseEnum('');
         assert.strictEqual(enumObjList.length, 0);
+
+        let teststr = `typedef enum OType {`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 0);
+
+        teststr = `}; typedef enum OType //{} {}`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 0);
+
+        teststr = `typedefinde enumute OType { }`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 0);
+
+        teststr = `TYPEDEFfinde ENUMute OType { }`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 0);
+
+        teststr = `export typedef enum OType { }`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 1);
+        let enumItem = enumObjList[0];
+        assert.strictEqual(enumItem.name, 'OType');
+
+        teststr = `typedef enum OType { }`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 1);
+
+        teststr = `typedef enum { }`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 1);
+
+        teststr = `typedef enum { }`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 1);
+
+        teststr = `typedef enum { ENUM_1 = 1, ENUM_2 = 2  }`;
+        enumObjList = parsec.parseEnum(teststr);
+        assert.strictEqual(enumObjList.length, 1);
     });
 });