1/* 2 * Copyright (C) 2023-2025 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 */ 15 16import deviceManager from '@ohos.driver.deviceManager' 17import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 18 19describe("DeviceManagerJsTest", function () { 20 var deviceId = null; 21 22 function callback(data) { 23 console.info("callback" + JSON.stringify(data)); 24 expect(typeof(data.x)).assertEqual("number"); 25 } 26 27 function callback2() { 28 console.info("callback2" + JSON.stringify(data)); 29 expect(typeof(data.x)).assertEqual("number"); 30 } 31 32 beforeAll(function() { 33 console.info('beforeAll called'); 34 try { 35 var devices = deviceManager.queryDevices(deviceManager.BusType.USB); 36 if (devices != null && devices.length > 0 && devices[0] != null) { 37 deviceId = BigInt(devices[0].deviceId); 38 console.log('Device ID:', deviceId.toString()); 39 } else { 40 console.log('No devices found.'); 41 } 42 } catch (err) { 43 console.error('Error occurred:', err); 44 } 45 46 if (deviceId == null) { 47 console.log('Device ID has not been set.'); 48 } 49 console.info('beforeAll called end'); 50 }) 51 52 afterAll(function() { 53 console.info('afterAll called') 54 }) 55 56 beforeEach(function() { 57 console.info('beforeEach called') 58 }) 59 60 afterEach(function() { 61 console.info('afterEach called') 62 }) 63 64 const PARAMETER_ERROR_CODE = 401 65 const SERVICE_EXCEPTION_CODE = 22900001 66 const SERVICE_EXCEPTION_CODE_NEW = 26300001 67 const SERVICE_NOT_BOUND = 26300003 68 69 /* 70 * @tc.name:DeviceManager_queryDevices_001 71 * @tc.desc:verify queryDevice result 72 * @tc.type: FUNC 73 */ 74 it("DeviceManager_queryDevices_001", 0, function () { 75 console.info('----------------------DeviceManager_queryDevices_001---------------------------'); 76 try { 77 var devices = deviceManager.queryDevices(deviceManager.BusType.USB); 78 expect(devices != null).assertEqual(true); 79 if (devices.length > 0) { 80 expect(devices[0] != null).assertEqual(true); 81 expect(devices[0].vendorId != null).assertEqual(true); 82 expect(devices[0].productId != null).assertEqual(true); 83 } 84 } catch (err) { 85 expect(err.code).assertEqual(SERVICE_EXCEPTION_CODE); 86 } 87 }) 88 89 /* 90 * @tc.name:DeviceManager_queryDevices_002 91 * @tc.desc:verify queryDevice no param result 92 * @tc.type: FUNC 93 */ 94 it("DeviceManager_queryDevices_002", 0, function () { 95 console.info('----------------------DeviceManager_queryDevices_002---------------------------'); 96 try { 97 var devices = deviceManager.queryDevices(); 98 expect(devices != null).assertEqual(true); 99 } catch (err) { 100 expect(err.code).assertEqual(SERVICE_EXCEPTION_CODE); 101 } 102 }) 103 104 /* 105 * @tc.name:DeviceManager_bindDevices_003 106 * @tc.desc:verify bindDevice invalid param 107 * @tc.type: FUNC 108 */ 109 it("DeviceManager_bindDevices_003", 0, async function (done) { 110 console.info('----------------------DeviceManager_bindDevices_003---------------------------'); 111 try { 112 deviceManager.bindDevice('fakeid', (error, data) => { 113 expect(false).assertTrue(); 114 done(); 115 }, (error, data) => { 116 expect(false).assertTrue(); 117 done(); 118 }); 119 expect(false).assertTrue(); 120 done(); 121 } catch (error) { 122 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 123 done(); 124 } 125 }) 126 127 /* 128 * @tc.name:DeviceManager_bindDevices_004 129 * @tc.desc:verify bindDevice any device 130 * @tc.type: FUNC 131 */ 132 it("DeviceManager_bindDevices_004", 0, async function (done) { 133 console.info('----------------------DeviceManager_bindDevices_004---------------------------'); 134 try { 135 deviceManager.bindDevice(12345, (error, data) => { 136 expect(false).assertTrue(); 137 done(); 138 }, (error, data) => { 139 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 140 done(); 141 }); 142 expect(false).assertTrue(); 143 done(); 144 } catch (error) { 145 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 146 done(); 147 } 148 }) 149 150 /* 151 * @tc.name:DeviceManager_bindDeviceDriver_005 152 * @tc.desc:verify bindDeviceDriver any device 153 * @tc.type: FUNC 154 */ 155 it("DeviceManager_bindDeviceDriver_005", 0, async function (done) { 156 console.info('----------------------DeviceManager_bindDeviceDriver_005---------------------------'); 157 try { 158 deviceManager.bindDeviceDriver(12345, (error, data) => { 159 expect(false).assertTrue(); 160 done(); 161 }, (error, data) => { 162 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 163 done(); 164 }); 165 expect(false).assertTrue(); 166 done(); 167 } catch (error) { 168 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 169 done(); 170 } 171 }) 172 173 /* 174 * @tc.name:DeviceManager_bindDevices_006 175 * @tc.desc:verify bindDevice invalid param count 176 * @tc.type: FUNC 177 */ 178 it("DeviceManager_bindDevices_006", 0, async function (done) { 179 console.info('----------------------DeviceManager_bindDevices_006---------------------------'); 180 try { 181 deviceManager.bindDevice(); 182 expect(false).assertTrue(); 183 done(); 184 } catch (error) { 185 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 186 done(); 187 } 188 }) 189 190 /* 191 * @tc.name:DeviceManager_bindDevices_007 192 * @tc.desc:verify bindDevice invalid param 193 * @tc.type: FUNC 194 */ 195 it("DeviceManager_bindDevices_007", 0, async function (done) { 196 console.info('----------------------DeviceManager_bindDevices_007---------------------------'); 197 try { 198 deviceManager.bindDevice(12345); 199 expect(false).assertTrue(); 200 done(); 201 } catch (error) { 202 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 203 done(); 204 } 205 }) 206 207 /* 208 * @tc.name:DeviceManager_bindDevices_008 209 * @tc.desc:verify bindDevice invalid param 210 * @tc.type: FUNC 211 */ 212 it("DeviceManager_bindDevices_008", 0, async function (done) { 213 console.info('----------------------DeviceManager_bindDevices_008---------------------------'); 214 try { 215 deviceManager.bindDevice(12345, 23456); 216 expect(false).assertTrue(); 217 done(); 218 } catch (error) { 219 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 220 done(); 221 } 222 }) 223 224 /* 225 * @tc.name:DeviceManager_bindDevices_009 226 * @tc.desc:verify bindDevice promise 227 * @tc.type: FUNC 228 */ 229 it("DeviceManager_bindDevices_009", 0, async function (done) { 230 console.info('----------------------DeviceManager_bindDevices_009---------------------------'); 231 try { 232 deviceManager.bindDevice('fakeid', (error, data) => { 233 expect(false).assertTrue(); 234 done(); 235 }).then(data => { 236 expect(false).assertTrue(); 237 done(); 238 }, error => { 239 expect(false).assertTrue(); 240 done(); 241 }); 242 expect(false).assertTrue(); 243 done(); 244 } catch (error) { 245 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 246 done(); 247 } 248 }) 249 250 /* 251 * @tc.name:DeviceManager_bindDevices_010 252 * @tc.desc:verify bindDevice promise 253 * @tc.type: FUNC 254 */ 255 it("DeviceManager_bindDevices_010", 0, async function (done) { 256 console.info('----------------------DeviceManager_bindDevices_010---------------------------'); 257 try { 258 deviceManager.bindDevice(12345, (error, data) => { 259 expect(false).assertTrue(); 260 done(); 261 }).then(data => { 262 expect(false).assertTrue(); 263 done(); 264 }, error => { 265 expect(false).assertTrue(); 266 done(); 267 }); 268 expect(false).assertTrue(); 269 done(); 270 } catch (error) { 271 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 272 done(); 273 } 274 }) 275 276 /* 277 * @tc.name:DeviceManager_bindDeviceDriver_011 278 * @tc.desc:verify bindDeviceDriver promise 279 * @tc.type: FUNC 280 */ 281 it("DeviceManager_bindDeviceDriver_011", 0, async function (done) { 282 console.info('----------------------DeviceManager_bindDeviceDriver_011---------------------------'); 283 try { 284 deviceManager.bindDeviceDriver(12345, (error, data) => { 285 expect(false).assertTrue(); 286 done(); 287 }).then(data => { 288 expect(data != null).assertTrue(); 289 let remoteDeviceDriver = data; 290 expect(remoteDeviceDriver.deviceId != null).assertTrue(); 291 expect(remoteDeviceDriver.remote != null).assertTrue(); 292 done(); 293 }, error => { 294 expect(false).assertTrue(); 295 done(); 296 }); 297 expect(false).assertTrue(); 298 done(); 299 } catch (error) { 300 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 301 done(); 302 } 303 }) 304 305 /* 306 * @tc.name:DeviceManager_unbindDevices_012 307 * @tc.desc:verify unbindDevice any device 308 * @tc.type: FUNC 309 */ 310 it("DeviceManager_unbindDevices_012", 0, async function (done) { 311 console.info('----------------------DeviceManager_unbindDevices_012---------------------------'); 312 try { 313 deviceManager.unbindDevice('fakeid', (error, data) => { 314 expect(false).assertTrue(); 315 done(); 316 }); 317 expect(false).assertTrue(); 318 done(); 319 } catch (error) { 320 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 321 done(); 322 } 323 }) 324 325 /* 326 * @tc.name:DeviceManager_unbindDevices_013 327 * @tc.desc:verify unbindDevice any device 328 * @tc.type: FUNC 329 */ 330 it("DeviceManager_unbindDevices_013", 0, async function (done) { 331 console.info('----------------------DeviceManager_unbindDevices_013---------------------------'); 332 try { 333 deviceManager.unbindDevice(12345, (error, data) => { 334 expect(false).assertTrue(); 335 done(); 336 }); 337 expect(false).assertTrue(); 338 done(); 339 } catch (error) { 340 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 341 done(); 342 } 343 }) 344 345 /* 346 * @tc.name:DeviceManager_unbindDevices_014 347 * @tc.desc:verify unbindDevice invalid param 348 * @tc.type: FUNC 349 */ 350 it("DeviceManager_unbindDevices_014", 0, async function (done) { 351 console.info('----------------------DeviceManager_unbindDevices_014---------------------------'); 352 try { 353 deviceManager.unbindDevice(); 354 expect(false).assertTrue(); 355 done(); 356 } catch (error) { 357 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 358 done(); 359 } 360 }) 361 362 /* 363 * @tc.name:DeviceManager_unbindDevices_015 364 * @tc.desc:verify unbindDevice promise 365 * @tc.type: FUNC 366 */ 367 it("DeviceManager_unbindDevices_015", 0, async function (done) { 368 console.info('----------------------DeviceManager_unbindDevices_015---------------------------'); 369 try { 370 deviceManager.unbindDevice(12345).then(data => { 371 expect(false).assertTrue(); 372 done(); 373 }, error => { 374 expect(false).assertTrue(); 375 done(); 376 }); 377 expect(false).assertTrue(); 378 done(); 379 } catch (error) { 380 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 381 done(); 382 } 383 }) 384/* 385 * @tc.name:DeviceManager_bindDriverWithDeviceId_003 386 * @tc.desc:verify bindDriverWithDeviceId invalid param 387 * @tc.type: FUNC 388 */ 389it("DeviceManager_bindDriverWithDeviceId_003", 0, async function (done) { 390 console.info('----------------------DeviceManager_bindDriverWithDeviceId_003---------------------------'); 391 try { 392 deviceManager.bindDevice('fakeid', (error, data) => { 393 expect(false).assertTrue(); 394 done(); 395 }, (error, data) => { 396 expect(false).assertTrue(); 397 done(); 398 }); 399 expect(false).assertTrue(); 400 done(); 401 } catch (error) { 402 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 403 done(); 404 } 405}) 406 407/* 408 * @tc.name:DeviceManager_bindDriverWithDeviceId_004 409 * @tc.desc:verify bindDevice any device 410 * @tc.type: FUNC 411 */ 412it("DeviceManager_bindDriverWithDeviceId_004", 0, async function (done) { 413 console.info('----------------------DeviceManager_bindDriverWithDeviceId_004---------------------------'); 414 try { 415 deviceManager.bindDevice(12345, (error, data) => { 416 expect(false).assertTrue(); 417 done(); 418 }, (error, data) => { 419 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 420 done(); 421 }); 422 expect(false).assertTrue(); 423 done(); 424 } catch (error) { 425 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 426 done(); 427 } 428}) 429 430/* 431 * @tc.name:DeviceManager_bindDeviceDriver_005 432 * @tc.desc:verify bindDeviceDriver any device 433 * @tc.type: FUNC 434 */ 435it("DeviceManager_bindDeviceDriver_005", 0, async function (done) { 436 console.info('----------------------DeviceManager_bindDeviceDriver_005---------------------------'); 437 try { 438 deviceManager.bindDeviceDriver(12345, (error, data) => { 439 expect(false).assertTrue(); 440 done(); 441 }, (error, data) => { 442 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 443 done(); 444 }); 445 expect(false).assertTrue(); 446 done(); 447 } catch (error) { 448 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 449 done(); 450 } 451}) 452 453/* 454 * @tc.name:DeviceManager_bindDriverWithDeviceId_006 455 * @tc.desc:verify bindDevice invalid param count 456 * @tc.type: FUNC 457 */ 458it("DeviceManager_bindDriverWithDeviceId_006", 0, async function (done) { 459 console.info('----------------------DeviceManager_bindDriverWithDeviceId_006---------------------------'); 460 try { 461 deviceManager.bindDevice(); 462 expect(false).assertTrue(); 463 done(); 464 } catch (error) { 465 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 466 done(); 467 } 468}) 469 470/* 471 * @tc.name:DeviceManager_bindDriverWithDeviceId_007 472 * @tc.desc:verify bindDevice invalid param 473 * @tc.type: FUNC 474 */ 475it("DeviceManager_bindDriverWithDeviceId_007", 0, async function (done) { 476 console.info('----------------------DeviceManager_bindDriverWithDeviceId_007---------------------------'); 477 try { 478 deviceManager.bindDevice(12345); 479 expect(false).assertTrue(); 480 done(); 481 } catch (error) { 482 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 483 done(); 484 } 485}) 486 487/* 488 * @tc.name:DeviceManager_bindDriverWithDeviceId_008 489 * @tc.desc:verify bindDevice invalid param 490 * @tc.type: FUNC 491 */ 492it("DeviceManager_bindDriverWithDeviceId_008", 0, async function (done) { 493 console.info('----------------------DeviceManager_bindDriverWithDeviceId_008---------------------------'); 494 try { 495 deviceManager.bindDevice(12345, 23456); 496 expect(false).assertTrue(); 497 done(); 498 } catch (error) { 499 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 500 done(); 501 } 502}) 503 504/* 505 * @tc.name:DeviceManager_bindDriverWithDeviceId_009 506 * @tc.desc:verify bindDevice promise 507 * @tc.type: FUNC 508 */ 509it("DeviceManager_bindDriverWithDeviceId_009", 0, async function (done) { 510 console.info('----------------------DeviceManager_bindDriverWithDeviceId_009---------------------------'); 511 try { 512 deviceManager.bindDevice('fakeid', (error, data) => { 513 expect(false).assertTrue(); 514 done(); 515 }).then(data => { 516 expect(false).assertTrue(); 517 done(); 518 }, error => { 519 expect(false).assertTrue(); 520 done(); 521 }); 522 expect(false).assertTrue(); 523 done(); 524 } catch (error) { 525 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 526 done(); 527 } 528}) 529 530/* 531 * @tc.name:DeviceManager_bindDriverWithDeviceId_010 532 * @tc.desc:verify bindDevice promise 533 * @tc.type: FUNC 534 */ 535it("DeviceManager_bindDriverWithDeviceId_010", 0, async function (done) { 536 console.info('----------------------DeviceManager_bindDriverWithDeviceId_010---------------------------'); 537 try { 538 deviceManager.bindDevice(12345, (error, data) => { 539 expect(false).assertTrue(); 540 done(); 541 }).then(data => { 542 expect(false).assertTrue(); 543 done(); 544 }, error => { 545 expect(false).assertTrue(); 546 done(); 547 }); 548 expect(false).assertTrue(); 549 done(); 550 } catch (error) { 551 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 552 done(); 553 } 554}) 555 556/* 557 * @tc.name:DeviceManager_bindDeviceDriver_011 558 * @tc.desc:verify bindDeviceDriver promise 559 * @tc.type: FUNC 560 */ 561it("DeviceManager_bindDeviceDriver_011", 0, async function (done) { 562 console.info('----------------------DeviceManager_bindDeviceDriver_011---------------------------'); 563 try { 564 deviceManager.bindDeviceDriver(12345, (error, data) => { 565 expect(false).assertTrue(); 566 done(); 567 }).then(data => { 568 expect(data != null).assertTrue(); 569 let remoteDeviceDriver = data; 570 expect(remoteDeviceDriver.deviceId != null).assertTrue(); 571 expect(remoteDeviceDriver.remote != null).assertTrue(); 572 done(); 573 }, error => { 574 expect(false).assertTrue(); 575 done(); 576 }); 577 expect(false).assertTrue(); 578 done(); 579 } catch (error) { 580 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 581 done(); 582 } 583}) 584 585/* 586 * @tc.name:DeviceManager_unbindDriverWithDeviceId_012 587 * @tc.desc:verify unbindDevice any device 588 * @tc.type: FUNC 589 */ 590it("DeviceManager_unbindDriverWithDeviceId_012", 0, async function (done) { 591 console.info('----------------------DeviceManager_unbindDriverWithDeviceId_012---------------------------'); 592 try { 593 deviceManager.unbindDevice('fakeid', (error, data) => { 594 expect(false).assertTrue(); 595 done(); 596 }); 597 expect(false).assertTrue(); 598 done(); 599 } catch (error) { 600 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 601 done(); 602 } 603}) 604 605/* 606 * @tc.name:DeviceManager_unbindDriverWithDeviceId_013 607 * @tc.desc:verify unbindDevice any device 608 * @tc.type: FUNC 609 */ 610it("DeviceManager_unbindDriverWithDeviceId_013", 0, async function (done) { 611 console.info('----------------------DeviceManager_unbindDriverWithDeviceId_013---------------------------'); 612 try { 613 deviceManager.unbindDevice(12345, (error, data) => { 614 expect(false).assertTrue(); 615 done(); 616 }); 617 expect(false).assertTrue(); 618 done(); 619 } catch (error) { 620 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 621 done(); 622 } 623}) 624 625/* 626 * @tc.name:DeviceManager_unbindDriverWithDeviceId_014 627 * @tc.desc:verify unbindDevice invalid param 628 * @tc.type: FUNC 629 */ 630it("DeviceManager_unbindDriverWithDeviceId_014", 0, async function (done) { 631 console.info('----------------------DeviceManager_unbindDriverWithDeviceId_014---------------------------'); 632 try { 633 deviceManager.unbindDevice(); 634 expect(false).assertTrue(); 635 done(); 636 } catch (error) { 637 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 638 done(); 639 } 640}) 641 642/* 643 * @tc.name:DeviceManager_unbindDriverWithDeviceId_015 644 * @tc.desc:verify unbindDevice promise 645 * @tc.type: FUNC 646 */ 647it("DeviceManager_unbindDriverWithDeviceId_015", 0, async function (done) { 648 console.info('----------------------DeviceManager_unbindDriverWithDeviceId_015---------------------------'); 649 try { 650 deviceManager.unbindDevice(12345).then(data => { 651 expect(false).assertTrue(); 652 done(); 653 }, error => { 654 expect(false).assertTrue(); 655 done(); 656 }); 657 expect(false).assertTrue(); 658 done(); 659 } catch (error) { 660 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 661 done(); 662 } 663}) 664 /* 665 * @tc.name:DeviceManager_unbindDriverWithDeviceId_016 666 * @tc.desc:verify unbindDevice promise 667 * @tc.type: FUNC 668 */ 669 it("DeviceManager_unbindDriverWithDeviceId_016", 0, async function (done) { 670 console.info('----------------------DeviceManager_unbindDriverWithDeviceId_016---------------------------'); 671 try { 672 if (deviceId == null) { 673 console.log('Device ID has not been set.'); 674 expect(true).assertTrue(); 675 done(); 676 return; 677 } 678 deviceManager.unbindDriverWithDeviceId(deviceId).then(data => { 679 expect(false).assertTrue(); 680 done(); 681 }, error => { 682 expect(false).assertTrue(); 683 done(); 684 }); 685 expect(false).assertTrue(); 686 done(); 687 } catch (error) { 688 expect(error.code).assertEqual(SERVICE_NOT_BOUND); 689 done(); 690 } 691 }) 692 693 /* 694 * @tc.name:DeviceManager_unbindDriverWithDeviceId_017 695 * @tc.desc:verify unbindDevice promise 696 * @tc.type: FUNC 697 */ 698 it("DeviceManager_unbindDriverWithDeviceId_017", 0, async function (done) { 699 console.info('----------------------DeviceManager_unbindDriverWithDeviceId_017---------------------------'); 700 try { 701 if (deviceId == null) { 702 console.log('Device ID has not been set.'); 703 expect(true).assertTrue(); 704 done(); 705 return; 706 } 707 deviceManager.unbindDriverWithDeviceId(deviceId, (error, data) => { 708 expect(false).assertTrue(); 709 done(); 710 }); 711 expect(false).assertTrue(); 712 done(); 713 } catch (error) { 714 expect(error.code).assertEqual(SERVICE_NOT_BOUND); 715 done(); 716 } 717 }) 718 719 /* 720 * @tc.name:DeviceManager_queryDeviceInfo_001 721 * @tc.desc:verify queryDeviceInfo invalid param 722 * @tc.type: FUNC 723 */ 724 it("DeviceManager_queryDeviceInfo_001", 0, async function () { 725 console.info('----------------------DeviceManager_queryDeviceInfo_001---------------------------'); 726 try { 727 deviceManager.queryDeviceInfo('invalidDeviceId'); 728 expect(false).assertTrue(); 729 } catch (error) { 730 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 731 } 732 }) 733 734 function isUsbDevice(deviceId) { 735 return (deviceId & 0x00000000FFFFFFFF) === deviceManager.BusType.USB; 736 } 737 738 function assertInterfaceDesc(interfaceDesc) { 739 expect(Object.prototype.toString.call(interfaceDesc)).assertEqual('[object Object]'); 740 console.log('interfaceDesc.bInterfaceNumber:' + interfaceDesc.bInterfaceNumber); 741 expect(typeof(interfaceDesc.bInterfaceNumber)).assertEqual('number'); 742 console.log('interfaceDesc.bClass:' + interfaceDesc.bClass); 743 expect(typeof(interfaceDesc.bClass)).assertEqual('number'); 744 console.log('interfaceDesc.bSubClass:' + interfaceDesc.bSubClass); 745 expect(typeof(interfaceDesc.bSubClass)).assertEqual('number'); 746 console.log('interfaceDesc.bProtocol:' + interfaceDesc.bProtocol); 747 expect(typeof(interfaceDesc.bProtocol)).assertEqual('number'); 748 } 749 750 function assertUsbDeviceInfoExt(usbDeviceInfo) { 751 expect(Object.prototype.toString.call(usbDeviceInfo)).assertEqual('[object Object]'); 752 console.log('usbDeviceInfo.vendorId:' + usbDeviceInfo.vendorId); 753 expect(typeof(usbDeviceInfo.vendorId)).assertEqual('number'); 754 console.log('usbDeviceInfo.productId:' + usbDeviceInfo.productId); 755 expect(typeof(usbDeviceInfo.productId)).assertEqual('number'); 756 expect(Array.isArray(usbDeviceInfo.interfaceDescList)).assertTrue(); 757 for (const desc of usbDeviceInfo.interfaceDescList) { 758 assertInterfaceDesc(desc); 759 } 760 } 761 762 function assertDeviceInfo(deviceInfo) { 763 expect(Object.prototype.toString.call(deviceInfo)).assertEqual('[object Object]'); 764 console.log('deviceInfo.deviceId:' + deviceInfo.deviceId); 765 expect(typeof(deviceInfo.deviceId)).assertEqual('number'); 766 console.log('deviceInfo.isDriverMatched:' + deviceInfo.isDriverMatched); 767 expect(typeof(deviceInfo.isDriverMatched)).assertEqual('boolean'); 768 if (deviceInfo.isDriverMatched) { 769 console.log('deviceInfo.driverUid:' + deviceInfo.driverUid); 770 expect(typeof(deviceInfo.driverUid)).assertEqual('string'); 771 } 772 if (isUsbDevice(deviceInfo.deviceId)) { 773 assertUsbDeviceInfoExt(deviceInfo) 774 } 775 } 776 777 /* 778 * @tc.name:DeviceManager_queryDeviceInfo_002 779 * @tc.desc:verify queryDeviceInfo none deviceId 780 * @tc.type: FUNC 781 */ 782 it("DeviceManager_queryDeviceInfo_002", 0, async function () { 783 console.info('----------------------DeviceManager_queryDeviceInfo_002---------------------------'); 784 try { 785 const deviceInfos = deviceManager.queryDeviceInfo(); 786 expect(Array.isArray(deviceInfos)).assertTrue(); 787 for (const deviceInfo of deviceInfos) { 788 assertDeviceInfo(deviceInfo); 789 } 790 } catch (error) { 791 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 792 } 793 }) 794 795 /* 796 * @tc.name:DeviceManager_queryDeviceInfo_003 797 * @tc.desc:verify queryDeviceInfo has deviceId 798 * @tc.type: FUNC 799 */ 800 it("DeviceManager_queryDeviceInfo_003", 0, async function () { 801 console.info('----------------------DeviceManager_queryDeviceInfo_003---------------------------'); 802 try { 803 const deviceInfos = deviceManager.queryDeviceInfo(12345); 804 expect(Array.isArray(deviceInfos)).assertTrue(); 805 for (const deviceInfo of deviceInfos) { 806 assertDeviceInfo(deviceInfo); 807 } 808 } catch (error) { 809 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 810 } 811 }) 812 813 /* 814 * @tc.name:DeviceManager_queryDriverInfo_001 815 * @tc.desc:verify queryDriverInfo invalid param 816 * @tc.type: FUNC 817 */ 818 it("DeviceManager_queryDriverInfo_001", 0, async function () { 819 console.info('----------------------DeviceManager_queryDriverInfo_001---------------------------'); 820 try { 821 deviceManager.queryDriverInfo(12345); 822 expect(false).assertTrue(); 823 } catch (error) { 824 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 825 } 826 }) 827 828 function assertDriverInfo(driverInfo) { 829 expect(Object.prototype.toString.call(driverInfo)).assertEqual('[object Object]'); 830 console.log('driverInfo.busType:' + driverInfo.busType); 831 expect(typeof(driverInfo.busType)).assertEqual('number'); 832 console.log('driverInfo.driverUid:' + driverInfo.driverUid); 833 expect(typeof(driverInfo.driverUid)).assertEqual('string'); 834 console.log('driverInfo.driverName:' + driverInfo.driverName); 835 expect(typeof(driverInfo.driverName)).assertEqual('string'); 836 console.log('driverInfo.driverVersion:' + driverInfo.driverVersion); 837 expect(typeof(driverInfo.driverVersion)).assertEqual('string'); 838 console.log('driverInfo.driverSize:' + driverInfo.driverSize); 839 expect(typeof(driverInfo.driverSize)).assertEqual('string'); 840 console.log('driverInfo.description:' + driverInfo.description); 841 expect(typeof(driverInfo.description)).assertEqual('string'); 842 if (driverInfo.busType === deviceManager.BusType.USB) { 843 console.log('driverInfo.productIdList:' + JSON.stringify(driverInfo.productIdList)); 844 expect(Array.isArray(driverInfo.productIdList)).assertTrue(); 845 console.log('driverInfo.vendorIdList:' + JSON.stringify(driverInfo.vendorIdList)); 846 expect(Array.isArray(driverInfo.vendorIdList)).assertTrue(); 847 for (const productId of driverInfo.productIdList) { 848 expect(typeof(productId)).assertEqual('number'); 849 } 850 for (const vendorId of driverInfo.vendorIdList) { 851 expect(typeof(vendorId)).assertEqual('number'); 852 } 853 } 854 } 855 856 /* 857 * @tc.name:DeviceManager_queryDriverInfo_002 858 * @tc.desc:verify queryDriverInfo none driverUid 859 * @tc.type: FUNC 860 */ 861 it("DeviceManager_queryDriverInfo_002", 0, async function () { 862 console.info('----------------------DeviceManager_queryDriverInfo_002---------------------------'); 863 try { 864 const driverInfos = deviceManager.queryDriverInfo(); 865 expect(Array.isArray(driverInfos)).assertTrue(); 866 for (const driverInfo of driverInfos) { 867 assertDriverInfo(driverInfo); 868 } 869 } catch (error) { 870 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 871 } 872 }) 873 874 /* 875 * @tc.name:DeviceManager_queryDriverInfo_003 876 * @tc.desc:verify queryDriverInfo has driverUid 877 * @tc.type: FUNC 878 */ 879 it("DeviceManager_queryDriverInfo_003", 0, async function () { 880 console.info('----------------------DeviceManager_queryDriverInfo_003---------------------------'); 881 try { 882 const driverInfos = deviceManager.queryDriverInfo('driver-12345'); 883 expect(Array.isArray(driverInfos)).assertTrue(); 884 for (const driverInfo of driverInfos) { 885 assertDriverInfo(driverInfo); 886 } 887 } catch (error) { 888 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 889 } 890 }) 891})