1/* 2 * Copyright (c) 2021-2024 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 usbManager from '@ohos.usbManager'; 17import { UiDriver, BY } from '@ohos.UiTest'; 18import CheckEmptyUtils from './CheckEmptyUtils.js'; 19import EventConstants from './EventConstants.js'; 20import parameter from '@ohos.systemparameter'; 21import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium' 22 23/* usb device pipe test */ 24export default function UsbDevicePipeJsFunctionsTestEx() { 25describe('UsbDevicePipeJsFunctionsTestEx', function () { 26 27 let gDeviceList; 28 let gPipe; 29 let isDeviceConnected; 30 const TAG = "[UsbDevicePipeJsFunctionsTest]"; 31 32 function deviceConnected() { 33 if (gDeviceList.length > 0) { 34 console.info(TAG, "Test USB device is connected"); 35 return true; 36 } 37 console.info(TAG, "Test USB device is not connected"); 38 return false; 39 } 40 41 beforeAll(async function () { 42 console.log(TAG, '*************Usb Unit UsbDevicePipeJsFunctionsTestEx Begin*************'); 43 var Version = usbManager.getVersion(); 44 console.info(TAG, 'usb unit begin test getversion :' + Version); 45 46 // version > 17 host currentMode = 2 device currentMode = 1 47 gDeviceList = usbManager.getDevices(); 48 isDeviceConnected = deviceConnected(); 49 if (isDeviceConnected) { 50 let hasRight = usbManager.hasRight(gDeviceList[0].name); 51 if (!hasRight) { 52 console.info(TAG, `beforeAll: usb requestRight start`); 53 await getPermission(); 54 CheckEmptyUtils.sleep(1000); 55 await driveFn(); 56 CheckEmptyUtils.sleep(1000); 57 } 58 gPipe = usbManager.connectDevice(gDeviceList[0]); 59 console.info(TAG, 'usb unit connectDevice gPipe ret : ' + JSON.stringify(gPipe)); 60 } 61 }) 62 beforeEach(function () { 63 console.info(TAG, 'beforeEach: *************Usb Unit Test Ex Case*************'); 64 gDeviceList = usbManager.getDevices(); 65 console.info(TAG, 'beforeEach return devices : ' + JSON.stringify(gDeviceList)); 66 }) 67 afterEach(function () { 68 console.info(TAG, 'afterEach: *************Usb Unit Test Ex Case*************'); 69 gDeviceList = null; 70 }) 71 afterAll(function () { 72 let isPipClose = usbManager.closePipe(gPipe); 73 console.info(TAG, 'usb unit close gPipe ret : ' + isPipClose); 74 console.log(TAG, '*************Usb Unit UsbDevicePipeJsFunctionsTestEx End*************'); 75 }) 76 77 async function driveFn() { 78 console.info('**************driveFn**************'); 79 try { 80 let driver = await UiDriver.create(); 81 console.info(TAG, ` come in driveFn`); 82 console.info(TAG, `driver is ${JSON.stringify(driver)}`); 83 CheckEmptyUtils.sleep(1000); 84 let button = await driver.findComponent(BY.text('允许')); 85 console.info(TAG, `button is ${JSON.stringify(button)}`); 86 CheckEmptyUtils.sleep(1000); 87 await button.click(); 88 } catch (err) { 89 console.info(TAG, 'err is ' + err); 90 return; 91 } 92 } 93 94 async function getPermission() { 95 console.info('**************getPermission**************'); 96 try { 97 usbManager.requestRight(gDeviceList[0].name).then(hasRight => { 98 console.info(TAG, `usb requestRight success, hasRight: ${hasRight}`); 99 }) 100 } catch (err) { 101 console.info(TAG, `usb getPermission to requestRight hasRight fail: `, err); 102 return 103 } 104 } 105 106 function findInitPoint(testParam, j) { 107 var bfind = false; 108 for (var k = 0; k < testParam.config.interfaces[j].endpoints.length; k++) { 109 var endpoint = testParam.config.interfaces[j].endpoints[k]; 110 if (endpoint.type == EventConstants.USB_ENDPOINT_XFER_BULK) { 111 112 bfind = true; 113 if (endpoint.direction == usbManager.USB_REQUEST_DIR_TO_DEVICE) { 114 testParam.outEndpoint = endpoint; 115 testParam.maxOutSize = endpoint.maxPacketSize; 116 } else if (endpoint.direction == usbManager.USB_REQUEST_DIR_FROM_DEVICE) { 117 testParam.inEndpoint = endpoint; 118 testParam.maxInSize = endpoint.maxPacketSize; 119 } 120 } 121 } 122 if (bfind) { 123 testParam.interface = testParam.config.interfaces[j]; 124 return true; 125 } 126 return false; 127 } 128 129 function getFlag(testParam, j) { 130 if (testParam.config.interfaces[j].clazz != 10 || 131 testParam.config.interfaces[j].subClass != 0 || 132 testParam.config.interfaces[j].protocol != 2) { 133 return false; 134 } 135 136 if (testParam.config.interfaces[j].endpoints.length == 0) { 137 return false; 138 } 139 140 return true; 141 } 142 143 function initPoint(testParam) { 144 for (var j = 0; j < testParam.config.interfaces.length; j++) { 145 if (getFlag(testParam, j)) { 146 if (findInitPoint(testParam, j)) { 147 break 148 } 149 } 150 } 151 } 152 153 // Prefabrication transmission related parameters 154 function getTransferTestParam() { 155 var testParam = { 156 device: null, 157 config: null, 158 pip: null, 159 inEndpoint: null, 160 outEndpoint: null, 161 interface: null, 162 usbRequest: null, 163 sendData: '', 164 isClaimed: 0, 165 maxInSize: 1024, 166 maxOutSize: 1024 167 } 168 169 console.info(TAG, 'usb case gDeviceList.length: ' + gDeviceList.length); 170 for (var i = 0; i < gDeviceList.length; i++) { 171 testParam.device = gDeviceList[i]; 172 testParam.config = testParam.device.configs[0]; 173 testParam.pip = gPipe; 174 initPoint(testParam); 175 } 176 return testParam; 177 } 178 179 function getPipe(testCaseName) { 180 gPipe = usbManager.connectDevice(devices); 181 console.info(TAG, `usb ${testCaseName} connectDevice getPipe ret: ${JSON.stringify(gPipe)}`); 182 expect(gPipe.length > 0).assertTrue(); 183 } 184 185 186 function toReleaseInterface(testCaseName, conIndex, interIndex) { 187 gDeviceList = usbManager.getDevices(); 188 let tmpInterface = gDeviceList[0].configs[conIndex].interfaces[interIndex]; 189 let isClaim = usbManager.releaseInterface(gPipe, tmpInterface); 190 console.info(TAG, `usb ${testCaseName} toReleaseInterface ret: ${JSON.stringify(isClaim)}`); 191 expect(isClaim).assertEqual(0); 192 } 193 194 /** 195 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_0700 196 * @tc.name : testBulkTransfer006 197 * @tc.desc : Negative test: bulk transfer, send data, error outEndpoint.address = 123 198 * @tc.size : MediumTest 199 * @tc.type : Function 200 * @tc.level : Level 2 201 */ 202 it('testBulkTransfer006', 0, async function () { 203 console.info(TAG, 'usb testBulkTransfer006 begin'); 204 if (!isDeviceConnected) { 205 expect(isDeviceConnected).assertFalse(); 206 return 207 } 208 var testParam = getTransferTestParam(); 209 if (testParam.interface == null || testParam.outEndpoint == null) { 210 expect(testParam.interface == null).assertFalse(); 211 expect(testParam.outEndpoint == null).assertFalse(); 212 return 213 } 214 215 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 216 expect(testParam.isClaimed).assertEqual(0); 217 218 testParam.sendData = 'send time 13213213 wzy 03'; 219 var tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 220 var TmpTestParam = testParam; 221 TmpTestParam.outEndpoint.address = 123; 222 try { 223 await usbManager.bulkTransfer(TmpTestParam.pip, TmpTestParam.outEndpoint, tmpUint8Array, 5000).then(data => { 224 console.info(TAG, 'usb case testBulkTransfer006 ret: ' + data); 225 console.info(TAG, 'usb case testBulkTransfer006 send data: ' + CheckEmptyUtils.ab2str(tmpUint8Array)); 226 expect(data).assertEqual(-1); 227 }) 228 } catch(error) { 229 console.info(TAG, 'usb testBulkTransfer006 write error : ' + JSON.stringify(error)); 230 expect(error !== null).assertFalse(); 231 } 232 }) 233 234 /** 235 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_0800 236 * @tc.name : testBulkTransfer007 237 * @tc.desc : Negative test: bulk transfer, send data, error outEndpoint.number = 123 238 * @tc.size : MediumTest 239 * @tc.type : Function 240 * @tc.level : Level 2 241 */ 242 it('testBulkTransfer007', 0, async function () { 243 console.info(TAG, 'usb testBulkTransfer007 begin'); 244 if (!isDeviceConnected) { 245 expect(isDeviceConnected).assertFalse(); 246 return 247 } 248 var testParam = getTransferTestParam(); 249 if (testParam.interface == null || testParam.outEndpoint == null) { 250 expect(testParam.interface == null).assertFalse(); 251 expect(testParam.outEndpoint == null).assertFalse(); 252 return 253 } 254 255 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 256 expect(testParam.isClaimed).assertEqual(0); 257 258 testParam.sendData = 'send time 13213213 wzy 04'; 259 var tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 260 var TmpTestParam = testParam; 261 TmpTestParam.outEndpoint.number = 123; 262 try { 263 await usbManager.bulkTransfer(TmpTestParam.pip, TmpTestParam.outEndpoint, tmpUint8Array, 5000).then(data => { 264 console.info(TAG, 'usb case testBulkTransfer007 ret: ' + data); 265 console.info(TAG, 'usb case testBulkTransfer007 send data: ' + CheckEmptyUtils.ab2str(tmpUint8Array)); 266 expect(data > 0).assertTrue(); 267 }) 268 } catch(error) { 269 console.info(TAG, 'usb testBulkTransfer007 write error : ' + JSON.stringify(error)); 270 expect(error !== null).assertFalse(); 271 } 272 }) 273 274 /** 275 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_0900 276 * @tc.name : testBulkTransfer008 277 * @tc.desc : Negative test: bulk transfer, send data, error outEndpoint.type = 123 278 * @tc.size : MediumTest 279 * @tc.type : Function 280 * @tc.level : Level 2 281 */ 282 it('testBulkTransfer008', 0, async function () { 283 console.info(TAG, 'usb testBulkTransfer008 begin'); 284 if (!isDeviceConnected) { 285 expect(isDeviceConnected).assertFalse(); 286 return 287 } 288 var testParam = getTransferTestParam(); 289 if (testParam.interface == null || testParam.outEndpoint == null) { 290 expect(testParam.interface == null).assertFalse(); 291 expect(testParam.outEndpoint == null).assertFalse(); 292 return 293 } 294 295 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 296 expect(testParam.isClaimed).assertEqual(0); 297 298 testParam.sendData = 'send time 13213213 wzy 05'; 299 var tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 300 var TmpTestParam = testParam; 301 TmpTestParam.outEndpoint.type = 123; 302 try { 303 await usbManager.bulkTransfer(TmpTestParam.pip, TmpTestParam.outEndpoint, tmpUint8Array, 5000).then(data => { 304 console.info(TAG, 'usb case testBulkTransfer008 ret: ' + data); 305 console.info(TAG, 'usb case testBulkTransfer008 send data: ' + CheckEmptyUtils.ab2str(tmpUint8Array)); 306 expect(data > 0).assertTrue(); 307 }) 308 } catch(error) { 309 console.info(TAG, 'usb testBulkTransfer008 write error : ' + JSON.stringify(error)); 310 expect(error !== null).assertFalse(); 311 } 312 }) 313 314 /** 315 * @tc.number : SUB_USB_HostManager_JS_ErrCode_0900 316 * @tc.name : testBulkTransfer009 317 * @tc.desc : Negative test: bulk transfer, parameter number exception, input a parameter 318 * @tc.size : MediumTest 319 * @tc.type : Function 320 * @tc.level : Level 2 321 */ 322 it('testBulkTransfer009', 0, async function () { 323 console.info(TAG, 'usb testBulkTransfer009 begin'); 324 if (!isDeviceConnected) { 325 expect(isDeviceConnected).assertFalse(); 326 return 327 } 328 var testParam = getTransferTestParam(); 329 if (testParam.interface == null || testParam.inEndpoint == null) { 330 expect(testParam.interface == null).assertFalse(); 331 expect(testParam.inEndpoint == null).assertFalse(); 332 return 333 } 334 335 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 336 expect(testParam.isClaimed).assertEqual(0); 337 338 try { 339 await usbManager.bulkTransfer(testParam.pip).then(data => { 340 console.info(TAG, 'usb case testBulkTransfer009 ret: ' + data); 341 expect(data === null).assertTrue(); 342 }) 343 } catch (err) { 344 console.info(TAG, 'usb testBulkTransfer009 catch err code: ' + err.code + ' message: ' + err.message); 345 expect(err.code).assertEqual(401); 346 } 347 }) 348 349 /** 350 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3600 351 * @tc.name : testBulkTransfer010 352 * @tc.desc : Negative test: bulk transfer, parameter number exception, input two parameter 353 * @tc.size : MediumTest 354 * @tc.type : Function 355 * @tc.level : Level 2 356 */ 357 it('testBulkTransfer010', 0, async function () { 358 console.info(TAG, 'usb testBulkTransfer010 begin'); 359 if (!isDeviceConnected) { 360 expect(isDeviceConnected).assertFalse(); 361 return 362 } 363 var testParam = getTransferTestParam(); 364 if (testParam.interface == null || testParam.inEndpoint == null) { 365 expect(testParam.interface == null).assertFalse(); 366 expect(testParam.inEndpoint == null).assertFalse(); 367 return 368 } 369 370 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 371 expect(testParam.isClaimed).assertEqual(0); 372 373 try { 374 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint).then(data => { 375 console.info(TAG, 'usb case testBulkTransfer010 ret: ' + data); 376 expect(data === null).assertTrue(); 377 }) 378 } catch (err) { 379 console.info(TAG, 'usb testBulkTransfer010 catch err code: ' + err.code + ' message: ' + err.message); 380 expect(err.code).assertEqual(401); 381 } 382 }) 383 384 /** 385 * @tc.number : SUB_USB_HostManager_JS_ErrCode_2400 386 * @tc.name : testBulkTransfer011 387 * @tc.desc : Negative test: bulk transfer, parameter number exception, necessary parameters not input 388 * @tc.size : MediumTest 389 * @tc.type : Function 390 * @tc.level : Level 2 391 */ 392 it('testBulkTransfer011', 0, async function () { 393 console.info(TAG, 'usb testBulkTransfer011 begin'); 394 if (!isDeviceConnected) { 395 expect(isDeviceConnected).assertFalse(); 396 return 397 } 398 399 try { 400 await usbManager.bulkTransfer().then(data => { 401 console.info(TAG, 'usb case testBulkTransfer011 ret: ' + data); 402 expect(data === null).assertTrue(); 403 }) 404 } catch (err) { 405 console.info(TAG, 'usb testBulkTransfer011 catch err code: ' + err.code + ' message: ' + err.message); 406 expect(err.code).assertEqual(401); 407 } 408 }) 409 410 /** 411 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3000 412 * @tc.name : testBulkTransfer012 413 * @tc.desc : Negative test: bulk transfer, parameter pipe type error 414 * @tc.size : MediumTest 415 * @tc.type : Function 416 * @tc.level : Level 2 417 */ 418 it('testBulkTransfer012', 0, async function () { 419 console.info(TAG, 'usb testBulkTransfer012 begin'); 420 if (!isDeviceConnected) { 421 expect(isDeviceConnected).assertFalse(); 422 return 423 } 424 425 var testParam = getTransferTestParam(); 426 if (testParam.interface == null || testParam.inEndpoint == null) { 427 console.info(TAG, 'usb case testParam_interface and testParam_inEndpoint is null'); 428 expect(testParam.interface == null).assertFalse(); 429 expect(testParam.inEndpoint == null).assertFalse(); 430 return 431 } 432 433 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 434 expect(testParam.isClaimed).assertEqual(0); 435 436 console.info(TAG, 'usb case readData begin'); 437 var tmpTestParam = testParam; 438 tmpTestParam.pip = "invalid"; 439 var tmpUint8Array = new Uint8Array(testParam.maxInSize); 440 try { 441 await usbManager.bulkTransfer(tmpTestParam.pip, tmpTestParam.inEndpoint, tmpUint8Array, 5000).then(data => { 442 console.info(TAG, 'usb case testBulkTransfer012 ret: ' + data); 443 expect(data === null).assertTrue(); 444 }) 445 } catch (err) { 446 console.info(TAG, 'usb testBulkTransfer012 catch err code: ' + err.code + ' message: ' + err.message); 447 expect(err.code).assertEqual(401); 448 } 449 }) 450 451 /** 452 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3700 453 * @tc.name : testBulkTransfer013 454 * @tc.desc : Negative test: bulk transfer, parameter endpoint type error 455 * @tc.size : MediumTest 456 * @tc.type : Function 457 * @tc.level : Level 2 458 */ 459 it('testBulkTransfer013', 0, async function () { 460 console.info(TAG, 'usb testBulkTransfer013 begin'); 461 if (!isDeviceConnected) { 462 expect(isDeviceConnected).assertFalse(); 463 return 464 } 465 var testParam = getTransferTestParam(); 466 if (testParam.interface == null || testParam.inEndpoint == null) { 467 console.info(TAG, 'usb case testParam_interface and testParam_inEndpoint is null'); 468 expect(testParam.interface == null).assertFalse(); 469 expect(testParam.inEndpoint == null).assertFalse(); 470 return 471 } 472 473 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 474 expect(testParam.isClaimed).assertEqual(0); 475 476 console.info(TAG, 'usb case readData begin'); 477 var tmpTestParam = testParam; 478 tmpTestParam.inEndpoint = "invalid"; 479 var tmpUint8Array = new Uint8Array(testParam.maxInSize); 480 try { 481 await usbManager.bulkTransfer(tmpTestParam.pip, tmpTestParam.inEndpoint, tmpUint8Array, 5000).then(data => { 482 console.info(TAG, 'usb case testBulkTransfer013 ret: ' + data); 483 expect(data === null).assertTrue(); 484 }) 485 } catch (err) { 486 console.info(TAG, 'usb testBulkTransfer013 catch err code: ' + err.code + ' message: ' + err.message); 487 expect(err.code).assertEqual(401); 488 } 489 }) 490 491 /** 492 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3800 493 * @tc.name : testBulkTransfer014 494 * @tc.desc : Negative test: bulk transfer, parameter Uint8Array type error 495 * @tc.size : MediumTest 496 * @tc.type : Function 497 * @tc.level : Level 2 498 */ 499 it('testBulkTransfer014', 0, async function () { 500 console.info(TAG, 'usb testBulkTransfer014 begin'); 501 if (!isDeviceConnected) { 502 expect(isDeviceConnected).assertFalse(); 503 return 504 } 505 var testParam = getTransferTestParam(); 506 if (testParam.interface == null || testParam.inEndpoint == null) { 507 console.info(TAG, 'usb case testParam_interface and testParam_inEndpoint is null'); 508 expect(testParam.interface == null).assertFalse(); 509 expect(testParam.inEndpoint == null).assertFalse(); 510 return 511 } 512 513 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 514 expect(testParam.isClaimed).assertEqual(0); 515 516 console.info(TAG, 'usb case readData begin'); 517 var tmpUint8Array = "invalid"; 518 try { 519 await usbManager.bulkTransfer(testParam.pip, testParam.inEndpoint, tmpUint8Array, 5000).then(data => { 520 console.info(TAG, 'usb case testBulkTransfer014 ret: ' + data); 521 expect(data === null).assertTrue(); 522 }) 523 } catch (err) { 524 console.info(TAG, 'usb testBulkTransfer014 catch err code: ' + err.code + ' message: ' + err.message); 525 expect(err.code).assertEqual(401); 526 } 527 }) 528 529 /** 530 * @tc.number : SUB_USB_HostManager_JS_ErrCode_4100 531 * @tc.name : testBulkTransfer015 532 * @tc.desc : Negative test: bulk transfer, parameter timeout type error 533 * @tc.size : MediumTest 534 * @tc.type : Function 535 * @tc.level : Level 2 536 */ 537 it('testBulkTransfer015', 0, async function () { 538 console.info(TAG, 'usb testBulkTransfer015 begin'); 539 if (!isDeviceConnected) { 540 expect(isDeviceConnected).assertFalse(); 541 return 542 } 543 var testParam = getTransferTestParam(); 544 if (testParam.interface == null || testParam.inEndpoint == null) { 545 console.info(TAG, 'usb case testParam_interface and testParam_inEndpoint is null'); 546 expect(testParam.interface == null).assertFalse(); 547 expect(testParam.inEndpoint == null).assertFalse(); 548 return 549 } 550 551 testParam.isClaimed = usbManager.claimInterface(testParam.pip, testParam.interface, true); 552 expect(testParam.isClaimed).assertEqual(0); 553 554 console.info(TAG, 'usb case testBulkTransfer015 readData begin'); 555 let tmpTimeOut = "invalid"; 556 let tmpUint8Array = new Uint8Array(testParam.maxInSize); 557 await usbManager.bulkTransfer(testParam.pip, testParam.inEndpoint, tmpUint8Array, tmpTimeOut).then(data => { 558 console.info(TAG, 'usb case testBulkTransfer015 ret: ' + data); 559 console.info(TAG, 'usb case testBulkTransfer015 readData: ' + CheckEmptyUtils.ab2str(tmpUint8Array)); 560 expect(data >= 0).assertTrue(); 561 }).catch(error => { 562 console.info(TAG, 'usb testBulkTransfer015 readData error : ' + JSON.stringify(error)); 563 expect(error === null).assertTrue(); 564 }); 565 }) 566 567 /** 568 * @tc.number : SUB_USB_HostManager_JS_Compatibility_2400 569 * @tc.name : testClaimInterface006 570 * @tc.desc : Negative test: Get interface, USBInterface afferent error id 571 * @tc.size : MediumTest 572 * @tc.type : Function 573 * @tc.level : Level 2 574 */ 575 it('testClaimInterface006', 0, function () { 576 console.info(TAG, 'usb testClaimInterface006 begin'); 577 if (!isDeviceConnected) { 578 expect(isDeviceConnected).assertFalse(); 579 return 580 } 581 582 if (gDeviceList[0].configs.length == 0) { 583 console.info(TAG, 'usb case testClaimInterface006 current device.configs.length = 0'); 584 expect(gDeviceList[0].configs.length == 0).assertFalse(); 585 return 586 } 587 588 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 589 if (gDeviceList[0].configs[j].interfaces.length == 0) { 590 console.info(TAG, 'usb case testClaimInterface006 current device.configs.interfaces.length = 0'); 591 } 592 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 593 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 594 TmpInterface.id = 123; 595 var isClaim = usbManager.claimInterface(gPipe, TmpInterface, true); 596 console.info(TAG, 'usb case testClaimInterface006 function return: ' + isClaim); 597 expect(isClaim !== 0).assertTrue(); 598 } 599 } 600 }) 601 602 /** 603 * @tc.number : SUB_USB_HostManager_JS_Compatibility_2500 604 * @tc.name : testClaimInterface007 605 * @tc.desc : Negative test: Get interface, USBInterface afferent error protocol 606 * @tc.size : MediumTest 607 * @tc.type : Function 608 * @tc.level : Level 2 609 */ 610 it('testClaimInterface007', 0, function () { 611 console.info(TAG, 'usb testClaimInterface007 begin'); 612 if (!isDeviceConnected) { 613 expect(isDeviceConnected).assertFalse(); 614 return 615 } 616 617 if (gDeviceList[0].configs.length == 0) { 618 console.info(TAG, 'usb case testClaimInterface007 current device.configs.length = 0'); 619 expect(gDeviceList[0].configs.length == 0).assertFalse(); 620 return 621 } 622 623 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 624 if (gDeviceList[0].configs[j].interfaces.length == 0) { 625 console.info(TAG, 'usb case testClaimInterface007 current device.configs.interfaces.length = 0'); 626 } 627 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 628 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 629 TmpInterface.protocol = 120; 630 var isClaim = usbManager.claimInterface(gPipe, TmpInterface, true); 631 console.info(TAG, 'usb case testClaimInterface007 function return: ' + isClaim); 632 expect(isClaim).assertEqual(0); 633 } 634 } 635 }) 636 637 /** 638 * @tc.number : SUB_USB_HostManager_JS_Compatibility_2600 639 * @tc.name : testClaimInterface008 640 * @tc.desc : Negative test: Get interface, USBInterface afferent error clazz 641 * @tc.size : MediumTest 642 * @tc.type : Function 643 * @tc.level : Level 2 644 */ 645 it('testClaimInterface008', 0, function () { 646 console.info(TAG, 'usb testClaimInterface008 begin'); 647 if (!isDeviceConnected) { 648 expect(isDeviceConnected).assertFalse(); 649 return 650 } 651 652 if (gDeviceList[0].configs.length == 0) { 653 console.info(TAG, 'usb case testClaimInterface008 current device.configs.length = 0'); 654 expect(gDeviceList[0].configs.length == 0).assertFalse(); 655 return 656 } 657 658 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 659 if (gDeviceList[0].configs[j].interfaces.length == 0) { 660 console.info(TAG, 'usb case testClaimInterface008 current device.configs.interfaces.length = 0'); 661 } 662 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 663 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 664 TmpInterface.clazz = 784; 665 var isClaim = usbManager.claimInterface(gPipe, TmpInterface, true); 666 console.info(TAG, 'usb case testClaimInterface008 function return: ' + isClaim); 667 expect(isClaim).assertEqual(0); 668 } 669 } 670 }) 671 672 /** 673 * @tc.number : SUB_USB_HostManager_JS_Compatibility_2700 674 * @tc.name : testClaimInterface009 675 * @tc.desc : Negative test: Get interface, USBInterface afferent error name 676 * @tc.size : MediumTest 677 * @tc.type : Function 678 * @tc.level : Level 2 679 */ 680 it('testClaimInterface009', 0, function () { 681 console.info(TAG, 'usb SUB_USB_HostManager_JS_Compatibility_2700 begin'); 682 if (!isDeviceConnected) { 683 expect(isDeviceConnected).assertFalse(); 684 return 685 } 686 687 if (gDeviceList[0].configs.length == 0) { 688 console.info(TAG, 'usb case testClaimInterface009 current device.configs.length = 0'); 689 expect(gDeviceList[0].configs.length == 0).assertFalse(); 690 return 691 } 692 693 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 694 if (gDeviceList[0].configs[j].interfaces.length == 0) { 695 console.info(TAG, 'usb case testClaimInterface009 current device.configs.interfaces.length = 0'); 696 } 697 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 698 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 699 TmpInterface.name = '123sdf'; 700 var isClaim = usbManager.claimInterface(gPipe, TmpInterface, true) 701 console.info(TAG, 'usb case testClaimInterface009 function return: ' + isClaim); 702 expect(isClaim).assertEqual(0); 703 } 704 } 705 }) 706 707 /** 708 * @tc.number : SUB_USB_HostManager_JS_Compatibility_2800 709 * @tc.name : testClaimInterface010 710 * @tc.desc : Negative test: Get interface, USBInterface afferent error subClass 711 * @tc.size : MediumTest 712 * @tc.type : Function 713 * @tc.level : Level 2 714 */ 715 it('testClaimInterface010', 0, function () { 716 console.info(TAG, 'usb SUB_USB_HostManager_JS_Compatibility_2800 begin'); 717 if (!isDeviceConnected) { 718 expect(isDeviceConnected).assertFalse(); 719 return 720 } 721 722 if (gDeviceList[0].configs.length == 0) { 723 console.info(TAG, 'usb case testClaimInterface010 current device.configs.length = 0'); 724 expect(gDeviceList[0].configs.length == 0).assertFalse(); 725 return 726 } 727 728 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 729 if (gDeviceList[0].configs[j].interfaces.length == 0) { 730 console.info(TAG, 'usb case testClaimInterface010 current device.configs.interfaces.length = 0'); 731 } 732 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 733 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 734 TmpInterface.subClass = 1210; 735 var isClaim = usbManager.claimInterface(gPipe, TmpInterface, true); 736 console.info(TAG, 'usb case testClaimInterface010 function return: ' + isClaim); 737 expect(isClaim).assertEqual(0); 738 } 739 } 740 }) 741 742 /** 743 * @tc.number : SUB_USB_HostManager_JS_ErrCode_1000 744 * @tc.name : testClaimInterface011 745 * @tc.desc : Negative test: Get interface, parameter number exception, input a parameter 746 * @tc.size : MediumTest 747 * @tc.type : Function 748 * @tc.level : Level 2 749 */ 750 it('testClaimInterface011', 0, function () { 751 console.info(TAG, 'usb testClaimInterface011 begin'); 752 if (!isDeviceConnected) { 753 expect(isDeviceConnected).assertFalse(); 754 return 755 } 756 757 if (gDeviceList[0].configs.length == 0) { 758 console.info(TAG, 'usb testClaimInterface011 case current device.configs.length = 0'); 759 expect(gDeviceList[0].configs.length == 0).assertFalse(); 760 return 761 } 762 try { 763 var maskCode = usbManager.claimInterface("invalid"); 764 console.info(TAG, 'usb testClaimInterface011 case claimInterface return: ' + maskCode); 765 expect(maskCode === null).assertTrue(); 766 } catch (err) { 767 console.info(TAG, 'usb testClaimInterface011 catch err code: ' + err.code + ' message: ' + err.message); 768 expect(err.code).assertEqual(401); 769 } 770 }) 771 772 /** 773 * @tc.number : SUB_USB_HostManager_JS_ErrCode_2500 774 * @tc.name : testClaimInterface012 775 * @tc.desc : Negative test: Get interface, parameter number exception, necessary parameters not input 776 * @tc.size : MediumTest 777 * @tc.type : Function 778 * @tc.level : Level 2 779 */ 780 it('testClaimInterface012', 0, function () { 781 console.info(TAG, 'usb testClaimInterface012 begin'); 782 if (!isDeviceConnected) { 783 expect(isDeviceConnected).assertFalse(); 784 return 785 } 786 787 if (gDeviceList[0].configs.length == 0) { 788 console.info(TAG, 'usb testClaimInterface012 case current device.configs.length = 0'); 789 expect(gDeviceList[0].configs.length == 0).assertFalse(); 790 return 791 } 792 try { 793 var maskCode = usbManager.claimInterface(); 794 console.info(TAG, 'usb testClaimInterface012 case claimInterface return: ' + maskCode); 795 expect(maskCode === null).assertTrue(); 796 } catch (err) { 797 console.info(TAG, 'usb testClaimInterface012 catch err code: ' + err.code + ' message: ' + err.message); 798 expect(err.code).assertEqual(401); 799 } 800 }) 801 802 /** 803 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3100 804 * @tc.name : testClaimInterface013 805 * @tc.desc : Negative test: Get interface, parameter pipe type error 806 * @tc.size : MediumTest 807 * @tc.type : Function 808 * @tc.level : Level 2 809 */ 810 it('testClaimInterface013', 0, function () { 811 console.info(TAG, 'usb testClaimInterface013 begin'); 812 if (!isDeviceConnected) { 813 expect(isDeviceConnected).assertFalse(); 814 return 815 } 816 817 var testParamPip = "invalid"; 818 try { 819 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 820 if (gDeviceList[0].configs[j].interfaces.length == 0) { 821 console.info(TAG, 'usb case testClaimInterface013 current device.configs.interfaces.length = 0'); 822 expect(gDeviceList[0].configs[j].interfaces.length == 0).assertFalse(); 823 } 824 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 825 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 826 var maskCode = usbManager.claimInterface(testParamPip, TmpInterface, true); 827 console.info(TAG, 'usb testClaimInterface013 case claimInterface return: ' + maskCode); 828 expect(maskCode === null).assertTrue(); 829 } 830 } 831 } catch (err) { 832 console.info(TAG, 'usb testClaimInterface013 catch err code: ' + err.code + ' message: ' + err.message); 833 expect(err.code).assertEqual(401); 834 } 835 }) 836 837 /** 838 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3900 839 * @tc.name : testClaimInterface014 840 * @tc.desc : Negative test: Get interface, parameter iface type error 841 * @tc.size : MediumTest 842 * @tc.type : Function 843 * @tc.level : Level 2 844 */ 845 it('testClaimInterface014', 0, function () { 846 console.info(TAG, 'usb testClaimInterface014 begin'); 847 if (!isDeviceConnected) { 848 expect(isDeviceConnected).assertFalse(); 849 return 850 } 851 852 var TmpInterface = "invalid"; 853 try { 854 var maskCode = usbManager.claimInterface(gPipe, TmpInterface); 855 console.info(TAG, 'usb testClaimInterface014 case claimInterface return: ' + maskCode); 856 expect(maskCode === null).assertTrue(); 857 } catch (err) { 858 console.info(TAG, 'usb testClaimInterface014 catch err code: ' + err.code + ' message: ' + err.message); 859 expect(err.code).assertEqual(401); 860 } 861 }) 862 863 /** 864 * @tc.number : SUB_USB_HostManager_JS_Compatibility_1600 865 * @tc.name : testReleaseInterface001 866 * @tc.desc : Negative test: release Interface, error Interface id 867 * @tc.size : MediumTest 868 * @tc.type : Function 869 * @tc.level : Level 2 870 */ 871 it('testReleaseInterface001', 0, function () { 872 console.info(TAG, 'usb testReleaseInterface001 begin'); 873 if (!isDeviceConnected) { 874 expect(isDeviceConnected).assertFalse(); 875 return 876 } 877 878 if (gDeviceList[0].configs.length == 0) { 879 console.info(TAG, 'usb testReleaseInterface001 case current device.configs.length = 0'); 880 expect(gDeviceList[0].configs.length == 0).assertFalse(); 881 return 882 } 883 884 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 885 if (gDeviceList[0].configs[j].interfaces.length == 0) { 886 console.info(TAG, 'usb testReleaseInterface001 case current device.configs.interfaces.length = 0'); 887 expect(gDeviceList[0].configs[j].interfaces.length == 0).assertFalse(); 888 } 889 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 890 let tmpInterface = gDeviceList[0].configs[j].interfaces[k]; 891 let isClaimed = usbManager.claimInterface(gPipe, tmpInterface, true); 892 console.info(TAG, 'usb case testReleaseInterface001 claimInterface return: ' + isClaimed); 893 expect(isClaimed).assertEqual(0); 894 895 tmpInterface.id = 134; 896 let isClaim = usbManager.releaseInterface(gPipe, tmpInterface); 897 console.info(TAG, 'usb case testReleaseInterface001 function return: ' + isClaim); 898 expect(isClaim !== 0).assertTrue(); 899 toReleaseInterface('testReleaseInterface001', j, k); 900 } 901 } 902 }) 903 904 /** 905 * @tc.number : SUB_USB_HostManager_JS_Compatibility_1700 906 * @tc.name : testReleaseInterface002 907 * @tc.desc : Negative test: release Interface, error Interface name 908 * @tc.size : MediumTest 909 * @tc.type : Function 910 * @tc.level : Level 2 911 */ 912 it('testReleaseInterface002', 0, function () { 913 console.info(TAG, 'usb testReleaseInterface002 begin'); 914 if (!isDeviceConnected) { 915 expect(isDeviceConnected).assertFalse(); 916 return 917 } 918 919 if (gDeviceList[0].configs.length == 0) { 920 console.info(TAG, 'usb testReleaseInterface002 case current device.configs.length = 0'); 921 expect(gDeviceList[0].configs.length == 0).assertFalse(); 922 return 923 } 924 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 925 if (gDeviceList[0].configs[j].interfaces.length == 0) { 926 console.info(TAG, 'usb testReleaseInterface002 case current device.configs.interfaces.length = 0'); 927 expect(gDeviceList[0].configs[j].interfaces.length == 0).assertFalse(); 928 } 929 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 930 var tmpInterface = gDeviceList[0].configs[j].interfaces[k]; 931 let isClaimed = usbManager.claimInterface(gPipe, tmpInterface, true); 932 expect(isClaimed).assertEqual(0); 933 934 tmpInterface.name = '134wer'; 935 var isClaim = usbManager.releaseInterface(gPipe, tmpInterface); 936 console.info(TAG, 'usb case testReleaseInterface002 function return: ' + isClaim); 937 expect(isClaim == 0).assertTrue(); 938 } 939 } 940 }) 941 942 /** 943 * @tc.number : SUB_USB_HostManager_JS_Compatibility_1800 944 * @tc.name : testReleaseInterface003 945 * @tc.desc : Negative test: release Interface, error Interface clazz 946 * @tc.size : MediumTest 947 * @tc.type : Function 948 * @tc.level : Level 2 949 */ 950 it('testReleaseInterface003', 0, function () { 951 console.info(TAG, 'usb testReleaseInterface003 begin'); 952 if (!isDeviceConnected) { 953 expect(isDeviceConnected).assertFalse(); 954 return 955 } 956 957 if (gDeviceList[0].configs.length == 0) { 958 console.info(TAG, 'usb testReleaseInterface003 case current device.configs.length = 0'); 959 xpect(gDeviceList[0].configs.length == 0).assertFalse(); 960 return 961 } 962 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 963 if (gDeviceList[0].configs[j].interfaces.length == 0) { 964 console.info(TAG, 'usb testReleaseInterface003 case current device.configs.interfaces.length = 0'); 965 } 966 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 967 var tmpInterface = gDeviceList[0].configs[j].interfaces[k]; 968 let isClaimed = usbManager.claimInterface(gPipe, tmpInterface, true); 969 expect(isClaimed).assertEqual(0); 970 971 tmpInterface.clazz = 78; 972 var isClaim = usbManager.releaseInterface(gPipe, tmpInterface); 973 console.info(TAG, 'usb case testReleaseInterface003 function return: ' + isClaim); 974 expect(isClaim == 0).assertTrue(); 975 } 976 } 977 }) 978 979 /** 980 * @tc.number : SUB_USB_HostManager_JS_Compatibility_1900 981 * @tc.name : testReleaseInterface004 982 * @tc.desc : Negative test: release Interface, error Interface protocol 983 * @tc.size : MediumTest 984 * @tc.type : Function 985 * @tc.level : Level 2 986 */ 987 it('testReleaseInterface004', 0, function () { 988 console.info(TAG, 'usb SUB_USB_HostManager_JS_Compatibility_1900 begin'); 989 if (!isDeviceConnected) { 990 expect(isDeviceConnected).assertFalse(); 991 return 992 } 993 994 if (gDeviceList[0].configs.length == 0) { 995 console.info(TAG, 'usb testReleaseInterface004 case current device.configs.length = 0'); 996 expect(false).assertTrue(); 997 return 998 } 999 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1000 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1001 console.info(TAG, 'usb testReleaseInterface004 case current device.configs.interfaces.length = 0'); 1002 } 1003 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 1004 var tmpInterface = gDeviceList[0].configs[j].interfaces[k]; 1005 let isClaimed = usbManager.claimInterface(gPipe, tmpInterface, true); 1006 expect(isClaimed).assertEqual(0); 1007 1008 tmpInterface.protocol = 124; 1009 var isClaim = usbManager.releaseInterface(gPipe, tmpInterface); 1010 console.info(TAG, 'usb case testReleaseInterface004 function return: ' + isClaim); 1011 expect(isClaim == 0).assertTrue(); 1012 } 1013 } 1014 }) 1015 1016 /** 1017 * @tc.number : SUB_USB_HostManager_JS_Compatibility_2000 1018 * @tc.name : testReleaseInterface005 1019 * @tc.desc : Negative test: release Interface, error Interface subClass 1020 * @tc.size : MediumTest 1021 * @tc.type : Function 1022 * @tc.level : Level 2 1023 */ 1024 it('testReleaseInterface005', 0, function () { 1025 console.info(TAG, 'usb testReleaseInterface005 begin'); 1026 if (!isDeviceConnected) { 1027 expect(isDeviceConnected).assertFalse(); 1028 return 1029 } 1030 1031 if (gDeviceList[0].configs.length == 0) { 1032 console.info(TAG, 'usb testReleaseInterface005 case current device.configs.length = 0'); 1033 expect(false).assertTrue(); 1034 return 1035 } 1036 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1037 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1038 console.info(TAG, 'usb testReleaseInterface005 case current device.configs.interfaces.length = 0'); 1039 } 1040 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 1041 var tmpInterface = gDeviceList[0].configs[j].interfaces[k]; 1042 let isClaimed = usbManager.claimInterface(gPipe, tmpInterface, true); 1043 expect(isClaimed).assertEqual(0); 1044 1045 tmpInterface.subClass = 784; 1046 var isClaim = usbManager.releaseInterface(gPipe, tmpInterface); 1047 console.info(TAG, 'usb case testReleaseInterface005 function return: ' + isClaim); 1048 expect(isClaim == 0).assertTrue(); 1049 } 1050 } 1051 }) 1052 1053 /** 1054 * @tc.number : SUB_USB_HostManager_JS_ErrCode_1400 1055 * @tc.name : testReleaseInterface006 1056 * @tc.desc : Negative test: release Interface, parameter number exception, input a parameter 1057 * @tc.size : MediumTest 1058 * @tc.type : Function 1059 * @tc.level : Level 2 1060 */ 1061 it('testReleaseInterface006', 0, function () { 1062 console.info(TAG, 'usb testReleaseInterface006 begin'); 1063 if (!isDeviceConnected) { 1064 expect(isDeviceConnected).assertFalse(); 1065 return 1066 } 1067 1068 try { 1069 var maskCode = usbManager.releaseInterface("invalid"); 1070 console.info(TAG, 'usb testReleaseInterface006 case releaseInterface return: ' + maskCode); 1071 expect(maskCode === null).assertTrue(); 1072 } catch (err) { 1073 console.info(TAG, 'usb testReleaseInterface006 catch err code: ' + err.code + ' message: ' + err.message); 1074 expect(err.code).assertEqual(401); 1075 } 1076 }) 1077 1078 /** 1079 * @tc.number : SUB_USB_HostManager_JS_ErrCode_2600 1080 * @tc.name : testReleaseInterface007 1081 * @tc.desc : Negative test: release Interface, parameter number exception, necessary parameters not input 1082 * @tc.size : MediumTest 1083 * @tc.type : Function 1084 * @tc.level : Level 2 1085 */ 1086 it('testReleaseInterface007', 0, function () { 1087 console.info(TAG, 'usb testReleaseInterface007 begin'); 1088 if (!isDeviceConnected) { 1089 expect(isDeviceConnected).assertFalse(); 1090 return 1091 } 1092 1093 try { 1094 var maskCode = usbManager.releaseInterface(); 1095 console.info(TAG, 'usb testReleaseInterface007 case releaseInterface return: ' + maskCode); 1096 expect(maskCode === null).assertTrue(); 1097 } catch (err) { 1098 console.info(TAG, 'usb testReleaseInterface007 catch err code: ' + err.code + ' message: ' + err.message); 1099 expect(err.code).assertEqual(401); 1100 } 1101 }) 1102 1103 /** 1104 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3300 1105 * @tc.name : testReleaseInterface008 1106 * @tc.desc : Negative test: release Interface, parameter pipe type error 1107 * @tc.size : MediumTest 1108 * @tc.type : Function 1109 * @tc.level : Level 2 1110 */ 1111 it('testReleaseInterface008', 0, function () { 1112 console.info(TAG, 'usb testReleaseInterface008 begin'); 1113 if (!isDeviceConnected) { 1114 expect(isDeviceConnected).assertFalse(); 1115 return 1116 } 1117 1118 var testParamPip = "invalid"; 1119 try { 1120 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1121 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1122 console.info(TAG, 'usb case testReleaseInterface008 current device.configs.interfaces.length = 0'); 1123 } 1124 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 1125 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 1126 var maskCode = usbManager.releaseInterface(testParamPip, TmpInterface); 1127 console.info(TAG, 'usb testReleaseInterface008 case releaseInterface return: ' + maskCode); 1128 expect(maskCode === null).assertTrue(); 1129 } 1130 } 1131 } catch (err) { 1132 console.info(TAG, 'usb testReleaseInterface008 catch err code: ' + err.code + ' message: ' + err.message); 1133 expect(err.code).assertEqual(401); 1134 } 1135 }) 1136 1137 /** 1138 * @tc.number : SUB_USB_HostManager_JS_ErrCode_1500 1139 * @tc.name : testReleaseInterface009 1140 * @tc.desc : Negative test: release Interface, parameter iface type error 1141 * @tc.size : MediumTest 1142 * @tc.type : Function 1143 * @tc.level : Level 2 1144 */ 1145 it('testReleaseInterface009', 0, function () { 1146 console.info(TAG, 'usb testReleaseInterface009 begin'); 1147 if (!isDeviceConnected) { 1148 expect(isDeviceConnected).assertFalse(); 1149 return 1150 } 1151 1152 var TmpInterface = "invalid"; 1153 try { 1154 var maskCode = usbManager.releaseInterface(gPipe, TmpInterface); 1155 console.info(TAG, 'usb testReleaseInterface009 case releaseInterface return: ' + maskCode); 1156 expect(false).assertTrue(); 1157 } catch (err) { 1158 console.info(TAG, 'usb testReleaseInterface009 catch err code: ' + err.code + ' message: ' + err.message); 1159 expect(err.code).assertEqual(401); 1160 } 1161 }) 1162 1163 /** 1164 * @tc.number : SUB_USB_HostManager_JS_Compatibility_4200 1165 * @tc.name : testSetInterface003 1166 * @tc.desc : Negative test: Set device interface, Interface protocol error 1167 * @tc.size : MediumTest 1168 * @tc.type : Function 1169 * @tc.level : Level 2 1170 */ 1171 it('testSetInterface003', 0, function () { 1172 console.info(TAG, 'usb testSetInterface003 begin'); 1173 if (!isDeviceConnected) { 1174 expect(isDeviceConnected).assertFalse(); 1175 return 1176 } 1177 1178 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1179 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1180 console.info(TAG, 'usb case testSetInterface003 current device.configs.interfaces.length = 0'); 1181 expect(gDeviceList[0].configs[j].interfaces.length == 0).assertFalse(0); 1182 } 1183 var isClaimed = usbManager.claimInterface(gPipe, gDeviceList[0].configs[j].interfaces[0], true); 1184 expect(isClaimed).assertEqual(0); 1185 1186 var tmpInterface = gDeviceList[0].configs[j].interfaces[0]; 1187 tmpInterface.protocol = 482; 1188 var ret = usbManager.setInterface(gPipe, tmpInterface); 1189 console.info(TAG, 'usb case testSetInterface003 return : ' + ret); 1190 expect(ret == 0).assertTrue(); 1191 1192 toReleaseInterface('testSetInterface003', j, 0); 1193 } 1194 }) 1195 1196 /** 1197 * @tc.number : SUB_USB_HostManager_JS_Compatibility_4300 1198 * @tc.name : testSetInterface004 1199 * @tc.desc : Negative test: Set device interface, Interface clazz error 1200 * @tc.size : MediumTest 1201 * @tc.type : Function 1202 * @tc.level : Level 2 1203 */ 1204 it('testSetInterface004', 0, function () { 1205 console.info(TAG, 'usb testSetInterface004 begin'); 1206 if (!isDeviceConnected) { 1207 expect(isDeviceConnected).assertFalse(); 1208 return 1209 } 1210 1211 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1212 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1213 console.info(TAG, 'usb case testSetInterface004 current device.configs.interfaces.length = 0'); 1214 expect(gDeviceList[0].configs[j].interfaces.length == 0).assertFalse(0); 1215 } 1216 var isClaimed = usbManager.claimInterface(gPipe, gDeviceList[0].configs[j].interfaces[0], true); 1217 expect(isClaimed).assertEqual(0); 1218 1219 var tmpInterface = gDeviceList[0].configs[j].interfaces[0]; 1220 tmpInterface.clazz = 482; 1221 var ret = usbManager.setInterface(gPipe, tmpInterface); 1222 console.info(TAG, 'usb case testSetInterface004 return : ' + ret); 1223 expect(ret == 0).assertTrue(); 1224 1225 toReleaseInterface('testSetInterface004', j, 0); 1226 } 1227 }) 1228 1229 /** 1230 * @tc.number : SUB_USB_HostManager_JS_Compatibility_4400 1231 * @tc.name : testSetInterface005 1232 * @tc.desc : Negative test: Set device interface, Interface subClass error 1233 * @tc.size : MediumTest 1234 * @tc.type : Function 1235 * @tc.level : Level 2 1236 */ 1237 it('testSetInterface005', 0, function () { 1238 console.info(TAG, 'usb testSetInterface005 begin'); 1239 if (!isDeviceConnected) { 1240 expect(isDeviceConnected).assertFalse(); 1241 return 1242 } 1243 1244 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1245 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1246 console.info(TAG, 'usb case testSetInterface005 current device.configs.interfaces.length = 0'); 1247 expect(gDeviceList[0].configs[j].interfaces.length == 0).assertFalse(0); 1248 } 1249 var isClaimed = usbManager.claimInterface(gPipe, gDeviceList[0].configs[j].interfaces[0], true); 1250 expect(isClaimed).assertEqual(0); 1251 1252 var tmpInterface = gDeviceList[0].configs[j].interfaces[0]; 1253 tmpInterface.subClass = 482; 1254 var ret = usbManager.setInterface(gPipe, tmpInterface); 1255 console.info(TAG, 'usb case testSetInterface005 return : ' + ret); 1256 expect(ret == 0).assertTrue(); 1257 1258 toReleaseInterface('testSetInterface005', j, 0); 1259 } 1260 }) 1261 1262 /** 1263 * @tc.number : SUB_USB_HostManager_JS_Compatibility_4500 1264 * @tc.name : testSetInterface006 1265 * @tc.desc : Negative test: Set device interface, Interface name error 1266 * @tc.size : MediumTest 1267 * @tc.type : Function 1268 * @tc.level : Level 2 1269 */ 1270 it('testSetInterface006', 0, function () { 1271 console.info(TAG, 'usb testSetInterface006 begin'); 1272 if (!isDeviceConnected) { 1273 expect(isDeviceConnected).assertFalse(); 1274 return 1275 } 1276 1277 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1278 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1279 console.info(TAG, 'usb case testSetInterface005 current device.configs.interfaces.length = 0'); 1280 expect(gDeviceList[0].configs[j].interfaces.length == 0).assertFalse(0); 1281 } 1282 var isClaimed = usbManager.claimInterface(gPipe, gDeviceList[0].configs[j].interfaces[0], true); 1283 expect(isClaimed).assertEqual(0); 1284 1285 var tmpInterface = gDeviceList[0].configs[j].interfaces[0]; 1286 tmpInterface.name = 'wer32'; 1287 var ret = usbManager.setInterface(gPipe, tmpInterface); 1288 console.info(TAG, 'usb case testSetInterface006 return : ' + ret); 1289 expect(ret == 0).assertTrue(); 1290 1291 toReleaseInterface('testSetInterface006', j, 0); 1292 } 1293 }) 1294 1295 /** 1296 * @tc.number : SUB_USB_HostManager_JS_ErrCode_1200 1297 * @tc.name : testSetInterface007 1298 * @tc.desc : Negative test: Set device interface, parameter number exception, input a parameter 1299 * @tc.size : MediumTest 1300 * @tc.type : Function 1301 * @tc.level : Level 2 1302 */ 1303 it('testSetInterface007', 0, function () { 1304 console.info(TAG, 'usb testSetInterface007 begin'); 1305 if (!isDeviceConnected) { 1306 expect(isDeviceConnected).assertFalse(); 1307 return 1308 } 1309 1310 try { 1311 var maskCode = usbManager.setInterface("invalid"); 1312 console.info(TAG, 'usb testSetInterface007 case setInterface return: ' + maskCode); 1313 expect(maskCode === null).assertTrue(); 1314 } catch (err) { 1315 console.info(TAG, 'usb testSetInterface007 catch err code: ' + err.code + ' message: ' + err.message); 1316 expect(err.code).assertEqual(401); 1317 } 1318 }) 1319 1320 /** 1321 * @tc.number : SUB_USB_HostManager_JS_ErrCode_2700 1322 * @tc.name : testSetInterface008 1323 * @tc.desc : Negative test: Set device interface, parameter number exception, necessary parameters not input 1324 * @tc.size : MediumTest 1325 * @tc.type : Function 1326 * @tc.level : Level 2 1327 */ 1328 it('testSetInterface008', 0, function () { 1329 console.info(TAG, 'usb testSetInterface008 begin'); 1330 if (!isDeviceConnected) { 1331 expect(isDeviceConnected).assertFalse(); 1332 return 1333 } 1334 1335 try { 1336 var maskCode = usbManager.setInterface(); 1337 console.info(TAG, 'usb testSetInterface008 case setInterface return: ' + maskCode); 1338 expect(maskCode === null).assertTrue(); 1339 } catch (err) { 1340 console.info(TAG, 'usb testSetInterface008 catch err code: ' + err.code + ' message: ' + err.message); 1341 expect(err.code).assertEqual(401); 1342 } 1343 }) 1344 1345 /** 1346 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3400 1347 * @tc.name : testSetInterface009 1348 * @tc.desc : Negative test: Set device interface, parameter pipe type error 1349 * @tc.size : MediumTest 1350 * @tc.type : Function 1351 * @tc.level : Level 2 1352 */ 1353 it('testSetInterface009', 0, function () { 1354 console.info(TAG, 'usb testSetInterface009 begin'); 1355 if (!isDeviceConnected) { 1356 expect(isDeviceConnected).assertFalse(); 1357 return 1358 } 1359 1360 var testParamPip = "invalid"; 1361 try { 1362 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1363 if (gDeviceList[0].configs[j].interfaces.length == 0) { 1364 console.info(TAG, 'usb case testSetInterface009 current device.configs.interfaces.length = 0'); 1365 } 1366 for (var k = 0; k < gDeviceList[0].configs[j].interfaces.length; k++) { 1367 var TmpInterface = gDeviceList[0].configs[j].interfaces[k]; 1368 var maskCode = usbManager.setInterface(testParamPip, TmpInterface); 1369 console.info(TAG, 'usb testSetInterface009 case setInterface return: ' + maskCode); 1370 expect(maskCode === null).assertTrue(); 1371 } 1372 } 1373 } catch (err) { 1374 console.info(TAG, 'usb testSetInterface009 catch err code: ' + err.code + ' message: ' + err.message); 1375 expect(err.code).assertEqual(401); 1376 } 1377 }) 1378 1379 /** 1380 * @tc.number : SUB_USB_HostManager_JS_ErrCode_4300 1381 * @tc.name : testSetInterface010 1382 * @tc.desc : Negative test: Set device interface, parameter iface type error 1383 * @tc.size : MediumTest 1384 * @tc.type : Function 1385 * @tc.level : Level 2 1386 */ 1387 it('testSetInterface010', 0, function () { 1388 console.info(TAG, 'usb testSetInterface010 begin'); 1389 if (!isDeviceConnected) { 1390 expect(isDeviceConnected).assertFalse(); 1391 return 1392 } 1393 1394 var TmpInterface = "invalid"; 1395 try { 1396 var maskCode = usbManager.setInterface(gPipe, TmpInterface); 1397 console.info(TAG, 'usb testSetInterface010 case setInterface return: ' + maskCode); 1398 expect(maskCode === null).assertTrue(); 1399 } catch (err) { 1400 console.info(TAG, 'usb testSetInterface010 catch err code: ' + err.code + ' message: ' + err.message); 1401 expect(err.code).assertEqual(401); 1402 } 1403 }) 1404 1405 /** 1406 * @tc.number : SUB_USB_HostManager_JS_Compatibility_3700 1407 * @tc.name : testSetConfiguration003 1408 * @tc.desc : Negative test: Set Device Configuration, USBConfig name error 1409 * @tc.size : MediumTest 1410 * @tc.type : Function 1411 * @tc.level : Level 2 1412 */ 1413 it('testSetConfiguration003', 0, function () { 1414 console.info(TAG, 'usb testSetConfiguration003 begin'); 1415 if (!isDeviceConnected) { 1416 expect(isDeviceConnected).assertFalse(); 1417 return 1418 } 1419 1420 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1421 var config = gDeviceList[0].configs[j]; 1422 config.name = 'asdfsd'; 1423 var ret = usbManager.setConfiguration(gPipe, config); 1424 console.info(TAG, 'usb case testSetConfiguration003 return : ' + ret); 1425 expect(ret).assertEqual(0); 1426 } 1427 }) 1428 1429 /** 1430 * @tc.number : SUB_USB_HostManager_JS_Compatibility_3800 1431 * @tc.name : testSetConfiguration004 1432 * @tc.desc : Negative test: Set Device Configuration, USBConfig name, id error 1433 * @tc.size : MediumTest 1434 * @tc.type : Function 1435 * @tc.level : Level 2 1436 */ 1437 it('testSetConfiguration004', 0, function () { 1438 console.info(TAG, 'usb testSetConfiguration004 begin'); 1439 if (!isDeviceConnected) { 1440 expect(isDeviceConnected).assertFalse(); 1441 return 1442 } 1443 1444 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1445 var config = gDeviceList[0].configs[j]; 1446 config.name = 'asdfsd'; 1447 config.id = 154; 1448 var ret = usbManager.setConfiguration(gPipe, config); 1449 console.info(TAG, 'usb case testSetConfiguration004 return : ' + ret); 1450 expect(ret).assertLess(0); 1451 } 1452 }) 1453 1454 /** 1455 * @tc.number : SUB_USB_HostManager_JS_Compatibility_3900 1456 * @tc.name : testSetConfiguration005 1457 * @tc.desc : Negative test: Set Device Configuration, USBConfig attributes error 1458 * @tc.size : MediumTest 1459 * @tc.type : Function 1460 * @tc.level : Level 2 1461 */ 1462 it('testSetConfiguration005', 0, function () { 1463 console.info(TAG, 'usb testSetConfiguration005 begin'); 1464 if (!isDeviceConnected) { 1465 expect(isDeviceConnected).assertFalse(); 1466 return 1467 } 1468 1469 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1470 var config = gDeviceList[0].configs[j]; 1471 config.attributes = 154; 1472 var ret = usbManager.setConfiguration(gPipe, config); 1473 console.info(TAG, 'usb case testSetConfiguration005 return : ' + ret); 1474 expect(ret == 0).assertTrue(); 1475 } 1476 }) 1477 1478/** 1479 * @tc.number : SUB_USB_HostManager_JS_Compatibility_4000 1480 * @tc.name : testSetConfiguration006 1481 * @tc.desc : Negative test: Set Device Configuration, USBConfig name interval(1-16) error 1482 * @tc.size : MediumTest 1483 * @tc.type : Function 1484 * @tc.level : Level 2 1485 */ 1486 it('testSetConfiguration006', 0, function () { 1487 console.info(TAG, 'usb testSetConfiguration006 begin'); 1488 if (!isDeviceConnected) { 1489 expect(isDeviceConnected).assertFalse(); 1490 return 1491 } 1492 if (gDeviceList.length == 0) { 1493 console.info(TAG, 'usb case get_device_list is null') 1494 expect(false).assertTrue(); 1495 return 1496 } 1497 1498 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1499 var config = gDeviceList[0].configs[j]; 1500 config.name = 'asdfsd'; 1501 config.interfaces[0].endpoints[0].interval = 0; 1502 var ret = usbManager.setConfiguration(gPipe, config); 1503 console.info(TAG, 'usb case testSetConfiguration006 return : ' + ret); 1504 expect(ret == 0).assertTrue(); 1505 } 1506 }) 1507 1508 /** 1509 * @tc.number : SUB_USB_HostManager_JS_ErrCode_1100 1510 * @tc.name : testSetConfiguration007 1511 * @tc.desc : Negative test: Set Device Configuration, parameter number exception, input a parameter 1512 * @tc.size : MediumTest 1513 * @tc.type : Function 1514 * @tc.level : Level 2 1515 */ 1516 it('testSetConfiguration007', 0, function () { 1517 console.info(TAG, 'usb testSetConfiguration007 begin'); 1518 if (!isDeviceConnected) { 1519 expect(isDeviceConnected).assertFalse(); 1520 return 1521 } 1522 1523 try { 1524 var maskCode = usbManager.setConfiguration("invalid"); 1525 console.info(TAG, 'usb testSetConfiguration007 case setConfiguration return: ' + maskCode); 1526 expect(maskCode === null).assertTrue(); 1527 } catch (err) { 1528 console.info(TAG, 'usb testSetConfiguration007 catch err code: ' + err.code + ' message: ' + err.message); 1529 expect(err.code).assertEqual(401); 1530 } 1531 }) 1532 1533 /** 1534 * @tc.number : SUB_USB_HostManager_JS_ErrCode_2800 1535 * @tc.name : testSetConfiguration008 1536 * @tc.desc : Negative test: Set Device Configuration, parameter number exception, necessary parameters not input 1537 * @tc.size : MediumTest 1538 * @tc.type : Function 1539 * @tc.level : Level 2 1540 */ 1541 it('testSetConfiguration008', 0, function () { 1542 console.info(TAG, 'usb testSetConfiguration008 begin'); 1543 if (!isDeviceConnected) { 1544 expect(isDeviceConnected).assertFalse(); 1545 return 1546 } 1547 1548 try { 1549 var maskCode = usbManager.setConfiguration(); 1550 console.info(TAG, 'usb testSetConfiguration008 case setConfiguration return: ' + maskCode); 1551 expect(maskCode === null).assertTrue(); 1552 } catch (err) { 1553 console.info(TAG, 'usb testSetConfiguration008 catch err code: ' + err.code + ' message: ' + err.message); 1554 expect(err.code).assertEqual(401); 1555 } 1556 }) 1557 1558 /** 1559 * @tc.number : SUB_USB_HostManager_JS_ErrCode_3500 1560 * @tc.name : testSetConfiguration009 1561 * @tc.desc : Negative test: Set Device Configuration, parameter pipe type error 1562 * @tc.size : MediumTest 1563 * @tc.type : Function 1564 * @tc.level : Level 2 1565 */ 1566 it('testSetConfiguration009', 0, function () { 1567 console.info(TAG, 'usb testSetConfiguration009 begin'); 1568 if (!isDeviceConnected) { 1569 expect(isDeviceConnected).assertFalse(); 1570 return 1571 } 1572 1573 var testParamPip = "invalid"; 1574 try { 1575 for (var j = 0; j < gDeviceList[0].configs.length; j++) { 1576 var TmpConfig = gDeviceList[0].configs[j]; 1577 var maskCode = usbManager.setConfiguration(testParamPip, TmpConfig); 1578 console.info(TAG, 'usb testSetConfiguration009 case setConfiguration return: ' + maskCode); 1579 expect(maskCode === null).assertTrue(); 1580 } 1581 } catch (err) { 1582 console.info(TAG, 'usb testSetConfiguration009 catch err code: ' + err.code + ' message: ' + err.message); 1583 expect(err.code).assertEqual(401); 1584 } 1585 }) 1586 1587 /** 1588 * @tc.number : SUB_USB_HostManager_JS_ErrCode_4200 1589 * @tc.name : testSetConfiguration010 1590 * @tc.desc : Negative test: Set Device Configuration, parameter config type error 1591 * @tc.size : MediumTest 1592 * @tc.type : Function 1593 * @tc.level : Level 2 1594 */ 1595 it('testSetConfiguration010', 0, function () { 1596 console.info(TAG, 'usb testSetConfiguration010 begin'); 1597 if (!isDeviceConnected) { 1598 expect(isDeviceConnected).assertFalse(); 1599 return 1600 } 1601 1602 var TmpConfig = "invalid"; 1603 try { 1604 var maskCode = usbManager.setConfiguration(gPipe, TmpConfig); 1605 console.info(TAG, 'usb testSetConfiguration010 case setConfiguration return: ' + maskCode); 1606 expect(maskCode === null).assertTrue(); 1607 } catch (err) { 1608 console.info(TAG, 'usb testSetConfiguration010 catch err code: ' + err.code + ' message: ' + err.message); 1609 expect(err.code).assertEqual(401); 1610 } 1611 }) 1612 1613}) 1614} 1615