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 == 401).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 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 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 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 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 receiver.test; 331 } 332 } 333 334 function isString(value) { 335 return typeof value === "string"; 336 } 337 338 /** 339 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_WITH_SIZE_0100 340 * @tc.name : createImageReceiver 341 * @tc.desc : 1.set size,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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_WITH_SIZE_0100", 0, async function (done) { 349 let size = { 350 height: HEIGHT, 351 width: WIDTH 352 } 353 var receiver = image.createImageReceiver(size, image.ImageFormat.JPEG, CAPACITY); 354 expect(receiver != undefined).assertTrue(); 355 done(); 356 return; 357 }); 358 359 /** 360 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0100 361 * @tc.name : createImageReceiver 362 * @tc.desc : 1.set width,height,format,capacity 363 * 2.create ImageReceiver 364 * 3.return ImageReceiver not empty 365 * @tc.size : MEDIUM 366 * @tc.type : Functional 367 * @tc.level : Level 0 368 */ 369 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0100", 0, async function (done) { 370 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 371 if (receiver == undefined) { 372 expect(false).assertTrue(); 373 console.info("receiver_001 undefined"); 374 done(); 375 return; 376 } else { 377 globalreceiver = receiver; 378 expect(receiver.size.width == WIDTH).assertTrue(); 379 expect(receiver.size.height == HEIGHT).assertTrue(); 380 expect(receiver.capacity == CAPACITY).assertTrue(); 381 expect(receiver.format == FORMATJPEG).assertTrue(); 382 done(); 383 return; 384 } 385 }); 386 387 /** 388 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0200 389 * @tc.name : createImageReceiver 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0200", 0, async function (done) { 398 createRecriver( 399 done, 400 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0200", 401 WIDTH, 402 HEIGHT, 403 FORMATJPEG, 404 "hd!" 405 ); 406 }); 407 408 /** 409 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0100 410 * @tc.name : createImageReceiver-wrong format 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0100", 0, async function (done) { 419 createRecriver( 420 done, 421 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0100", 422 WIDTH, 423 HEIGHT, 424 null, 425 CAPACITY 426 ); 427 }); 428 429 /** 430 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0200 431 * @tc.name : createImageReceiver-wrong height 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0200", 0, async function (done) { 440 createRecriver( 441 done, 442 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0200", 443 WIDTH, 444 null, 445 FORMATJPEG, 446 CAPACITY 447 ); 448 }); 449 450 /** 451 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0300 452 * @tc.name : createImageReceiver-wrong width 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0300", 0, async function (done) { 461 createRecriver( 462 done, 463 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0300", 464 null, 465 HEIGHT, 466 FORMATJPEG, 467 CAPACITY 468 ); 469 }); 470 471 /** 472 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0400 473 * @tc.name : createImageReceiver-wrong capacity 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0400", 0, async function (done) { 482 createRecriver( 483 done, 484 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0400", 485 WIDTH, 486 HEIGHT, 487 FORMATJPEG, 488 null 489 ); 490 }); 491 492 /** 493 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0500 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0500", 0, async function (done) { 503 createRecriver( 504 done, 505 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0500", 506 false, 507 HEIGHT, 508 FORMATJPEG, 509 CAPACITY 510 ); 511 }); 512 513 /** 514 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0600 515 * @tc.name : createImageReceiver- wrong width 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0600", 0, async function (done) { 524 createRecriver( 525 done, 526 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0600", 527 { a: 10 }, 528 HEIGHT, 529 FORMATJPEG, 530 CAPACITY 531 ); 532 }); 533 534 /** 535 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0300 536 * @tc.name : createImageReceiver 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_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0300", 0, async function (done) { 545 createRecriver( 546 done, 547 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0300", 548 WIDTH, 549 false, 550 FORMATJPEG, 551 CAPACITY 552 ); 553 }); 554 555 /** 556 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0700 557 * @tc.name : createImageReceiver- wrong format 558 * @tc.desc : 1.set width,height,format,capacity 559 * 2.create ImageReceiver 560 * 3.return ImageReceiver empty 561 * @tc.size : MEDIUM 562 * @tc.type : Functional 563 * @tc.level : Level 0 564 */ 565 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0700", 0, async function (done) { 566 createRecriver( 567 done, 568 "SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_ERROR_0700", 569 WIDTH, 570 HEIGHT, 571 "form.", 572 CAPACITY 573 ); 574 }); 575 576 /** 577 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0400 578 * @tc.name : createImageReceiver 579 * @tc.desc : 1.set width,height,format,capacity 580 * 2.create ImageReceiver 581 * 3.return ImageReceiver not empty 582 * @tc.size : MEDIUM 583 * @tc.type : Functional 584 * @tc.level : Level 0 585 */ 586 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0400", 0, async function (done) { 587 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 588 if (receiver == undefined) { 589 expect(false).assertTrue(); 590 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_CREATEIMAGERECEIVER_0400 undefined"); 591 done(); 592 return; 593 } else { 594 globalreceiver = receiver; 595 expect(receiver.size.width == WIDTH).assertTrue(); 596 expect(receiver.size.height == HEIGHT).assertTrue(); 597 expect(receiver.capacity == CAPACITY).assertTrue(); 598 expect(receiver.format == FORMATJPEG).assertTrue(); 599 done(); 600 return; 601 } 602 }); 603 604 /** 605 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100 606 * @tc.name : getReceivingSurfaceId-promise 607 * @tc.desc : 1.create ImageReceiver 608 * 2.call getReceivingSurfaceId 609 * 3.return SurfaceId 610 * @tc.size : MEDIUM 611 * @tc.type : Functional 612 * @tc.level : Level 0 613 */ 614 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100", 0, async function (done) { 615 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 616 if (receiver != undefined) { 617 globalreceiver = receiver; 618 receiver 619 .getReceivingSurfaceId() 620 .then((id) => { 621 console.info( 622 "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100 getReceivingSurfaceId [" + 623 id + 624 "]" 625 ); 626 expect(isString(id)).assertTrue(); 627 done(); 628 return; 629 }) 630 .catch((error) => { 631 console.log("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_PROMISE_0100 error: " + error); 632 expect(false).assertTrue(); 633 done(); 634 return; 635 }); 636 } else { 637 expect(false).assertTrue(); 638 done(); 639 return; 640 } 641 }); 642 643 /** 644 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100 645 * @tc.name : getReceivingSurfaceId-callback 646 * @tc.desc : 1.create ImageReceiver 647 * 2.call getReceivingSurfaceId 648 * 3.return SurfaceId 649 * @tc.size : MEDIUM 650 * @tc.type : Functional 651 * @tc.level : Level 0 652 */ 653 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100", 0, async function (done) { 654 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 655 if (receiver != undefined) { 656 globalreceiver = receiver; 657 receiver.getReceivingSurfaceId((err, id) => { 658 console.info( 659 "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100 getReceivingSurfaceId call back [" + 660 id + 661 "]" 662 ); 663 expect(isString(id)).assertTrue(); 664 done(); 665 return; 666 }); 667 } else { 668 expect(false).assertTrue(); 669 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETRECEIVINGSURFACEID_CALLBACK_0100 finished"); 670 done(); 671 return; 672 } 673 }); 674 675 /** 676 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0100 677 * @tc.name : release-promise 678 * @tc.desc : 1.create ImageReceiver 679 * 2.call release 680 * @tc.size : MEDIUM 681 * @tc.type : Functional 682 * @tc.level : Level 0 683 */ 684 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0100", 0, async function (done) { 685 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 686 if (receiver != undefined) { 687 globalreceiver = receiver; 688 receiver 689 .release() 690 .then(() => { 691 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0100 release "); 692 expect(true).assertTrue(); 693 done(); 694 return; 695 }) 696 .catch((error) => { 697 expect(false).assertTrue(); 698 done(); 699 return; 700 }); 701 } else { 702 expect(false).assertTrue(); 703 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0100 finished"); 704 done(); 705 return; 706 } 707 }); 708 709 /** 710 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 711 * @tc.name : release-callback 712 * @tc.desc : 1.create ImageReceiver 713 * 2.call release 714 * @tc.size : MEDIUM 715 * @tc.type : Functional 716 * @tc.level : Level 0 717 */ 718 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_CALLBACK_0100", 0, async function (done) { 719 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 720 if (receiver != undefined) { 721 globalreceiver = receiver; 722 receiver.release((err) => { 723 if (err) { 724 expect(false).assertTrue(); 725 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 release fail"); 726 done(); 727 return; 728 } else { 729 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 release call back"); 730 expect(true).assertTrue(); 731 done(); 732 return; 733 } 734 }); 735 } else { 736 expect(false).assertTrue(); 737 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_CALLBACK_0100 finished"); 738 done(); 739 return; 740 } 741 }); 742 743 /** 744 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 745 * @tc.name : readLatestImage-promise 746 * @tc.desc : 1.create ImageReceiver 747 * 2.call readLatestImage 748 * 3.return image 749 * @tc.size : MEDIUM 750 * @tc.type : Functional 751 * @tc.level : Level 0 752 */ 753 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100", 0, async function (done) { 754 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 755 var error = receiver.checkDeviceTest; 756 if (DEVICE_CODE == error) { 757 expect(error == DEVICE_CODE).assertTrue(); 758 done(); 759 return; 760 } 761 receiver.test; 762 if (receiver != undefined) { 763 globalreceiver = receiver; 764 receiver 765 .readLatestImage() 766 .then((img) => { 767 globalImg = img; 768 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 readLatestImage Success"); 769 expect(img != undefined).assertTrue(); 770 done(); 771 return; 772 }) 773 .catch((error) => { 774 console.log("SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 error: " + error); 775 expect(false).assertTrue(); 776 done(); 777 return; 778 }); 779 } else { 780 expect(false).assertTrue(); 781 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_PROMISE_0100 finished"); 782 done(); 783 return; 784 } 785 }); 786 787 /** 788 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100 789 * @tc.name : readLatestImage-callback 790 * @tc.desc : 1.create ImageReceiver 791 * 2.call readLatestImage 792 * 3.return image 793 * @tc.size : MEDIUM 794 * @tc.type : Functional 795 * @tc.level : Level 0 796 */ 797 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100", 0, async function (done) { 798 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 799 var error = receiver.checkDeviceTest; 800 if (DEVICE_CODE == error) { 801 expect(error == DEVICE_CODE).assertTrue(); 802 done(); 803 return; 804 } 805 receiver.test; 806 if (receiver != undefined) { 807 globalreceiver = receiver; 808 receiver.readLatestImage((err, img) => { 809 globalImg = img; 810 console.info( 811 "SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100 readLatestImage call back Success" 812 ); 813 expect(img != undefined).assertTrue(); 814 done(); 815 return; 816 }); 817 } else { 818 expect(false).assertTrue(); 819 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_READLATESTIMAGE_CALLBACK_0100 finished"); 820 done(); 821 return; 822 } 823 }); 824 825 /** 826 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 827 * @tc.name : readNextImage-promise 828 * @tc.desc : 1.create ImageReceiver 829 * 2.call readNextImage 830 * 3.return image 831 * @tc.size : MEDIUM 832 * @tc.type : Functional 833 * @tc.level : Level 0 834 */ 835 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100", 0, async function (done) { 836 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 837 var error = receiver.checkDeviceTest; 838 if (DEVICE_CODE == error) { 839 expect(error == DEVICE_CODE).assertTrue(); 840 done(); 841 return; 842 } 843 receiver.test; 844 expect(receiver != undefined).assertTrue(); 845 if (receiver != undefined) { 846 globalreceiver = receiver; 847 receiver 848 .readNextImage() 849 .then((img) => { 850 globalImg = img; 851 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 readNextImage Success"); 852 expect(img != undefined).assertTrue(); 853 done(); 854 return; 855 }) 856 .catch((error) => { 857 console.log("SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 error: " + error); 858 expect(false).assertTrue(); 859 done(); 860 return; 861 }); 862 } else { 863 expect(false).assertTrue(); 864 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_PROMISE_0100 finished"); 865 done(); 866 return; 867 } 868 }); 869 870 /** 871 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100 872 * @tc.name : readNextImage-callback 873 * @tc.desc : 1.create ImageReceiver 874 * 2.call readNextImage 875 * 3.return image 876 * @tc.size : MEDIUM 877 * @tc.type : Functional 878 * @tc.level : Level 0 879 */ 880 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100", 0, async function (done) { 881 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 882 var error = receiver.checkDeviceTest; 883 if (DEVICE_CODE == error) { 884 expect(error == DEVICE_CODE).assertTrue(); 885 done(); 886 return; 887 } 888 receiver.test; 889 if (receiver != undefined) { 890 globalreceiver = receiver; 891 receiver.readNextImage((err, img) => { 892 if (err) { 893 expect(false).assertTrue(); 894 done(); 895 return; 896 } else { 897 globalImg = img; 898 console.info( 899 "SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100 readNextImage call back Success" 900 ); 901 expect(img != undefined).assertTrue(); 902 done(); 903 return; 904 } 905 }); 906 } else { 907 expect(false).assertTrue(); 908 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_READNEXTIMAGE_CALLBACK_0100 finished"); 909 done(); 910 return; 911 } 912 }); 913 914 /** 915 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_PROMISE_JPEG_0100 916 * @tc.name : getComponent-jpeg 917 * @tc.desc : 1.create ImageReceiver 918 * 2.call on 919 * 3.readLatestImage 920 * 4.call getComponent 921 * @tc.size : MEDIUM 922 * @tc.type : Functional 923 * @tc.level : Level 0 924 */ 925 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_PROMISE_JPEG_0100", 0, async function (done) { 926 function checkFormat(imgformat) { 927 expect(imgformat == RGBA); 928 } 929 function checkStride(rowStride, pixelStride) { 930 expect(rowStride == WIDTH / Jpg_Stride); 931 expect(pixelStride == Jpg_Stride); 932 } 933 getComponentPromise( 934 done, 935 "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_PROMISE_JPEG_0100", 936 FORMATJPEG, 937 JPEG, 938 checkFormat, 939 checkStride 940 ); 941 }); 942 943 /** 944 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_CALLBACK_JPEG_0100 945 * @tc.name : getComponent-jpeg 946 * @tc.desc : 1.create ImageReceiver 947 * 2.call on 948 * 3.readLatestImage 949 * 4.call getComponent 950 * @tc.size : MEDIUM 951 * @tc.type : Functional 952 * @tc.level : Level 0 953 */ 954 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_CALLBACK_JPEG_0100", 0, async function (done) { 955 function checkFormat(imgformat) { 956 expect(imgformat == RGBA); 957 } 958 function checkStride(rowStride, pixelStride) { 959 expect(rowStride == WIDTH / Jpg_Stride); 960 expect(pixelStride == Jpg_Stride); 961 } 962 getComponentCb( 963 done, 964 "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_CALLBACK_JPEG_0100", 965 FORMATJPEG, 966 JPEG, 967 checkFormat, 968 checkStride 969 ); 970 }); 971 972 /** 973 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_RECEIVERON_0100 974 * @tc.name : on 975 * @tc.desc : 1.create ImageReceiver 976 * 2.call on 977 * @tc.size : MEDIUM 978 * @tc.type : Functional 979 * @tc.level : Level 0 980 */ 981 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_RECEIVERON_0100", 0, async function (done) { 982 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 983 if (receiver == undefined) { 984 expect(false).assertTrue(); 985 done(); 986 return; 987 } else { 988 globalreceiver = receiver; 989 var error = receiver.checkDeviceTest; 990 if (DEVICE_CODE == error) { 991 expect(error == DEVICE_CODE).assertTrue(); 992 done(); 993 return; 994 } 995 let pass = false; 996 receiver.on("imageArrival", (err) => { 997 if (err) { 998 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_RECEIVERON_0100 on err" + err); 999 expect(false).assertTrue(); 1000 done(); 1001 return; 1002 } else { 1003 pass = true; 1004 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_RECEIVERON_0100 on call back IN"); 1005 } 1006 }); 1007 1008 receiver.test; 1009 await sleep(2000); 1010 expect(pass).assertTrue(); 1011 done(); 1012 return; 1013 } 1014 }); 1015 1016 /** 1017 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0200 1018 * @tc.name : release-promise 1019 * @tc.desc : 1.create ImageReceiver 1020 * 2.call on 1021 * 3.readLatestImage 1022 * 4.call release 1023 * 5.return the operation result 1024 * @tc.size : MEDIUM 1025 * @tc.type : Functional 1026 * @tc.level : Level 0 1027 */ 1028 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0200", 0, async function (done) { 1029 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 1030 if (receiver == undefined) { 1031 expect(false).assertTrue(); 1032 done(); 1033 return; 1034 } 1035 globalreceiver = receiver; 1036 var error = receiver.checkDeviceTest; 1037 if (DEVICE_CODE == error) { 1038 expect(error == DEVICE_CODE).assertTrue(); 1039 done(); 1040 return; 1041 } 1042 receiver.on("imageArrival", () => { 1043 expect(true).assertTrue(); 1044 }); 1045 1046 receiver.test; 1047 1048 receiver 1049 .readLatestImage() 1050 .then((img) => { 1051 if (img == undefined) { 1052 expect(false).assertTrue(); 1053 done(); 1054 return; 1055 } else { 1056 globalImg = img; 1057 expect(img.size.width == WIDTH).assertTrue(); 1058 expect(img.size.height == HEIGHT).assertTrue(); 1059 expect(img.format == RGBA).assertTrue(); 1060 expect(img.clipRect.size.width == WIDTH).assertTrue(); 1061 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 1062 expect(img.clipRect.x == 0).assertTrue(); 1063 expect(img.clipRect.y == 0).assertTrue(); 1064 1065 img.release() 1066 .then(() => { 1067 expect(true).assertTrue(); 1068 done(); 1069 return; 1070 }) 1071 .catch((error) => { 1072 console.log("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0200 err" + error); 1073 expect(false).assertTrue(); 1074 done(); 1075 return; 1076 }); 1077 } 1078 }) 1079 .catch((error) => { 1080 console.log("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_PROMISE_0200 readLatestImage err" + error); 1081 expect(false).assertTrue(); 1082 done(); 1083 return; 1084 }); 1085 }); 1086 1087 /** 1088 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_CALLBACK_0200 1089 * @tc.name : release-callback 1090 * @tc.desc : 1.create ImageReceiver 1091 * 2.call on 1092 * 3.readLatestImage 1093 * 4.call release 1094 * 5.return the operation result 1095 * @tc.size : MEDIUM 1096 * @tc.type : Functional 1097 * @tc.level : Level 0 1098 */ 1099 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_RELEASE_CALLBACK_0200", 0, async function (done) { 1100 var receiver = image.createImageReceiver(WIDTH, HEIGHT, FORMATJPEG, CAPACITY); 1101 if (receiver == undefined) { 1102 expect(false).assertTrue(); 1103 done(); 1104 return; 1105 } 1106 globalreceiver = receiver; 1107 var error = receiver.checkDeviceTest; 1108 if (DEVICE_CODE == error) { 1109 expect(error == DEVICE_CODE).assertTrue(); 1110 done(); 1111 return; 1112 } 1113 receiver.on("imageArrival", () => { 1114 expect(true).assertTrue(); 1115 }); 1116 receiver.test; 1117 receiver.readLatestImage((err, img) => { 1118 if (img == undefined) { 1119 expect(false).assertTrue(); 1120 done(); 1121 return; 1122 } 1123 globalImg = img; 1124 expect(img.size.width == WIDTH).assertTrue(); 1125 expect(img.size.height == HEIGHT).assertTrue(); 1126 expect(img.format == RGBA).assertTrue(); 1127 expect(img.clipRect.size.width == WIDTH).assertTrue(); 1128 expect(img.clipRect.size.height == HEIGHT).assertTrue(); 1129 expect(img.clipRect.x == 0).assertTrue(); 1130 expect(img.clipRect.y == 0).assertTrue(); 1131 1132 img.release((err) => { 1133 if (err) { 1134 expect(false).assertTrue(); 1135 done(); 1136 return; 1137 } else { 1138 expect(true).assertTrue(); 1139 done(); 1140 return; 1141 } 1142 }); 1143 }); 1144 }); 1145 1146 /** 1147 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0100 1148 * @tc.name : getComponent-wrong format 1149 * @tc.desc : 1.create ImageReceiver 1150 * 2.call on 1151 * 3.readLatestImage 1152 * 4.call getComponent 1153 * @tc.size : MEDIUM 1154 * @tc.type : Functional 1155 * @tc.level : Level 0 1156 */ 1157 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0100", 0, async function (done) { 1158 getComponentCbErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0100", FORMATJPEG, null); 1159 }); 1160 1161 /** 1162 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0200 1163 * @tc.name : getComponent-wrong format 1164 * @tc.desc : 1.create ImageReceiver 1165 * 2.call on 1166 * 3.readLatestImage 1167 * 4.call getComponent 1168 * @tc.size : MEDIUM 1169 * @tc.type : Functional 1170 * @tc.level : Level 0 1171 */ 1172 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0200", 0, async function (done) { 1173 getComponentCbErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0200", FORMATJPEG, "ab"); 1174 }); 1175 1176 /** 1177 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0300 1178 * @tc.name : getComponent-wrong format 1179 * @tc.desc : 1.create ImageReceiver 1180 * 2.call on 1181 * 3.readLatestImage 1182 * 4.call getComponent 1183 * @tc.size : MEDIUM 1184 * @tc.type : Functional 1185 * @tc.level : Level 0 1186 */ 1187 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0300", 0, async function (done) { 1188 getComponentCbErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0300", FORMATJPEG, 0.1); 1189 }); 1190 1191 /** 1192 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0400 1193 * @tc.name : getComponent-wrong format 1194 * @tc.desc : 1.create ImageReceiver 1195 * 2.call on 1196 * 3.readLatestImage 1197 * 4.call getComponent 1198 * @tc.size : MEDIUM 1199 * @tc.type : Functional 1200 * @tc.level : Level 0 1201 */ 1202 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0400", 0, async function (done) { 1203 getComponentCbErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0400", FORMATJPEG, { a: 1 }); 1204 }); 1205 1206 /** 1207 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0500 1208 * @tc.name : getComponent-wrong format 1209 * @tc.desc : 1.create ImageReceiver 1210 * 2.call on 1211 * 3.readLatestImage 1212 * 4.call getComponent 1213 * @tc.size : MEDIUM 1214 * @tc.type : Functional 1215 * @tc.level : Level 0 1216 */ 1217 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0500", 0, async function (done) { 1218 getComponentProErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0500", FORMATJPEG, null); 1219 }); 1220 1221 /** 1222 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0600 1223 * @tc.name : getComponent-wrong format 1224 * @tc.desc : 1.create ImageReceiver 1225 * 2.call on 1226 * 3.readLatestImage 1227 * 4.call getComponent 1228 * @tc.size : MEDIUM 1229 * @tc.type : Functional 1230 * @tc.level : Level 0 1231 */ 1232 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0600", 0, async function (done) { 1233 getComponentProErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0600", FORMATJPEG, "ab"); 1234 }); 1235 1236 /** 1237 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0700 1238 * @tc.name : getComponent-wrong format 1239 * @tc.desc : 1.create ImageReceiver 1240 * 2.call on 1241 * 3.readLatestImage 1242 * 4.call getComponent 1243 * @tc.size : MEDIUM 1244 * @tc.type : Functional 1245 * @tc.level : Level 0 1246 */ 1247 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0700", 0, async function (done) { 1248 getComponentProErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0700", FORMATJPEG, 0.1); 1249 }); 1250 1251 /** 1252 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0800 1253 * @tc.name : getComponent-wrong format 1254 * @tc.desc : 1.create ImageReceiver 1255 * 2.call on 1256 * 3.readLatestImage 1257 * 4.call getComponent 1258 * @tc.size : MEDIUM 1259 * @tc.type : Functional 1260 * @tc.level : Level 0 1261 */ 1262 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0800", 0, async function (done) { 1263 getComponentProErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_GETCOMPONENT_ERROR_0800", FORMATJPEG, { a: 1 }); 1264 }); 1265 1266 /** 1267 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0100 1268 * @tc.name : on-1 1269 * @tc.desc : 1.create ImageReceiver 1270 * 2.call on 1271 * @tc.size : MEDIUM 1272 * @tc.type : Functional 1273 * @tc.level : Level 0 1274 */ 1275 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0100", 0, async function (done) { 1276 onErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0100", 1); 1277 }); 1278 1279 /** 1280 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0200 1281 * @tc.name : on-null 1282 * @tc.desc : 1.create ImageReceiver 1283 * 2.call on 1284 * @tc.size : MEDIUM 1285 * @tc.type : Functional 1286 * @tc.level : Level 0 1287 */ 1288 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0200", 0, async function (done) { 1289 onErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0200", null); 1290 }); 1291 1292 /** 1293 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0300 1294 * @tc.name : on-{a : 1} 1295 * @tc.desc : 1.create ImageReceiver 1296 * 2.call on 1297 * @tc.size : MEDIUM 1298 * @tc.type : Functional 1299 * @tc.level : Level 0 1300 */ 1301 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0300", 0, async function (done) { 1302 onErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0300", { a: 1 }); 1303 }); 1304 1305 /** 1306 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0400 1307 * @tc.name : on-'a' 1308 * @tc.desc : 1.create ImageReceiver 1309 * 2.call on 1310 * @tc.size : MEDIUM 1311 * @tc.type : Functional 1312 * @tc.level : Level 0 1313 */ 1314 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0400", 0, async function (done) { 1315 onErr(done, "SUB_MULTIMEDIA_IMAGE_RECEIVER_IMAGERECEIVER_ON_ERROR_0400", "a"); 1316 }); 1317 1318 /** 1319 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_SUCCESS_0100 1320 * @tc.name : imageReceiver-off-'imageArrival' 1321 * @tc.desc : 1.Create ImageReceiver 1322 * 2.Close callback subscription (call receiver.off (a)) 1323 * 3.Pass in the correct parameter for a in off (a) 1324 * 4.View the subscription effect of Image Receiver callback 1325 * @tc.size : MEDIUM 1326 * @tc.type : Functional 1327 * @tc.level : Level 0 1328 */ 1329 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_SUCCESS_0100", 0, async function (done) { 1330 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_SUCCESS_0100 start'); 1331 let size = {height: HEIGHT, width: WIDTH} 1332 var receiver = image.createImageReceiver(size, image.ImageFormat.JPEG, CAPACITY); 1333 if (receiver == undefined) { 1334 expect(false).assertTrue(); 1335 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_SUCCESS_0100 create image receiver failed'); 1336 done(); 1337 return; 1338 } else { 1339 globalreceiver = receiver; 1340 var error = receiver.checkDeviceTest; 1341 if (DEVICE_CODE == error) { 1342 expect(error == DEVICE_CODE).assertTrue(); 1343 done(); 1344 return; 1345 } 1346 let ret = receiver.off("imageArrival"); 1347 if (ret == undefined) { 1348 expect(false).assertTrue(); 1349 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_SUCCESS_0100 off failed'); 1350 done(); 1351 return; 1352 } else { 1353 expect(true).assertTrue(); 1354 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_SUCCESS_0100 off success'); 1355 done(); 1356 return; 1357 } 1358 } 1359 }); 1360 1361 /** 1362 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_ERROR_0200 1363 * @tc.name : imageReceiver-off-'a' 1364 * @tc.desc : 1.Create ImageReceiver 1365 * 2.Close callback subscription (call receiver.off (a)) 1366 * 3.Wrong parameter passed in for a in off (a) 1367 * 4.View the subscription effect of Image Receiver callback 1368 * @tc.size : MEDIUM 1369 * @tc.type : Functional 1370 * @tc.level : Level 0 1371 */ 1372 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_ERROR_0200", 0, async function (done) { 1373 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_ERROR_0200 start'); 1374 let size = {height: HEIGHT, width: WIDTH} 1375 var receiver = image.createImageReceiver(size, image.ImageFormat.JPEG, CAPACITY); 1376 expect(receiver != undefined).assertTrue(); 1377 if (receiver == undefined) { 1378 expect(false).assertTrue(); 1379 done(); 1380 return; 1381 } else { 1382 globalreceiver = receiver; 1383 var error = receiver.checkDeviceTest; 1384 if (DEVICE_CODE == error) { 1385 expect(error == DEVICE_CODE).assertTrue(); 1386 done(); 1387 return; 1388 } 1389 try { 1390 receiver.off('a'); 1391 expect(false).assertTrue(); 1392 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_ERROR_0200 off failed'); 1393 done(); 1394 } catch (error) { 1395 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_ERROR_0200 error: ' + JSON.stringify(error)); 1396 expect(error.code == 1).assertTrue(); 1397 done(); 1398 } 1399 } 1400 }); 1401 1402 /** 1403 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300 1404 * @tc.name : imageReceiver-on-off 1405 * @tc.desc : 1.Create ImageReceiver 1406 * 2.Image Receiver enables callback subscription 1407 * (calling receiver.on ("imageArrival")): (Print image information in callback) 1408 * 3.Image Receiver closes callback subscription (calls receiver.off ("imageArrival")) 1409 * 4.View the subscription effect of Image Receiver callback 1410 * @tc.size : MEDIUM 1411 * @tc.type : Functional 1412 * @tc.level : Level 0 1413 */ 1414 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300", 0, async function (done) { 1415 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300 start'); 1416 let size = {height: HEIGHT, width: WIDTH} 1417 var receiver = image.createImageReceiver(size, image.ImageFormat.JPEG, CAPACITY); 1418 if (receiver == undefined) { 1419 expect(false).assertTrue(); 1420 done(); 1421 return; 1422 } else { 1423 globalreceiver = receiver; 1424 var error = receiver.checkDeviceTest; 1425 if (DEVICE_CODE == error) { 1426 expect(error == DEVICE_CODE).assertTrue(); 1427 done(); 1428 return; 1429 } 1430 let pass = true; 1431 receiver.on("imageArrival", (err) => { 1432 if (err) { 1433 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300 on err" + err); 1434 expect(false).assertTrue(); 1435 done(); 1436 return; 1437 } else { 1438 pass = false; 1439 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300 on call back IN"); 1440 receiver.readLatestImage((err, img) => { 1441 if (err) { 1442 expect(false).assertTrue(); 1443 done(); 1444 return; 1445 } else { 1446 globalImg = img; 1447 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300 Img Size Height" + img.size.height); 1448 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300 Img Size Width" + img.size.width); 1449 } 1450 }); 1451 } 1452 }); 1453 receiver.off("imageArrival"); 1454 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_ON_AND_OFF_0300 off success'); 1455 receiver.test; 1456 await sleep(2000); 1457 expect(pass).assertTrue(); 1458 done(); 1459 return; 1460 } 1461 }); 1462 1463 /** 1464 * @tc.number : SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_AND_ON_0400 1465 * @tc.name : imageReceiver-off-on 1466 * @tc.desc : 1.Create ImageReceiver 1467 * 2.Image Receiver closes callback subscription (calls receiver.off ("imageArrival")) 1468 * 3.Image Receiver enables callback subscription 1469 * (calling receiver.on ("imageArrival")): (Print image information in callback) 1470 * 4.View the subscription effect of Image Receiver callback 1471 * @tc.size : MEDIUM 1472 * @tc.type : Functional 1473 * @tc.level : Level 0 1474 */ 1475 it("SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_AND_ON_0400", 0, async function (done) { 1476 console.info('SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_AND_ON_0400 start'); 1477 let size = {height: HEIGHT, width: WIDTH} 1478 var receiver = image.createImageReceiver(size, image.ImageFormat.JPEG, CAPACITY); 1479 if (receiver == undefined) { 1480 expect(false).assertTrue(); 1481 done(); 1482 return; 1483 } else { 1484 globalreceiver = receiver; 1485 var error = receiver.checkDeviceTest; 1486 if (DEVICE_CODE == error) { 1487 expect(error == DEVICE_CODE).assertTrue(); 1488 done(); 1489 return; 1490 } 1491 let pass = false; 1492 receiver.off("imageArrival"); 1493 receiver.on("imageArrival", (err) => { 1494 if (err) { 1495 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_AND_ON_0400 on err" + err); 1496 expect(false).assertTrue(); 1497 done(); 1498 return; 1499 } else { 1500 if (pass) { 1501 return; 1502 } 1503 pass = true; 1504 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_AND_ON_0400 on call back IN"); 1505 receiver.readLatestImage((err, img) => { 1506 if (err) { 1507 expect(false).assertTrue(); 1508 done(); 1509 return; 1510 } else { 1511 globalImg = img; 1512 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_AND_ON_0400 Img Size Height: " + img.size.height); 1513 console.info("SUB_MULTIMEDIA_IMAGE_RECEIVER_OFF_AND_ON_0400 Img Size Width: " + img.size.width); 1514 expect(pass).assertTrue(); 1515 done(); 1516 return; 1517 } 1518 }); 1519 } 1520 }); 1521 receiver.test; 1522 } 1523 }); 1524 }); 1525}