1/** 2 * Copyright (c) 2024 SwanLink (Jiangsu) Technology Development Co., LTD. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import { describe, it, expect, afterEach, TestType, Level, Size } from '@ohos/hypium'; 17import { 18 ArkTSUtils, 19 collections, 20 ErrorEvent, 21 JSON, 22 lang, 23 MessageEvents, 24 taskpool, 25 worker, 26 ThreadWorkerPriority 27} from '@kit.ArkTS'; 28import { GetTime, Sleep } from '../utils/utils'; 29 30declare class ArkTools { 31 static forceFullGC(): void; 32} 33 34@Concurrent 35export function printNum(args: number): number { 36 console.info('printNum: ' + args); 37 return args; 38} 39 40@Sendable 41export class SendableObject { 42 a: number = 45; 43} 44 45class TestObj { 46 private message: string = "this is a message from TestObj" 47 48 public getMessage(): string { 49 return this.message; 50 } 51 52 public getMessageWithInput(str: string): string { 53 return this.message + " with input: " + str; 54 } 55} 56 57class TestObjAsync { 58 private message: string = "this is worker" 59 60 public async getMessage(): Promise<string> { 61 return this.message; 62 } 63 64 public getMessageWithInput(str: string): string { 65 return this.message + " with input: " + str; 66 } 67} 68 69class TestObjTime { 70 private message: string = "this is worker" 71 72 public getMessage(): string { 73 let start: number = new Date().getTime(); 74 while (new Date().getTime() - start < 1000) { 75 continue; 76 } 77 return this.message; 78 } 79 80 public getMessageWithInput(str: string): string { 81 return this.message + " with input: " + str; 82 } 83} 84 85@Sendable 86export function undefinedReturn(): undefined { 87 return undefined 88} 89 90export default function workerErrorCodeTest() { 91 describe('workerErrorCodeTest', () => { 92 afterEach(async () => { 93 await Sleep(50); 94 }) 95 /** 96 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_0100 97 * @tc.name : testThreadWorkerErrorCode0001 98 * @tc.desc : WorkerEventListener Constructor 10200004 99 * @tc.size : MediumTest 100 * @tc.type : Function 101 * @tc.level : Level 1 102 */ 103 it('testThreadWorkerErrorCode0001', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 104 const caseName = "testThreadWorkerErrorCode0001"; 105 let num = 0; 106 const workerInstance: worker.ThreadWorker = 107 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 108 priority: ThreadWorkerPriority.HIGH 109 }); 110 workerInstance.postMessage(10); 111 workerInstance.onmessage = (e) => { 112 workerInstance.terminate(); 113 } 114 workerInstance.onexit = (code) => { 115 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 116 setTimeout(() => { 117 try { 118 workerInstance.addEventListener("workerInstance_addEventListener", () => { 119 console.log('workerInstance_addEventListener listener callback'); 120 }) 121 } catch (err) { 122 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 123 num++; 124 expect(err.code).assertEqual(10200004) 125 } 126 }) 127 } 128 while (num < 1) { 129 await Sleep(100) 130 } 131 done(); 132 }); 133 /** 134 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_0300 135 * @tc.name : testThreadWorkerErrorCode0003 136 * @tc.desc : WorkerEventTarget9+ addEventListener9+ 10200004 137 * @tc.size : MediumTest 138 * @tc.type : Function 139 * @tc.level : Level 1 140 */ 141 it('testThreadWorkerErrorCode0003', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 142 const caseName = "testThreadWorkerErrorCode0003"; 143 let num = 0; 144 const workerInstance: worker.ThreadWorker = 145 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 146 priority: ThreadWorkerPriority.HIGH 147 }); 148 workerInstance.postMessage(10); 149 workerInstance.onmessage = (e) => { 150 workerInstance.terminate(); 151 } 152 workerInstance.onexit = (code) => { 153 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 154 setTimeout(() => { 155 try { 156 workerInstance.addEventListener("workerInstance_addEventListener", () => { 157 console.log('workerInstance_addEventListener callback'); 158 }) 159 } catch (err) { 160 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 161 num++; 162 expect(err.code).assertEqual(10200004) 163 } 164 }) 165 } 166 while (num < 1) { 167 await Sleep(100) 168 } 169 done(); 170 }); 171 /** 172 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_0500 173 * @tc.name : testThreadWorkerErrorCode0005 174 * @tc.desc : WorkerEventTarget9+ dispatchEvent9+ 10200004 175 * @tc.size : MediumTest 176 * @tc.type : Function 177 * @tc.level : Level 1 178 */ 179 it('testThreadWorkerErrorCode0005', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 180 const caseName = "testThreadWorkerErrorCode0005"; 181 let num = 0; 182 const workerInstance: worker.ThreadWorker = 183 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 184 priority: ThreadWorkerPriority.HIGH 185 }); 186 workerInstance.postMessage(10); 187 workerInstance.onmessage = (e) => { 188 workerInstance.terminate(); 189 } 190 workerInstance.onexit = (code) => { 191 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 192 setTimeout(() => { 193 try { 194 workerInstance.dispatchEvent({ 195 type: "eventType", timeStamp: 0 196 }); 197 } catch (err) { 198 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 199 num++; 200 expect(err.code).assertEqual(10200004) 201 } 202 }) 203 } 204 while (num < 1) { 205 await Sleep(100) 206 } 207 done(); 208 }); 209 /** 210 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_0600 211 * @tc.name : testThreadWorkerErrorCode0006 212 * @tc.desc : WorkerEventTarget9+ removeEventListener9+ 10200004 213 * @tc.size : MediumTest 214 * @tc.type : Function 215 * @tc.level : Level 1 216 */ 217 it('testThreadWorkerErrorCode0006', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 218 const caseName = "testThreadWorkerErrorCode0006"; 219 let num = 0; 220 const workerInstance: worker.ThreadWorker = 221 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 222 priority: ThreadWorkerPriority.HIGH 223 }); 224 workerInstance.postMessage(10); 225 workerInstance.onmessage = (e) => { 226 workerInstance.terminate(); 227 } 228 workerInstance.addEventListener("workerInstance_addEventListener", () => { 229 console.log('workerInstance_addEventListener callback'); 230 }) 231 workerInstance.onexit = (code) => { 232 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 233 setTimeout(() => { 234 try { 235 workerInstance.removeEventListener("workerInstance_addEventListener"); 236 } catch (err) { 237 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 238 num++; 239 expect(err.code).assertEqual(10200004) 240 } 241 }) 242 } 243 while (num < 1) { 244 await Sleep(100) 245 } 246 done(); 247 }); 248 /** 249 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_0700 250 * @tc.name : testThreadWorkerErrorCode0007 251 * @tc.desc : WorkerEventTarget9+ removeAllListener9+ 10200004 252 * @tc.size : MediumTest 253 * @tc.type : Function 254 * @tc.level : Level 1 255 */ 256 it('testThreadWorkerErrorCode0007', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 257 const caseName = "testThreadWorkerErrorCode0007"; 258 let num = 0; 259 const workerInstance: worker.ThreadWorker = 260 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 261 priority: ThreadWorkerPriority.HIGH 262 }); 263 workerInstance.postMessage(10); 264 workerInstance.onmessage = (e) => { 265 workerInstance.terminate(); 266 } 267 workerInstance.addEventListener("workerInstance_addEventListener", () => { 268 console.log('workerInstance_addEventListener callback'); 269 }) 270 workerInstance.onexit = (code) => { 271 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 272 setTimeout(() => { 273 try { 274 workerInstance.removeAllListener(); 275 } catch (err) { 276 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 277 num++; 278 expect(err.code).assertEqual(10200004) 279 } 280 }) 281 } 282 while (num < 1) { 283 await Sleep(100) 284 } 285 done(); 286 }); 287 /** 288 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_0800 289 * @tc.name : testThreadWorkerErrorCode0008 290 * @tc.desc : ThreadWorkerGlobalScope onmessage9+ 10200004 291 * @tc.size : MediumTest 292 * @tc.type : Function 293 * @tc.level : Level 1 294 */ 295 it('testThreadWorkerErrorCode0008', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 296 const caseName = "testThreadWorkerErrorCode0008"; 297 try { 298 let bool = false; 299 const workerInstance: worker.ThreadWorker = 300 new worker.ThreadWorker("../../workers/ErrorCode/WorkerOnmessage1", { 301 priority: ThreadWorkerPriority.HIGH 302 }); 303 workerInstance.postMessage(10); 304 workerInstance.onmessage = (e) => { 305 console.log(`${caseName} main onmessage code: ` + JSON.stringify(e)); 306 } 307 workerInstance.onexit = (code) => { 308 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 309 bool = true; 310 } 311 while (!bool) { 312 await Sleep(200) 313 console.log(`${caseName} main while code: ` + JSON.stringify(bool)); 314 } 315 done(); 316 } catch (err) { 317 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 318 expect().assertFail(); 319 done(); 320 } 321 }); 322 /** 323 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1300 324 * @tc.name : testThreadWorkerErrorCode0013 325 * @tc.desc : ThreadWorkerGlobalScope postMessage9+ 10200004 326 * @tc.size : MediumTest 327 * @tc.type : Function 328 * @tc.level : Level 1 329 */ 330 it('testThreadWorkerErrorCode0013', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 331 const caseName = "testThreadWorkerErrorCode0013"; 332 let bool = false 333 try { 334 const workerInstance: worker.ThreadWorker = 335 new worker.ThreadWorker("../../workers/ErrorCode/WorkerPostMessage1", 336 { 337 priority: ThreadWorkerPriority.HIGH 338 }); 339 workerInstance.postMessage(10); 340 workerInstance.onmessage = (e) => { 341 workerInstance.terminate(); 342 } 343 workerInstance.onexit = (code) => { 344 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 345 bool = true 346 } 347 while (!bool) { 348 await Sleep(200) 349 } 350 done(); 351 } catch (err) { 352 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 353 expect(err.code).assertEqual(10200004) 354 done(); 355 } 356 }); 357 /** 358 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1400 359 * @tc.name : testThreadWorkerErrorCode0014 360 * @tc.desc : ThreadWorkerGlobalScope postMessage9+ 10200006 361 * @tc.size : MediumTest 362 * @tc.type : Function 363 * @tc.level : Level 1 364 */ 365 it('testThreadWorkerErrorCode0014', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 366 const caseName = "testThreadWorkerErrorCode0014"; 367 let bool = false 368 const workerInstance: worker.ThreadWorker = 369 new worker.ThreadWorker("../../workers/ErrorCode/WorkerPostMessage4", { 370 priority: ThreadWorkerPriority.HIGH 371 }); 372 workerInstance.postMessage(10); 373 workerInstance.onmessage = (e) => { 374 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 375 expect(e.data).assertEqual(10200006) 376 workerInstance.terminate(); 377 } 378 workerInstance.onexit = (code) => { 379 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 380 bool = true 381 } 382 while (!bool) { 383 await Sleep(200) 384 } 385 done(); 386 }); 387 /** 388 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1500 389 * @tc.name : testThreadWorkerErrorCode0015 390 * @tc.desc : ThreadWorkerGlobalScope postMessage9+ 10200004 391 * @tc.size : MediumTest 392 * @tc.type : Function 393 * @tc.level : Level 1 394 */ 395 it('testThreadWorkerErrorCode0015', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 396 const caseName = "testThreadWorkerErrorCode0015"; 397 let bool = false 398 const workerInstance: worker.ThreadWorker = 399 new worker.ThreadWorker("../../workers/ErrorCode/WorkerPostMessage3", 400 { 401 priority: ThreadWorkerPriority.HIGH 402 }); 403 workerInstance.onmessage = (e) => { 404 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 405 workerInstance.terminate() 406 } 407 workerInstance.postMessage(1); 408 workerInstance.onexit = (code) => { 409 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 410 bool = true 411 try { 412 workerInstance.postMessage(10); 413 } catch (err) { 414 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 415 expect(err.code).assertEqual(10200004) 416 done(); 417 } 418 } 419 while (!bool) { 420 await Sleep(200) 421 } 422 done(); 423 424 }); 425 /** 426 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1600 427 * @tc.name : testThreadWorkerErrorCode0016 428 * @tc.desc : ThreadWorkerGlobalScope postMessage9+ 10200006 429 * @tc.size : MediumTest 430 * @tc.type : Function 431 * @tc.level : Level 1 432 */ 433 it('testThreadWorkerErrorCode0016', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 434 const caseName = "testThreadWorkerErrorCode0016"; 435 let bool = false 436 try { 437 const workerInstance: worker.ThreadWorker = 438 new worker.ThreadWorker("../../workers/ErrorCode/WorkerPostMessage4", 439 { 440 priority: ThreadWorkerPriority.HIGH 441 }); 442 workerInstance.postMessage(10); 443 workerInstance.onmessage = (e) => { 444 workerInstance.terminate(); 445 } 446 workerInstance.onexit = (code) => { 447 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 448 bool = true 449 } 450 while (!bool) { 451 await Sleep(200) 452 } 453 done(); 454 } catch (err) { 455 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 456 expect(err.code).assertEqual(10200006) 457 done(); 458 } 459 }); 460 /** 461 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1700 462 * @tc.name : testThreadWorkerErrorCode0017 463 * @tc.desc : ThreadWorkerGlobalScope postMessageWithSharedSendable12+ 10200004 464 * @tc.size : MediumTest 465 * @tc.type : Function 466 * @tc.level : Level 1 467 */ 468 it('testThreadWorkerErrorCode0017', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 469 const caseName = "testThreadWorkerErrorCode0017"; 470 let bool = false 471 try { 472 const workerInstance: worker.ThreadWorker = 473 new worker.ThreadWorker("../../workers/ErrorCode/WorkerPostMessage5", 474 { 475 priority: ThreadWorkerPriority.HIGH 476 }); 477 workerInstance.postMessage(10); 478 workerInstance.onmessage = (e) => { 479 workerInstance.terminate() 480 } 481 workerInstance.onexit = (code) => { 482 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 483 bool = true 484 } 485 while (!bool) { 486 await Sleep(200) 487 } 488 done(); 489 } catch (err) { 490 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 491 expect(err.code).assertEqual(10200004) 492 done(); 493 } 494 }); 495 /** 496 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1800 497 * @tc.name : testThreadWorkerErrorCode0018 498 * @tc.desc : ThreadWorkerGlobalScope postMessageWithSharedSendable12+ 10200006 499 * @tc.size : MediumTest 500 * @tc.type : Function 501 * @tc.level : Level 1 502 */ 503 it('testThreadWorkerErrorCode0018', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 504 const caseName = "testThreadWorkerErrorCode0018"; 505 let bool = false 506 const workerInstance: worker.ThreadWorker = 507 new worker.ThreadWorker("../../workers/ErrorCode/WorkerPostMessage6", { 508 priority: ThreadWorkerPriority.HIGH 509 }); 510 workerInstance.postMessage(10); 511 workerInstance.onmessage = (e) => { 512 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 513 expect(e.data).assertEqual(10200006) 514 workerInstance.terminate(); 515 } 516 workerInstance.onexit = (code) => { 517 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 518 bool = true 519 } 520 while (!bool) { 521 await Sleep(200) 522 } 523 done(); 524 }); 525 /** 526 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1900 527 * @tc.name : testThreadWorkerErrorCode0019 528 * @tc.desc : ThreadWorkerGlobalScope callGlobalCallObjectMethod11+ 10200004 529 * @tc.size : MediumTest 530 * @tc.type : Function 531 * @tc.level : Level 1 532 */ 533 it('testThreadWorkerErrorCode0019', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 534 const caseName = "testThreadWorkerErrorCode0019"; 535 let finish = false 536 const workerInstance: worker.ThreadWorker = 537 new worker.ThreadWorker("../../workers/ErrorCode/WorkerRegister1", { 538 priority: ThreadWorkerPriority.HIGH 539 }); 540 workerInstance.postMessage(10); 541 let registerObj = new TestObj(); 542 workerInstance.registerGlobalCallObject("myObj", registerObj); 543 workerInstance.onmessage = (e) => { 544 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 545 expect(e.data).assertEqual(10200004) 546 workerInstance.terminate(); 547 } 548 workerInstance.onexit = (code) => { 549 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 550 finish = true 551 } 552 while (!finish) { 553 await Sleep(100) 554 } 555 done(); 556 }); 557 /** 558 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2000 559 * @tc.name : testThreadWorkerErrorCode0020 560 * @tc.desc : ThreadWorkerGlobalScope callGlobalCallObjectMethod11+ 10200006 561 * @tc.size : MediumTest 562 * @tc.type : Function 563 * @tc.level : Level 1 564 */ 565 it('testThreadWorkerErrorCode0020', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 566 const caseName = "testThreadWorkerErrorCode0020"; 567 let finish = false 568 const workerInstance: worker.ThreadWorker = 569 new worker.ThreadWorker("../../workers/ErrorCode/WorkerRegister2", { 570 priority: ThreadWorkerPriority.HIGH 571 }); 572 let registerObj = new TestObj(); 573 workerInstance.registerGlobalCallObject("myObj", registerObj); 574 workerInstance.postMessage(10); 575 workerInstance.onmessage = (e) => { 576 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 577 expect(e.data).assertEqual(10200006) 578 workerInstance.terminate(); 579 } 580 workerInstance.onexit = (code) => { 581 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 582 finish = true 583 } 584 while (!finish) { 585 await Sleep(100) 586 } 587 done(); 588 }); 589 /** 590 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2100 591 * @tc.name : testThreadWorkerErrorCode0021 592 * @tc.desc : ThreadWorkerGlobalScope callGlobalCallObjectMethod11+ 10200019 593 * @tc.size : MediumTest 594 * @tc.type : Function 595 * @tc.level : Level 1 596 */ 597 it('testThreadWorkerErrorCode0021', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 598 const caseName = "testThreadWorkerErrorCode0021"; 599 let finish = false 600 const workerInstance: worker.ThreadWorker = 601 new worker.ThreadWorker("../../workers/ErrorCode/WorkerRegister3", { 602 priority: ThreadWorkerPriority.HIGH 603 }); 604 workerInstance.postMessage(10); 605 workerInstance.onmessage = (e) => { 606 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 607 expect(e.data).assertEqual(10200019) 608 workerInstance.terminate(); 609 } 610 workerInstance.onexit = (code) => { 611 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 612 finish = true 613 } 614 while (!finish) { 615 await Sleep(100) 616 } 617 done(); 618 }); 619 /** 620 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2200 621 * @tc.name : testThreadWorkerErrorCode0022 622 * @tc.desc : ThreadWorkerGlobalScope callGlobalCallObjectMethod11+ 10200020 623 * @tc.size : MediumTest 624 * @tc.type : Function 625 * @tc.level : Level 1 626 */ 627 it('testThreadWorkerErrorCode0022', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 628 const caseName = "testThreadWorkerErrorCode0022"; 629 let finish = false 630 const workerInstance: worker.ThreadWorker = 631 new worker.ThreadWorker("../../workers/ErrorCode/WorkerRegister4", { 632 priority: ThreadWorkerPriority.HIGH 633 }); 634 let registerObj = new TestObjAsync(); 635 workerInstance.registerGlobalCallObject("myObj", registerObj); 636 workerInstance.postMessage(10); 637 workerInstance.onmessage = (e) => { 638 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 639 expect(e.data).assertEqual(10200020) 640 workerInstance.terminate(); 641 } 642 workerInstance.onexit = (code) => { 643 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 644 finish = true 645 } 646 while (!finish) { 647 await Sleep(100) 648 } 649 done(); 650 }); 651 /** 652 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2300 653 * @tc.name : testThreadWorkerErrorCode0023 654 * @tc.desc : ThreadWorkerGlobalScope callGlobalCallObjectMethod11+ 10200021 655 * @tc.size : MediumTest 656 * @tc.type : Function 657 * @tc.level : Level 1 658 */ 659 it('testThreadWorkerErrorCode0023', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 660 const caseName = "testThreadWorkerErrorCode0023"; 661 let finish = false 662 const workerInstance: worker.ThreadWorker = 663 new worker.ThreadWorker("../../workers/ErrorCode/WorkerRegister5", { 664 priority: ThreadWorkerPriority.HIGH 665 }); 666 let registerObj = new TestObjTime(); 667 workerInstance.registerGlobalCallObject("myObj", registerObj); 668 workerInstance.postMessage(10); 669 workerInstance.onmessage = (e) => { 670 console.log(`${caseName} main onmessage: ` + JSON.stringify(e.data)); 671 expect(e.data).assertEqual(10200021) 672 workerInstance.terminate(); 673 } 674 workerInstance.onexit = (code) => { 675 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 676 finish = true 677 } 678 while (!finish) { 679 await Sleep(100) 680 } 681 done(); 682 }); 683 /** 684 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2500 685 * @tc.name : testThreadWorkerErrorCode0025 686 * @tc.desc : ThreadWorker9+ constructor9+ 10200007 687 * @tc.size : MediumTest 688 * @tc.type : Function 689 * @tc.level : Level 1 690 */ 691 it('testThreadWorkerErrorCode0025', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 692 const caseName = "testThreadWorkerErrorCode0025"; 693 let bool = false; 694 try { 695 const workerInstance: worker.ThreadWorker = new worker.ThreadWorker("../workers/ErrorCode/WorkerData"); 696 workerInstance.postMessage(10); 697 workerInstance.onmessage = (e) => { 698 workerInstance.terminate(); 699 } 700 workerInstance.onexit = (code) => { 701 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 702 bool = true 703 } 704 while (!bool) { 705 await Sleep(100) 706 } 707 done(); 708 } catch (err) { 709 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 710 expect(err.code).assertEqual(10200007) 711 done(); 712 } 713 }); 714 /** 715 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2600 716 * @tc.name : testThreadWorkerErrorCode0026 717 * @tc.desc : ThreadWorker9+ onexit9+ 10200004 718 * @tc.size : MediumTest 719 * @tc.type : Function 720 * @tc.level : Level 1 721 */ 722 it('testThreadWorkerErrorCode0026', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 723 const caseName = "testThreadWorkerErrorCode0026"; 724 let bool = false; 725 const workerInstance: worker.ThreadWorker = 726 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 727 priority: ThreadWorkerPriority.HIGH 728 }); 729 workerInstance.postMessage(10); 730 workerInstance.terminate(); 731 workerInstance.onmessage = (e) => { 732 } 733 workerInstance.onexit = (code) => { 734 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 735 setTimeout(() => { 736 try { 737 workerInstance.terminate(); 738 workerInstance.onexit = (code) => { 739 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 740 } 741 } catch (err) { 742 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 743 expect(err.code).assertEqual(10200004) 744 bool = true; 745 } 746 }) 747 } 748 while (!bool) { 749 await Sleep(200) 750 } 751 done(); 752 }); 753 /** 754 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2700 755 * @tc.name : testThreadWorkerErrorCode0027 756 * @tc.desc : ThreadWorker9+ onerror9+ 10200004 757 * @tc.size : MediumTest 758 * @tc.type : Function 759 * @tc.level : Level 1 760 */ 761 it('testThreadWorkerErrorCode0027', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 762 const caseName = "testThreadWorkerErrorCode0027"; 763 try { 764 let bool = false; 765 const workerInstance: worker.ThreadWorker = 766 new worker.ThreadWorker("../../workers/ErrorCode/WorkerOnmessageError2", 767 { 768 priority: ThreadWorkerPriority.HIGH 769 }); 770 workerInstance.postMessage(10); 771 workerInstance.terminate(); 772 workerInstance.onmessage = (e) => { 773 } 774 workerInstance.onerror = (e) => { 775 console.log(`${caseName} main onexit code: ` + JSON.stringify(e)); 776 } 777 workerInstance.onexit = (code) => { 778 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 779 setTimeout(() => { 780 try { 781 workerInstance.onerror = (e) => { 782 console.log(`${caseName} main onexit code: ` + JSON.stringify(e)); 783 } 784 bool = true; 785 } catch (err) { 786 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 787 expect(err.code).assertEqual(10200004) 788 bool = true; 789 } 790 }) 791 } 792 while (!bool) { 793 await Sleep(200) 794 } 795 done(); 796 } catch (err) { 797 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 798 expect(err.code).assertEqual(10200004) 799 done(); 800 } 801 }); 802 /** 803 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2800 804 * @tc.name : testThreadWorkerErrorCode0028 805 * @tc.desc : ThreadWorker9+ onAllErrors9+ 10200004 806 * @tc.size : MediumTest 807 * @tc.type : Function 808 * @tc.level : Level 1 809 */ 810 it('testThreadWorkerErrorCode0028', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 811 const caseName = "testThreadWorkerErrorCode0028"; 812 let bool = false; 813 const workerInstance: worker.ThreadWorker = 814 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 815 priority: ThreadWorkerPriority.HIGH 816 }); 817 workerInstance.postMessage(10); 818 workerInstance.terminate(); 819 workerInstance.onmessage = (e) => { 820 } 821 workerInstance.onexit = (code) => { 822 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 823 setTimeout(() => { 824 try { 825 workerInstance.onAllErrors = (e: ErrorEvent) => { 826 console.log(`${caseName} main onexit code: ` + JSON.stringify(e)); 827 } 828 bool = true; 829 } catch (err) { 830 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 831 expect(err.code).assertEqual(10200004) 832 bool = true; 833 } 834 }) 835 } 836 while (!bool) { 837 await Sleep(300) 838 } 839 done(); 840 }); 841 /** 842 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2900 843 * @tc.name : testThreadWorkerErrorCode0029 844 * @tc.desc : ThreadWorker9+ onmessageerror9+ 10200004 845 * @tc.size : MediumTest 846 * @tc.type : Function 847 * @tc.level : Level 1 848 */ 849 it('testThreadWorkerErrorCode0029', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 850 const caseName = "testThreadWorkerErrorCode0029"; 851 try { 852 let bool = false; 853 const workerInstance: worker.ThreadWorker = 854 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 855 priority: ThreadWorkerPriority.HIGH 856 }); 857 workerInstance.postMessage(10); 858 workerInstance.onmessage = (e) => { 859 workerInstance.terminate(); 860 } 861 workerInstance.onexit = (code) => { 862 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 863 setTimeout(() => { 864 try { 865 workerInstance.onmessageerror = (err: MessageEvents) => { 866 console.log('onmessageerror'); 867 } 868 bool = true; 869 } catch (err) { 870 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 871 expect(err.code).assertEqual(10200004) 872 bool = true 873 } 874 }) 875 } 876 while (!bool) { 877 await Sleep(200) 878 } 879 done(); 880 } catch (err) { 881 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 882 expect(err.code).assertEqual(10200004) 883 done(); 884 } 885 }); 886 /** 887 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_3000 888 * @tc.name : testThreadWorkerErrorCode0030 889 * @tc.desc : ThreadWorker9+ postMessage9+ 10200004 890 * @tc.size : MediumTest 891 * @tc.type : Function 892 * @tc.level : Level 1 893 */ 894 it('testThreadWorkerErrorCode0030', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 895 const caseName = "testThreadWorkerErrorCode0030"; 896 let bool = false; 897 const workerInstance: worker.ThreadWorker = 898 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 899 priority: ThreadWorkerPriority.HIGH 900 }); 901 workerInstance.terminate(); 902 workerInstance.onmessage = (e) => { 903 } 904 workerInstance.onexit = (code) => { 905 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 906 setTimeout(() => { 907 try { 908 workerInstance.postMessage(10); 909 } catch (err) { 910 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 911 expect(err.code).assertEqual(10200004) 912 bool = true; 913 } 914 }) 915 } 916 while (!bool) { 917 await Sleep(200) 918 } 919 done(); 920 }); 921 /** 922 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_3100 923 * @tc.name : testThreadWorkerErrorCode0031 924 * @tc.desc : ThreadWorker9+ postMessage9+ 10200004 925 * @tc.size : MediumTest 926 * @tc.type : Function 927 * @tc.level : Level 1 928 */ 929 it('testThreadWorkerErrorCode0031', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 930 const caseName = "testThreadWorkerErrorCode0031"; 931 let bool = false; 932 const workerInstance: worker.ThreadWorker = 933 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 934 priority: ThreadWorkerPriority.HIGH 935 }); 936 workerInstance.terminate(); 937 workerInstance.onmessage = (e) => { 938 } 939 workerInstance.onexit = (code) => { 940 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 941 setTimeout(() => { 942 try { 943 workerInstance.postMessage(10); 944 } catch (err) { 945 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 946 expect(err.code).assertEqual(10200004) 947 bool = true; 948 } 949 }) 950 } 951 while (!bool) { 952 await Sleep(200) 953 } 954 done(); 955 }); 956 /** 957 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_3200 958 * @tc.name : testThreadWorkerErrorCode0032 959 * @tc.desc : ThreadWorker9+ postMessageWithSharedSendable12+ 10200004 960 * @tc.size : MediumTest 961 * @tc.type : Function 962 * @tc.level : Level 1 963 */ 964 it('testThreadWorkerErrorCode0032', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 965 const caseName = "testThreadWorkerErrorCode0032"; 966 let bool = false; 967 const workerInstance: worker.ThreadWorker = 968 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 969 priority: ThreadWorkerPriority.HIGH 970 }); 971 workerInstance.terminate(); 972 let object: SendableObject = new SendableObject(); 973 workerInstance.onmessage = (e) => { 974 } 975 workerInstance.onexit = (code) => { 976 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 977 setTimeout(() => { 978 try { 979 workerInstance.postMessageWithSharedSendable(object); 980 } catch (err) { 981 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 982 expect(err.code).assertEqual(10200004) 983 bool = true; 984 } 985 }) 986 } 987 while (!bool) { 988 await Sleep(200) 989 } 990 done(); 991 }); 992 /** 993 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_3300 994 * @tc.name : testThreadWorkerErrorCode0033 995 * @tc.desc : ThreadWorker9+ postMessageWithSharedSendable12+ 10200006 996 * @tc.size : MediumTest 997 * @tc.type : Function 998 * @tc.level : Level 1 999 */ 1000 it('testThreadWorkerErrorCode0033', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1001 const caseName = "testThreadWorkerErrorCode0033"; 1002 try { 1003 let bool = false; 1004 const workerInstance: worker.ThreadWorker = 1005 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1006 priority: ThreadWorkerPriority.HIGH 1007 }); 1008 let task: taskpool.Task = new taskpool.Task(printNum, 10) 1009 workerInstance.postMessageWithSharedSendable(task); 1010 workerInstance.onmessage = (e) => { 1011 workerInstance.terminate(); 1012 } 1013 workerInstance.onexit = (code) => { 1014 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1015 bool = true 1016 } 1017 workerInstance.onerror = (err: ErrorEvent) => { 1018 console.log(`${caseName} main onerror code: ` + JSON.stringify(err)); 1019 } 1020 while (!bool) { 1021 await Sleep(500) 1022 } 1023 expect().assertFail(); 1024 done(); 1025 } catch (err) { 1026 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1027 expect(err.code).assertEqual(10200006) 1028 done(); 1029 } 1030 }); 1031 /** 1032 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_3400 1033 * @tc.name : testThreadWorkerErrorCode0034 1034 * @tc.desc : ThreadWorker9+ on9+ 10200004 1035 * @tc.size : MediumTest 1036 * @tc.type : Function 1037 * @tc.level : Level 1 1038 */ 1039 it('testThreadWorkerErrorCode0034', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1040 const caseName = "testThreadWorkerErrorCode0034"; 1041 try { 1042 let bool = false; 1043 const workerInstance: worker.ThreadWorker = 1044 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1045 priority: ThreadWorkerPriority.HIGH 1046 }); 1047 workerInstance.postMessage(10); 1048 workerInstance.onmessage = (e) => { 1049 workerInstance.terminate(); 1050 } 1051 workerInstance.onexit = (code) => { 1052 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1053 setTimeout(() => { 1054 try { 1055 workerInstance.on("workerInstance_on", () => { 1056 console.log('workerInstance_on callback'); 1057 }) 1058 } catch (err) { 1059 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1060 expect(err.code).assertEqual(10200004) 1061 bool = true; 1062 } 1063 }) 1064 } 1065 while (!bool) { 1066 await Sleep(200) 1067 } 1068 done(); 1069 } catch (err) { 1070 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1071 expect(err.code).assertEqual(10200004) 1072 done(); 1073 } 1074 }); 1075 1076 /** 1077 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_3600 1078 * @tc.name : testThreadWorkerErrorCode0036 1079 * @tc.desc : ThreadWorker9+ once9+ 10200004 1080 * @tc.size : MediumTest 1081 * @tc.type : Function 1082 * @tc.level : Level 1 1083 */ 1084 it('testThreadWorkerErrorCode0036', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1085 const caseName = "testThreadWorkerErrorCode0036"; 1086 try { 1087 let bool = false; 1088 const workerInstance: worker.ThreadWorker = 1089 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1090 priority: ThreadWorkerPriority.HIGH 1091 }); 1092 workerInstance.postMessage(10); 1093 workerInstance.onmessage = (e) => { 1094 workerInstance.terminate(); 1095 } 1096 workerInstance.onexit = (code) => { 1097 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1098 setTimeout(() => { 1099 try { 1100 workerInstance.once("workerInstance_once", () => { 1101 console.log('workerInstance_once callback'); 1102 }) 1103 } catch (err) { 1104 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1105 expect(err.code).assertEqual(10200004) 1106 bool = true; 1107 } 1108 }) 1109 } 1110 while (!bool) { 1111 await Sleep(200) 1112 } 1113 done(); 1114 } catch (err) { 1115 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1116 expect(err.code).assertEqual(10200004) 1117 done(); 1118 } 1119 }); 1120 1121 /** 1122 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_3800 1123 * @tc.name : testThreadWorkerErrorCode0038 10200004 1124 * @tc.desc : ThreadWorker9+ off9+ 1125 * @tc.size : MediumTest 1126 * @tc.type : Function 1127 * @tc.level : Level 1 1128 */ 1129 it('testThreadWorkerErrorCode0038', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1130 const caseName = "testThreadWorkerErrorCode0038"; 1131 try { 1132 let bool = false; 1133 const workerInstance: worker.ThreadWorker = 1134 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1135 priority: ThreadWorkerPriority.HIGH 1136 }); 1137 workerInstance.postMessage(10); 1138 workerInstance.onmessage = (e) => { 1139 workerInstance.terminate(); 1140 } 1141 workerInstance.on("workerInstance_on", () => { 1142 console.log('workerInstance_on callback'); 1143 }) 1144 workerInstance.onexit = (code) => { 1145 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1146 setTimeout(() => { 1147 try { 1148 workerInstance.off("workerInstance_on") 1149 } catch (err) { 1150 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1151 expect(err.code).assertEqual(10200004) 1152 bool = true; 1153 } 1154 }) 1155 } 1156 while (!bool) { 1157 await Sleep(200) 1158 } 1159 done(); 1160 } catch (err) { 1161 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1162 expect(err.code).assertEqual(10200004) 1163 done(); 1164 } 1165 }); 1166 1167 /** 1168 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4000 1169 * @tc.name : testThreadWorkerErrorCode0040 1170 * @tc.desc : ThreadWorker9+ addEventListener9+ 10200004 1171 * @tc.size : MediumTest 1172 * @tc.type : Function 1173 * @tc.level : Level 1 1174 */ 1175 it('testThreadWorkerErrorCode0040', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1176 const caseName = "testThreadWorkerErrorCode0040"; 1177 try { 1178 let bool = false; 1179 const workerInstance: worker.ThreadWorker = 1180 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1181 priority: ThreadWorkerPriority.HIGH 1182 }); 1183 workerInstance.postMessage(10); 1184 workerInstance.onmessage = (e) => { 1185 workerInstance.terminate(); 1186 } 1187 workerInstance.onexit = (code) => { 1188 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1189 setTimeout(() => { 1190 try { 1191 workerInstance.addEventListener("workerInstance_addEventListener", () => { 1192 console.log('workerInstance_addEventListener callback'); 1193 }) 1194 } catch (err) { 1195 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1196 expect(err.code).assertEqual(10200004) 1197 bool = true; 1198 } 1199 }) 1200 } 1201 while (!bool) { 1202 await Sleep(200) 1203 } 1204 done(); 1205 } catch (err) { 1206 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1207 expect(err.code).assertEqual(10200004) 1208 done(); 1209 } 1210 }); 1211 1212 /** 1213 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4200 1214 * @tc.name : testThreadWorkerErrorCode0042 1215 * @tc.desc : ThreadWorker9+ dispatchEvent9+ 10200004 1216 * @tc.size : MediumTest 1217 * @tc.type : Function 1218 * @tc.level : Level 1 1219 */ 1220 it('testThreadWorkerErrorCode0042', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1221 const caseName = "testThreadWorkerErrorCode0042"; 1222 let bool = false; 1223 const workerInstance: worker.ThreadWorker = 1224 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1225 priority: ThreadWorkerPriority.HIGH 1226 }); 1227 workerInstance.postMessage(10); 1228 workerInstance.onmessage = (e) => { 1229 workerInstance.terminate(); 1230 } 1231 workerInstance.onexit = (code) => { 1232 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1233 setTimeout(() => { 1234 try { 1235 workerInstance.dispatchEvent({ 1236 type: "eventType", timeStamp: 0 1237 }); 1238 } catch (err) { 1239 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1240 expect(err.code).assertEqual(10200004) 1241 bool = true; 1242 } 1243 }) 1244 } 1245 while (!bool) { 1246 await Sleep(200) 1247 } 1248 done(); 1249 }); 1250 /** 1251 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4300 1252 * @tc.name : testThreadWorkerErrorCode0043 1253 * @tc.desc : ThreadWorker9+ removeEventListener9+ 10200004 1254 * @tc.size : MediumTest 1255 * @tc.type : Function 1256 * @tc.level : Level 1 1257 */ 1258 it('testThreadWorkerErrorCode0043', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1259 const caseName = "testThreadWorkerErrorCode0043"; 1260 let bool = false; 1261 const workerInstance: worker.ThreadWorker = 1262 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1263 priority: ThreadWorkerPriority.HIGH 1264 }); 1265 workerInstance.postMessage(10); 1266 workerInstance.onmessage = (e) => { 1267 workerInstance.terminate(); 1268 } 1269 workerInstance.on("workerInstance_on", () => { 1270 console.log('workerInstance_on callback'); 1271 }) 1272 workerInstance.onexit = (code) => { 1273 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1274 setTimeout(() => { 1275 try { 1276 workerInstance.removeEventListener("workerInstance_on") 1277 } catch (err) { 1278 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1279 expect(err.code).assertEqual(10200004) 1280 bool = true; 1281 } 1282 }) 1283 } 1284 while (!bool) { 1285 await Sleep(200) 1286 } 1287 done(); 1288 }); 1289 1290 /** 1291 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4500 1292 * @tc.name : testThreadWorkerErrorCode0045 1293 * @tc.desc : ThreadWorker9+ registerGlobalCallObject9+ 10200004 1294 * @tc.size : MediumTest 1295 * @tc.type : Function 1296 * @tc.level : Level 1 1297 */ 1298 it('testThreadWorkerErrorCode0045', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1299 const caseName = "testThreadWorkerErrorCode0045"; 1300 let bool = false; 1301 const workerInstance: worker.ThreadWorker = 1302 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1303 priority: ThreadWorkerPriority.HIGH 1304 }); 1305 let registerObj = new TestObj(); 1306 workerInstance.postMessage(10); 1307 workerInstance.terminate(); 1308 workerInstance.onmessage = (e) => { 1309 } 1310 workerInstance.onexit = (code) => { 1311 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1312 setTimeout(() => { 1313 try { 1314 workerInstance.registerGlobalCallObject("myObj", registerObj); 1315 } catch (err) { 1316 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1317 expect(err.code).assertEqual(10200004); 1318 bool = true; 1319 } 1320 }) 1321 } 1322 while (!bool) { 1323 await Sleep(200) 1324 } 1325 done(); 1326 }); 1327 /** 1328 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4600 1329 * @tc.name : testThreadWorkerErrorCode0046 1330 * @tc.desc : ThreadWorker9+ unregisterGlobalCallObject9+ 10200004 1331 * @tc.size : MediumTest 1332 * @tc.type : Function 1333 * @tc.level : Level 1 1334 */ 1335 it('testThreadWorkerErrorCode0046', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1336 const caseName = "testThreadWorkerErrorCode0046"; 1337 let bool = false; 1338 const workerInstance: worker.ThreadWorker = 1339 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1340 priority: ThreadWorkerPriority.HIGH 1341 }); 1342 let registerObj = new TestObj(); 1343 workerInstance.registerGlobalCallObject("myObj", registerObj); 1344 workerInstance.postMessage(10); 1345 workerInstance.terminate(); 1346 workerInstance.onmessage = (e) => { 1347 } 1348 workerInstance.onexit = (code) => { 1349 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1350 setTimeout(() => { 1351 try { 1352 workerInstance.unregisterGlobalCallObject("myObj"); 1353 } catch (err) { 1354 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1355 expect(err.code).assertEqual(10200004) 1356 bool = true; 1357 } 1358 }) 1359 } 1360 while (!bool) { 1361 await Sleep(500) 1362 } 1363 done(); 1364 }); 1365 /** 1366 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_2400 1367 * @tc.name : testThreadWorkerErrorCode0024 1368 * @tc.desc : ThreadWorker9+ constructor9+ 10200003 1369 * @tc.size : MediumTest 1370 * @tc.type : Function 1371 * @tc.level : Level 1 1372 */ 1373 it('testThreadWorkerErrorCode0024', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1374 const caseName = "testThreadWorkerErrorCode0024"; 1375 const workerInstancesONE: worker.ThreadWorker[] = []; 1376 try { 1377 for (let i: number = 0; i < 64; i++) { 1378 workerInstancesONE.push(new worker.ThreadWorker('../../workers/ErrorCode/WorkerData', 1379 { 1380 priority: ThreadWorkerPriority.HIGH 1381 })); 1382 } 1383 const workerInstance: worker.ThreadWorker = 1384 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1385 priority: ThreadWorkerPriority.HIGH 1386 }); 1387 } catch (err) { 1388 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1389 expect(err.code).assertEqual(10200003) 1390 } 1391 let count = 0 1392 for (let i: number = 0; i < 64; i++) { 1393 try { 1394 let worker: worker.ThreadWorker = workerInstancesONE[i] 1395 worker.terminate() 1396 worker.onexit = (code) => { 1397 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1398 count++ 1399 } 1400 } catch (e) { 1401 console.log(`${caseName} main catch: ` + JSON.stringify(e)); 1402 count++ 1403 } 1404 } 1405 while (count < 64) { 1406 await Sleep(100) 1407 } 1408 done(); 1409 1410 }); 1411 /** 1412 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4301 1413 * @tc.name : testThreadWorkerErrorCode0043_2 1414 * @tc.desc : ThreadWorker9+ removeEventListener9+ 10200004 1415 * @tc.size : MediumTest 1416 * @tc.type : Function 1417 * @tc.level : Level 1 1418 */ 1419 it('testThreadWorkerErrorCode0043_2', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, 1420 async (done: Function) => { 1421 const caseName = "testThreadWorkerErrorCode0043_2"; 1422 let bool = false; 1423 const workerInstance: worker.ThreadWorker = 1424 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1425 priority: ThreadWorkerPriority.HIGH 1426 }); 1427 workerInstance.postMessage(10); 1428 workerInstance.onmessage = (e) => { 1429 workerInstance.terminate(); 1430 } 1431 workerInstance.on("workerInstance_on", () => { 1432 console.log('workerInstance_on callback'); 1433 }) 1434 workerInstance.onexit = (code) => { 1435 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1436 setTimeout(() => { 1437 try { 1438 workerInstance.removeEventListener("workerInstance_on", () => { 1439 console.log('workerInstance_on removeEventListener callback'); 1440 }) 1441 } catch (err) { 1442 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1443 expect(err.code).assertEqual(10200004) 1444 bool = true; 1445 } 1446 }) 1447 } 1448 while (!bool) { 1449 await Sleep(200) 1450 } 1451 done(); 1452 }); 1453 /** 1454 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_1000 1455 * @tc.name : testThreadWorkerErrorCode0010 1456 * @tc.desc : ThreadWorkerGlobalScope onmessageerror9+ 10200004 1457 * @tc.size : MediumTest 1458 * @tc.type : Function 1459 * @tc.level : Level 1 1460 */ 1461 it('testThreadWorkerErrorCode0010', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1462 const caseName = "testThreadWorkerErrorCode0010"; 1463 try { 1464 let bool = false; 1465 const workerInstance: worker.ThreadWorker = 1466 new worker.ThreadWorker("../../workers/ErrorCode/WorkerOnmessageError1", { 1467 priority: ThreadWorkerPriority.HIGH 1468 }); 1469 workerInstance.postMessage('aa'); 1470 workerInstance.onmessage = (e) => { 1471 } 1472 workerInstance.onexit = (code) => { 1473 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1474 bool = true 1475 } 1476 while (!bool) { 1477 await Sleep(200) 1478 console.log(`${caseName} main while code: ` + JSON.stringify(bool)); 1479 } 1480 done(); 1481 } catch (err) { 1482 console.error(`${caseName} failed, error: ${err.code} =>${err.message}`); 1483 expect(err.code).assertEqual(10200004) 1484 done(); 1485 } 1486 }); 1487 1488 1489 /** 1490 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4700 1491 * @tc.name : testThreadWorkerErrorCode0047 1492 * @tc.desc : ThreadWorker9+ 1493 * @tc.size : MediumTest 1494 * @tc.type : Function 1495 * @tc.level : Level 1 1496 */ 1497 it('testThreadWorkerErrorCode0047', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1498 const caseName = "testThreadWorkerErrorCode0047"; 1499 let bool = false; 1500 const workerInstance: worker.ThreadWorker = 1501 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1502 priority: ThreadWorkerPriority.HIGH 1503 }); 1504 let buffer = new ArrayBuffer(1) 1505 workerInstance.postMessage(buffer, {transfer: [buffer]}); 1506 workerInstance.onmessage = (e) => { 1507 workerInstance.terminate(); 1508 } 1509 workerInstance.onexit = (code) => { 1510 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1511 bool = true; 1512 } 1513 while (!bool) { 1514 await Sleep(100) 1515 } 1516 done(); 1517 }); 1518 /** 1519 * @tc.number : SUB_RUNTIME_LANGUAGE_BACKEND_WORKER_Error_Code_4800 1520 * @tc.name : testThreadWorkerErrorCode0048 1521 * @tc.desc : ThreadWorker9+ 1522 * @tc.size : MediumTest 1523 * @tc.type : Function 1524 * @tc.level : Level 1 1525 */ 1526 it('testThreadWorkerErrorCode0048', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL1, async (done: Function) => { 1527 const caseName = "testThreadWorkerErrorCode0048"; 1528 let bool = false; 1529 const workerInstance: worker.ThreadWorker = 1530 new worker.ThreadWorker("../../workers/ErrorCode/WorkerData", { 1531 priority: ThreadWorkerPriority.HIGH 1532 }); 1533 let buffer = new ArrayBuffer(1) 1534 workerInstance.postMessage(buffer, {}); 1535 workerInstance.onmessage = (e) => { 1536 workerInstance.terminate(); 1537 } 1538 workerInstance.onexit = (code) => { 1539 console.log(`${caseName} main onexit code: ` + JSON.stringify(code)); 1540 bool = true; 1541 } 1542 while (!bool) { 1543 await Sleep(100) 1544 } 1545 done(); 1546 }); 1547 1548 }) 1549}