/* * Copyright (C) 2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the 'License') * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an 'AS IS' BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // @ts-nocheck import app from '@system.app' import worker from "@ohos.worker" import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium' export default function threadWorkerTest() { describe('threadWorkerTest', function () { afterAll(function () { console.info('total case over') }) function promiseCase() { let p = new Promise(function (resolve, reject) { setTimeout(function () { resolve() }, 100) }).then(undefined, (error) => { }) return p } // check worker constructor is ok /** * @tc.name: threadWorker_constructor_test_001 * @tc.desc: worker constructor to Creates a worker instance. */ it('threadWorker_constructor_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false ss.onexit = function () { isTerminate = true } expect(ss != null).assertTrue() ss.terminate() while (!isTerminate) { await promiseCase() } done() }) /** * @tc.name: threadWorker_constructor_test_002 * @tc.desc: worker constructor to Creates a worker instance. */ it('threadWorker_constructor_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js", {name:"new worker", shared:"False"}) let isTerminate = false ss.onexit = function () { isTerminate = true } expect(ss != null).assertTrue() ss.terminate() while (!isTerminate) { await promiseCase() } done() }) /** * @tc.name: threadWorker_constructor_test_003 * @tc.desc: worker constructor to Creates a worker instance. */ it('threadWorker_constructor_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js", {type:"classic", name:"new worker", shared:"false"}) let isTerminate = false ss.onexit = function () { isTerminate = true } expect(ss != null).assertTrue() ss.terminate() while (!isTerminate) { await promiseCase() } done() }) /** * @tc.name: threadWorker_constructor_test_004 * @tc.desc: worker constructor to Creates a worker instance. */ it('threadWorker_constructor_test_004', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js", {type:"classic", name:"new worker", shared:"true"}) let isTerminate = false ss.onexit = function () { isTerminate = true } expect(ss != null).assertTrue() ss.terminate() while (!isTerminate) { await promiseCase() } done() }) /** * @tc.name: threadWorker_constructor_test_005 * @tc.desc: worker constructor to Creates a worker instance when throw error. */ it('threadWorker_constructor_test_005', 0, async function (done) { var ss = [] try { let a = 0 while (a <= 8) { ss[a] = new worker.ThreadWorker("workers/newworker.js") a += 1 } } catch (error) { expect(error.name == "BusinessError").assertTrue() let msg = "Worker initialization failure, the number of workers exceeds the maximum." expect(error.message).assertEqual(msg) let b = 7 let flag = 0 while (b >= 0) { ss[b].onexit = function () { flag += 1 } ss[b].terminate() b -= 1 } while (flag != 8) { await promiseCase() } done() } }) /** * @tc.name: threadWorker_constructor_test_006 * @tc.desc: worker constructor to Creates a worker instance when throw error. */ it('threadWorker_constructor_test_006', 0, async function (done) { try { let ss = new worker.ThreadWorker("workers/newworker.js", {type:"other", name:"new worker", shared:"true"}) } catch (error) { expect(error.name == "BusinessError").assertTrue() expect(error.message == "the type must be classic, unsupport others now.").assertTrue() done() } }) /** * @tc.name: threadWorker_constructor_test_007 * @tc.desc: worker constructor to Creates a worker instance when throw error. */ it('threadWorker_constructor_test_007', 0, async function (done) { try { let ss = new worker.ThreadWorker("workers/newworker.js", {type:1, name:"new worker", shared:"true"}) } catch (error) { expect(error.name == "BusinessError").assertTrue() expect(error.message == "the type of type must be string.").assertTrue() done() } }) /** * @tc.name: threadWorker_constructor_test_008 * @tc.desc: worker constructor to Creates a worker instance when throw error. */ it('threadWorker_constructor_test_008', 0, async function (done) { try { let ss = new worker.ThreadWorker("workers/newworker.js", {type:"classic1", name:1, shared:"true"}) } catch (error) { expect(error.name == "BusinessError").assertTrue() expect(error.message == "the type of name in worker must be string.").assertTrue() done() } }) /** * @tc.name: threadWorker_constructor_test_009 * @tc.desc: worker constructor to Creates a worker instance when throw error. */ it('threadWorker_constructor_test_009', 0, async function (done) { try { let ss = new worker.ThreadWorker() } catch (error) { expect(error.name == "BusinessError").assertTrue() expect(error.message == "the number of create worker param must be more than 1 with new").assertTrue() done() } }) // check postMessage is ok // main post "hello world", will receive "hello world worker" /** * @tc.name: threadWorker_postMessage_test_001 * @tc.desc: Sends a message to the worker thread. */ it('threadWorker_postMessage_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_002.js") let res = undefined let flag = false let isTerminate = false ss.onexit = function () { isTerminate = true } ss.onmessage = function (e) { res = e.data flag = true } ss.postMessage("hello world") while (!flag) { await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } expect(res).assertEqual("hello world worker") done() }) // check postMessage is ok // main post 12 , will receive 12 * 2 + 1 /** * @tc.name: threadWorker_postMessage_test_002 * @tc.desc: Sends a message to the worker thread. */ it('threadWorker_postMessage_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_003.js") let res = undefined let flag = false let isTerminate = false ss.onexit = function () { isTerminate = true } ss.onmessage = function (e) { res = e.data flag = true } ss.postMessage(12) while (!flag) { await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } expect(res).assertEqual(25) done() }) // check postMessage is ok // main post {message:"hello world"} , will receive {message:"hello world worker"} /** * @tc.name: threadWorker_postMessage_test_003 * @tc.desc: Sends a message to the worker thread. */ it('threadWorker_postMessage_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_004.js") let res = undefined let flag = false let isTerminate = false ss.onexit = function () { isTerminate = true } ss.onmessage = function (e) { res = e.data.message flag = true } ss.postMessage({"message":"hello world"}) while (!flag) { await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } expect(res).assertEqual("hello world worker") done() }) // check worker name is ok /** * @tc.name: threadWorker_postMessage_test_004 * @tc.desc: Sends a message to the worker thread. */ it('threadWorker_postMessage_test_004', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_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 console.info("worker:: type " + e.type) console.info("worker:: timeStamp " + e.timeStamp) flag = true } ss.postMessage("hello world") while (!flag) { await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } expect(res).assertEqual("zhangsan") done() }) // check worker transfer buffer is ok /** * @tc.name: threadWorker_postMessage_test_005 * @tc.desc: Sends a message to the worker thread. */ it('threadWorker_postMessage_test_005', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_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 try { length = buffer.byteLength } catch (e) { exception = e.message } ss.terminate() while (!isTerminate) { await promiseCase() } console.log("worker:: length is " + length) console.log("worker:: exception is " + exception) if (typeof exception == "undefined") { expect(length).assertEqual(0) } else { expect(exception).assertEqual("IsDetachedBuffer") } done() }) // check worker handle error is ok /** * @tc.name: threadWorker_postMessage_test_006 * @tc.desc: Sends a message to the worker thread. */ it('threadWorker_postMessage_test_006', 0, async function (done) { const ss = new worker.ThreadWorker("workers/newworker_007.js") let res = undefined let flag = false let isTerminate = false ss.onerror = function (e) { res = e.message console.info("worker:: filename " + e.filename) console.info("worker:: lineno " + e.lineno) console.info("worker:: colno " + e.colno) console.info("worker:: error " + e.error) flag = true } ss.onexit = function () { isTerminate = true } ss.postMessage("hello world") while (!flag) { await promiseCase() } expect(res).assertEqual("Error: 123") done() }) // check worker handle error is ok /** * @tc.name: threadWorker_postMessage_test_007 * @tc.desc: Sends a message to the worker thread when throw error. */ it('threadWorker_postMessage_test_007', 0, async function (done) { try { const ss = new worker.ThreadWorker("workers/newworker_007.js") ss.postMessage() } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker messageObject must be not null with postMessage") } done() }) // check worker terminate is ok /** * @tc.name: threadWorker_terminate_test_001 * @tc.desc: Terminates the worker thread to stop the worker from receiving messages. */ it('threadWorker_terminate_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let res = 0 let flag = false ss.onexit = function () { flag = true res++ } ss.terminate() while (!flag) { await promiseCase() } expect(res).assertEqual(1) done() }) // check worker terminate is ok /** * @tc.name: threadWorker_terminate_test_002 * @tc.desc: Terminates the worker thread to stop the worker from receiving messages. */ it('threadWorker_terminate_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let res = 0 let flag = false ss.onexit = function () { flag = true res++ } // Repeated execution terminate ss.terminate() ss.terminate() while (!flag) { await promiseCase() } expect(res).assertEqual(1) done() }) // check worker terminate is ok /** * @tc.name: threadWorker_terminate_test_003 * @tc.desc: Terminates the worker thread to stop the worker from receiving messages. */ it('threadWorker_terminate_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let res = 0 let flag = false ss.onexit = function () { flag = true res++ } ss.onmessage = function (e) { res++ } ss.terminate() while (!flag) { await promiseCase() } expect(res).assertEqual(1) try { ss.postMessage("hello world") await promiseCase() } catch (error) { let msg = "Worker instance is not running, maybe worker is terminated when PostMessage" expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual(msg) done() } }) // check worker on function is ok /** * @tc.name: threadWorker_on_test_001 * @tc.desc: Adds an event listener to the worker. */ it('threadWorker_on_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ times++ }) ss.dispatchEvent({type: "zhangsan"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(times).assertEqual(1) done() }) // check worker on function is ok /** * @tc.name: threadWorker_on_test_002 * @tc.desc: Adds an event listener to the worker. */ it('threadWorker_on_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ times-- }) ss.on("lisi", ()=>{ 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 /** * @tc.name: threadWorker_on_test_003 * @tc.desc: Adds an event listener to the worker. */ it('threadWorker_on_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ times++ }) for (let i=0;i<10;i++) { ss.dispatchEvent({type: "zhangsan"}) } ss.terminate() while (!isTerminate) { await promiseCase() } console.log("times " + times) expect(times).assertEqual(10) done() }) // check worker on function is ok /** * @tc.name: threadWorker_on_test_004 * @tc.desc: Adds an event listener to the worker when throw error. */ it('threadWorker_on_test_004', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false try { ss.on(1, ()=>{}) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker add listener 1st param must be string") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker on function is ok /** * @tc.name: threadWorker_on_test_005 * @tc.desc: Adds an event listener to the worker when throw error. */ it('threadWorker_on_test_005', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false try { ss.on("zhangSan", "error") } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker add listener 2st param must be callable") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker on function is ok /** * @tc.name: threadWorker_on_test_006 * @tc.desc: Adds an event listener to the worker when throw error. */ it('threadWorker_on_test_006', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false try { ss.on() } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("worker add listener param count must be not less than 2.") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) /** * @tc.name: threadWorker_on_test_007 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once when throw error. */ it('threadWorker_on_test_007', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false try { ss.on("zhangsan", ()=>{ times++ }) ss.dispatchEvent({type: "zhangsan"}) ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } ss.on("lisi", ()=>{ times++ }) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker instance is not running, maybe worker is terminated") done() } }) // check worker once function is ok /** * @tc.name: threadWorker_once_test_001 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once. */ it('threadWorker_once_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.once("zhangsan", ()=>{ times++ }) ss.dispatchEvent({type: "zhangsan"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(times).assertEqual(1) done() }) // check worker once function is ok /** * @tc.name: threadWorker_once_test_002 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once. */ it('threadWorker_once_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.once("zhangsan", ()=>{ times++ }) for (let i=0;i<10;i++) { ss.dispatchEvent({type: "zhangsan"}) } ss.terminate() while (!isTerminate) { await promiseCase() } expect(times).assertEqual(1) done() }) /** * @tc.name: threadWorker_once_test_003 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once. */ it('threadWorker_once_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.once("zhangsan", ()=>{ times-- }) ss.once("lisi", ()=>{ times++ }) ss.dispatchEvent({type: "zhangsan"}) ss.dispatchEvent({type: "lisi"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(times).assertEqual(0) done() }) /** * @tc.name: threadWorker_once_test_004 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once when throw error. */ it('threadWorker_once_test_004', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false try { ss.once(1, ()=>{ times++ }) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker add listener 1st param must be string") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) /** * @tc.name: threadWorker_once_test_005 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once when throw error. */ it('threadWorker_once_test_005', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false try { ss.once("zhangsan", "error") } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker add listener 2st param must be callable") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) /** * @tc.name: threadWorker_once_test_006 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once when throw error. */ it('threadWorker_once_test_006', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false try { ss.once() } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("worker add listener param count must be not less than 2.") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) /** * @tc.name: threadWorker_once_test_007 * @tc.desc: Adds an event listener to the worker and removes the event listener automically after it is invoked once when throw error. */ it('threadWorker_once_test_007', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let isTerminate = false try { ss.once("zhangsan", ()=>{ times++ }) ss.dispatchEvent({type: "zhangsan"}) ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } ss.once("lisi", ()=>{ times++ }) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker instance is not running, maybe worker is terminated") done() } }) // check worker addEventListener function is ok /** * @tc.name: threadWorker_addEventListener_test_001 * @tc.desc: Add an event listener to the Worker. */ it('threadWorker_addEventListener_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ 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 /** * @tc.name: threadWorker_addEventListener_test_002 * @tc.desc: Add an event listener to the Worker. */ it('threadWorker_addEventListener_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ times++ }) ss.addEventListener("lisi", ()=>{ 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 /** * @tc.name: threadWorker_addEventListener_test_003 * @tc.desc: Add an event listener to the Worker. */ it('threadWorker_addEventListener_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ times++ }) for (let i=0;i<10;i++) { ss.dispatchEvent({type: "zhangsan"}) } ss.terminate() while (!isTerminate) { await promiseCase() } expect(times).assertEqual(10) done() }) // check worker addEventListener function is ok /** * @tc.name: threadWorker_addEventListener_test_004 * @tc.desc: Add an event listener to the Worker when throw error. */ it('threadWorker_addEventListener_test_004', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false try { ss.addEventListener(1, ()=>{ times++ }) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker add listener 1st param must be string") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker addEventListener function is ok /** * @tc.name: threadWorker_addEventListener_test_005 * @tc.desc: Add an event listener to the Worker when throw error. */ it('threadWorker_addEventListener_test_005', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false try { ss.addEventListener("zhangsan", "error") } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker add listener 2st param must be callable") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker addEventListener function is ok /** * @tc.name: threadWorker_addEventListener_test_006 * @tc.desc: Add an event listener to the Worker when throw error. */ it('threadWorker_addEventListener_test_006', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false try { ss.addEventListener() } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("worker add listener param count must be not less than 2.") ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker addEventListener function is ok /** * @tc.name: threadWorker_addEventListener_test_007 * @tc.desc: Add an event listener to the Worker when throw error. */ it('threadWorker_addEventListener_test_007', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false try { ss.addEventListener("zhangsan", ()=>{ times++ }) ss.dispatchEvent({type: "zhangsan"}) ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } ss.addEventListener("lisi", ()=>{ times++ }) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker instance is not running, maybe worker is terminated") done() } }) // check worker addEventListener function is ok /** * @tc.name: threadWorker_addEventListener_test_008 * @tc.desc: Add an event listener to the Worker when throw error. */ it('threadWorker_addEventListener_test_008', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let times = 0 let isTerminate = false try { ss.addEventListener("zhangsan", ()=>{ times++ }) ss.dispatchEvent({type: "zhangsan"}) ss.onexit = function () { isTerminate = true } ss.terminate() while (!isTerminate) { await promiseCase() } ss.dispatchEvent({type: "zhangsan"}) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker instance is not running, maybe worker has been terminated") done() } }) // check worker off function is ok /** * @tc.name: threadWorker_off_test_001 * @tc.desc: Removes an event listener to the worker. */ it('threadWorker_off_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ zhangSanTimes++ }) ss.dispatchEvent({type: "zhangsan"}) expect(zhangSanTimes).assertEqual(1) ss.off("zhangsan") ss.dispatchEvent({type: "zhangsan"}) ss.dispatchEvent({type: "zhangsan"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(zhangSanTimes).assertEqual(1) done() }) // check worker off function is ok /** * @tc.name: threadWorker_off_test_002 * @tc.desc: Removes an event listener to the worker. */ it('threadWorker_off_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ zhangSanTimes++ }) ss.dispatchEvent({type: "zhangsan"}) ss.dispatchEvent({type: "zhangsan"}) expect(zhangSanTimes).assertEqual(2) for (let i=0;i<3;i++) { ss.off("zhangsan") } ss.dispatchEvent({type: "zhangsan"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(zhangSanTimes).assertEqual(2) done() }) // check worker off function is ok /** * @tc.name: threadWorker_off_test_003 * @tc.desc: Removes an event listener to the worker when throw error. */ it('threadWorker_off_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ zhangSanTimes++ }) ss.terminate() while (!isTerminate) { await promiseCase() } try { ss.off("zhangsan") } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker instance is not running, maybe worker is terminated") done() } }) // check worker off function is ok /** * @tc.name: threadWorker_off_test_004 * @tc.desc: Removes an event listener to the worker when throw error. */ it('threadWorker_off_test_004', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ zhangSanTimes++ }) try { ss.off() } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("the remove listener param must be not less than 1") ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker off function is ok /** * @tc.name: threadWorker_off_test_005 * @tc.desc: Removes an event listener to the worker when throw error. */ it('threadWorker_off_test_005', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.on("zhangsan", ()=>{ zhangSanTimes++ }) try { ss.off(1) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("the type of remove listener 1st param must be string") ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker removeEventListener function is ok /** * @tc.name: threadWorker_removeListener_test_001 * @tc.desc: Removes an event defined for the worker. */ it('threadWorker_removeListener_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ zhangSanTimes++ }) ss.dispatchEvent({type: "zhangsan"}) expect(zhangSanTimes).assertEqual(1) ss.removeEventListener("zhangsan") ss.dispatchEvent({type: "zhangsan"}) ss.dispatchEvent({type: "zhangsan"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(zhangSanTimes).assertEqual(1) done() }) // check worker removeEventListener function is ok /** * @tc.name: threadWorker_removeListener_test_002 * @tc.desc: Removes an event defined for the worker. */ it('threadWorker_removeListener_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ zhangSanTimes++ }) ss.dispatchEvent({type: "zhangsan"}) ss.dispatchEvent({type: "zhangsan"}) expect(zhangSanTimes).assertEqual(2) for (let i=0;i<3;i++) { ss.removeEventListener("zhangsan") } ss.dispatchEvent({type: "zhangsan"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(zhangSanTimes).assertEqual(2) done() }) // check worker removeAllListener function is ok /** * @tc.name: threadWorker_removeListener_test_003 * @tc.desc: Removes an event defined for the worker. */ it('threadWorker_removeListener_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ zhangSanTimes++ }) let liSiTimes = 0 ss.addEventListener("lisi", ()=>{ liSiTimes++ }) ss.dispatchEvent({type: "zhangsan"}) ss.dispatchEvent({type: "zhangsan"}) expect(zhangSanTimes).assertEqual(2) ss.dispatchEvent({type: "lisi"}) ss.dispatchEvent({type: "lisi"}) expect(liSiTimes).assertEqual(2) ss.removeAllListener() ss.dispatchEvent({type: "zhangsan"}) ss.dispatchEvent({type: "zhangsan"}) expect(zhangSanTimes).assertEqual(2) ss.dispatchEvent({type: "lisi"}) ss.dispatchEvent({type: "lisi"}) ss.terminate() while (!isTerminate) { await promiseCase() } expect(liSiTimes).assertEqual(2) done() }) // check worker removeAllListener function is ok /** * @tc.name: threadWorker_removeListener_test_003 * @tc.desc: Removes an event defined for the worker when throw error. */ it('threadWorker_removeListener_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ zhangSanTimes++ }) ss.terminate() while (!isTerminate) { await promiseCase() } try { ss.removeAllListener() } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker instance is not running, maybe worker is terminated") done() } }) // check worker removeAllListener function is ok /** * @tc.name: threadWorker_removeListener_test_004 * @tc.desc: Removes an event defined for the worker when throw error. */ it('threadWorker_removeListener_test_004', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ zhangSanTimes++ }) ss.terminate() while (!isTerminate) { await promiseCase() } try { ss.removeEventListener("zhangsan") } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("Worker instance is not running, maybe worker is terminated") done() } }) // check worker removeAllListener function is ok /** * @tc.name: threadWorker_removeListener_test_005 * @tc.desc: Removes an event defined for the worker when throw error. */ it('threadWorker_removeListener_test_005', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ zhangSanTimes++ }) try { ss.removeEventListener() } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("the remove listener param must be not less than 1") ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check worker removeAllListener function is ok /** * @tc.name: threadWorker_removeListener_test_006 * @tc.desc: Removes an event defined for the worker when throw error. */ it('threadWorker_removeListener_test_006', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker.js") let zhangSanTimes = 0 let isTerminate = false ss.onexit = function () { isTerminate = true } ss.addEventListener("zhangsan", ()=>{ zhangSanTimes++ }) try { ss.removeEventListener(1) } catch (error) { expect(error.name).assertEqual("BusinessError") expect(error.message).assertEqual("the type of remove listener 1st param must be string") ss.terminate() while (!isTerminate) { await promiseCase() } done() } }) // check parentPort.close is ok /** * @tc.name: threadWorker_parentPortClose_test_001 * @tc.desc: Close the worker thread to stop the worker from receiving messages. */ it('threadWorker_parentPortClose_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_008.js") let res = 0 let flag = false ss.onexit = function (e) { res++ flag = true } ss.postMessage("abc") while (!flag) { await promiseCase() } expect(res).assertEqual(1) done() }) // check parentPort.close is ok /** * @tc.name: threadWorker_parentPortClose_test_002 * @tc.desc: Close the worker thread to stop the worker from receiving messages. */ it('threadWorker_parentPortClose_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_008.js") let res = 0 let flag = false ss.onexit = function () { flag = true } ss.onmessage = function (e) { res++ } ss.postMessage("abc") while (!flag) { await promiseCase() } try { ss.postMessage("hello") } catch (error) { expect(res).assertEqual(0) expect(error.name).assertEqual("BusinessError") let msg = "Worker instance is not running, maybe worker is terminated when PostMessage" expect(error.message).assertEqual(msg) done() } }) // check onmessageerror is ok /** * @tc.name: threadWorker_onmessageerror_test_001 * @tc.desc: The onmessage attribute of the worker specifies the event handler when the worker receives a message that cannot be serialized. The event handler is executed in the host thread */ it('threadWorker_onmessageerror_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_008.js") let res = 0 let flag = false ss.onexit = function () { flag = true } ss.onmessageerror = function (e) { res++ } ss.postMessage("abc") while (!flag) { await promiseCase() } expect(res).assertEqual(0) done() }) // check onmessageerror is ok /** * @tc.name: threadWorker_onmessageerror_test_002 * @tc.desc: The onmessage attribute of the worker specifies the event handler when the worker receives a message that cannot be serialized. The event handler is executed in the host thread */ it('threadWorker_onmessageerror_test_002', 0, async function (done) { try { var ss = new worker.ThreadWorker("workers/newworker_008.js") var res = 0 var flag = false ss.onexit = function() { flag = true } ss.onmessageerror = function (e) { flag = true res++ } function foo() { } ss.postMessage(foo) while (!flag) { await promiseCase() } } catch (error) { flag = false ss.postMessage("terminate") while (!flag) { await promiseCase() } expect(res).assertEqual(1) expect(error.name).assertEqual("BusinessError") let msg = "Serializing an uncaught exception failed, failed to serialize message." expect(error.message).assertEqual(msg) done() } }) // check new second worker is ok /** * @tc.name: threadWorker_new_second_worker_test_001 * @tc.desc: Create a second worker. */ it('threadWorker_new_second_worker_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_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 } ss.postMessage({type: "new", value: 12}) while (!flag) { console.log("worker:: foo wait") await promiseCase() } console.log("worker:: " + res) 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 /** * @tc.name: threadWorker_new_second_worker_test_002 * @tc.desc: Create a third worker. */ it('threadWorker_new_second_worker_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_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 } ss.onerror = function(ee) { console.log("worker:: " + ee.message) } 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) { ss.postMessage({type: "wait"}) await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } done() }) // check second worker postMessage number is ok /** * @tc.name: threadWorker_second_worker_postMessage_test_001 * @tc.desc: Check if the postMessage function of the second worker is ok. */ it('threadWorker_second_worker_postMessage_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_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 } ss.onerror = function(ee) { console.log("worker:: " + ee.message) } 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) { ss.postMessage({type: "wait"}) await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } done() }) // check second worker postMessage string is ok /** * @tc.name: threadWorker_second_worker_postMessage_test_002 * @tc.desc: Check if the postMessage function of the second worker is ok. */ it('threadWorker_second_worker_postMessage_test_002', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_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 } ss.onerror = function(ee) { console.log("worker:: " + ee.message) } 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) { ss.postMessage({type: "wait"}) await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } done() }) // check second worker postMessage array is ok /** * @tc.name: threadWorker_second_worker_postMessage_test_003 * @tc.desc: Check if the postMessage function of the second worker is ok. */ it('threadWorker_second_worker_postMessage_test_003', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_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 } ss.onerror = function(ee) { console.log("worker:: " + ee.message) } 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) { ss.postMessage({type: "wait"}) await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } done() }) // check third worker postMessage is ok /** * @tc.name: threadWorker_third_worker_postMessage_test_001 * @tc.desc: Check if the postMessage function of the third worker is ok. */ it('threadWorker_third_worker_postMessage_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_015.js") let flag = false let res = undefined let isTerminate = false ss.onexit = function() { isTerminate = true } ss.onmessage = function(e) { flag = true res = e.data } ss.onerror = function(ee) { console.log("worker:: " + ee.message) } ss.postMessage({type: "new", value: 10}) while (!flag) { ss.postMessage({type: "wait"}) await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } expect(res).assertEqual(16) done() }) // check second worker terminate is ok /** * @tc.name: threadWorker_second_worker_terminate_test_001 * @tc.desc: Check if the terminate function of the second worker is ok. */ it('threadWorker_second_worker_terminate_test_001', 0, async function (done) { let ss = new worker.ThreadWorker("workers/newworker_011.js") let flag = false let res = undefined let isTerminate = false ss.onexit = function() { isTerminate = true } ss.onmessage = function(e) { flag = true res = e.data } ss.onerror = function(ee) { console.log("worker:: " + ee.message) } ss.postMessage({type: "new", value: 12}) while (!flag) { ss.postMessage({type: "wait"}) await promiseCase() } flag = false ss.postMessage({type: "terminate"}) while (!flag) { ss.postMessage({type: "wait"}) await promiseCase() } ss.terminate() while (!isTerminate) { await promiseCase() } expect(res).assertEqual("terminate") done() }) }) }