1/* 2 * Copyright (C) 2021 Huawei Device 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 */ 15import image from "@ohos.multimedia.image"; 16import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium"; 17 18export default function ImageReceiver() { 19 describe("ImageReceiver", function () { 20 let globalreceiver; 21 let globalImg; 22 const WIDTH = 8192; 23 const HEIGHT = 8; 24 const CAPACITY = 8; 25 const RGBA = 12; 26 const Jpg_Stride = 1; 27 const DEVICE_CODE = 801; 28 const { JPEG: FORMATJPEG } = image.ImageFormat; 29 const { JPEG } = image.ComponentType; 30 beforeAll(async function () { 31 console.info("beforeAll case"); 32 }); 33 34 beforeEach(function () { 35 console.info("beforeEach case"); 36 }); 37 38 afterEach(async function () { 39 if (globalImg != undefined) { 40 console.info("globalImg release start"); 41 try { 42 await globalImg.release(); 43 } catch (error) { 44 console.info("globalImg release fail"); 45 } 46 } 47 if (globalreceiver != undefined) { 48 console.info("globalreceiver release start"); 49 try { 50 await globalreceiver.release(); 51 } catch (error) { 52 console.info("globalreceiver release fail"); 53 } 54 } 55 console.info("afterEach case"); 56 }); 57 58 afterAll(async function () { 59 console.info("afterAll case"); 60 }); 61 62 async function sleep(times = 200) { 63 await new Promise((res) => 64 setTimeout(() => { 65 res(); 66 }, times) 67 ); 68 } 69 70 async function createRecriver(done, testNum, wid, hei, fmt, cap) { 71 try { 72 image.createImageReceiver(wid, hei, fmt, cap); 73 expect(false).assertTrue(); 74 done(); 75 return; 76 } catch (error) { 77 expect(error.code == 1).assertTrue(); 78 console.info(`${testNum} err message` + error); 79 done(); 80 return; 81 } 82 } 83 84 async function getComponentProErr(done, testNum, format, param) { 85 var receiver = image.createImageReceiver(WIDTH, HEIGHT, format, CAPACITY); 86 let once = false; 87 if (receiver == undefined) { 88 expect(false).assertTrue(); 89 done(); 90 return; 91 } else { 92 globalreceiver = receiver; 93 var error = receiver.checkDeviceTest; 94 if (DEVICE_CODE == error) { 95 expect(error == DEVICE_CODE).assertTrue(); 96 done(); 97 return; 98 } 99 receiver.on("imageArrival", () => { 100 if (once) { 101 return; 102 } 103 once = true; 104 receiver.readLatestImage(async (err, img) => { 105 if (img == undefined) { 106 expect(false).assertTrue(); 107 done(); 108 return; 109 } else { 110 globalImg = img; 111 expect(img.size.width == WIDTH).assertTrue(); 112 expect(img.size.height == HEIGHT).assertTrue(); 113 console.log(`${testNum} img.format: ${img.format}`) 114 expect(img.clipRect.size.width == WIDTH).assertTrue(); 115 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 116 expect(img.clipRect.x == 0).assertTrue(); 117 expect(img.clipRect.y == 0).assertTrue(); 118 try { 119 await img.getComponent(param); 120 expect(false).assertTrue(); 121 done(); 122 return; 123 } catch (error) { 124 expect(error.code == 1).assertTrue(); 125 console.log(`${testNum} error msg: ` + error); 126 done(); 127 return; 128 } 129 } 130 }); 131 expect(true).assertTrue(); 132 }); 133 var dummy = receiver.test; 134 } 135 } 136 137 async function getComponentCbErr(done, testNum, format, param) { 138 var receiver = image.createImageReceiver(WIDTH, HEIGHT, format, CAPACITY); 139 let once = false; 140 if (receiver == undefined) { 141 expect(false).assertTrue(); 142 done(); 143 return; 144 } else { 145 globalreceiver = receiver; 146 var error = receiver.checkDeviceTest; 147 if (DEVICE_CODE == error) { 148 expect(error == DEVICE_CODE).assertTrue(); 149 done(); 150 return; 151 } 152 receiver.on("imageArrival", () => { 153 if (once) { 154 return; 155 } 156 once = true; 157 receiver.readLatestImage(async (err, img) => { 158 if (img == undefined) { 159 expect(false).assertTrue(); 160 done(); 161 return; 162 } else { 163 globalImg = img; 164 expect(img.size.width == WIDTH).assertTrue(); 165 expect(img.size.height == HEIGHT).assertTrue(); 166 console.log(`${testNum} img.format: ${img.format}`) 167 expect(img.clipRect.size.width == WIDTH).assertTrue(); 168 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 169 expect(img.clipRect.x == 0).assertTrue(); 170 expect(img.clipRect.y == 0).assertTrue(); 171 try { 172 img.getComponent(param, (err, component) => { 173 expect(false).assertTrue(); 174 done(); 175 return; 176 }); 177 } catch (error) { 178 expect(error.code == 1).assertTrue(); 179 console.log(`${testNum} error msg: ` + error); 180 done(); 181 return; 182 } 183 } 184 }); 185 expect(true).assertTrue(); 186 }); 187 var dummy = receiver.test; 188 } 189 } 190 191 async function getComponentPromise(done, testNum, format, param, checkFormat, checkStride) { 192 var receiver = image.createImageReceiver(WIDTH, HEIGHT, format, CAPACITY); 193 let once = false; 194 if (receiver == undefined) { 195 expect(false).assertTrue(); 196 return; 197 } 198 globalreceiver = receiver; 199 var error = receiver.checkDeviceTest; 200 if (DEVICE_CODE == error) { 201 expect(error == DEVICE_CODE).assertTrue(); 202 done(); 203 return; 204 } 205 receiver.on("imageArrival", () => { 206 if (once) { 207 return; 208 } 209 once = true; 210 receiver.readLatestImage((err, img) => { 211 if (err) { 212 expect(false).assertTrue(); 213 done(); 214 return; 215 } else { 216 globalImg = img; 217 expect(img.size.width == WIDTH).assertTrue(); 218 expect(img.size.height == HEIGHT).assertTrue(); 219 checkFormat(img.format); 220 expect(img.clipRect.size.width == WIDTH).assertTrue(); 221 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 222 expect(img.clipRect.x == 0).assertTrue(); 223 expect(img.clipRect.y == 0).assertTrue(); 224 img.getComponent(param) 225 .then((component) => { 226 if (component == undefined) { 227 expect(false).assertTrue(); 228 done(); 229 return; 230 } 231 expect(component.componentType == param).assertTrue(); 232 expect(component.byteBuffer != undefined).assertTrue(); 233 checkStride(component.rowStride, component.pixelStride); 234 done(); 235 return; 236 }) 237 .catch((error) => { 238 console.log(`${testNum} error:` + error); 239 expect(false).assertTrue(); 240 done(); 241 return; 242 }); 243 } 244 }); 245 expect(true).assertTrue(); 246 }); 247 var dummy = receiver.test; 248 } 249 250 async function getComponentCb(done, testNum, format, param, checkFormat, checkStride) { 251 var receiver = image.createImageReceiver(WIDTH, HEIGHT, format, CAPACITY); 252 let once = false; 253 if (receiver == undefined) { 254 expect(false).assertTrue(); 255 done(); 256 return; 257 } 258 var error = receiver.checkDeviceTest; 259 if (DEVICE_CODE == error) { 260 expect(error == DEVICE_CODE).assertTrue(); 261 done(); 262 return; 263 } 264 receiver.on("imageArrival", () => { 265 if (once) { 266 return; 267 } 268 once = true; 269 receiver.readLatestImage((err, img) => { 270 if (err) { 271 expect(false).assertTrue(); 272 done(); 273 return; 274 } else { 275 globalImg = img; 276 expect(img.size.width == WIDTH).assertTrue(); 277 expect(img.size.height == HEIGHT).assertTrue(); 278 checkFormat(img.format); 279 expect(img.clipRect.size.width == WIDTH).assertTrue(); 280 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 281 expect(img.clipRect.x == 0).assertTrue(); 282 expect(img.clipRect.y == 0).assertTrue(); 283 img.getComponent(param, (err, component) => { 284 if (err) { 285 expect(false).assertTrue(); 286 console.log(`${testNum} geterror: ` + err); 287 done(); 288 return; 289 } else { 290 expect(component != undefined).assertTrue(); 291 expect(component.componentType == param).assertTrue(); 292 expect(component.byteBuffer != undefined).assertTrue(); 293 checkStride(component.rowStride, component.pixelStride); 294 done(); 295 return; 296 } 297 }); 298 } 299 }); 300 expect(true).assertTrue(); 301 }); 302 var dummy = receiver.test; 303 } 304 305 async function onErr(done, testNum, param) { 306 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 307 expect(receiver != undefined).assertTrue(); 308 if (receiver == undefined) { 309 expect(false).assertTrue(); 310 done(); 311 return; 312 } else { 313 globalreceiver = receiver; 314 try { 315 var error = receiver.checkDeviceTest; 316 if (DEVICE_CODE == error) { 317 expect(error == DEVICE_CODE).assertTrue(); 318 done(); 319 return; 320 } 321 receiver.on(param, () => { 322 expect(false).assertTrue(); 323 }); 324 } catch (error) { 325 expect(error.code == 1).assertTrue(); 326 console.log(`${testNum} error msg: ` + error); 327 done(); 328 return; 329 } 330 var dummy = receiver.test; 331 } 332 } 333 334 function isString(value) { 335 return typeof value === "string"; 336 } 337 338 /** 339 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0100 340 * @tc.name : createImageReceiver 341 * @tc.desc : 1.set width,height,format,capacity 342 * 2.create ImageReceiver 343 * 3.return ImageReceiver not empty 344 * @tc.size : MEDIUM 345 * @tc.type : Functional 346 * @tc.level : Level 0 347 */ 348 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0100", 0, async function (done) { 349 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 350 if (receiver == undefined) { 351 expect(false).assertTrue(); 352 console.info("receiver_001 undefined"); 353 done(); 354 return; 355 } else { 356 globalreceiver = receiver; 357 expect(receiver.size.width == WIDTH).assertTrue(); 358 expect(receiver.size.height == HEIGHT).assertTrue(); 359 expect(receiver.capacity == CAPACITY).assertTrue(); 360 expect(receiver.format == FORMATJPEG).assertTrue(); 361 done(); 362 return; 363 } 364 }); 365 366 /** 367 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0200 368 * @tc.name : createImageReceiver 369 * @tc.desc : 1.set width,height,format,capacity 370 * 2.create ImageReceiver 371 * 3.return ImageReceiver empty 372 * @tc.size : MEDIUM 373 * @tc.type : Functional 374 * @tc.level : Level 0 375 */ 376 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0200", 0, async function (done) { 377 createRecriver( 378 done, 379 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0200", 380 WIDTH, 381 HEIGHT, 382 FORMATJPEG, 383 "hd!" 384 ); 385 }); 386 387 /** 388 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0100 389 * @tc.name : createImageReceiver-wrong format 390 * @tc.desc : 1.set width,height,format,capacity 391 * 2.create ImageReceiver 392 * 3.return ImageReceiver empty 393 * @tc.size : MEDIUM 394 * @tc.type : Functional 395 * @tc.level : Level 0 396 */ 397 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0100", 0, async function (done) { 398 createRecriver( 399 done, 400 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0100", 401 WIDTH, 402 HEIGHT, 403 null, 404 CAPACITY 405 ); 406 }); 407 408 /** 409 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0200 410 * @tc.name : createImageReceiver-wrong height 411 * @tc.desc : 1.set width,height,format,capacity 412 * 2.create ImageReceiver 413 * 3.return ImageReceiver empty 414 * @tc.size : MEDIUM 415 * @tc.type : Functional 416 * @tc.level : Level 0 417 */ 418 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0200", 0, async function (done) { 419 createRecriver( 420 done, 421 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0200", 422 WIDTH, 423 null, 424 FORMATJPEG, 425 CAPACITY 426 ); 427 }); 428 429 /** 430 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0300 431 * @tc.name : createImageReceiver-wrong width 432 * @tc.desc : 1.set width,height,format,capacity 433 * 2.create ImageReceiver 434 * 3.return ImageReceiver empty 435 * @tc.size : MEDIUM 436 * @tc.type : Functional 437 * @tc.level : Level 0 438 */ 439 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0300", 0, async function (done) { 440 createRecriver( 441 done, 442 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0300", 443 null, 444 HEIGHT, 445 FORMATJPEG, 446 CAPACITY 447 ); 448 }); 449 450 /** 451 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0400 452 * @tc.name : createImageReceiver-wrong capacity 453 * @tc.desc : 1.set width,height,format,capacity 454 * 2.create ImageReceiver 455 * 3.return ImageReceiver empty 456 * @tc.size : MEDIUM 457 * @tc.type : Functional 458 * @tc.level : Level 0 459 */ 460 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0400", 0, async function (done) { 461 createRecriver( 462 done, 463 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0400", 464 WIDTH, 465 HEIGHT, 466 FORMATJPEG, 467 null 468 ); 469 }); 470 471 /** 472 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0500 473 * @tc.name : createImageReceiver-wrong width 474 * @tc.desc : 1.set width,height,format,capacity 475 * 2.create ImageReceiver 476 * 3.return ImageReceiver empty 477 * @tc.size : MEDIUM 478 * @tc.type : Functional 479 * @tc.level : Level 0 480 */ 481 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0500", 0, async function (done) { 482 createRecriver( 483 done, 484 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0500", 485 false, 486 HEIGHT, 487 FORMATJPEG, 488 CAPACITY 489 ); 490 }); 491 492 /** 493 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0600 494 * @tc.name : createImageReceiver- wrong width 495 * @tc.desc : 1.set width,height,format,capacity 496 * 2.create ImageReceiver 497 * 3.return ImageReceiver empty 498 * @tc.size : MEDIUM 499 * @tc.type : Functional 500 * @tc.level : Level 0 501 */ 502 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0600", 0, async function (done) { 503 createRecriver( 504 done, 505 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0600", 506 { a: 10 }, 507 HEIGHT, 508 FORMATJPEG, 509 CAPACITY 510 ); 511 }); 512 513 /** 514 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0300 515 * @tc.name : createImageReceiver 516 * @tc.desc : 1.set width,height,format,capacity 517 * 2.create ImageReceiver 518 * 3.return ImageReceiver empty 519 * @tc.size : MEDIUM 520 * @tc.type : Functional 521 * @tc.level : Level 0 522 */ 523 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0300", 0, async function (done) { 524 createRecriver( 525 done, 526 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0300", 527 WIDTH, 528 false, 529 FORMATJPEG, 530 CAPACITY 531 ); 532 }); 533 534 /** 535 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0700 536 * @tc.name : createImageReceiver- wrong format 537 * @tc.desc : 1.set width,height,format,capacity 538 * 2.create ImageReceiver 539 * 3.return ImageReceiver empty 540 * @tc.size : MEDIUM 541 * @tc.type : Functional 542 * @tc.level : Level 0 543 */ 544 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0700", 0, async function (done) { 545 createRecriver( 546 done, 547 "SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0700", 548 WIDTH, 549 HEIGHT, 550 "form.", 551 CAPACITY 552 ); 553 }); 554 555 /** 556 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0400 557 * @tc.name : createImageReceiver 558 * @tc.desc : 1.set width,height,format,capacity 559 * 2.create ImageReceiver 560 * 3.return ImageReceiver not empty 561 * @tc.size : MEDIUM 562 * @tc.type : Functional 563 * @tc.level : Level 0 564 */ 565 it("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0400", 0, async function (done) { 566 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 567 if (receiver == undefined) { 568 expect(false).assertTrue(); 569 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0400 undefined"); 570 done(); 571 return; 572 } else { 573 globalreceiver = receiver; 574 expect(receiver.size.width == WIDTH).assertTrue(); 575 expect(receiver.size.height == HEIGHT).assertTrue(); 576 expect(receiver.capacity == CAPACITY).assertTrue(); 577 expect(receiver.format == FORMATJPEG).assertTrue(); 578 done(); 579 return; 580 } 581 }); 582 583 /** 584 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100 585 * @tc.name : getReceivingSurfaceId-promise 586 * @tc.desc : 1.create ImageReceiver 587 * 2.call getReceivingSurfaceId 588 * 3.return SurfaceId 589 * @tc.size : MEDIUM 590 * @tc.type : Functional 591 * @tc.level : Level 0 592 */ 593 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100", 0, async function (done) { 594 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 595 if (receiver != undefined) { 596 globalreceiver = receiver; 597 receiver 598 .getReceivingSurfaceId() 599 .then((id) => { 600 console.info( 601 "SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100 getReceivingSurfaceId [" + 602 id + 603 "]" 604 ); 605 expect(isString(id)).assertTrue(); 606 done(); 607 return; 608 }) 609 .catch((error) => { 610 console.log("SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100 error: " + error); 611 expect(false).assertTrue(); 612 done(); 613 return; 614 }); 615 } else { 616 expect(false).assertTrue(); 617 done(); 618 return; 619 } 620 }); 621 622 /** 623 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100 624 * @tc.name : getReceivingSurfaceId-callback 625 * @tc.desc : 1.create ImageReceiver 626 * 2.call getReceivingSurfaceId 627 * 3.return SurfaceId 628 * @tc.size : MEDIUM 629 * @tc.type : Functional 630 * @tc.level : Level 0 631 */ 632 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100", 0, async function (done) { 633 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 634 if (receiver != undefined) { 635 globalreceiver = receiver; 636 receiver.getReceivingSurfaceId((err, id) => { 637 console.info( 638 "SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100 getReceivingSurfaceId call back [" + 639 id + 640 "]" 641 ); 642 expect(isString(id)).assertTrue(); 643 done(); 644 return; 645 }); 646 } else { 647 expect(false).assertTrue(); 648 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100 finished"); 649 done(); 650 return; 651 } 652 }); 653 654 /** 655 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0100 656 * @tc.name : release-promise 657 * @tc.desc : 1.create ImageReceiver 658 * 2.call release 659 * @tc.size : MEDIUM 660 * @tc.type : Functional 661 * @tc.level : Level 0 662 */ 663 it("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0100", 0, async function (done) { 664 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 665 if (receiver != undefined) { 666 globalreceiver = receiver; 667 receiver 668 .release() 669 .then(() => { 670 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0100 release "); 671 expect(true).assertTrue(); 672 done(); 673 return; 674 }) 675 .catch((error) => { 676 expect(false).assertTrue(); 677 done(); 678 return; 679 }); 680 } else { 681 expect(false).assertTrue(); 682 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0100 finished"); 683 done(); 684 return; 685 } 686 }); 687 688 /** 689 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 690 * @tc.name : release-callback 691 * @tc.desc : 1.create ImageReceiver 692 * 2.call release 693 * @tc.size : MEDIUM 694 * @tc.type : Functional 695 * @tc.level : Level 0 696 */ 697 it("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_CALLBACK_0100", 0, async function (done) { 698 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 699 if (receiver != undefined) { 700 globalreceiver = receiver; 701 receiver.release((err) => { 702 if (err) { 703 expect(false).assertTrue(); 704 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 release fail"); 705 done(); 706 return; 707 } else { 708 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 release call back"); 709 expect(true).assertTrue(); 710 done(); 711 return; 712 } 713 }); 714 } else { 715 expect(false).assertTrue(); 716 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 finished"); 717 done(); 718 return; 719 } 720 }); 721 722 /** 723 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 724 * @tc.name : readLatestImage-promise 725 * @tc.desc : 1.create ImageReceiver 726 * 2.call readLatestImage 727 * 3.return image 728 * @tc.size : MEDIUM 729 * @tc.type : Functional 730 * @tc.level : Level 0 731 */ 732 it("SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100", 0, async function (done) { 733 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 734 var error = receiver.checkDeviceTest; 735 if (DEVICE_CODE == error) { 736 expect(error == DEVICE_CODE).assertTrue(); 737 done(); 738 return; 739 } 740 var dummy = receiver.test; 741 if (receiver != undefined) { 742 globalreceiver = receiver; 743 receiver 744 .readLatestImage() 745 .then((img) => { 746 globalImg = img; 747 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 readLatestImage Success"); 748 expect(img != undefined).assertTrue(); 749 done(); 750 return; 751 }) 752 .catch((error) => { 753 console.log("SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 error: " + error); 754 expect(false).assertTrue(); 755 done(); 756 return; 757 }); 758 } else { 759 expect(false).assertTrue(); 760 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 finished"); 761 done(); 762 return; 763 } 764 }); 765 766 /** 767 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100 768 * @tc.name : readLatestImage-callback 769 * @tc.desc : 1.create ImageReceiver 770 * 2.call readLatestImage 771 * 3.return image 772 * @tc.size : MEDIUM 773 * @tc.type : Functional 774 * @tc.level : Level 0 775 */ 776 it("SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100", 0, async function (done) { 777 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 778 var error = receiver.checkDeviceTest; 779 if (DEVICE_CODE == error) { 780 expect(error == DEVICE_CODE).assertTrue(); 781 done(); 782 return; 783 } 784 var dummy = receiver.test; 785 if (receiver != undefined) { 786 globalreceiver = receiver; 787 receiver.readLatestImage((err, img) => { 788 globalImg = img; 789 console.info( 790 "SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100 readLatestImage call back Success" 791 ); 792 expect(img != undefined).assertTrue(); 793 done(); 794 return; 795 }); 796 } else { 797 expect(false).assertTrue(); 798 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100 finished"); 799 done(); 800 return; 801 } 802 }); 803 804 /** 805 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 806 * @tc.name : readNextImage-promise 807 * @tc.desc : 1.create ImageReceiver 808 * 2.call readNextImage 809 * 3.return image 810 * @tc.size : MEDIUM 811 * @tc.type : Functional 812 * @tc.level : Level 0 813 */ 814 it("SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100", 0, async function (done) { 815 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 816 var error = receiver.checkDeviceTest; 817 if (DEVICE_CODE == error) { 818 expect(error == DEVICE_CODE).assertTrue(); 819 done(); 820 return; 821 } 822 var dummy = receiver.test; 823 expect(receiver != undefined).assertTrue(); 824 if (receiver != undefined) { 825 globalreceiver = receiver; 826 receiver 827 .readNextImage() 828 .then((img) => { 829 globalImg = img; 830 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 readNextImage Success"); 831 expect(img != undefined).assertTrue(); 832 done(); 833 return; 834 }) 835 .catch((error) => { 836 console.log("SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 error: " + error); 837 expect(false).assertTrue(); 838 done(); 839 return; 840 }); 841 } else { 842 expect(false).assertTrue(); 843 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 finished"); 844 done(); 845 return; 846 } 847 }); 848 849 /** 850 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100 851 * @tc.name : readNextImage-callback 852 * @tc.desc : 1.create ImageReceiver 853 * 2.call readNextImage 854 * 3.return image 855 * @tc.size : MEDIUM 856 * @tc.type : Functional 857 * @tc.level : Level 0 858 */ 859 it("SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100", 0, async function (done) { 860 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 861 var error = receiver.checkDeviceTest; 862 if (DEVICE_CODE == error) { 863 expect(error == DEVICE_CODE).assertTrue(); 864 done(); 865 return; 866 } 867 var dummy = receiver.test; 868 if (receiver != undefined) { 869 globalreceiver = receiver; 870 receiver.readNextImage((err, img) => { 871 if (err) { 872 expect(false).assertTrue(); 873 done(); 874 return; 875 } else { 876 globalImg = img; 877 console.info( 878 "SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100 readNextImage call back Success" 879 ); 880 expect(img != undefined).assertTrue(); 881 done(); 882 return; 883 } 884 }); 885 } else { 886 expect(false).assertTrue(); 887 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100 finished"); 888 done(); 889 return; 890 } 891 }); 892 893 /** 894 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_PROMISE_JPEG_0100 895 * @tc.name : getComponent-jpeg 896 * @tc.desc : 1.create ImageReceiver 897 * 2.call on 898 * 3.readLatestImage 899 * 4.call getComponent 900 * @tc.size : MEDIUM 901 * @tc.type : Functional 902 * @tc.level : Level 0 903 */ 904 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_PROMISE_JPEG_0100", 0, async function (done) { 905 function checkFormat(imgformat) { 906 expect(imgformat == RGBA); 907 } 908 function checkStride(rowStride, pixelStride) { 909 expect(rowStride == WIDTH / Jpg_Stride); 910 expect(pixelStride == Jpg_Stride); 911 } 912 getComponentPromise( 913 done, 914 "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_PROMISE_JPEG_0100", 915 FORMATJPEG, 916 JPEG, 917 checkFormat, 918 checkStride 919 ); 920 }); 921 922 /** 923 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_CALLBACK_JPEG_0100 924 * @tc.name : getComponent-jpeg 925 * @tc.desc : 1.create ImageReceiver 926 * 2.call on 927 * 3.readLatestImage 928 * 4.call getComponent 929 * @tc.size : MEDIUM 930 * @tc.type : Functional 931 * @tc.level : Level 0 932 */ 933 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_CALLBACK_JPEG_0100", 0, async function (done) { 934 function checkFormat(imgformat) { 935 expect(imgformat == RGBA); 936 } 937 function checkStride(rowStride, pixelStride) { 938 expect(rowStride == WIDTH / Jpg_Stride); 939 expect(pixelStride == Jpg_Stride); 940 } 941 getComponentCb( 942 done, 943 "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_CALLBACK_JPEG_0100", 944 FORMATJPEG, 945 JPEG, 946 checkFormat, 947 checkStride 948 ); 949 }); 950 951 /** 952 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_RECEIVERON_0100 953 * @tc.name : on 954 * @tc.desc : 1.create ImageReceiver 955 * 2.call on 956 * @tc.size : MEDIUM 957 * @tc.type : Functional 958 * @tc.level : Level 0 959 */ 960 it("SUB_GRAPHIC_IMAGE_RECEIVER_RECEIVERON_0100", 0, async function (done) { 961 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 962 if (receiver == undefined) { 963 expect(false).assertTrue(); 964 done(); 965 return; 966 } else { 967 globalreceiver = receiver; 968 var error = receiver.checkDeviceTest; 969 if (DEVICE_CODE == error) { 970 expect(error == DEVICE_CODE).assertTrue(); 971 done(); 972 return; 973 } 974 let pass = false; 975 receiver.on("imageArrival", (err) => { 976 if (err) { 977 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_RECEIVERON_0100 on err" + err); 978 expect(false).assertTrue(); 979 done(); 980 return; 981 } else { 982 pass = true; 983 console.info("SUB_GRAPHIC_IMAGE_RECEIVER_RECEIVERON_0100 on call back IN"); 984 } 985 }); 986 987 var dummy = receiver.test; 988 await sleep(2000); 989 expect(pass).assertTrue(); 990 done(); 991 return; 992 } 993 }); 994 995 /** 996 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0200 997 * @tc.name : release-promise 998 * @tc.desc : 1.create ImageReceiver 999 * 2.call on 1000 * 3.readLatestImage 1001 * 4.call release 1002 * 5.return the operation result 1003 * @tc.size : MEDIUM 1004 * @tc.type : Functional 1005 * @tc.level : Level 0 1006 */ 1007 it("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0200", 0, async function (done) { 1008 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 1009 if (receiver == undefined) { 1010 expect(false).assertTrue(); 1011 done(); 1012 return; 1013 } 1014 globalreceiver = receiver; 1015 var error = receiver.checkDeviceTest; 1016 if (DEVICE_CODE == error) { 1017 expect(error == DEVICE_CODE).assertTrue(); 1018 done(); 1019 return; 1020 } 1021 receiver.on("imageArrival", () => { 1022 expect(true).assertTrue(); 1023 }); 1024 1025 var dummy = receiver.test; 1026 1027 receiver 1028 .readLatestImage() 1029 .then((img) => { 1030 if (img == undefined) { 1031 expect(false).assertTrue(); 1032 done(); 1033 return; 1034 } else { 1035 globalImg = img; 1036 expect(img.size.width == WIDTH).assertTrue(); 1037 expect(img.size.height == HEIGHT).assertTrue(); 1038 expect(img.format == RGBA).assertTrue(); 1039 expect(img.clipRect.size.width == WIDTH).assertTrue(); 1040 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 1041 expect(img.clipRect.x == 0).assertTrue(); 1042 expect(img.clipRect.y == 0).assertTrue(); 1043 1044 img.release() 1045 .then(() => { 1046 expect(true).assertTrue(); 1047 done(); 1048 return; 1049 }) 1050 .catch((error) => { 1051 console.log("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0200 err" + error); 1052 expect(false).assertTrue(); 1053 done(); 1054 return; 1055 }); 1056 } 1057 }) 1058 .catch((error) => { 1059 console.log("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_PROMISE_0200 readLatestImage err" + error); 1060 expect(false).assertTrue(); 1061 done(); 1062 return; 1063 }); 1064 }); 1065 1066 /** 1067 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_CALLBACK_0200 1068 * @tc.name : release-callback 1069 * @tc.desc : 1.create ImageReceiver 1070 * 2.call on 1071 * 3.readLatestImage 1072 * 4.call release 1073 * 5.return the operation result 1074 * @tc.size : MEDIUM 1075 * @tc.type : Functional 1076 * @tc.level : Level 0 1077 */ 1078 it("SUB_GRAPHIC_IMAGE_RECEIVER_RELEASE_CALLBACK_0200", 0, async function (done) { 1079 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 1080 if (receiver == undefined) { 1081 expect(false).assertTrue(); 1082 done(); 1083 return; 1084 } 1085 globalreceiver = receiver; 1086 var error = receiver.checkDeviceTest; 1087 if (DEVICE_CODE == error) { 1088 expect(error == DEVICE_CODE).assertTrue(); 1089 done(); 1090 return; 1091 } 1092 receiver.on("imageArrival", () => { 1093 expect(true).assertTrue(); 1094 }); 1095 var dummy = receiver.test; 1096 receiver.readLatestImage((err, img) => { 1097 if (img == undefined) { 1098 expect(false).assertTrue(); 1099 done(); 1100 return; 1101 } 1102 globalImg = img; 1103 expect(img.size.width == WIDTH).assertTrue(); 1104 expect(img.size.height == HEIGHT).assertTrue(); 1105 expect(img.format == RGBA).assertTrue(); 1106 expect(img.clipRect.size.width == WIDTH).assertTrue(); 1107 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 1108 expect(img.clipRect.x == 0).assertTrue(); 1109 expect(img.clipRect.y == 0).assertTrue(); 1110 1111 img.release((err) => { 1112 if (err) { 1113 expect(false).assertTrue(); 1114 done(); 1115 return; 1116 } else { 1117 expect(true).assertTrue(); 1118 done(); 1119 return; 1120 } 1121 }); 1122 }); 1123 }); 1124 1125 /** 1126 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0100 1127 * @tc.name : getComponent-wrong format 1128 * @tc.desc : 1.create ImageReceiver 1129 * 2.call on 1130 * 3.readLatestImage 1131 * 4.call getComponent 1132 * @tc.size : MEDIUM 1133 * @tc.type : Functional 1134 * @tc.level : Level 0 1135 */ 1136 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0100", 0, async function (done) { 1137 getComponentCbErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0100", FORMATJPEG, null); 1138 }); 1139 1140 /** 1141 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0200 1142 * @tc.name : getComponent-wrong format 1143 * @tc.desc : 1.create ImageReceiver 1144 * 2.call on 1145 * 3.readLatestImage 1146 * 4.call getComponent 1147 * @tc.size : MEDIUM 1148 * @tc.type : Functional 1149 * @tc.level : Level 0 1150 */ 1151 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0200", 0, async function (done) { 1152 getComponentCbErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0200", FORMATJPEG, "ab"); 1153 }); 1154 1155 /** 1156 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0300 1157 * @tc.name : getComponent-wrong format 1158 * @tc.desc : 1.create ImageReceiver 1159 * 2.call on 1160 * 3.readLatestImage 1161 * 4.call getComponent 1162 * @tc.size : MEDIUM 1163 * @tc.type : Functional 1164 * @tc.level : Level 0 1165 */ 1166 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0300", 0, async function (done) { 1167 getComponentCbErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0300", FORMATJPEG, 0.1); 1168 }); 1169 1170 /** 1171 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0400 1172 * @tc.name : getComponent-wrong format 1173 * @tc.desc : 1.create ImageReceiver 1174 * 2.call on 1175 * 3.readLatestImage 1176 * 4.call getComponent 1177 * @tc.size : MEDIUM 1178 * @tc.type : Functional 1179 * @tc.level : Level 0 1180 */ 1181 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0400", 0, async function (done) { 1182 getComponentCbErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0400", FORMATJPEG, { a: 1 }); 1183 }); 1184 1185 /** 1186 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0500 1187 * @tc.name : getComponent-wrong format 1188 * @tc.desc : 1.create ImageReceiver 1189 * 2.call on 1190 * 3.readLatestImage 1191 * 4.call getComponent 1192 * @tc.size : MEDIUM 1193 * @tc.type : Functional 1194 * @tc.level : Level 0 1195 */ 1196 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0500", 0, async function (done) { 1197 getComponentProErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0500", FORMATJPEG, null); 1198 }); 1199 1200 /** 1201 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0600 1202 * @tc.name : getComponent-wrong format 1203 * @tc.desc : 1.create ImageReceiver 1204 * 2.call on 1205 * 3.readLatestImage 1206 * 4.call getComponent 1207 * @tc.size : MEDIUM 1208 * @tc.type : Functional 1209 * @tc.level : Level 0 1210 */ 1211 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0600", 0, async function (done) { 1212 getComponentProErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0600", FORMATJPEG, "ab"); 1213 }); 1214 1215 /** 1216 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0700 1217 * @tc.name : getComponent-wrong format 1218 * @tc.desc : 1.create ImageReceiver 1219 * 2.call on 1220 * 3.readLatestImage 1221 * 4.call getComponent 1222 * @tc.size : MEDIUM 1223 * @tc.type : Functional 1224 * @tc.level : Level 0 1225 */ 1226 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0700", 0, async function (done) { 1227 getComponentProErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0700", FORMATJPEG, 0.1); 1228 }); 1229 1230 /** 1231 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0800 1232 * @tc.name : getComponent-wrong format 1233 * @tc.desc : 1.create ImageReceiver 1234 * 2.call on 1235 * 3.readLatestImage 1236 * 4.call getComponent 1237 * @tc.size : MEDIUM 1238 * @tc.type : Functional 1239 * @tc.level : Level 0 1240 */ 1241 it("SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0800", 0, async function (done) { 1242 getComponentProErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0800", FORMATJPEG, { a: 1 }); 1243 }); 1244 1245 /** 1246 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0100 1247 * @tc.name : on-1 1248 * @tc.desc : 1.create ImageReceiver 1249 * 2.call on 1250 * @tc.size : MEDIUM 1251 * @tc.type : Functional 1252 * @tc.level : Level 0 1253 */ 1254 it("SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0100", 0, async function (done) { 1255 onErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0100", 1); 1256 }); 1257 1258 /** 1259 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0200 1260 * @tc.name : on-null 1261 * @tc.desc : 1.create ImageReceiver 1262 * 2.call on 1263 * @tc.size : MEDIUM 1264 * @tc.type : Functional 1265 * @tc.level : Level 0 1266 */ 1267 it("SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0200", 0, async function (done) { 1268 onErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0200", null); 1269 }); 1270 1271 /** 1272 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0300 1273 * @tc.name : on-{a : 1} 1274 * @tc.desc : 1.create ImageReceiver 1275 * 2.call on 1276 * @tc.size : MEDIUM 1277 * @tc.type : Functional 1278 * @tc.level : Level 0 1279 */ 1280 it("SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0300", 0, async function (done) { 1281 onErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0300", { a: 1 }); 1282 }); 1283 1284 /** 1285 * @tc.number : SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0400 1286 * @tc.name : on-'a' 1287 * @tc.desc : 1.create ImageReceiver 1288 * 2.call on 1289 * @tc.size : MEDIUM 1290 * @tc.type : Functional 1291 * @tc.level : Level 0 1292 */ 1293 it("SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0400", 0, async function (done) { 1294 onErr(done, "SUB_GRAPHIC_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0400", "a"); 1295 }); 1296 }); 1297}