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