1/* 2 * Copyright (C) 2023 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 function callback(data) { 21 console.info("callback" + JSON.stringify(data)); 22 expect(typeof(data.x)).assertEqual("number"); 23 } 24 25 function callback2() { 26 console.info("callback2" + JSON.stringify(data)); 27 expect(typeof(data.x)).assertEqual("number"); 28 } 29 30 beforeAll(function() { 31 console.info('beforeAll called') 32 }) 33 34 afterAll(function() { 35 console.info('afterAll called') 36 }) 37 38 beforeEach(function() { 39 console.info('beforeEach called') 40 }) 41 42 afterEach(function() { 43 console.info('afterEach called') 44 }) 45 46 const PARAMETER_ERROR_CODE = 401 47 const SERVICE_EXCEPTION_CODE = 22900001 48 const SERVICE_EXCEPTION_CODE_NEW = 26300001 49 50 /* 51 * @tc.name:DeviceManager_queryDevices_001 52 * @tc.desc:verify queryDevice result 53 * @tc.type: FUNC 54 */ 55 it("DeviceManager_queryDevices_001", 0, function () { 56 console.info('----------------------DeviceManager_queryDevices_001---------------------------'); 57 try { 58 var devices = deviceManager.queryDevices(deviceManager.BusType.USB); 59 expect(devices != null).assertEqual(true); 60 if (devices.length > 0) { 61 expect(devices[0] != null).assertEqual(true); 62 expect(devices[0].vendorId != null).assertEqual(true); 63 expect(devices[0].productId != null).assertEqual(true); 64 } 65 } catch (err) { 66 expect(err.code).assertEqual(SERVICE_EXCEPTION_CODE); 67 } 68 }) 69 70 /* 71 * @tc.name:DeviceManager_queryDevices_002 72 * @tc.desc:verify queryDevice no param result 73 * @tc.type: FUNC 74 */ 75 it("DeviceManager_queryDevices_002", 0, function () { 76 console.info('----------------------DeviceManager_queryDevices_002---------------------------'); 77 try { 78 var devices = deviceManager.queryDevices(); 79 expect(devices != null).assertEqual(true); 80 } catch (err) { 81 expect(err.code).assertEqual(SERVICE_EXCEPTION_CODE); 82 } 83 }) 84 85 /* 86 * @tc.name:DeviceManager_bindDevices_003 87 * @tc.desc:verify bindDevice invalid param 88 * @tc.type: FUNC 89 */ 90 it("DeviceManager_bindDevices_003", 0, async function (done) { 91 console.info('----------------------DeviceManager_bindDevices_003---------------------------'); 92 try { 93 deviceManager.bindDevice('fakeid', (error, data) => { 94 expect(false).assertTrue(); 95 done(); 96 }, (error, data) => { 97 expect(false).assertTrue(); 98 done(); 99 }); 100 expect(false).assertTrue(); 101 done(); 102 } catch (error) { 103 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 104 done(); 105 } 106 }) 107 108 /* 109 * @tc.name:DeviceManager_bindDevices_004 110 * @tc.desc:verify bindDevice any device 111 * @tc.type: FUNC 112 */ 113 it("DeviceManager_bindDevices_004", 0, async function (done) { 114 console.info('----------------------DeviceManager_bindDevices_004---------------------------'); 115 try { 116 deviceManager.bindDevice(12345, (error, data) => { 117 expect(false).assertTrue(); 118 done(); 119 }, (error, data) => { 120 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 121 done(); 122 }); 123 expect(false).assertTrue(); 124 done(); 125 } catch (error) { 126 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 127 done(); 128 } 129 }) 130 131 /* 132 * @tc.name:DeviceManager_bindDeviceDriver_005 133 * @tc.desc:verify bindDeviceDriver any device 134 * @tc.type: FUNC 135 */ 136 it("DeviceManager_bindDeviceDriver_005", 0, async function (done) { 137 console.info('----------------------DeviceManager_bindDeviceDriver_005---------------------------'); 138 try { 139 deviceManager.bindDeviceDriver(12345, (error, data) => { 140 expect(false).assertTrue(); 141 done(); 142 }, (error, data) => { 143 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 144 done(); 145 }); 146 expect(false).assertTrue(); 147 done(); 148 } catch (error) { 149 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 150 done(); 151 } 152 }) 153 154 /* 155 * @tc.name:DeviceManager_bindDevices_006 156 * @tc.desc:verify bindDevice invalid param count 157 * @tc.type: FUNC 158 */ 159 it("DeviceManager_bindDevices_006", 0, async function (done) { 160 console.info('----------------------DeviceManager_bindDevices_006---------------------------'); 161 try { 162 deviceManager.bindDevice(); 163 expect(false).assertTrue(); 164 done(); 165 } catch (error) { 166 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 167 done(); 168 } 169 }) 170 171 /* 172 * @tc.name:DeviceManager_bindDevices_007 173 * @tc.desc:verify bindDevice invalid param 174 * @tc.type: FUNC 175 */ 176 it("DeviceManager_bindDevices_007", 0, async function (done) { 177 console.info('----------------------DeviceManager_bindDevices_007---------------------------'); 178 try { 179 deviceManager.bindDevice(12345); 180 expect(false).assertTrue(); 181 done(); 182 } catch (error) { 183 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 184 done(); 185 } 186 }) 187 188 /* 189 * @tc.name:DeviceManager_bindDevices_008 190 * @tc.desc:verify bindDevice invalid param 191 * @tc.type: FUNC 192 */ 193 it("DeviceManager_bindDevices_008", 0, async function (done) { 194 console.info('----------------------DeviceManager_bindDevices_008---------------------------'); 195 try { 196 deviceManager.bindDevice(12345, 23456); 197 expect(false).assertTrue(); 198 done(); 199 } catch (error) { 200 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 201 done(); 202 } 203 }) 204 205 /* 206 * @tc.name:DeviceManager_bindDevices_009 207 * @tc.desc:verify bindDevice promise 208 * @tc.type: FUNC 209 */ 210 it("DeviceManager_bindDevices_009", 0, async function (done) { 211 console.info('----------------------DeviceManager_bindDevices_009---------------------------'); 212 try { 213 deviceManager.bindDevice('fakeid', (error, data) => { 214 expect(false).assertTrue(); 215 done(); 216 }).then(data => { 217 expect(false).assertTrue(); 218 done(); 219 }, error => { 220 expect(false).assertTrue(); 221 done(); 222 }); 223 expect(false).assertTrue(); 224 done(); 225 } catch (error) { 226 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 227 done(); 228 } 229 }) 230 231 /* 232 * @tc.name:DeviceManager_bindDevices_010 233 * @tc.desc:verify bindDevice promise 234 * @tc.type: FUNC 235 */ 236 it("DeviceManager_bindDevices_010", 0, async function (done) { 237 console.info('----------------------DeviceManager_bindDevices_010---------------------------'); 238 try { 239 deviceManager.bindDevice(12345, (error, data) => { 240 expect(false).assertTrue(); 241 done(); 242 }).then(data => { 243 expect(false).assertTrue(); 244 done(); 245 }, error => { 246 expect(false).assertTrue(); 247 done(); 248 }); 249 expect(false).assertTrue(); 250 done(); 251 } catch (error) { 252 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 253 done(); 254 } 255 }) 256 257 /* 258 * @tc.name:DeviceManager_bindDeviceDriver_011 259 * @tc.desc:verify bindDeviceDriver promise 260 * @tc.type: FUNC 261 */ 262 it("DeviceManager_bindDeviceDriver_011", 0, async function (done) { 263 console.info('----------------------DeviceManager_bindDeviceDriver_011---------------------------'); 264 try { 265 deviceManager.bindDeviceDriver(12345, (error, data) => { 266 expect(false).assertTrue(); 267 done(); 268 }).then(data => { 269 expect(data != null).assertTrue(); 270 let remoteDeviceDriver = data; 271 expect(remoteDeviceDriver.deviceId != null).assertTrue(); 272 expect(remoteDeviceDriver.remote != null).assertTrue(); 273 done(); 274 }, error => { 275 expect(false).assertTrue(); 276 done(); 277 }); 278 expect(false).assertTrue(); 279 done(); 280 } catch (error) { 281 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 282 done(); 283 } 284 }) 285 286 /* 287 * @tc.name:DeviceManager_unbindDevices_012 288 * @tc.desc:verify unbindDevice any device 289 * @tc.type: FUNC 290 */ 291 it("DeviceManager_unbindDevices_012", 0, async function (done) { 292 console.info('----------------------DeviceManager_unbindDevices_012---------------------------'); 293 try { 294 deviceManager.unbindDevice('fakeid', (error, data) => { 295 expect(false).assertTrue(); 296 done(); 297 }); 298 expect(false).assertTrue(); 299 done(); 300 } catch (error) { 301 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 302 done(); 303 } 304 }) 305 306 /* 307 * @tc.name:DeviceManager_unbindDevices_013 308 * @tc.desc:verify unbindDevice any device 309 * @tc.type: FUNC 310 */ 311 it("DeviceManager_unbindDevices_013", 0, async function (done) { 312 console.info('----------------------DeviceManager_unbindDevices_013---------------------------'); 313 try { 314 deviceManager.unbindDevice(12345, (error, data) => { 315 expect(false).assertTrue(); 316 done(); 317 }); 318 expect(false).assertTrue(); 319 done(); 320 } catch (error) { 321 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 322 done(); 323 } 324 }) 325 326 /* 327 * @tc.name:DeviceManager_unbindDevices_014 328 * @tc.desc:verify unbindDevice invalid param 329 * @tc.type: FUNC 330 */ 331 it("DeviceManager_unbindDevices_014", 0, async function (done) { 332 console.info('----------------------DeviceManager_unbindDevices_014---------------------------'); 333 try { 334 deviceManager.unbindDevice(); 335 expect(false).assertTrue(); 336 done(); 337 } catch (error) { 338 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 339 done(); 340 } 341 }) 342 343 /* 344 * @tc.name:DeviceManager_unbindDevices_015 345 * @tc.desc:verify unbindDevice promise 346 * @tc.type: FUNC 347 */ 348 it("DeviceManager_unbindDevices_015", 0, async function (done) { 349 console.info('----------------------DeviceManager_unbindDevices_015---------------------------'); 350 try { 351 deviceManager.unbindDevice(12345).then(data => { 352 expect(false).assertTrue(); 353 done(); 354 }, error => { 355 expect(false).assertTrue(); 356 done(); 357 }); 358 expect(false).assertTrue(); 359 done(); 360 } catch (error) { 361 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE); 362 done(); 363 } 364 }) 365 366 /* 367 * @tc.name:DeviceManager_queryDeviceInfo_001 368 * @tc.desc:verify queryDeviceInfo invalid param 369 * @tc.type: FUNC 370 */ 371 it("DeviceManager_queryDeviceInfo_001", 0, async function () { 372 console.info('----------------------DeviceManager_queryDeviceInfo_001---------------------------'); 373 try { 374 deviceManager.queryDeviceInfo('invalidDeviceId'); 375 expect(false).assertTrue(); 376 } catch (error) { 377 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 378 } 379 }) 380 381 function isUsbDevice(deviceId) { 382 return (deviceId & 0x00000000FFFFFFFF) === deviceManager.BusType.USB; 383 } 384 385 function assertInterfaceDesc(interfaceDesc) { 386 expect(Object.prototype.toString.call(interfaceDesc)).assertEqual('[object Object]'); 387 console.log('interfaceDesc.bInterfaceNumber:' + interfaceDesc.bInterfaceNumber); 388 expect(typeof(interfaceDesc.bInterfaceNumber)).assertEqual('number'); 389 console.log('interfaceDesc.bClass:' + interfaceDesc.bClass); 390 expect(typeof(interfaceDesc.bClass)).assertEqual('number'); 391 console.log('interfaceDesc.bSubClass:' + interfaceDesc.bSubClass); 392 expect(typeof(interfaceDesc.bSubClass)).assertEqual('number'); 393 console.log('interfaceDesc.bProtocol:' + interfaceDesc.bProtocol); 394 expect(typeof(interfaceDesc.bProtocol)).assertEqual('number'); 395 } 396 397 function assertUsbDeviceInfoExt(usbDeviceInfo) { 398 expect(Object.prototype.toString.call(usbDeviceInfo)).assertEqual('[object Object]'); 399 console.log('usbDeviceInfo.vendorId:' + usbDeviceInfo.vendorId); 400 expect(typeof(usbDeviceInfo.vendorId)).assertEqual('number'); 401 console.log('usbDeviceInfo.productId:' + usbDeviceInfo.productId); 402 expect(typeof(usbDeviceInfo.productId)).assertEqual('number'); 403 expect(Array.isArray(usbDeviceInfo.interfaceDescList)).assertTrue(); 404 for (const desc of usbDeviceInfo.interfaceDescList) { 405 assertInterfaceDesc(desc); 406 } 407 } 408 409 function assertDeviceInfo(deviceInfo) { 410 expect(Object.prototype.toString.call(deviceInfo)).assertEqual('[object Object]'); 411 console.log('deviceInfo.deviceId:' + deviceInfo.deviceId); 412 expect(typeof(deviceInfo.deviceId)).assertEqual('number'); 413 console.log('deviceInfo.isDriverMatched:' + deviceInfo.isDriverMatched); 414 expect(typeof(deviceInfo.isDriverMatched)).assertEqual('boolean'); 415 if (deviceInfo.isDriverMatched) { 416 console.log('deviceInfo.driverUid:' + deviceInfo.driverUid); 417 expect(typeof(deviceInfo.driverUid)).assertEqual('string'); 418 } 419 if (isUsbDevice(deviceInfo.deviceId)) { 420 assertUsbDeviceInfoExt(deviceInfo) 421 } 422 } 423 424 /* 425 * @tc.name:DeviceManager_queryDeviceInfo_002 426 * @tc.desc:verify queryDeviceInfo none deviceId 427 * @tc.type: FUNC 428 */ 429 it("DeviceManager_queryDeviceInfo_002", 0, async function () { 430 console.info('----------------------DeviceManager_queryDeviceInfo_002---------------------------'); 431 try { 432 const deviceInfos = deviceManager.queryDeviceInfo(); 433 expect(Array.isArray(deviceInfos)).assertTrue(); 434 for (const deviceInfo of deviceInfos) { 435 assertDeviceInfo(deviceInfo); 436 } 437 } catch (error) { 438 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 439 } 440 }) 441 442 /* 443 * @tc.name:DeviceManager_queryDeviceInfo_003 444 * @tc.desc:verify queryDeviceInfo has deviceId 445 * @tc.type: FUNC 446 */ 447 it("DeviceManager_queryDeviceInfo_003", 0, async function () { 448 console.info('----------------------DeviceManager_queryDeviceInfo_003---------------------------'); 449 try { 450 const deviceInfos = deviceManager.queryDeviceInfo(12345); 451 expect(Array.isArray(deviceInfos)).assertTrue(); 452 for (const deviceInfo of deviceInfos) { 453 assertDeviceInfo(deviceInfo); 454 } 455 } catch (error) { 456 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 457 } 458 }) 459 460 /* 461 * @tc.name:DeviceManager_queryDriverInfo_001 462 * @tc.desc:verify queryDriverInfo invalid param 463 * @tc.type: FUNC 464 */ 465 it("DeviceManager_queryDriverInfo_001", 0, async function () { 466 console.info('----------------------DeviceManager_queryDriverInfo_001---------------------------'); 467 try { 468 deviceManager.queryDriverInfo(12345); 469 expect(false).assertTrue(); 470 } catch (error) { 471 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 472 } 473 }) 474 475 function assertDriverInfo(driverInfo) { 476 expect(Object.prototype.toString.call(driverInfo)).assertEqual('[object Object]'); 477 console.log('driverInfo.busType:' + driverInfo.busType); 478 expect(typeof(driverInfo.busType)).assertEqual('number'); 479 console.log('driverInfo.driverUid:' + driverInfo.driverUid); 480 expect(typeof(driverInfo.driverUid)).assertEqual('string'); 481 console.log('driverInfo.driverName:' + driverInfo.driverName); 482 expect(typeof(driverInfo.driverName)).assertEqual('string'); 483 console.log('driverInfo.driverVersion:' + driverInfo.driverVersion); 484 expect(typeof(driverInfo.driverVersion)).assertEqual('string'); 485 console.log('driverInfo.driverSize:' + driverInfo.driverSize); 486 expect(typeof(driverInfo.driverSize)).assertEqual('string'); 487 console.log('driverInfo.description:' + driverInfo.description); 488 expect(typeof(driverInfo.description)).assertEqual('string'); 489 if (driverInfo.busType === deviceManager.BusType.USB) { 490 console.log('driverInfo.productIdList:' + JSON.stringify(driverInfo.productIdList)); 491 expect(Array.isArray(driverInfo.productIdList)).assertTrue(); 492 console.log('driverInfo.vendorIdList:' + JSON.stringify(driverInfo.vendorIdList)); 493 expect(Array.isArray(driverInfo.vendorIdList)).assertTrue(); 494 for (const productId of driverInfo.productIdList) { 495 expect(typeof(productId)).assertEqual('number'); 496 } 497 for (const vendorId of driverInfo.vendorIdList) { 498 expect(typeof(vendorId)).assertEqual('number'); 499 } 500 } 501 } 502 503 /* 504 * @tc.name:DeviceManager_queryDriverInfo_002 505 * @tc.desc:verify queryDriverInfo none driverUid 506 * @tc.type: FUNC 507 */ 508 it("DeviceManager_queryDriverInfo_002", 0, async function () { 509 console.info('----------------------DeviceManager_queryDriverInfo_002---------------------------'); 510 try { 511 const driverInfos = deviceManager.queryDriverInfo(); 512 expect(Array.isArray(driverInfos)).assertTrue(); 513 for (const driverInfo of driverInfos) { 514 assertDriverInfo(driverInfo); 515 } 516 } catch (error) { 517 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 518 } 519 }) 520 521 /* 522 * @tc.name:DeviceManager_queryDriverInfo_003 523 * @tc.desc:verify queryDriverInfo has driverUid 524 * @tc.type: FUNC 525 */ 526 it("DeviceManager_queryDriverInfo_003", 0, async function () { 527 console.info('----------------------DeviceManager_queryDriverInfo_003---------------------------'); 528 try { 529 const driverInfos = deviceManager.queryDriverInfo('driver-12345'); 530 expect(Array.isArray(driverInfos)).assertTrue(); 531 for (const driverInfo of driverInfos) { 532 assertDriverInfo(driverInfo); 533 } 534 } catch (error) { 535 expect(error.code).assertEqual(SERVICE_EXCEPTION_CODE_NEW); 536 } 537 }) 538})