Modify the use case of worker

Describe:The worker warehouse has modified the maximum number of
workers, so the test case of the worker needs to be modified.

Issues:https://gitee.com/openharmony/js_worker_module/issues/I4ZPSISigned-off-by: Nwbdu <duwenbo7@huawei.com>

compileruntime/worker_lib_standard/src/main/js/default/workers/worker_009.js

@@ -24,8 +24,20 @@ parentPort.onmessage = function(e) {
     case "new":
       ss = new worker.Worker("workers/worker_0091.js");
       console.log("worker:: workerxx ");
+      ss.onexit = function() {
+        flag = true;
+      }
       parentPort.postMessage(ss != null);
       break;
+    case "wait":
+      if (flag) {
+        parentPort.postMessage("terminate");
+      }
+      break;
+    case "terminate":
+      flag = false;
+      ss.terminate();
+      break;
     default:
       break;
   }

compileruntime/worker_lib_standard/src/main/js/default/workers/worker_010.js

@@ -29,6 +29,10 @@ parentPort.onmessage = function(e) {
         backValue = ee.data;
         flag = true;
       }
+      ss.onexit = function() {
+        backValue = "terminate";
+        flag = true;
+      }
       ss.postMessage(data.value);
       break;
     case "wait":
@@ -36,6 +40,10 @@ parentPort.onmessage = function(e) {
         parentPort.postMessage(backValue);
       }
       break;
+    case "terminate":
+      flag = false;
+      ss.terminate();
+      break;
     default:
       break;
   }

compileruntime/worker_lib_standard/src/main/js/default/workers/worker_012.js

@@ -29,6 +29,10 @@ parentPort.onmessage = function(e) {
         backValue = ee.data;
         flag = true;
       }
+      ss.onexit = function() {
+        backValue = "terminate";
+        flag = true;
+      }
       ss.postMessage({type: "new"});
       break;
     case "wait":
@@ -36,6 +40,10 @@ parentPort.onmessage = function(e) {
         parentPort.postMessage(backValue);
       }
       break;
+    case "terminate":
+      flag = false;
+      ss.terminate();
+      break;
     default:
       break;
   }

compileruntime/worker_lib_standard/src/main/js/default/workers/worker_013.js

@@ -29,6 +29,10 @@ parentPort.onmessage = function(e) {
         backValue = ee.data;
         flag = true;
       }
+      ss.onexit = function() {
+        backValue = "terminate";
+        flag = true;
+      }
       ss.postMessage(data.value);
       break;
     case "wait":
@@ -36,6 +40,10 @@ parentPort.onmessage = function(e) {
         parentPort.postMessage(backValue);
       }
       break;
+    case "terminate":
+      flag = false;
+      ss.terminate();
+      break;
     default:
       break;
   }

compileruntime/worker_lib_standard/src/main/js/default/workers/worker_014.js

@@ -29,6 +29,10 @@ parentPort.onmessage = function(e) {
         backValue = ee.data;
         flag = true;
       }
+      ss.onexit = function() {
+        backValue = "terminate";
+        flag = true;
+      }
       ss.postMessage(data.value);
       break;
     case "wait":
@@ -36,6 +40,10 @@ parentPort.onmessage = function(e) {
         parentPort.postMessage(backValue);
       }
       break;
+    case "terminate":
+      flag = false;
+      ss.terminate();
+      break;
     default:
       break;
   }

compileruntime/worker_lib_standard/src/main/js/test/Worker.test.js

@@ -16,7 +16,7 @@
 // @ts-nocheck
 import app from '@system.app'
 import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
-import worker from "@ohos.worker";
+import worker from "@ohos.worker"
 
 describe('workerTest', function () {
 
@@ -28,43 +28,95 @@ describe('workerTest', function () {
         let p = new Promise(function (resolve, reject) {
             setTimeout(function () {
                 resolve()
-            }, 100);
+            }, 100)
         }).then(undefined, (error) => {
         })
         return p
     }
 
     // check worker constructor is ok
-    it('worker_constructor_test_001', 0, function () {
+    it('worker_constructor_test_001', 0, async function (done) {
         let ss = new worker.Worker("workers/worker.js")
+        let isTerminate = false
+
+        ss.onexit = function () {
+			isTerminate = true
+        }
+
         expect(ss != null).assertTrue()
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+        done()
     })
 
-    it('worker_constructor_test_002', 0, function () {
-        let ss = new worker.Worker("workers/worker.js",{name:"second worker",shared:"False"})
+    it('worker_constructor_test_002', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js", {name:"second worker", shared:"False"})
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
+
         expect(ss != null).assertTrue()
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+        done()
     })
 
-    it('worker_constructor_test_003', 0, function () {
-        let ss = new worker.Worker("workers/worker.js",{type:"classic",name:"second worker",shared:"false"})
+    it('worker_constructor_test_003', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js", {type:"classic", name:"second worker", shared:"false"})
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
+
         expect(ss != null).assertTrue()
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+        done()
     })
 
-    it('worker_constructor_test_004', 0, function () {
-        let ss = new worker.Worker("workers/worker.js",{type:"classic",name:"third worker",shared:"true"})
+    it('worker_constructor_test_004', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js", {type:"classic", name:"third worker", shared:"true"})
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
+
         expect(ss != null).assertTrue()
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+        done()
     })
 
     // check postMessage is ok
     // main post "hello world", will receive "hello world worker"
     it('worker_postMessage_test_001', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_002.js");
+        let ss = new worker.Worker("workers/worker_002.js")
 
         let res = undefined
         let flag = false
-
+        let isTerminate = false
+		
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            res = e.data;
+            res = e.data
             flag = true
         }
 
@@ -72,6 +124,12 @@ describe('workerTest', function () {
         while (!flag) {
             await promiseCase()
         }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(res).assertEqual("hello world worker")
         done()
     })
@@ -79,13 +137,17 @@ describe('workerTest', function () {
     // check postMessage is ok
     // main post 12 , will receive 12 * 2 + 1
     it('worker_postMessage_test_002', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_003.js");
+        let ss = new worker.Worker("workers/worker_003.js")
 
         let res = undefined
         let flag = false
+        let isTerminate = false
 
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            res = e.data;
+            res = e.data
             flag = true
         }
 
@@ -93,6 +155,12 @@ describe('workerTest', function () {
         while (!flag) {
             await promiseCase()
         }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(res).assertEqual(25)
         done()
     })
@@ -100,13 +168,17 @@ describe('workerTest', function () {
     // check postMessage is ok
     // main post {message:"hello world"} , will receive {message:"hello world worker"}
     it('worker_postMessage_test_003', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_004.js");
+        let ss = new worker.Worker("workers/worker_004.js")
 
         let res = undefined
         let flag = false
+        let isTerminate = false
 
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            res = e.data.message;
+            res = e.data.message
             flag = true
         }
 
@@ -114,19 +186,29 @@ describe('workerTest', function () {
         while (!flag) {
             await promiseCase()
         }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(res).assertEqual("hello world worker")
         done()
     })
 
     // check worker name is ok
     it('worker_postMessage_test_004', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_005.js", {name: "zhangsan"});
+        let ss = new worker.Worker("workers/worker_005.js", {name: "zhangsan"})
 
         let res = undefined
         let flag = false
+        let isTerminate = false
 
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            res = e.data;
+            res = e.data
             flag = true
         }
 
@@ -134,23 +216,39 @@ describe('workerTest', function () {
         while (!flag) {
             await promiseCase()
         }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(res).assertEqual("zhangsan")
         done()
     })
 
     // check worker transfer buffer is ok
-    it('worker_postMessage_test_005', 0, function () {
-        let ss = new worker.Worker("workers/worker_006.js");
+    it('worker_postMessage_test_005', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker_006.js")
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
 
         const buffer = new ArrayBuffer(8)
         expect(buffer.byteLength).assertEqual(8)
         ss.postMessage(buffer, [buffer])
-        let length = undefined;
-        let exception = undefined;
+        let length = undefined
+        let exception = undefined
         try {
-            length = buffer.byteLength;
+            length = buffer.byteLength
         } catch (e) {
-            exception = e.message;
+            exception = e.message
+        }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
         }
 
         console.log("worker:: length is " + length)
@@ -161,55 +259,68 @@ describe('workerTest', function () {
         } else {
             expect(exception).assertEqual("IsDetachedBuffer")
         }
+        done()
     })
 
     // check worker handle error is ok
     it('worker_postMessage_test_006', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_007.js");
+        let ss = new worker.Worker("workers/worker_007.js")
 
         let res = undefined
         let flag = false
+        let isTerminate = false
 
         ss.onerror = function (e) {
-            res = e.message;
+            res = e.message
             flag = true
         }
+        ss.onexit = function () {
+            isTerminate = true
+        }
 
         ss.postMessage("hello world")
         while (!flag) {
             await promiseCase()
         }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(res).assertEqual("Error: 123")
         done()
     })
 
     // check worker terminate is ok
     it('worker_terminate_test_001', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker.js");
+        let ss = new worker.Worker("workers/worker.js")
         let res = 0
         let flag = false
 
         ss.onexit = function () {
             flag = true
-            res++;
+            res++
         }
+
         ss.terminate()
         while (!flag) {
             await promiseCase()
         }
+
         expect(res).assertEqual(1)
         done()
     })
 
     // check worker terminate is ok
     it('worker_terminate_test_002', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker.js");
+        let ss = new worker.Worker("workers/worker.js")
         let res = 0
         let flag = false
 
         ss.onexit = function () {
             flag = true
-            res++;
+            res++
         }
 
         // Repeated execution terminate
@@ -219,23 +330,23 @@ describe('workerTest', function () {
         while (!flag) {
             await promiseCase()
         }
+
         expect(res).assertEqual(1)
         done()
     })
 
     // check worker terminate is ok
     it('worker_terminate_test_003', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker.js");
+        let ss = new worker.Worker("workers/worker.js")
         let res = 0
         let flag = false
 
         ss.onexit = function () {
             flag = true
-            res++;
+            res++
         }
-
         ss.onmessage = function (e) {
-            res++;
+            res++
         }
 
         ss.terminate()
@@ -251,74 +362,124 @@ describe('workerTest', function () {
     })
 
     // check worker on function is ok
-    it('worker_on_test_001', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_on_test_001', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let times = 0
+        let isTerminate = false
 
-        let times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.on("zhangsan", ()=>{
-            times++;
+            times++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(1)
+        done()
     })
 
     // check worker on function is ok
-    it('worker_on_test_002', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_on_test_002', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let times = 0
+        let isTerminate = false
 
-        let times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.on("zhangsan", ()=>{
-            times--;
+            times--
         })
-
         ss.on("lisi", ()=>{
-            times++;
+            times++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "lisi"})
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(0)
+        done()
     })
 
     // check worker on function is ok
-    it('worker_on_test_003', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_on_test_003', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let times = 0
+        let isTerminate = false
 
-        let times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.on("zhangsan", ()=>{
-            times++;
+            times++
         })
 
         for (let i=0;i<10;i++)
         {
             ss.dispatchEvent({type: "zhangsan"})
         }
-        console.log("times " + times);
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
+        console.log("times " + times)
         expect(times).assertEqual(10)
+        done()
     })
 
     // check worker once function is ok
-    it('worker_once_test_001', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_once_test_001', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let times = 0
+        let isTerminate = false
 
-        let times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.once("zhangsan", ()=>{
-            times++;
+            times++
         })
         ss.dispatchEvent({type: "zhangsan"})
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(1)
+        done()
     })
 
     // check worker once function is ok
-    it('worker_once_test_002', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_once_test_002', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let times = 0
+        let isTerminate = false
 
-        let times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.once("zhangsan", ()=>{
-            times++;
+            times++
         })
 
         for (let i=0;i<10;i++)
@@ -326,68 +487,111 @@ describe('workerTest', function () {
             ss.dispatchEvent({type: "zhangsan"})
         }
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(1)
+        done()
     })
 
-    it('worker_once_test_003', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_once_test_003', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let times = 0
+        let isTerminate = false
 
-        let times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.once("zhangsan", ()=>{
-            times--;
+            times--
         })
 
         ss.once("lisi", ()=>{
-            times++;
+            times++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "lisi"})
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(0)
+        done()
     })
 
     // check worker addEventListener function is ok
-    it('worker_addEventListener_test_001', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_addEventListener_test_001', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let times = 0
+        let isTerminate = false
 
-        let times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.addEventListener("zhangsan", ()=>{
-            times++;
+            times++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "zhangsan"})
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(2)
+        done()
     })
 
     // check worker addEventListener function is ok
-    it('worker_addEventListener_test_002', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_addEventListener_test_002', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
 
-        let times = 0;
+        let times = 0
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.addEventListener("zhangsan", ()=>{
-            times++;
+            times++
         })
-
         ss.addEventListener("lisi", ()=>{
-            times++;
+            times++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "lisi"})
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(2)
+        done()
     })
 
     // check worker addEventListener function is ok
-    it('worker_addEventListener_test_003', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_addEventListener_test_003', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
 
-        let times = 0;
+        let times = 0
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.addEventListener("zhangsan", ()=>{
-            times++;
+            times++
         })
 
         for (let i=0;i<10;i++)
@@ -395,40 +599,63 @@ describe('workerTest', function () {
             ss.dispatchEvent({type: "zhangsan"})
         }
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
         expect(times).assertEqual(10)
+        done()
     })
 
     // check worker off function is ok
-    it('worker_off_test_001', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_off_test_001', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let zhangSanTimes = 0
+        let isTerminate = false
 
-        let zhangsan_times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.on("zhangsan", ()=>{
-            zhangsan_times++;
+            zhangSanTimes++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(1)
+        expect(zhangSanTimes).assertEqual(1)
 
         ss.off("zhangsan")
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(1)
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
+        expect(zhangSanTimes).assertEqual(1)
+        done()
     })
 
     // check worker off function is ok
-    it('worker_off_test_002', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_off_test_002', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let zhangSanTimes = 0
+        let isTerminate = false
 
-        let zhangsan_times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.on("zhangsan", ()=>{
-            zhangsan_times++;
+            zhangSanTimes++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(2)
+        expect(zhangSanTimes).assertEqual(2)
 
         for (let i=0;i<3;i++)
         {
@@ -436,40 +663,64 @@ describe('workerTest', function () {
         }
 
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(2)
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
+        expect(zhangSanTimes).assertEqual(2)
+        done()
     })
 
     // check worker removeEventListener function is ok
-    it('worker_removeListener_test_001', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_removeListener_test_001', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let zhangSanTimes = 0
+        let isTerminate = false
 
-        let zhangsan_times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.addEventListener("zhangsan", ()=>{
-            zhangsan_times++;
+            zhangSanTimes++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(1)
+        expect(zhangSanTimes).assertEqual(1)
 
         ss.removeEventListener("zhangsan")
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(1)
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
+        expect(zhangSanTimes).assertEqual(1)
+        done()
     })
 
     // check worker removeEventListener function is ok
-    it('worker_removeListener_test_002', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_removeListener_test_002', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
+
+        let zhangSanTimes = 0
+        let isTerminate = false
 
-        let zhangsan_times = 0;
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.addEventListener("zhangsan", ()=>{
-            zhangsan_times++;
+            zhangSanTimes++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(2)
+        expect(zhangSanTimes).assertEqual(2)
 
         for (let i=0;i<3;i++)
         {
@@ -477,73 +728,92 @@ describe('workerTest', function () {
         }
 
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(2)
 
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
+        expect(zhangSanTimes).assertEqual(2)
+        done()
     })
 
     // check worker removeAllListener function is ok
-    it('worker_removeListener_test_003', 0, function () {
-        let ss = new worker.Worker("workers/worker.js");
+    it('worker_removeListener_test_003', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker.js")
 
-        let zhangsan_times = 0;
+        let zhangSanTimes = 0
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.addEventListener("zhangsan", ()=>{
-            zhangsan_times++;
+            zhangSanTimes++
         })
 
-        let lisi_times = 0;
+        let liSiTimes = 0
         ss.addEventListener("lisi", ()=>{
-            lisi_times++;
+            liSiTimes++
         })
 
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(2)
+        expect(zhangSanTimes).assertEqual(2)
 
         ss.dispatchEvent({type: "lisi"})
         ss.dispatchEvent({type: "lisi"})
-        expect(lisi_times).assertEqual(2)
+        expect(liSiTimes).assertEqual(2)
 
         ss.removeAllListener()
         ss.dispatchEvent({type: "zhangsan"})
         ss.dispatchEvent({type: "zhangsan"})
-        expect(zhangsan_times).assertEqual(2)
+        expect(zhangSanTimes).assertEqual(2)
 
         ss.dispatchEvent({type: "lisi"})
         ss.dispatchEvent({type: "lisi"})
-        expect(lisi_times).assertEqual(2)
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+
+        expect(liSiTimes).assertEqual(2)
+        done()
     })
 
     // check parentPort.close is ok
     it('worker_parentPortClose_test_001', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_008.js");
+        let ss = new worker.Worker("workers/worker_008.js")
         let res = 0
-        let flag = false;
+        let flag = false
 
         ss.onexit = function (e) {
-            res++;
-            flag = true;
+            res++
+            flag = true
         }
 
         ss.postMessage("abc")
         while (!flag) {
             await promiseCase()
         }
+
         expect(res).assertEqual(1)
         done()
     })
 
     // check parentPort.close is ok
     it('worker_parentPortClose_test_002', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_008.js");
+        let ss = new worker.Worker("workers/worker_008.js")
         let res = 0
-        let flag = false;
+        let flag = false
 
         ss.onexit = function () {
             flag = true
         }
 
         ss.onmessage = function (e) {
-            res++;
+            res++
         }
 
         ss.postMessage("abc")
@@ -559,16 +829,16 @@ describe('workerTest', function () {
 
     // check onmessageerror is ok
     it('worker_onmessageerror_test_001', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_008.js");
+        let ss = new worker.Worker("workers/worker_008.js")
         let res = 0
-        let flag = false;
+        let flag = false
 
         ss.onexit = function () {
             flag = true
         }
 
         ss.onmessageerror = function (e) {
-            res++;
+            res++
         }
 
         ss.postMessage("abc")
@@ -581,13 +851,13 @@ describe('workerTest', function () {
 
     // check onmessageerror is ok
     it('worker_onmessageerror_test_002', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_008.js");
+        let ss = new worker.Worker("workers/worker_008.js")
         let res = 0
-        let flag = false;
+        let flag = false
 
         ss.onmessageerror = function (e) {
-            flag = true;
-            res++;
+            flag = true
+            res++
         }
         function foo() {
         }
@@ -601,180 +871,258 @@ describe('workerTest', function () {
 
     // check new second worker is ok
     it('worker_new_second_worker_test_001', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_009.js");
-        let flag = false;
-        let res = undefined;
+        let ss = new worker.Worker("workers/worker_009.js")
+        let flag = false
+        let res = undefined
+        let isTerminate = false
+
+        ss.onexit = function () {
+            isTerminate = true
+        }
 
         ss.onmessage = function (e) {
-            flag = true;
-            res = e.data;
+            flag = true
+            res = e.data
         }
 
         ss.postMessage({type: "new", value: 12})
         while (!flag) {
             console.log("worker:: foo wait")
-            await promiseCase();
+            await promiseCase()
         }
+
         console.log("worker:: " + res)
-        expect(res).assertTrue();
-        done();
+        expect(res).assertTrue()
+
+        flag = false
+        ss.postMessage({type: "terminate"})
+        while (!flag) {
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
+        }
+        done()
     })
 
     // check new third worker is ok
     it('worker_new_second_worker_test_002', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_012.js");
-        let flag = false;
-        let res = undefined;
+        let ss = new worker.Worker("workers/worker_012.js")
+        let flag = false
+        let res = undefined
+        let isTerminate = false
 
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            flag = true;
-            res = e.data;
+            flag = true
+            res = e.data
         }
 
         ss.onerror = function(ee) {
             console.log("worker:: " + ee.message)
         }
 
-        ss.postMessage({type: "new", value: 12});
+        ss.postMessage({type: "new", value: 12})
+        while (!flag) {
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+        expect(res).assertTrue()
+
+        flag = false
+        ss.postMessage({type: "terminate"})
         while (!flag) {
-            console.log("worker:: worker_second_worker_postMessage_test_001 wait");
-            ss.postMessage({type: "wait"});
-            await promiseCase();
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
         }
-        expect(res).assertTrue();
-        done();
+        done()
     })
 
     // check second worker postMessage number is ok
     it('worker_second_worker_postMessage_test_001', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_010.js");
-        let flag = false;
-        let res = undefined;
+        let ss = new worker.Worker("workers/worker_010.js")
+        let flag = false
+        let res = undefined
+        let isTerminate = false
 
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            flag = true;
-            res = e.data;
+            flag = true
+            res = e.data
         }
 
         ss.onerror = function(ee) {
             console.log("worker:: " + ee.message)
         }
 
-        ss.postMessage({type: "new", value: 12});
+        ss.postMessage({type: "new", value: 12})
+        while (!flag) {
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+        expect(res).assertEqual(25)
+
+        flag = false
+        ss.postMessage({type: "terminate"})
         while (!flag) {
-            console.log("worker:: worker_second_worker_postMessage_test_001 wait");
-            ss.postMessage({type: "wait"});
-            await promiseCase();
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
         }
-        expect(res).assertEqual(25);
-        done();
+        done()
     })
 
     // check second worker postMessage string is ok
     it('worker_second_worker_postMessage_test_002', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_013.js");
-        let flag = false;
-        let res = undefined;
+        let ss = new worker.Worker("workers/worker_013.js")
+        let flag = false
+        let res = undefined
+        let isTerminate = false
 
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            flag = true;
-            res = e.data;
+            flag = true
+            res = e.data
         }
 
         ss.onerror = function(ee) {
             console.log("worker:: " + ee.message)
         }
 
-        ss.postMessage({type: "new", value: "hello world"});
+        ss.postMessage({type: "new", value: "hello world"})
+        while (!flag) {
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+        expect(res).assertEqual("hello world worker")
+
+        flag = false
+        ss.postMessage({type: "terminate"})
         while (!flag) {
-            console.log("worker:: worker_second_worker_postMessage_test_002 wait")
-            ss.postMessage({type: "wait"});
-            await promiseCase();
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
         }
-        expect(res).assertEqual("hello world worker");
-        done();
+        done()
     })
 
     // check second worker postMessage array is ok
     it('worker_second_worker_postMessage_test_003', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_014.js");
-        let flag = false;
-        let res = undefined;
+        let ss = new worker.Worker("workers/worker_014.js")
+        let flag = false
+        let res = undefined
+        let isTerminate = false
 
+        ss.onexit = function () {
+            isTerminate = true
+        }
         ss.onmessage = function (e) {
-            flag = true;
-            res = e.data;
+            flag = true
+            res = e.data
         }
 
         ss.onerror = function(ee) {
             console.log("worker:: " + ee.message)
         }
 
-        ss.postMessage({type: "new", value: [1, 2]});
+        ss.postMessage({type: "new", value: [1, 2]})
+        while (!flag) {
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+        expect(res[0]).assertEqual(2)
+        expect(res[1]).assertEqual(2)
+
+        flag = false
+        ss.postMessage({type: "terminate"})
         while (!flag) {
-            console.log("worker:: worker_second_worker_postMessage_test_003 wait")
-            ss.postMessage({type: "wait"});
-            await promiseCase();
+            ss.postMessage({type: "wait"})
+            await promiseCase()
+        }
+
+        ss.terminate()
+        while (!isTerminate) {
+            await promiseCase()
         }
-        expect(res[0]).assertEqual(2);
-        expect(res[1]).assertEqual(2);
-        done();
+        done()
     })
 
     // check third worker postMessage is ok
-    it('worker_second_worker_postMessage_test_004', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_015.js");
-        let flag = false;
-        let res = undefined;
+    it('worker_third_worker_postMessage_test_001', 0, async function (done) {
+        let ss = new worker.Worker("workers/worker_015.js")
+        let flag = false
+        let res = undefined
 
         ss.onmessage = function (e) {
-            flag = true;
-            res = e.data;
+            flag = true
+            res = e.data
         }
 
         ss.onerror = function(ee) {
             console.log("worker:: " + ee.message)
         }
 
-        ss.postMessage({type: "new", value: 10});
+        ss.postMessage({type: "new", value: 10})
         while (!flag) {
-            console.log("worker:: worker_second_worker_postMessage_test_003 wait")
-            ss.postMessage({type: "wait"});
-            await promiseCase();
+            ss.postMessage({type: "wait"})
+            await promiseCase()
         }
-        expect(res).assertEqual(16);
-        done();
+        expect(res).assertEqual(16)
+
+        done()
     })
 
     // check second worker terminate is ok
     it('worker_second_worker_terminate_test_001', 0, async function (done) {
-        let ss = new worker.Worker("workers/worker_011.js");
-        let flag = false;
-        let res = undefined;
+        let ss = new worker.Worker("workers/worker_011.js")
+        let flag = false
+        let res = undefined
 
         ss.onmessage = function (e) {
-            flag = true;
-            res = e.data;
+            flag = true
+            res = e.data
         }
 
         ss.onerror = function(ee) {
             console.log("worker:: " + ee.message)
         }
 
-        ss.postMessage({type: "new", value: 12});
+        ss.postMessage({type: "new", value: 12})
         while (!flag) {
-            ss.postMessage({type: "wait"});
-            await promiseCase();
+            ss.postMessage({type: "wait"})
+            await promiseCase()
         }
 
-        flag = false;
-        ss.postMessage({type: "terminate"});
+        flag = false
+        ss.postMessage({type: "terminate"})
         while (!flag) {
-            ss.postMessage({type: "wait"});
-            await promiseCase();
+            ss.postMessage({type: "wait"})
+            await promiseCase()
         }
 
-        expect(res).assertEqual("terminate");
-        done();
+        expect(res).assertEqual("terminate")
+        done()
     })
 })
\ No newline at end of file