1/* 2 * Copyright (c) 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 { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium' 20 21 22export default function UsbApiParamErrJsunitTest() { 23describe('UsbApiParamErrJsunitTest', function () { 24 25 const TAG = "[UsbApiParamErrJsunitTest]"; 26 const PARAM_NULL = null; 27 const PARAM_UNDEFINED = undefined; 28 const PARAM_NULLSTRING = ""; 29 const PARAM_NUMBERTYPE = 123; 30 const PARAM_ERRCODE = 401; 31 let gDeviceList; 32 let devices; 33 let gPipe = { 34 busNum: null, 35 devAddress: null 36 }; 37 let requestparam; 38 let isDeviceConnected; 39 function deviceConnected() { 40 if (gDeviceList.length > 0) { 41 console.info(TAG, "Test USB device is connected"); 42 return true; 43 } 44 console.info(TAG, "Test USB device is not connected"); 45 return false; 46 } 47 48 beforeAll(async function () { 49 console.log(TAG, '*************Usb Unit UsbApiParamErrJsunitTest Begin*************'); 50 const Version = usbManager.getVersion(); 51 console.info(TAG, 'usb unit begin test getversion :' + Version); 52 53 // version > 17 host currentMode = 2 device currentMode = 1 54 gDeviceList = usbManager.getDevices(); 55 console.info(TAG, 'usb unit begin test getDevices **********', JSON.stringify(gDeviceList)); 56 isDeviceConnected = deviceConnected(); 57 if (isDeviceConnected) { 58 let hasRight = usbManager.hasRight(gDeviceList[0].name); 59 if (!hasRight) { 60 console.info(TAG, `beforeAll: usb requestRight start`); 61 await getPermission(); 62 CheckEmptyUtils.sleep(1000); 63 await driveFn(); 64 CheckEmptyUtils.sleep(1000); 65 } 66 67 requestparam = getControlTransferParam(0x80, 0x06, (0x01 << 8 | 0), 0, 18); 68 } 69 }) 70 71 beforeEach(function () { 72 console.info(TAG, 'beforeEach: *************Usb Unit Test CaseEx*************'); 73 gDeviceList = usbManager.getDevices(); 74 if (isDeviceConnected) { 75 devices = gDeviceList[0]; 76 console.info(TAG, 'beforeEach return devices : ' + JSON.stringify(devices)); 77 gPipe.busNum = devices.busNum; 78 gPipe.devAddress = devices.devAddress; 79 console.info(TAG, 'beforeEach return devices : ' + JSON.stringify(gPipe)); 80 } 81 }) 82 83 afterEach(function () { 84 console.info(TAG, 'afterEach: *************Usb Unit Test CaseEx*************'); 85 devices = null; 86 console.info(TAG, 'beforeEach return devices : ' + JSON.stringify(devices)); 87 }) 88 89 afterAll(function () { 90 console.log(TAG, '*************Usb Unit UsbApiParamErrJsunitTest End*************'); 91 }) 92 93 async function driveFn() { 94 console.info('**************driveFn**************'); 95 try { 96 let driver = await UiDriver.create(); 97 console.info(TAG, ` come in driveFn`); 98 console.info(TAG, `driver is ${JSON.stringify(driver)}`); 99 CheckEmptyUtils.sleep(1000); 100 let button = await driver.findComponent(BY.text('允许')); 101 console.info(TAG, `button is ${JSON.stringify(button)}`); 102 CheckEmptyUtils.sleep(1000); 103 await button.click(); 104 } catch (err) { 105 console.info(TAG, 'err is ' + err); 106 return; 107 } 108 } 109 110 async function getPermission() { 111 console.info('**************getPermission**************'); 112 try { 113 usbManager.requestRight(gDeviceList[0].name).then(hasRight => { 114 console.info(TAG, `usb requestRight success, hasRight: ${hasRight}`); 115 }) 116 } catch (err) { 117 console.info(TAG, `usb getPermission to requestRight hasRight fail: `, err); 118 return 119 } 120 } 121 122 function getControlTransferParam(iReqType, iReq, iValue, iIndex, iLength) { 123 let tmpUint8Array = new Uint8Array(512); 124 125 let requestparam = { 126 bmRequestType: iReqType, 127 bRequest: iReq, 128 wValue: iValue, 129 wIndex: iIndex, 130 wLength: iLength, 131 data: tmpUint8Array 132 } 133 return requestparam; 134 } 135 136 function getPipe(testCaseName) { 137 gPipe = usbManager.connectDevice(devices); 138 console.info(TAG, `usb ${testCaseName} connectDevice getPipe ret: ${JSON.stringify(gPipe)}`); 139 expect(gPipe !== null).assertTrue(); 140 } 141 142 function toReleaseInterface(testCaseName, tInterface) { 143 let ret = usbManager.releaseInterface(gPipe, tInterface); 144 console.info(TAG, `usb ${testCaseName} releaseInterface ret: ${ret}`); 145 expect(ret).assertEqual(0); 146 } 147 148 function toClosePipe(testCaseName) { 149 let isPipClose = usbManager.closePipe(gPipe); 150 console.info(TAG, `usb ${testCaseName} closePipe ret: ${isPipClose}`); 151 expect(isPipClose).assertEqual(0); 152 } 153 154 /** 155 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0100 156 * @tc.name : testGetDevicesParamErr001 157 * @tc.desc : Negative test: Param is null 158 * @tc.size : MediumTest 159 * @tc.type : Function 160 * @tc.level : Level 3 161 */ 162 it('testGetDevicesParamErr001', 0, function () { 163 console.info(TAG, 'usb testGetDevicesParamErr001 begin'); 164 if (!isDeviceConnected) { 165 expect(isDeviceConnected).assertFalse(); 166 return 167 } 168 try { 169 gDeviceList = usbManager.getDevices(PARAM_NULL); 170 console.info(TAG, 'usb case getDevices ret length: ' + gDeviceList.length); 171 expect(gDeviceList === null).assertTrue(); 172 } catch (err) { 173 console.info(TAG, 'testGetDevicesParamErr001 catch err code: ', err.code, ', message: ', err.message); 174 expect(err.code).assertEqual(PARAM_ERRCODE); 175 } 176 }) 177 178 /** 179 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0200 180 * @tc.name : testGetDevicesParamErr002 181 * @tc.desc : Negative test: Param is undefined 182 * @tc.size : MediumTest 183 * @tc.type : Function 184 * @tc.level : Level 3 185 */ 186 it('testGetDevicesParamErr002', 0, function () { 187 console.info(TAG, 'usb testGetDevicesParamErr002 begin'); 188 if (!isDeviceConnected) { 189 expect(isDeviceConnected).assertFalse(); 190 return 191 } 192 try { 193 gDeviceList = usbManager.getDevices(PARAM_UNDEFINED); 194 console.info(TAG, 'usb case getDevices ret length: ' + gDeviceList.length); 195 expect(gDeviceList === null).assertTrue(); 196 } catch (err) { 197 console.info(TAG, 'testGetDevicesParamErr002 catch err code: ', err.code, ', message: ', err.message); 198 expect(err.code).assertEqual(PARAM_ERRCODE); 199 } 200 }) 201 202 /** 203 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0300 204 * @tc.name : testGetDevicesParamErr003 205 * @tc.desc : Negative test: Param is null string 206 * @tc.size : MediumTest 207 * @tc.type : Function 208 * @tc.level : Level 3 209 */ 210 it('testGetDevicesParamErr003', 0, function () { 211 console.info(TAG, 'usb testGetDevicesParamErr003 begin'); 212 if (!isDeviceConnected) { 213 expect(isDeviceConnected).assertFalse(); 214 return 215 } 216 try { 217 gDeviceList = usbManager.getDevices(PARAM_NULLSTRING); 218 console.info(TAG, 'usb case getDevices ret length: ' + gDeviceList.length); 219 expect(gDeviceList === null).assertTrue(); 220 } catch (err) { 221 console.info(TAG, 'testGetDevicesParamErr003 catch err code: ', err.code, ', message: ', err.message); 222 expect(err.code).assertEqual(PARAM_ERRCODE); 223 } 224 }) 225 226 /** 227 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0400 228 * @tc.name : testHasRightParamErr001 229 * @tc.desc : Negative test: Param is null 230 * @tc.size : MediumTest 231 * @tc.type : Function 232 * @tc.level : Level 3 233 */ 234 it('testHasRightParamErr001', 0, function () { 235 console.info(TAG, 'usb testHasRightParamErr001 begin'); 236 if (!isDeviceConnected) { 237 expect(isDeviceConnected).assertFalse(); 238 return 239 } 240 try { 241 let isHasRight = usbManager.hasRight(PARAM_NULL); 242 console.info(TAG, 'usb case hasRight ret : ' + isHasRight); 243 expect(isHasRight === null).assertTrue(); 244 } catch (err) { 245 console.info(TAG, 'testHasRightParamErr001 catch err code: ', err.code, ', message: ', err.message); 246 expect(err.code).assertEqual(PARAM_ERRCODE); 247 } 248 }) 249 250 /** 251 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0500 252 * @tc.name : testHasRightParamErr002 253 * @tc.desc : Negative test: Param is undefined 254 * @tc.size : MediumTest 255 * @tc.type : Function 256 * @tc.level : Level 3 257 */ 258 it('testHasRightParamErr002', 0, function () { 259 console.info(TAG, 'usb testHasRightParamErr002 begin'); 260 if (!isDeviceConnected) { 261 expect(isDeviceConnected).assertFalse(); 262 return 263 } 264 try { 265 let isHasRight = usbManager.hasRight(PARAM_UNDEFINED); 266 console.info(TAG, 'usb case hasRight ret : ' + isHasRight); 267 expect(isHasRight === null).assertTrue(); 268 } catch (err) { 269 console.info(TAG, 'testHasRightParamErr002 catch err code: ', err.code, ', message: ', err.message); 270 expect(err.code).assertEqual(PARAM_ERRCODE); 271 } 272 }) 273 274 275 276 /** 277 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0600 278 * @tc.name : testRequestRightParamErr001 279 * @tc.desc : Negative test: Param is null 280 * @tc.size : MediumTest 281 * @tc.type : Function 282 * @tc.level : Level 3 283 */ 284 it('testRequestRightParamErr001', 0, async function () { 285 console.info(TAG, 'usb testRequestRightParamErr001 begin'); 286 if (!isDeviceConnected) { 287 expect(isDeviceConnected).assertFalse(); 288 return 289 } 290 try { 291 let isHasRight = await usbManager.requestRight(PARAM_NULL); 292 console.info(TAG, 'usb case requestRight ret : ' + isHasRight); 293 expect(isHasRight !== null).assertFalse(); 294 } catch (err) { 295 console.info(TAG, 'testRequestRightParamErr001 catch err code: ', err.code, ', message: ', err.message); 296 expect(err.code).assertEqual(PARAM_ERRCODE); 297 } 298 }) 299 300 /** 301 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0700 302 * @tc.name : testRequestRightParamErr002 303 * @tc.desc : Negative test: Param is undefined 304 * @tc.size : MediumTest 305 * @tc.type : Function 306 * @tc.level : Level 3 307 */ 308 it('testRequestRightParamErr002', 0, async function () { 309 console.info(TAG, 'usb testRequestRightParamErr002 begin'); 310 if (!isDeviceConnected) { 311 expect(isDeviceConnected).assertFalse(); 312 return 313 } 314 try { 315 let isHasRight = await usbManager.requestRight(PARAM_UNDEFINED); 316 console.info(TAG, 'usb case requestRight ret : ' + isHasRight); 317 expect(isHasRight !== null).assertFalse(); 318 } catch (err) { 319 console.info(TAG, 'testRequestRightParamErr002 catch err code: ', err.code, ', message: ', err.message); 320 expect(err.code).assertEqual(PARAM_ERRCODE); 321 } 322 }) 323 324 /** 325 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0800 326 * @tc.name : testRequestRightParamErr003 327 * @tc.desc : Negative test: Enter two parameters 328 * @tc.size : MediumTest 329 * @tc.type : Function 330 * @tc.level : Level 3 331 */ 332 it('testRequestRightParamErr003', 0, async function () { 333 console.info(TAG, 'usb testRequestRightParamErr003 begin'); 334 if (!isDeviceConnected) { 335 expect(isDeviceConnected).assertFalse(); 336 return 337 } 338 try { 339 for (var i = 0; i < gDeviceList.length; i++) { 340 let deviceName = gDeviceList[i].name; 341 let isHasRight = await usbManager.requestRight(deviceName, deviceName); 342 console.info(TAG, 'usb [', deviceName, '] requestRight ret : ' + isHasRight); 343 expect(isHasRight).assertTrue(); 344 } 345 } catch (err) { 346 console.info(TAG, 'testRequestRightParamErr003 catch err : ', err); 347 expect(err !== null).assertFalse(); 348 } 349 }) 350 351 /** 352 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0900 353 * @tc.name : testRemoveRightParamErr001 354 * @tc.desc : Negative test: Param is null 355 * @tc.size : MediumTest 356 * @tc.type : Function 357 * @tc.level : Level 3 358 */ 359 it('testRemoveRightParamErr001', 0, function () { 360 console.info(TAG, 'usb testRemoveRightParamErr001 begin'); 361 if (!isDeviceConnected) { 362 expect(isDeviceConnected).assertFalse(); 363 return 364 } 365 try { 366 let remRight = usbManager.removeRight(PARAM_NULL); 367 console.info(TAG, 'usb case removeRight ret : ' + remRight); 368 expect(remRight !== true).assertTrue(); 369 } catch (err) { 370 console.info(TAG, 'testRemoveRightParamErr001 catch err code: ', err.code, ', message: ', err.message); 371 expect(err.code).assertEqual(PARAM_ERRCODE); 372 } 373 }) 374 375 /** 376 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1000 377 * @tc.name : testRemoveRightParamErr002 378 * @tc.desc : Negative test: Param is undefined 379 * @tc.size : MediumTest 380 * @tc.type : Function 381 * @tc.level : Level 3 382 */ 383 it('testRemoveRightParamErr002', 0, function () { 384 console.info(TAG, 'usb testRemoveRightParamErr002 begin'); 385 if (!isDeviceConnected) { 386 expect(isDeviceConnected).assertFalse(); 387 return 388 } 389 try { 390 let remRight = usbManager.removeRight(PARAM_UNDEFINED); 391 console.info(TAG, 'usb case removeRight ret : ' + remRight); 392 expect(remRight !== true).assertTrue(); 393 } catch (err) { 394 console.info(TAG, 'testRemoveRightParamErr002 catch err code: ', err.code, ', message: ', err.message); 395 expect(err.code).assertEqual(PARAM_ERRCODE); 396 } 397 }) 398 399 /** 400 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1100 401 * @tc.name : testRemoveRightParamErr003 402 * @tc.desc : Negative test: Enter two parameters 403 * @tc.size : MediumTest 404 * @tc.type : Function 405 * @tc.level : Level 3 406 */ 407 it('testRemoveRightParamErr003', 0, async function () { 408 console.info(TAG, 'usb testRemoveRightParamErr003 begin'); 409 if (!isDeviceConnected) { 410 expect(isDeviceConnected).assertFalse(); 411 return 412 } 413 try { 414 for (var i = 0; i < gDeviceList.length; i++) { 415 let deviceName = gDeviceList[i].name; 416 let remRight = usbManager.removeRight(deviceName, deviceName); 417 console.info(TAG, 'usb [', deviceName, '] removeRight ret : ' + remRight); 418 expect(remRight).assertTrue(); 419 } 420 } catch (err) { 421 console.info(TAG, 'testRemoveRightParamErr003 catch err : ', err); 422 expect(err !== null).assertFalse(); 423 } 424 await getPermission(); 425 CheckEmptyUtils.sleep(1000); 426 await driveFn(); 427 CheckEmptyUtils.sleep(1000); 428 }) 429 430 /** 431 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1200 432 * @tc.name : testConnectDeviceParamErr001 433 * @tc.desc : Negative test: Param is null 434 * @tc.size : MediumTest 435 * @tc.type : Function 436 * @tc.level : Level 3 437 */ 438 it('testConnectDeviceParamErr001', 0, function () { 439 console.info(TAG, 'usb testConnectDeviceParamErr001 begin'); 440 if (!isDeviceConnected) { 441 expect(isDeviceConnected).assertFalse(); 442 return 443 } 444 try { 445 let ret = usbManager.connectDevice(PARAM_NULL); 446 console.info(TAG, 'usb case connectDevice ret : ', JSON.stringify(ret)); 447 expect(ret !== null).assertFalse(); 448 } catch (err) { 449 console.info(TAG, 'testConnectDeviceParamErr001 catch err code: ', err.code, ', message: ', err.message); 450 expect(err.code).assertEqual(PARAM_ERRCODE); 451 } 452 }) 453 454 /** 455 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1300 456 * @tc.name : testConnectDeviceParamErr002 457 * @tc.desc : Negative test: Param is undefined 458 * @tc.size : MediumTest 459 * @tc.type : Function 460 * @tc.level : Level 3 461 */ 462 it('testConnectDeviceParamErr002', 0, function () { 463 console.info(TAG, 'usb testConnectDeviceParamErr002 begin'); 464 if (!isDeviceConnected) { 465 expect(isDeviceConnected).assertFalse(); 466 return 467 } 468 try { 469 let ret = usbManager.connectDevice(PARAM_UNDEFINED); 470 console.info(TAG, 'usb case connectDevice ret : ', JSON.stringify(ret)); 471 expect(ret !== null).assertFalse(); 472 } catch (err) { 473 console.info(TAG, 'testConnectDeviceParamErr002 catch err code: ', err.code, ', message: ', err.message); 474 expect(err.code).assertEqual(PARAM_ERRCODE); 475 } 476 }) 477 478 /** 479 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1400 480 * @tc.name : testConnectDeviceParamErr003 481 * @tc.desc : Negative test: Param is null string "" 482 * @tc.size : MediumTest 483 * @tc.type : Function 484 * @tc.level : Level 3 485 */ 486 it('testConnectDeviceParamErr003', 0, function () { 487 console.info(TAG, 'usb testConnectDeviceParamErr003 begin'); 488 if (!isDeviceConnected) { 489 expect(isDeviceConnected).assertFalse(); 490 return 491 } 492 try { 493 let ret = usbManager.connectDevice(PARAM_NULLSTRING); 494 console.info(TAG, 'usb case connectDevice ret : ', JSON.stringify(ret)); 495 expect(ret !== null).assertFalse(); 496 } catch (err) { 497 console.info(TAG, 'testConnectDeviceParamErr003 catch err code: ', err.code, ', message: ', err.message); 498 expect(err.code).assertEqual(PARAM_ERRCODE); 499 } 500 }) 501 502 /** 503 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1500 504 * @tc.name : testConnectDeviceParamErr004 505 * @tc.desc : Negative test: Enter two parameters 506 * @tc.size : MediumTest 507 * @tc.type : Function 508 * @tc.level : Level 3 509 */ 510 it('testConnectDeviceParamErr004', 0, function () { 511 console.info(TAG, 'usb testConnectDeviceParamErr004 begin'); 512 if (!isDeviceConnected) { 513 expect(isDeviceConnected).assertFalse(); 514 return 515 } 516 try { 517 gPipe = usbManager.connectDevice(devices, devices); 518 console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe)); 519 expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); 520 } catch (err) { 521 console.info(TAG, 'testConnectDeviceParamErr004 catch err : ', err); 522 expect(err !== null).assertFalse(); 523 } 524 toClosePipe('testConnectDeviceParamErr004'); 525 }) 526 527 /** 528 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1600 529 * @tc.name : testConnectDeviceParamErr005 530 * @tc.desc : Negative test: devices name is null 531 * @tc.size : MediumTest 532 * @tc.type : Function 533 * @tc.level : Level 3 534 */ 535 it('testConnectDeviceParamErr005', 0, function () { 536 console.info(TAG, 'usb testConnectDeviceParamErr005 begin'); 537 if (!isDeviceConnected) { 538 expect(isDeviceConnected).assertFalse(); 539 return 540 } 541 try { 542 devices.name = PARAM_NULL; 543 let ret = usbManager.connectDevice(devices); 544 console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(ret)); 545 expect(ret !== null).assertFalse(); 546 } catch (err) { 547 console.info(TAG, 'testConnectDeviceParamErr005 catch err code: ', err.code, ', message: ', err.message); 548 expect(err.code).assertEqual(PARAM_ERRCODE); 549 } 550 }) 551 552 /** 553 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1700 554 * @tc.name : testConnectDeviceParamErr006 555 * @tc.desc : Negative test: devices name is undefined 556 * @tc.size : MediumTest 557 * @tc.type : Function 558 * @tc.level : Level 3 559 */ 560 it('testConnectDeviceParamErr006', 0, function () { 561 console.info(TAG, 'usb testConnectDeviceParamErr006 begin'); 562 if (!isDeviceConnected) { 563 expect(isDeviceConnected).assertFalse(); 564 return 565 } 566 try { 567 devices.name = PARAM_UNDEFINED; 568 let ret = usbManager.connectDevice(devices); 569 console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(ret)); 570 expect(ret !== null).assertFalse(); 571 } catch (err) { 572 console.info(TAG, 'testConnectDeviceParamErr006 catch err code: ', err.code, ', message: ', err.message); 573 expect(err.code).assertEqual(PARAM_ERRCODE); 574 } 575 }) 576 577 /** 578 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1800 579 * @tc.name : testConnectDeviceParamErr007 580 * @tc.desc : Negative test: devices name is number 123 581 * @tc.size : MediumTest 582 * @tc.type : Function 583 * @tc.level : Level 3 584 */ 585 it('testConnectDeviceParamErr007', 0, function () { 586 console.info(TAG, 'usb testConnectDeviceParamErr007 begin'); 587 if (!isDeviceConnected) { 588 expect(isDeviceConnected).assertFalse(); 589 return 590 } 591 try { 592 devices.name = PARAM_NUMBERTYPE; 593 let ret = usbManager.connectDevice(devices); 594 console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(ret)); 595 expect(ret !== null).assertFalse(); 596 } catch (err) { 597 console.info(TAG, 'testConnectDeviceParamErr007 catch err code: ', err.code, ', message: ', err.message); 598 expect(err.code).assertEqual(PARAM_ERRCODE); 599 } 600 }) 601 602 /** 603 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1900 604 * @tc.name : testConnectDeviceParamErr008 605 * @tc.desc : Negative test: devices busNum is null 606 * @tc.size : MediumTest 607 * @tc.type : Function 608 * @tc.level : Level 3 609 */ 610 it('testConnectDeviceParamErr008', 0, function () { 611 console.info(TAG, 'usb testConnectDeviceParamErr008 begin'); 612 if (!isDeviceConnected) { 613 expect(isDeviceConnected).assertFalse(); 614 return 615 } 616 try { 617 devices.busNum = PARAM_NULL; 618 let ret = usbManager.connectDevice(devices); 619 console.info(TAG, 'usb [busNum:null] connectDevice ret : ', JSON.stringify(ret)); 620 expect(ret !== null).assertFalse(); 621 } catch (err) { 622 console.info(TAG, 'testConnectDeviceParamErr008 catch err code: ', err.code, ', message: ', err.message); 623 expect(err.code).assertEqual(PARAM_ERRCODE); 624 } 625 }) 626 627 /** 628 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2000 629 * @tc.name : testConnectDeviceParamErr009 630 * @tc.desc : Negative test: devices busNum is undefined 631 * @tc.size : MediumTest 632 * @tc.type : Function 633 * @tc.level : Level 3 634 */ 635 it('testConnectDeviceParamErr009', 0, function () { 636 console.info(TAG, 'usb testConnectDeviceParamErr009 begin'); 637 if (!isDeviceConnected) { 638 expect(isDeviceConnected).assertFalse(); 639 return 640 } 641 try { 642 devices.busNum = PARAM_UNDEFINED; 643 let ret = usbManager.connectDevice(devices); 644 console.info(TAG, 'usb [busNum:undefined] connectDevice ret : ', JSON.stringify(ret)); 645 expect(ret !== null).assertFalse(); 646 } catch (err) { 647 console.info(TAG, 'testConnectDeviceParamErr009 catch err code: ', err.code, ', message: ', err.message); 648 expect(err.code).assertEqual(PARAM_ERRCODE); 649 } 650 }) 651 652 /** 653 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2100 654 * @tc.name : testConnectDeviceParamErr010 655 * @tc.desc : Negative test: devices busNum null string "" 656 * @tc.size : MediumTest 657 * @tc.type : Function 658 * @tc.level : Level 3 659 */ 660 it('testConnectDeviceParamErr010', 0, function () { 661 console.info(TAG, 'usb testConnectDeviceParamErr010 begin'); 662 if (!isDeviceConnected) { 663 expect(isDeviceConnected).assertFalse(); 664 return 665 } 666 try { 667 devices.busNum = PARAM_NULLSTRING; 668 let ret = usbManager.connectDevice(devices); 669 console.info(TAG, 'usb [busNum:null string] connectDevice ret : ', JSON.stringify(ret)); 670 expect(ret !== null).assertFalse(); 671 } catch (err) { 672 console.info(TAG, 'testConnectDeviceParamErr010 catch err code: ', err.code, ', message: ', err.message); 673 expect(err.code).assertEqual(PARAM_ERRCODE); 674 } 675 }) 676 677 /** 678 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2200 679 * @tc.name : testConnectDeviceParamErr011 680 * @tc.desc : Negative test: devices devAddress is null 681 * @tc.size : MediumTest 682 * @tc.type : Function 683 * @tc.level : Level 3 684 */ 685 it('testConnectDeviceParamErr011', 0, function () { 686 console.info(TAG, 'usb testConnectDeviceParamErr011 begin'); 687 if (!isDeviceConnected) { 688 expect(isDeviceConnected).assertFalse(); 689 return 690 } 691 try { 692 devices.devAddress = PARAM_NULL; 693 let ret = usbManager.connectDevice(devices); 694 console.info(TAG, 'usb [devAddress:null] connectDevice ret : ', JSON.stringify(ret)); 695 expect(ret !== null).assertFalse(); 696 } catch (err) { 697 console.info(TAG, 'testConnectDeviceParamErr011 catch err code: ', err.code, ', message: ', err.message); 698 expect(err.code).assertEqual(PARAM_ERRCODE); 699 } 700 }) 701 702 /** 703 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2300 704 * @tc.name : testConnectDeviceParamErr012 705 * @tc.desc : Negative test: devices devAddress is undefined 706 * @tc.size : MediumTest 707 * @tc.type : Function 708 * @tc.level : Level 3 709 */ 710 it('testConnectDeviceParamErr012', 0, function () { 711 console.info(TAG, 'usb testConnectDeviceParamErr012 begin'); 712 if (!isDeviceConnected) { 713 expect(isDeviceConnected).assertFalse(); 714 return 715 } 716 try { 717 devices.devAddress = PARAM_UNDEFINED; 718 let ret = usbManager.connectDevice(devices); 719 console.info(TAG, 'usb [devAddress:undefined] connectDevice ret : ', JSON.stringify(ret)); 720 expect(ret !== null).assertFalse(); 721 } catch (err) { 722 console.info(TAG, 'testConnectDeviceParamErr012 catch err code: ', err.code, ', message: ', err.message); 723 expect(err.code).assertEqual(PARAM_ERRCODE); 724 } 725 }) 726 727 /** 728 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2400 729 * @tc.name : testConnectDeviceParamErr013 730 * @tc.desc : Negative test: devices devAddress is null string 731 * @tc.size : MediumTest 732 * @tc.type : Function 733 * @tc.level : Level 3 734 */ 735 it('testConnectDeviceParamErr013', 0, function () { 736 console.info(TAG, 'usb testConnectDeviceParamErr013 begin'); 737 if (!isDeviceConnected) { 738 expect(isDeviceConnected).assertFalse(); 739 return 740 } 741 try { 742 devices.devAddress = PARAM_NULLSTRING; 743 let ret = usbManager.connectDevice(devices); 744 console.info(TAG, 'usb [devAddress:null string] connectDevice ret : ', JSON.stringify(ret)); 745 expect(ret !== null).assertFalse(); 746 } catch (err) { 747 console.info(TAG, 'testConnectDeviceParamErr013 catch err code: ', err.code, ', message: ', err.message); 748 expect(err.code).assertEqual(PARAM_ERRCODE); 749 } 750 }) 751 752 /** 753 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2500 754 * @tc.name : testConnectDeviceParamErr014 755 * @tc.desc : Negative test: devices serial is null 756 * @tc.size : MediumTest 757 * @tc.type : Function 758 * @tc.level : Level 3 759 */ 760 it('testConnectDeviceParamErr014', 0, function () { 761 console.info(TAG, 'usb testConnectDeviceParamErr014 begin'); 762 if (!isDeviceConnected) { 763 expect(isDeviceConnected).assertFalse(); 764 return 765 } 766 try { 767 devices.serial = PARAM_NULL; 768 let ret = usbManager.connectDevice(devices); 769 console.info(TAG, 'usb [serial:null] connectDevice ret : ', JSON.stringify(ret)); 770 expect(ret !== null).assertFalse(); 771 } catch (err) { 772 console.info(TAG, 'testConnectDeviceParamErr014 catch err code: ', err.code, ', message: ', err.message); 773 expect(err.code).assertEqual(PARAM_ERRCODE); 774 } 775 }) 776 777 /** 778 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2600 779 * @tc.name : testConnectDeviceParamErr015 780 * @tc.desc : Negative test: devices serial is undefined 781 * @tc.size : MediumTest 782 * @tc.type : Function 783 * @tc.level : Level 3 784 */ 785 it('testConnectDeviceParamErr015', 0, function () { 786 console.info(TAG, 'usb testConnectDeviceParamErr015 begin'); 787 if (!isDeviceConnected) { 788 expect(isDeviceConnected).assertFalse(); 789 return 790 } 791 try { 792 devices.serial = PARAM_UNDEFINED; 793 let ret = usbManager.connectDevice(devices); 794 console.info(TAG, 'usb [serial:undefined] connectDevice ret : ', JSON.stringify(ret)); 795 expect(ret !== null).assertFalse(); 796 } catch (err) { 797 console.info(TAG, 'testConnectDeviceParamErr015 catch err code: ', err.code, ', message: ', err.message); 798 expect(err.code).assertEqual(PARAM_ERRCODE); 799 } 800 }) 801 802 /** 803 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2700 804 * @tc.name : testConnectDeviceParamErr016 805 * @tc.desc : Negative test: devices serial is number 123 806 * @tc.size : MediumTest 807 * @tc.type : Function 808 * @tc.level : Level 3 809 */ 810 it('testConnectDeviceParamErr016', 0, function () { 811 console.info(TAG, 'usb testConnectDeviceParamErr016 begin'); 812 if (!isDeviceConnected) { 813 expect(isDeviceConnected).assertFalse(); 814 return 815 } 816 try { 817 devices.serial = PARAM_NUMBERTYPE; 818 let ret = usbManager.connectDevice(devices); 819 console.info(TAG, 'usb [serial:123] connectDevice ret : ', JSON.stringify(ret)); 820 expect(ret !== null).assertFalse(); 821 } catch (err) { 822 console.info(TAG, 'testConnectDeviceParamErr016 catch err code: ', err.code, ', message: ', err.message); 823 expect(err.code).assertEqual(PARAM_ERRCODE); 824 } 825 }) 826 827 /** 828 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2800 829 * @tc.name : testConnectDeviceParamErr017 830 * @tc.desc : Negative test: devices manufacturerName is null 831 * @tc.size : MediumTest 832 * @tc.type : Function 833 * @tc.level : Level 3 834 */ 835 it('testConnectDeviceParamErr017', 0, function () { 836 console.info(TAG, 'usb testConnectDeviceParamErr017 begin'); 837 if (!isDeviceConnected) { 838 expect(isDeviceConnected).assertFalse(); 839 return 840 } 841 try { 842 devices.manufacturerName = PARAM_NULL; 843 let ret = usbManager.connectDevice(devices); 844 console.info(TAG, 'usb [manufacturerName:null] connectDevice ret : ', JSON.stringify(ret)); 845 expect(ret !== null).assertFalse(); 846 } catch (err) { 847 console.info(TAG, 'testConnectDeviceParamErr017 catch err code: ', err.code, ', message: ', err.message); 848 expect(err.code).assertEqual(PARAM_ERRCODE); 849 } 850 }) 851 852 /** 853 * @tc.number : SUB_USB_HostManager_JS_ParamErr_2900 854 * @tc.name : testConnectDeviceParamErr018 855 * @tc.desc : Negative test: devices manufacturerName is undefined 856 * @tc.size : MediumTest 857 * @tc.type : Function 858 * @tc.level : Level 3 859 */ 860 it('testConnectDeviceParamErr018', 0, function () { 861 console.info(TAG, 'usb testConnectDeviceParamErr018 begin'); 862 if (!isDeviceConnected) { 863 expect(isDeviceConnected).assertFalse(); 864 return 865 } 866 try { 867 devices.manufacturerName = PARAM_UNDEFINED; 868 let ret = usbManager.connectDevice(devices); 869 console.info(TAG, 'usb [manufacturerName:undefined] connectDevice ret : ', JSON.stringify(ret)); 870 expect(ret !== null).assertFalse(); 871 } catch (err) { 872 console.info(TAG, 'testConnectDeviceParamErr018 catch err code: ', err.code, ', message: ', err.message); 873 expect(err.code).assertEqual(PARAM_ERRCODE); 874 } 875 }) 876 877 /** 878 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3000 879 * @tc.name : testConnectDeviceParamErr019 880 * @tc.desc : Negative test: devices manufacturerName is number 123 881 * @tc.size : MediumTest 882 * @tc.type : Function 883 * @tc.level : Level 3 884 */ 885 it('testConnectDeviceParamErr019', 0, function () { 886 console.info(TAG, 'usb testConnectDeviceParamErr019 begin'); 887 if (!isDeviceConnected) { 888 expect(isDeviceConnected).assertFalse(); 889 return 890 } 891 try { 892 devices.manufacturerName = PARAM_NUMBERTYPE; 893 let ret = usbManager.connectDevice(devices); 894 console.info(TAG, 'usb [manufacturerName:123] connectDevice ret : ', JSON.stringify(ret)); 895 expect(ret !== null).assertFalse(); 896 } catch (err) { 897 console.info(TAG, 'testConnectDeviceParamErr019 catch err code: ', err.code, ', message: ', err.message); 898 expect(err.code).assertEqual(PARAM_ERRCODE); 899 } 900 }) 901 902 /** 903 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3100 904 * @tc.name : testConnectDeviceParamErr020 905 * @tc.desc : Negative test: devices productName is null 906 * @tc.size : MediumTest 907 * @tc.type : Function 908 * @tc.level : Level 3 909 */ 910 it('testConnectDeviceParamErr020', 0, function () { 911 console.info(TAG, 'usb testConnectDeviceParamErr020 begin'); 912 if (!isDeviceConnected) { 913 expect(isDeviceConnected).assertFalse(); 914 return 915 } 916 try { 917 devices.productName = PARAM_NULL; 918 let ret = usbManager.connectDevice(devices); 919 console.info(TAG, 'usb [productName:null] connectDevice ret : ', JSON.stringify(ret)); 920 expect(ret !== null).assertFalse(); 921 } catch (err) { 922 console.info(TAG, 'testConnectDeviceParamErr020 catch err code: ', err.code, ', message: ', err.message); 923 expect(err.code).assertEqual(PARAM_ERRCODE); 924 } 925 }) 926 927 /** 928 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3200 929 * @tc.name : testConnectDeviceParamErr021 930 * @tc.desc : Negative test: devices productName is undefined 931 * @tc.size : MediumTest 932 * @tc.type : Function 933 * @tc.level : Level 3 934 */ 935 it('testConnectDeviceParamErr021', 0, function () { 936 console.info(TAG, 'usb testConnectDeviceParamErr021 begin'); 937 if (!isDeviceConnected) { 938 expect(isDeviceConnected).assertFalse(); 939 return 940 } 941 try { 942 devices.productName = PARAM_UNDEFINED; 943 let ret = usbManager.connectDevice(devices); 944 console.info(TAG, 'usb [productName:undefined] connectDevice ret : ', JSON.stringify(ret)); 945 expect(ret !== null).assertFalse(); 946 } catch (err) { 947 console.info(TAG, 'testConnectDeviceParamErr021 catch err code: ', err.code, ', message: ', err.message); 948 expect(err.code).assertEqual(PARAM_ERRCODE); 949 } 950 }) 951 952 /** 953 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3300 954 * @tc.name : testConnectDeviceParamErr022 955 * @tc.desc : Negative test: devices productName is number 123 956 * @tc.size : MediumTest 957 * @tc.type : Function 958 * @tc.level : Level 3 959 */ 960 it('testConnectDeviceParamErr022', 0, function () { 961 console.info(TAG, 'usb testConnectDeviceParamErr022 begin'); 962 if (!isDeviceConnected) { 963 expect(isDeviceConnected).assertFalse(); 964 return 965 } 966 try { 967 devices.productName = PARAM_NUMBERTYPE; 968 let ret = usbManager.connectDevice(devices); 969 console.info(TAG, 'usb [productName:123] connectDevice ret : ', JSON.stringify(ret)); 970 expect(ret !== null).assertFalse(); 971 } catch (err) { 972 console.info(TAG, 'testConnectDeviceParamErr022 catch err code: ', err.code, ', message: ', err.message); 973 expect(err.code).assertEqual(PARAM_ERRCODE); 974 } 975 }) 976 977 /** 978 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3400 979 * @tc.name : testConnectDeviceParamErr023 980 * @tc.desc : Negative test: devices version is null 981 * @tc.size : MediumTest 982 * @tc.type : Function 983 * @tc.level : Level 3 984 */ 985 it('testConnectDeviceParamErr023', 0, function () { 986 console.info(TAG, 'usb testConnectDeviceParamErr023 begin'); 987 if (!isDeviceConnected) { 988 expect(isDeviceConnected).assertFalse(); 989 return 990 } 991 try { 992 devices.version = PARAM_NULL; 993 let ret = usbManager.connectDevice(devices); 994 console.info(TAG, 'usb [version:null] connectDevice ret : ', JSON.stringify(ret)); 995 expect(ret !== null).assertFalse(); 996 } catch (err) { 997 console.info(TAG, 'testConnectDeviceParamErr023 catch err code: ', err.code, ', message: ', err.message); 998 expect(err.code).assertEqual(PARAM_ERRCODE); 999 } 1000 }) 1001 1002 /** 1003 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3500 1004 * @tc.name : testConnectDeviceParamErr024 1005 * @tc.desc : Negative test: devices version is undefined 1006 * @tc.size : MediumTest 1007 * @tc.type : Function 1008 * @tc.level : Level 3 1009 */ 1010 it('testConnectDeviceParamErr024', 0, function () { 1011 console.info(TAG, 'usb testConnectDeviceParamErr024 begin'); 1012 if (!isDeviceConnected) { 1013 expect(isDeviceConnected).assertFalse(); 1014 return 1015 } 1016 try { 1017 devices.version = PARAM_UNDEFINED; 1018 let ret = usbManager.connectDevice(devices); 1019 console.info(TAG, 'usb [version:undefined] connectDevice ret : ', JSON.stringify(ret)); 1020 expect(ret !== null).assertFalse(); 1021 } catch (err) { 1022 console.info(TAG, 'testConnectDeviceParamErr024 catch err code: ', err.code, ', message: ', err.message); 1023 expect(err.code).assertEqual(PARAM_ERRCODE); 1024 } 1025 }) 1026 1027 /** 1028 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3600 1029 * @tc.name : testConnectDeviceParamErr025 1030 * @tc.desc : Negative test: devices vendorId is null 1031 * @tc.size : MediumTest 1032 * @tc.type : Function 1033 * @tc.level : Level 3 1034 */ 1035 it('testConnectDeviceParamErr025', 0, function () { 1036 console.info(TAG, 'usb testConnectDeviceParamErr025 begin'); 1037 if (!isDeviceConnected) { 1038 expect(isDeviceConnected).assertFalse(); 1039 return 1040 } 1041 try { 1042 devices.vendorId = PARAM_NULL; 1043 let ret = usbManager.connectDevice(devices); 1044 console.info(TAG, 'usb [vendorId:null] connectDevice ret : ', JSON.stringify(ret)); 1045 expect(ret !== null).assertFalse(); 1046 } catch (err) { 1047 console.info(TAG, 'testConnectDeviceParamErr025 catch err code: ', err.code, ', message: ', err.message); 1048 expect(err.code).assertEqual(PARAM_ERRCODE); 1049 } 1050 }) 1051 1052 /** 1053 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3700 1054 * @tc.name : testConnectDeviceParamErr026 1055 * @tc.desc : Negative test: devices vendorId is undefined 1056 * @tc.size : MediumTest 1057 * @tc.type : Function 1058 * @tc.level : Level 3 1059 */ 1060 it('testConnectDeviceParamErr026', 0, function () { 1061 console.info(TAG, 'usb testConnectDeviceParamErr026 begin'); 1062 if (!isDeviceConnected) { 1063 expect(isDeviceConnected).assertFalse(); 1064 return 1065 } 1066 try { 1067 devices.vendorId = PARAM_UNDEFINED; 1068 let ret = usbManager.connectDevice(devices); 1069 console.info(TAG, 'usb [vendorId:undefined] connectDevice ret : ', JSON.stringify(ret)); 1070 expect(ret !== null).assertFalse(); 1071 } catch (err) { 1072 console.info(TAG, 'testConnectDeviceParamErr026 catch err code: ', err.code, ', message: ', err.message); 1073 expect(err.code).assertEqual(PARAM_ERRCODE); 1074 } 1075 }) 1076 1077 /** 1078 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3800 1079 * @tc.name : testConnectDeviceParamErr027 1080 * @tc.desc : Negative test: devices vendorId is null string "" 1081 * @tc.size : MediumTest 1082 * @tc.type : Function 1083 * @tc.level : Level 3 1084 */ 1085 it('testConnectDeviceParamErr027', 0, function () { 1086 console.info(TAG, 'usb testConnectDeviceParamErr027 begin'); 1087 if (!isDeviceConnected) { 1088 expect(isDeviceConnected).assertFalse(); 1089 return 1090 } 1091 try { 1092 devices.vendorId = PARAM_NULLSTRING; 1093 let ret = usbManager.connectDevice(devices); 1094 console.info(TAG, 'usb [vendorId:""] connectDevice ret : ', JSON.stringify(ret)); 1095 expect(ret !== null).assertFalse(); 1096 } catch (err) { 1097 console.info(TAG, 'testConnectDeviceParamErr027 catch err code: ', err.code, ', message: ', err.message); 1098 expect(err.code).assertEqual(PARAM_ERRCODE); 1099 } 1100 }) 1101 1102 /** 1103 * @tc.number : SUB_USB_HostManager_JS_ParamErr_3900 1104 * @tc.name : testConnectDeviceParamErr028 1105 * @tc.desc : Negative test: devices productId is null 1106 * @tc.size : MediumTest 1107 * @tc.type : Function 1108 * @tc.level : Level 3 1109 */ 1110 it('testConnectDeviceParamErr028', 0, function () { 1111 console.info(TAG, 'usb testConnectDeviceParamErr028 begin'); 1112 if (!isDeviceConnected) { 1113 expect(isDeviceConnected).assertFalse(); 1114 return 1115 } 1116 try { 1117 devices.productId = PARAM_NULL; 1118 let ret = usbManager.connectDevice(devices); 1119 console.info(TAG, 'usb [productId:null] connectDevice ret : ', JSON.stringify(ret)); 1120 expect(ret !== null).assertFalse(); 1121 } catch (err) { 1122 console.info(TAG, 'testConnectDeviceParamErr028 catch err code: ', err.code, ', message: ', err.message); 1123 expect(err.code).assertEqual(PARAM_ERRCODE); 1124 } 1125 }) 1126 1127 /** 1128 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4000 1129 * @tc.name : testConnectDeviceParamErr029 1130 * @tc.desc : Negative test: devices productId is undefined 1131 * @tc.size : MediumTest 1132 * @tc.type : Function 1133 * @tc.level : Level 3 1134 */ 1135 it('testConnectDeviceParamErr029', 0, function () { 1136 console.info(TAG, 'usb testConnectDeviceParamErr029 begin'); 1137 if (!isDeviceConnected) { 1138 expect(isDeviceConnected).assertFalse(); 1139 return 1140 } 1141 try { 1142 devices.productId = PARAM_UNDEFINED; 1143 let ret = usbManager.connectDevice(devices); 1144 console.info(TAG, 'usb [productId:undefined] connectDevice ret : ', JSON.stringify(ret)); 1145 expect(ret !== null).assertFalse(); 1146 } catch (err) { 1147 console.info(TAG, 'testConnectDeviceParamErr029 catch err code: ', err.code, ', message: ', err.message); 1148 expect(err.code).assertEqual(PARAM_ERRCODE); 1149 } 1150 }) 1151 1152 /** 1153 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4100 1154 * @tc.name : testConnectDeviceParamErr030 1155 * @tc.desc : Negative test: devices productId is null string "" 1156 * @tc.size : MediumTest 1157 * @tc.type : Function 1158 * @tc.level : Level 3 1159 */ 1160 it('testConnectDeviceParamErr030', 0, function () { 1161 console.info(TAG, 'usb testConnectDeviceParamErr030 begin'); 1162 if (!isDeviceConnected) { 1163 expect(isDeviceConnected).assertFalse(); 1164 return 1165 } 1166 try { 1167 devices.productId = PARAM_NULLSTRING; 1168 let ret = usbManager.connectDevice(devices); 1169 console.info(TAG, 'usb [productId:" "] connectDevice ret : ', JSON.stringify(ret)); 1170 expect(ret !== null).assertFalse(); 1171 } catch (err) { 1172 console.info(TAG, 'testConnectDeviceParamErr030 catch err code: ', err.code, ', message: ', err.message); 1173 expect(err.code).assertEqual(PARAM_ERRCODE); 1174 } 1175 }) 1176 1177 /** 1178 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4200 1179 * @tc.name : testConnectDeviceParamErr031 1180 * @tc.desc : Negative test: devices clazz is null 1181 * @tc.size : MediumTest 1182 * @tc.type : Function 1183 * @tc.level : Level 3 1184 */ 1185 it('testConnectDeviceParamErr031', 0, function () { 1186 console.info(TAG, 'usb testConnectDeviceParamErr031 begin'); 1187 if (!isDeviceConnected) { 1188 expect(isDeviceConnected).assertFalse(); 1189 return 1190 } 1191 try { 1192 devices.clazz = PARAM_NULL; 1193 let ret = usbManager.connectDevice(devices); 1194 console.info(TAG, 'usb [clazz:null] connectDevice ret : ', JSON.stringify(ret)); 1195 expect(ret !== null).assertFalse(); 1196 } catch (err) { 1197 console.info(TAG, 'testConnectDeviceParamErr031 catch err code: ', err.code, ', message: ', err.message); 1198 expect(err.code).assertEqual(PARAM_ERRCODE); 1199 } 1200 }) 1201 1202 /** 1203 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4300 1204 * @tc.name : testConnectDeviceParamErr032 1205 * @tc.desc : Negative test: devices clazz is undefined 1206 * @tc.size : MediumTest 1207 * @tc.type : Function 1208 * @tc.level : Level 3 1209 */ 1210 it('testConnectDeviceParamErr032', 0, function () { 1211 console.info(TAG, 'usb testConnectDeviceParamErr032 begin'); 1212 if (!isDeviceConnected) { 1213 expect(isDeviceConnected).assertFalse(); 1214 return 1215 } 1216 try { 1217 devices.clazz = PARAM_UNDEFINED; 1218 let ret = usbManager.connectDevice(devices); 1219 console.info(TAG, 'usb [clazz:undefined] connectDevice ret : ', JSON.stringify(ret)); 1220 expect(ret !== null).assertFalse(); 1221 } catch (err) { 1222 console.info(TAG, 'testConnectDeviceParamErr032 catch err code: ', err.code, ', message: ', err.message); 1223 expect(err.code).assertEqual(PARAM_ERRCODE); 1224 } 1225 }) 1226 1227 /** 1228 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4400 1229 * @tc.name : testConnectDeviceParamErr033 1230 * @tc.desc : Negative test: devices clazz is null string "" 1231 * @tc.size : MediumTest 1232 * @tc.type : Function 1233 * @tc.level : Level 3 1234 */ 1235 it('testConnectDeviceParamErr033', 0, function () { 1236 console.info(TAG, 'usb testConnectDeviceParamErr033 begin'); 1237 if (!isDeviceConnected) { 1238 expect(isDeviceConnected).assertFalse(); 1239 return 1240 } 1241 try { 1242 devices.clazz = PARAM_NULLSTRING; 1243 let ret = usbManager.connectDevice(devices); 1244 console.info(TAG, 'usb [clazz:""] connectDevice ret : ', JSON.stringify(ret)); 1245 expect(ret !== null).assertFalse(); 1246 } catch (err) { 1247 console.info(TAG, 'testConnectDeviceParamErr033 catch err code: ', err.code, ', message: ', err.message); 1248 expect(err.code).assertEqual(PARAM_ERRCODE); 1249 } 1250 }) 1251 1252 /** 1253 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4500 1254 * @tc.name : testConnectDeviceParamErr034 1255 * @tc.desc : Negative test: devices subClass is null 1256 * @tc.size : MediumTest 1257 * @tc.type : Function 1258 * @tc.level : Level 3 1259 */ 1260 it('testConnectDeviceParamErr034', 0, function () { 1261 console.info(TAG, 'usb testConnectDeviceParamErr034 begin'); 1262 if (!isDeviceConnected) { 1263 expect(isDeviceConnected).assertFalse(); 1264 return 1265 } 1266 try { 1267 devices.subClass = PARAM_NULL; 1268 let ret = usbManager.connectDevice(devices); 1269 console.info(TAG, 'usb [subClass:null] connectDevice ret : ', JSON.stringify(ret)); 1270 expect(ret !== null).assertFalse(); 1271 } catch (err) { 1272 console.info(TAG, 'testConnectDeviceParamErr034 catch err code: ', err.code, ', message: ', err.message); 1273 expect(err.code).assertEqual(PARAM_ERRCODE); 1274 } 1275 }) 1276 1277 /** 1278 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4600 1279 * @tc.name : testConnectDeviceParamErr035 1280 * @tc.desc : Negative test: devices subClass is undefined 1281 * @tc.size : MediumTest 1282 * @tc.type : Function 1283 * @tc.level : Level 3 1284 */ 1285 it('testConnectDeviceParamErr035', 0, function () { 1286 console.info(TAG, 'usb testConnectDeviceParamErr035 begin'); 1287 if (!isDeviceConnected) { 1288 expect(isDeviceConnected).assertFalse(); 1289 return 1290 } 1291 try { 1292 devices.subClass = PARAM_UNDEFINED; 1293 let ret = usbManager.connectDevice(devices); 1294 console.info(TAG, 'usb [subClass:undefined] connectDevice ret : ', JSON.stringify(ret)); 1295 expect(ret !== null).assertFalse(); 1296 } catch (err) { 1297 console.info(TAG, 'testConnectDeviceParamErr035 catch err code: ', err.code, ', message: ', err.message); 1298 expect(err.code).assertEqual(PARAM_ERRCODE); 1299 } 1300 }) 1301 1302 /** 1303 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4700 1304 * @tc.name : testConnectDeviceParamErr036 1305 * @tc.desc : Negative test: devices subClass is null string "" 1306 * @tc.size : MediumTest 1307 * @tc.type : Function 1308 * @tc.level : Level 3 1309 */ 1310 it('testConnectDeviceParamErr036', 0, function () { 1311 console.info(TAG, 'usb testConnectDeviceParamErr036 begin'); 1312 if (!isDeviceConnected) { 1313 expect(isDeviceConnected).assertFalse(); 1314 return 1315 } 1316 try { 1317 devices.subClass = PARAM_NULLSTRING; 1318 let ret = usbManager.connectDevice(devices); 1319 console.info(TAG, 'usb [subClass:""] connectDevice ret : ', JSON.stringify(ret)); 1320 expect(ret !== null).assertFalse(); 1321 } catch (err) { 1322 console.info(TAG, 'testConnectDeviceParamErr036 catch err code: ', err.code, ', message: ', err.message); 1323 expect(err.code).assertEqual(PARAM_ERRCODE); 1324 } 1325 }) 1326 1327 /** 1328 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4800 1329 * @tc.name : testConnectDeviceParamErr037 1330 * @tc.desc : Negative test: devices protocol is null 1331 * @tc.size : MediumTest 1332 * @tc.type : Function 1333 * @tc.level : Level 3 1334 */ 1335 it('testConnectDeviceParamErr037', 0, function () { 1336 console.info(TAG, 'usb testConnectDeviceParamErr037 begin'); 1337 if (!isDeviceConnected) { 1338 expect(isDeviceConnected).assertFalse(); 1339 return 1340 } 1341 try { 1342 devices.protocol = PARAM_NULL; 1343 let ret = usbManager.connectDevice(devices); 1344 console.info(TAG, 'usb [protocol:null] connectDevice ret : ', JSON.stringify(ret)); 1345 expect(ret !== null).assertFalse(); 1346 } catch (err) { 1347 console.info(TAG, 'testConnectDeviceParamErr037 catch err code: ', err.code, ', message: ', err.message); 1348 expect(err.code).assertEqual(PARAM_ERRCODE); 1349 } 1350 }) 1351 1352 /** 1353 * @tc.number : SUB_USB_HostManager_JS_ParamErr_4900 1354 * @tc.name : testConnectDeviceParamErr038 1355 * @tc.desc : Negative test: devices protocol is undefined 1356 * @tc.size : MediumTest 1357 * @tc.type : Function 1358 * @tc.level : Level 3 1359 */ 1360 it('testConnectDeviceParamErr038', 0, function () { 1361 console.info(TAG, 'usb testConnectDeviceParamErr038 begin'); 1362 if (!isDeviceConnected) { 1363 expect(isDeviceConnected).assertFalse(); 1364 return 1365 } 1366 try { 1367 devices.protocol = PARAM_UNDEFINED; 1368 let ret = usbManager.connectDevice(devices); 1369 console.info(TAG, 'usb [protocol:undefined] connectDevice ret : ', JSON.stringify(ret)); 1370 expect(ret !== null).assertFalse(); 1371 } catch (err) { 1372 console.info(TAG, 'testConnectDeviceParamErr038 catch err code: ', err.code, ', message: ', err.message); 1373 expect(err.code).assertEqual(PARAM_ERRCODE); 1374 } 1375 }) 1376 1377 /** 1378 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5000 1379 * @tc.name : testConnectDeviceParamErr039 1380 * @tc.desc : Negative test: devices protocol is null string "" 1381 * @tc.size : MediumTest 1382 * @tc.type : Function 1383 * @tc.level : Level 3 1384 */ 1385 it('testConnectDeviceParamErr039', 0, function () { 1386 console.info(TAG, 'usb testConnectDeviceParamErr039 begin'); 1387 if (!isDeviceConnected) { 1388 expect(isDeviceConnected).assertFalse(); 1389 return 1390 } 1391 try { 1392 devices.protocol = PARAM_NULLSTRING; 1393 let ret = usbManager.connectDevice(devices); 1394 console.info(TAG, 'usb [protocol:""] connectDevice ret : ', JSON.stringify(ret)); 1395 expect(ret !== null).assertFalse(); 1396 } catch (err) { 1397 console.info(TAG, 'testConnectDeviceParamErr039 catch err code: ', err.code, ', message: ', err.message); 1398 expect(err.code).assertEqual(PARAM_ERRCODE); 1399 } 1400 }) 1401 1402 /** 1403 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5100 1404 * @tc.name : testConnectDeviceParamErr040 1405 * @tc.desc : Negative test: devices configs is null 1406 * @tc.size : MediumTest 1407 * @tc.type : Function 1408 * @tc.level : Level 3 1409 */ 1410 it('testConnectDeviceParamErr040', 0, function () { 1411 console.info(TAG, 'usb testConnectDeviceParamErr040 begin'); 1412 if (!isDeviceConnected) { 1413 expect(isDeviceConnected).assertFalse(); 1414 return 1415 } 1416 try { 1417 devices.configs = PARAM_NULL; 1418 let ret = usbManager.connectDevice(devices); 1419 console.info(TAG, 'usb [configs:null] connectDevice ret : ', JSON.stringify(ret)); 1420 expect(ret !== null).assertFalse(); 1421 } catch (err) { 1422 console.info(TAG, 'testConnectDeviceParamErr040 catch err code: ', err.code, ', message: ', err.message); 1423 expect(err.code).assertEqual(PARAM_ERRCODE); 1424 } 1425 }) 1426 1427 /** 1428 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5200 1429 * @tc.name : testConnectDeviceParamErr041 1430 * @tc.desc : Negative test: devices configs is undefined 1431 * @tc.size : MediumTest 1432 * @tc.type : Function 1433 * @tc.level : Level 3 1434 */ 1435 it('testConnectDeviceParamErr041', 0, function () { 1436 console.info(TAG, 'usb testConnectDeviceParamErr041 begin'); 1437 if (!isDeviceConnected) { 1438 expect(isDeviceConnected).assertFalse(); 1439 return 1440 } 1441 try { 1442 devices.configs = PARAM_UNDEFINED; 1443 let ret = usbManager.connectDevice(devices); 1444 console.info(TAG, 'usb [configs:undefined] connectDevice ret : ', JSON.stringify(ret)); 1445 expect(ret !== null).assertFalse(); 1446 } catch (err) { 1447 console.info(TAG, 'testConnectDeviceParamErr041 catch err code: ', err.code, ', message: ', err.message); 1448 expect(err.code).assertEqual(PARAM_ERRCODE); 1449 } 1450 }) 1451 1452 /** 1453 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5300 1454 * @tc.name : testConnectDeviceParamErr042 1455 * @tc.desc : Negative test: devices configs is null string "" 1456 * @tc.size : MediumTest 1457 * @tc.type : Function 1458 * @tc.level : Level 3 1459 */ 1460 it('testConnectDeviceParamErr042', 0, function () { 1461 console.info(TAG, 'usb testConnectDeviceParamErr042 begin'); 1462 if (!isDeviceConnected) { 1463 expect(isDeviceConnected).assertFalse(); 1464 return 1465 } 1466 try { 1467 devices.configs = PARAM_NULLSTRING; 1468 let ret = usbManager.connectDevice(devices); 1469 console.info(TAG, 'usb [configs:""] connectDevice ret : ', JSON.stringify(ret)); 1470 expect(ret !== null).assertFalse(); 1471 } catch (err) { 1472 console.info(TAG, 'testConnectDeviceParamErr042 catch err code: ', err.code, ', message: ', err.message); 1473 expect(err.code).assertEqual(PARAM_ERRCODE); 1474 } 1475 }) 1476 1477 /** 1478 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5400 1479 * @tc.name : testConnectDeviceParamErr043 1480 * @tc.desc : Negative test: devices configs is number 123 1481 * @tc.size : MediumTest 1482 * @tc.type : Function 1483 * @tc.level : Level 3 1484 */ 1485 it('testConnectDeviceParamErr043', 0, function () { 1486 console.info(TAG, 'usb testConnectDeviceParamErr043 begin'); 1487 if (!isDeviceConnected) { 1488 expect(isDeviceConnected).assertFalse(); 1489 return 1490 } 1491 try { 1492 devices.configs = PARAM_NULLSTRING; 1493 let ret = usbManager.connectDevice(devices); 1494 console.info(TAG, 'usb [configs:123] connectDevice ret : ', JSON.stringify(ret)); 1495 expect(ret !== null).assertFalse(); 1496 } catch (err) { 1497 console.info(TAG, 'testConnectDeviceParamErr043 catch err code: ', err.code, ', message: ', err.message); 1498 expect(err.code).assertEqual(PARAM_ERRCODE); 1499 } 1500 }) 1501 1502 /** 1503 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5500 1504 * @tc.name : testClosePipeParamErr001 1505 * @tc.desc : Negative test: Enter two parameters 1506 * @tc.size : MediumTest 1507 * @tc.type : Function 1508 * @tc.level : Level 3 1509 */ 1510 it('testClosePipeParamErr001', 0, function () { 1511 console.info(TAG, 'usb testClosePipeParamErr001 begin'); 1512 if (!isDeviceConnected) { 1513 expect(isDeviceConnected).assertFalse(); 1514 return 1515 } 1516 getPipe('testClosePipeParamErr001'); 1517 try { 1518 let ret = usbManager.closePipe(gPipe, gPipe); 1519 console.info(TAG, 'usb Enter two parameters closePipe ret : ', ret); 1520 expect(ret).assertEqual(0); 1521 } catch (err) { 1522 console.info(TAG, 'testClosePipeParamErr001 catch err : ', err.code, ', message: ', err.message); 1523 expect(err !== null).assertFalse(); 1524 } 1525 }) 1526 1527 /** 1528 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5600 1529 * @tc.name : testClosePipeParamErr002 1530 * @tc.desc : Negative test: pipe busNum is null 1531 * @tc.size : MediumTest 1532 * @tc.type : Function 1533 * @tc.level : Level 3 1534 */ 1535 it('testClosePipeParamErr002', 0, function () { 1536 console.info(TAG, 'usb testClosePipeParamErr002 begin'); 1537 if (!isDeviceConnected) { 1538 expect(isDeviceConnected).assertFalse(); 1539 return 1540 } 1541 try { 1542 gPipe.busNum = PARAM_NULL; 1543 let ret = usbManager.closePipe(gPipe); 1544 console.info(TAG, 'usb [busNum:null] closePipe ret : ', ret); 1545 expect(ret !== null).assertFalse(); 1546 } catch (err) { 1547 console.info(TAG, 'testClosePipeParamErr002 catch err code: ', err.code, ', message: ', err.message); 1548 expect(err.code).assertEqual(PARAM_ERRCODE); 1549 } 1550 }) 1551 1552 /** 1553 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5700 1554 * @tc.name : testClosePipeParamErr003 1555 * @tc.desc : Negative test: pipe busNum is undefined 1556 * @tc.size : MediumTest 1557 * @tc.type : Function 1558 * @tc.level : Level 3 1559 */ 1560 it('testClosePipeParamErr003', 0, function () { 1561 console.info(TAG, 'usb testClosePipeParamErr003 begin'); 1562 if (!isDeviceConnected) { 1563 expect(isDeviceConnected).assertFalse(); 1564 return 1565 } 1566 try { 1567 gPipe.busNum = PARAM_UNDEFINED; 1568 let ret = usbManager.closePipe(gPipe); 1569 console.info(TAG, 'usb [busNum:undefined] closePipe ret : ', ret); 1570 expect(ret !== null).assertFalse(); 1571 } catch (err) { 1572 console.info(TAG, 'testClosePipeParamErr003 catch err code: ', err.code, ', message: ', err.message); 1573 expect(err.code).assertEqual(PARAM_ERRCODE); 1574 } 1575 }) 1576 1577 /** 1578 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5800 1579 * @tc.name : testClosePipeParamErr004 1580 * @tc.desc : Negative test: pipe busNum is null string "" 1581 * @tc.size : MediumTest 1582 * @tc.type : Function 1583 * @tc.level : Level 3 1584 */ 1585 it('testClosePipeParamErr004', 0, function () { 1586 console.info(TAG, 'usb testClosePipeParamErr004 begin'); 1587 if (!isDeviceConnected) { 1588 expect(isDeviceConnected).assertFalse(); 1589 return 1590 } 1591 try { 1592 gPipe.busNum = PARAM_NULLSTRING; 1593 let ret = usbManager.closePipe(gPipe); 1594 console.info(TAG, 'usb [busNum:""] closePipe ret : ', ret); 1595 expect(ret !== null).assertFalse(); 1596 } catch (err) { 1597 console.info(TAG, 'testClosePipeParamErr004 catch err code: ', err.code, ', message: ', err.message); 1598 expect(err.code).assertEqual(PARAM_ERRCODE); 1599 } 1600 }) 1601 1602 /** 1603 * @tc.number : SUB_USB_HostManager_JS_ParamErr_5900 1604 * @tc.name : testClosePipeParamErr005 1605 * @tc.desc : Negative test: pipe devAddress is null 1606 * @tc.size : MediumTest 1607 * @tc.type : Function 1608 * @tc.level : Level 3 1609 */ 1610 it('testClosePipeParamErr005', 0, function () { 1611 console.info(TAG, 'usb testClosePipeParamErr005 begin'); 1612 if (!isDeviceConnected) { 1613 expect(isDeviceConnected).assertFalse(); 1614 return 1615 } 1616 try { 1617 gPipe.devAddress = PARAM_NULL; 1618 let ret = usbManager.closePipe(gPipe); 1619 console.info(TAG, 'usb [devAddress:null] closePipe ret : ', ret); 1620 expect(ret !== null).assertFalse(); 1621 } catch (err) { 1622 console.info(TAG, 'testClosePipeParamErr005 catch err code: ', err.code, ', message: ', err.message); 1623 expect(err.code).assertEqual(PARAM_ERRCODE); 1624 } 1625 }) 1626 1627 /** 1628 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6000 1629 * @tc.name : testClosePipeParamErr006 1630 * @tc.desc : Negative test: pipe devAddress is undefined 1631 * @tc.size : MediumTest 1632 * @tc.type : Function 1633 * @tc.level : Level 3 1634 */ 1635 it('testClosePipeParamErr006', 0, function () { 1636 console.info(TAG, 'usb testClosePipeParamErr006 begin'); 1637 if (!isDeviceConnected) { 1638 expect(isDeviceConnected).assertFalse(); 1639 return 1640 } 1641 try { 1642 gPipe.devAddress = PARAM_UNDEFINED; 1643 let ret = usbManager.closePipe(gPipe); 1644 console.info(TAG, 'usb [devAddress:undefined] closePipe ret : ', ret); 1645 expect(ret !== null).assertFalse(); 1646 } catch (err) { 1647 console.info(TAG, 'testClosePipeParamErr006 catch err code: ', err.code, ', message: ', err.message); 1648 expect(err.code).assertEqual(PARAM_ERRCODE); 1649 } 1650 }) 1651 1652 /** 1653 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6100 1654 * @tc.name : testClosePipeParamErr007 1655 * @tc.desc : Negative test: devices devAddress is null string "" 1656 * @tc.size : MediumTest 1657 * @tc.type : Function 1658 * @tc.level : Level 3 1659 */ 1660 it('testClosePipeParamErr007', 0, function () { 1661 console.info(TAG, 'usb testClosePipeParamErr007 begin'); 1662 if (!isDeviceConnected) { 1663 expect(isDeviceConnected).assertFalse(); 1664 return 1665 } 1666 try { 1667 gPipe.devAddress = PARAM_NULLSTRING; 1668 let ret = usbManager.closePipe(gPipe); 1669 console.info(TAG, 'usb [devAddress:""] closePipe ret : ', ret); 1670 expect(ret !== null).assertFalse(); 1671 } catch (err) { 1672 console.info(TAG, 'testClosePipeParamErr007 catch err code: ', err.code, ', message: ', err.message); 1673 expect(err.code).assertEqual(PARAM_ERRCODE); 1674 } 1675 }) 1676 1677 /** 1678 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6200 1679 * @tc.name : testClosePipeParamErr008 1680 * @tc.desc : Negative test: Param is null 1681 * @tc.size : MediumTest 1682 * @tc.type : Function 1683 * @tc.level : Level 3 1684 */ 1685 it('testClosePipeParamErr008', 0, function () { 1686 console.info(TAG, 'usb testClosePipeParamErr008 begin'); 1687 if (!isDeviceConnected) { 1688 expect(isDeviceConnected).assertFalse(); 1689 return 1690 } 1691 try { 1692 let ret = usbManager.closePipe(PARAM_NULL); 1693 console.info(TAG, 'usb [param:null] closePipe ret : ', ret); 1694 expect(ret !== null).assertFalse(); 1695 } catch (err) { 1696 console.info(TAG, 'testClosePipeParamErr008 catch err code: ', err.code, ', message: ', err.message); 1697 expect(err.code).assertEqual(PARAM_ERRCODE); 1698 } 1699 }) 1700 1701 /** 1702 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6300 1703 * @tc.name : testClosePipeParamErr009 1704 * @tc.desc : Negative test: Param is undefined 1705 * @tc.size : MediumTest 1706 * @tc.type : Function 1707 * @tc.level : Level 3 1708 */ 1709 it('testClosePipeParamErr009', 0, function () { 1710 console.info(TAG, 'usb testClosePipeParamErr009 begin'); 1711 if (!isDeviceConnected) { 1712 expect(isDeviceConnected).assertFalse(); 1713 return 1714 } 1715 try { 1716 let ret = usbManager.closePipe(PARAM_UNDEFINED); 1717 console.info(TAG, 'usb [param:undefined] closePipe ret : ', ret); 1718 expect(ret !== null).assertFalse(); 1719 } catch (err) { 1720 console.info(TAG, 'testClosePipeParamErr009 catch err code: ', err.code, ', message: ', err.message); 1721 expect(err.code).assertEqual(PARAM_ERRCODE); 1722 } 1723 }) 1724 1725 /** 1726 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6400 1727 * @tc.name : testClosePipeParamErr010 1728 * @tc.desc : Negative test: Param is null string "" 1729 * @tc.size : MediumTest 1730 * @tc.type : Function 1731 * @tc.level : Level 3 1732 */ 1733 it('testClosePipeParamErr010', 0, function () { 1734 console.info(TAG, 'usb testClosePipeParamErr010 begin'); 1735 if (!isDeviceConnected) { 1736 expect(isDeviceConnected).assertFalse(); 1737 return 1738 } 1739 try { 1740 let ret = usbManager.closePipe(PARAM_NULLSTRING); 1741 console.info(TAG, 'usb [param:""] closePipe ret : ', ret); 1742 expect(ret !== null).assertFalse(); 1743 } catch (err) { 1744 console.info(TAG, 'testClosePipeParamErr010 catch err code: ', err.code, ', message: ', err.message); 1745 expect(err.code).assertEqual(PARAM_ERRCODE); 1746 } 1747 }) 1748 1749 /** 1750 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6500 1751 * @tc.name : testGetRawDescriptorParamErr001 1752 * @tc.desc : Negative test: Enter two parameters 1753 * @tc.size : MediumTest 1754 * @tc.type : Function 1755 * @tc.level : Level 3 1756 */ 1757 it('testGetRawDescriptorParamErr001', 0, function () { 1758 console.info(TAG, 'usb testGetRawDescriptorParamErr001 begin'); 1759 if (!isDeviceConnected) { 1760 expect(isDeviceConnected).assertFalse(); 1761 return 1762 } 1763 getPipe('testGetRawDescriptorParamErr001'); 1764 try { 1765 let ret = usbManager.getRawDescriptor(gPipe, gPipe); 1766 console.info(TAG, 'usb Enter two parameters getRawDescriptor ret : ', JSON.stringify(ret)); 1767 expect(ret.length >= 0).assertTrue(); 1768 } catch (err) { 1769 console.info(TAG, 'testGetRawDescriptorParamErr001 catch err code: ', err.code, ', message: ', err.message); 1770 expect(err !== null).assertFalse(); 1771 } 1772 toClosePipe('testGetRawDescriptorParamErr001'); 1773 }) 1774 1775 /** 1776 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6600 1777 * @tc.name : testGetRawDescriptorParamErr002 1778 * @tc.desc : Negative test: Param is null 1779 * @tc.size : MediumTest 1780 * @tc.type : Function 1781 * @tc.level : Level 3 1782 */ 1783 it('testGetRawDescriptorParamErr002', 0, function () { 1784 console.info(TAG, 'usb testGetRawDescriptorParamErr002 begin'); 1785 if (!isDeviceConnected) { 1786 expect(isDeviceConnected).assertFalse(); 1787 return 1788 } 1789 try { 1790 let ret = usbManager.getRawDescriptor(PARAM_NULL); 1791 console.info(TAG, 'usb [param:null] getRawDescriptor ret : ', JSON.stringify(ret)); 1792 expect(ret !== null).assertFalse(); 1793 } catch (err) { 1794 console.info(TAG, 'testGetRawDescriptorParamErr002 catch err code: ', err.code, ', message: ', err.message); 1795 expect(err.code).assertEqual(PARAM_ERRCODE); 1796 } 1797 }) 1798 1799 /** 1800 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6700 1801 * @tc.name : testGetRawDescriptorParamErr003 1802 * @tc.desc : Negative test: Param is undefined 1803 * @tc.size : MediumTest 1804 * @tc.type : Function 1805 * @tc.level : Level 3 1806 */ 1807 it('testGetRawDescriptorParamErr003', 0, function () { 1808 console.info(TAG, 'usb testGetRawDescriptorParamErr003 begin'); 1809 if (!isDeviceConnected) { 1810 expect(isDeviceConnected).assertFalse(); 1811 return 1812 } 1813 try { 1814 let ret = usbManager.getRawDescriptor(PARAM_UNDEFINED); 1815 console.info(TAG, 'usb [param:undefined] getRawDescriptor ret : ', JSON.stringify(ret)); 1816 expect(ret !== null).assertFalse(); 1817 } catch (err) { 1818 console.info(TAG, 'testGetRawDescriptorParamErr003 catch err code: ', err.code, ', message: ', err.message); 1819 expect(err.code).assertEqual(PARAM_ERRCODE); 1820 } 1821 }) 1822 1823 /** 1824 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6800 1825 * @tc.name : testGetRawDescriptorParamErr004 1826 * @tc.desc : Negative test: Param is null string "" 1827 * @tc.size : MediumTest 1828 * @tc.type : Function 1829 * @tc.level : Level 3 1830 */ 1831 it('testGetRawDescriptorParamErr004', 0, function () { 1832 console.info(TAG, 'usb testGetRawDescriptorParamErr004 begin'); 1833 if (!isDeviceConnected) { 1834 expect(isDeviceConnected).assertFalse(); 1835 return 1836 } 1837 try { 1838 let ret = usbManager.getRawDescriptor(PARAM_NULLSTRING); 1839 console.info(TAG, 'usb [param:""] getRawDescriptor ret : ', JSON.stringify(ret)); 1840 expect(ret !== null).assertFalse(); 1841 } catch (err) { 1842 console.info(TAG, 'testGetRawDescriptorParamErr004 catch err code: ', err.code, ', message: ', err.message); 1843 expect(err.code).assertEqual(PARAM_ERRCODE); 1844 } 1845 }) 1846 1847 /** 1848 * @tc.number : SUB_USB_HostManager_JS_ParamErr_6900 1849 * @tc.name : testGetRawDescriptorParamErr005 1850 * @tc.desc : Negative test: pipe busNum is null 1851 * @tc.size : MediumTest 1852 * @tc.type : Function 1853 * @tc.level : Level 3 1854 */ 1855 it('testGetRawDescriptorParamErr005', 0, function () { 1856 console.info(TAG, 'usb testGetRawDescriptorParamErr005 begin'); 1857 if (!isDeviceConnected) { 1858 expect(isDeviceConnected).assertFalse(); 1859 return 1860 } 1861 try { 1862 gPipe.busNum = PARAM_NULL; 1863 let ret = usbManager.getRawDescriptor(gPipe); 1864 console.info(TAG, 'usb [busNum:null] getRawDescriptor ret : ', JSON.stringify(ret)); 1865 expect(ret !== null).assertFalse(); 1866 } catch (err) { 1867 console.info(TAG, 'testGetRawDescriptorParamErr005 catch err code: ', err.code, ', message: ', err.message); 1868 expect(err.code).assertEqual(PARAM_ERRCODE); 1869 } 1870 }) 1871 1872 /** 1873 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7000 1874 * @tc.name : testGetRawDescriptorParamErr006 1875 * @tc.desc : Negative test: pipe busNum is undefined 1876 * @tc.size : MediumTest 1877 * @tc.type : Function 1878 * @tc.level : Level 3 1879 */ 1880 it('testGetRawDescriptorParamErr006', 0, function () { 1881 console.info(TAG, 'usb testGetRawDescriptorParamErr006 begin'); 1882 if (!isDeviceConnected) { 1883 expect(isDeviceConnected).assertFalse(); 1884 return 1885 } 1886 try { 1887 gPipe.busNum = PARAM_UNDEFINED; 1888 let ret = usbManager.getRawDescriptor(gPipe); 1889 console.info(TAG, 'usb [busNum:undefined] getRawDescriptor ret : ', JSON.stringify(ret)); 1890 expect(ret !== null).assertFalse(); 1891 } catch (err) { 1892 console.info(TAG, 'testGetRawDescriptorParamErr006 catch err code: ', err.code, ', message: ', err.message); 1893 expect(err.code).assertEqual(PARAM_ERRCODE); 1894 } 1895 }) 1896 1897 /** 1898 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7100 1899 * @tc.name : testGetRawDescriptorParamErr007 1900 * @tc.desc : Negative test: pipe busNum is null string "" 1901 * @tc.size : MediumTest 1902 * @tc.type : Function 1903 * @tc.level : Level 3 1904 */ 1905 it('testGetRawDescriptorParamErr007', 0, function () { 1906 console.info(TAG, 'usb testGetRawDescriptorParamErr007 begin'); 1907 if (!isDeviceConnected) { 1908 expect(isDeviceConnected).assertFalse(); 1909 return 1910 } 1911 try { 1912 gPipe.busNum = PARAM_NULLSTRING; 1913 let ret = usbManager.getRawDescriptor(gPipe); 1914 console.info(TAG, 'usb [busNum:""] getRawDescriptor ret : ', JSON.stringify(ret)); 1915 expect(ret !== null).assertFalse(); 1916 } catch (err) { 1917 console.info(TAG, 'testGetRawDescriptorParamErr007 catch err code: ', err.code, ', message: ', err.message); 1918 expect(err.code).assertEqual(PARAM_ERRCODE); 1919 } 1920 }) 1921 1922 /** 1923 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7200 1924 * @tc.name : testGetRawDescriptorParamErr008 1925 * @tc.desc : Negative test: pipe devAddress is null 1926 * @tc.size : MediumTest 1927 * @tc.type : Function 1928 * @tc.level : Level 3 1929 */ 1930 it('testGetRawDescriptorParamErr008', 0, function () { 1931 console.info(TAG, 'usb testGetRawDescriptorParamErr008 begin'); 1932 if (!isDeviceConnected) { 1933 expect(isDeviceConnected).assertFalse(); 1934 return 1935 } 1936 try { 1937 gPipe.devAddress = PARAM_NULL; 1938 let ret = usbManager.getRawDescriptor(gPipe); 1939 console.info(TAG, 'usb [devAddress:null] getRawDescriptor ret : ', JSON.stringify(ret)); 1940 expect(ret !== null).assertFalse(); 1941 } catch (err) { 1942 console.info(TAG, 'testGetRawDescriptorParamErr008 catch err code: ', err.code, ', message: ', err.message); 1943 expect(err.code).assertEqual(PARAM_ERRCODE); 1944 } 1945 }) 1946 1947 /** 1948 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7300 1949 * @tc.name : testGetRawDescriptorParamErr009 1950 * @tc.desc : Negative test: pipe devAddress is undefined 1951 * @tc.size : MediumTest 1952 * @tc.type : Function 1953 * @tc.level : Level 3 1954 */ 1955 it('testGetRawDescriptorParamErr009', 0, function () { 1956 console.info(TAG, 'usb testGetRawDescriptorParamErr009 begin'); 1957 if (!isDeviceConnected) { 1958 expect(isDeviceConnected).assertFalse(); 1959 return 1960 } 1961 try { 1962 gPipe.devAddress = PARAM_UNDEFINED; 1963 let ret = usbManager.getRawDescriptor(gPipe); 1964 console.info(TAG, 'usb [devAddress:undefined] getRawDescriptor ret : ', JSON.stringify(ret)); 1965 expect(ret !== null).assertFalse(); 1966 } catch (err) { 1967 console.info(TAG, 'testGetRawDescriptorParamErr009 catch err code: ', err.code, ', message: ', err.message); 1968 expect(err.code).assertEqual(PARAM_ERRCODE); 1969 } 1970 }) 1971 1972 /** 1973 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7400 1974 * @tc.name : testGetRawDescriptorParamErr010 1975 * @tc.desc : Negative test: devices devAddress is null string "" 1976 * @tc.size : MediumTest 1977 * @tc.type : Function 1978 * @tc.level : Level 3 1979 */ 1980 it('testGetRawDescriptorParamErr010', 0, function () { 1981 console.info(TAG, 'usb testGetRawDescriptorParamErr010 begin'); 1982 if (!isDeviceConnected) { 1983 expect(isDeviceConnected).assertFalse(); 1984 return 1985 } 1986 try { 1987 gPipe.devAddress = PARAM_NULLSTRING; 1988 let ret = usbManager.getRawDescriptor(gPipe); 1989 console.info(TAG, 'usb [devAddress:""] getRawDescriptor ret : ', JSON.stringify(ret)); 1990 expect(ret !== null).assertFalse(); 1991 } catch (err) { 1992 console.info(TAG, 'testGetRawDescriptorParamErr010 catch err code: ', err.code, ', message: ', err.message); 1993 expect(err.code).assertEqual(PARAM_ERRCODE); 1994 } 1995 }) 1996 1997 /** 1998 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7500 1999 * @tc.name : testGetFileDescriptorParamErr001 2000 * @tc.desc : Negative test: Enter two parameters 2001 * @tc.size : MediumTest 2002 * @tc.type : Function 2003 * @tc.level : Level 3 2004 */ 2005 it('testGetFileDescriptorParamErr001', 0, function () { 2006 console.info(TAG, 'usb testGetFileDescriptorParamErr001 begin'); 2007 if (!isDeviceConnected) { 2008 expect(isDeviceConnected).assertFalse(); 2009 return 2010 } 2011 getPipe('testGetRawDescriptorParamErr001'); 2012 try { 2013 let ret = usbManager.getFileDescriptor(gPipe, gPipe); 2014 console.info(TAG, 'usb Enter two parameters getFileDescriptor ret : ', ret); 2015 expect(ret >= 0).assertTrue(); 2016 } catch (err) { 2017 console.info(TAG, 'testGetFileDescriptorParamErr001 catch err code: ', 2018 err.code, ', message: ', err.message); 2019 expect(err !== null).assertFalse(); 2020 } 2021 toClosePipe('testGetRawDescriptorParamErr001'); 2022 }) 2023 2024 /** 2025 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7600 2026 * @tc.name : testGetFileDescriptorParamErr002 2027 * @tc.desc : Negative test: Param is null 2028 * @tc.size : MediumTest 2029 * @tc.type : Function 2030 * @tc.level : Level 3 2031 */ 2032 it('testGetFileDescriptorParamErr002', 0, function () { 2033 console.info(TAG, 'usb testGetFileDescriptorParamErr002 begin'); 2034 if (!isDeviceConnected) { 2035 expect(isDeviceConnected).assertFalse(); 2036 return 2037 } 2038 try { 2039 let ret = usbManager.getFileDescriptor(PARAM_NULL); 2040 console.info(TAG, 'usb [param:null] getFileDescriptor ret : ', ret); 2041 expect(ret !== null).assertFalse(); 2042 } catch (err) { 2043 console.info(TAG, 'testGetFileDescriptorParamErr002 catch err code: ', 2044 err.code, ', message: ', err.message); 2045 expect(err.code).assertEqual(PARAM_ERRCODE); 2046 } 2047 }) 2048 2049 /** 2050 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7700 2051 * @tc.name : testGetFileDescriptorParamErr003 2052 * @tc.desc : Negative test: Param is undefined 2053 * @tc.size : MediumTest 2054 * @tc.type : Function 2055 * @tc.level : Level 3 2056 */ 2057 it('testGetFileDescriptorParamErr003', 0, function () { 2058 console.info(TAG, 'usb testGetFileDescriptorParamErr003 begin'); 2059 if (!isDeviceConnected) { 2060 expect(isDeviceConnected).assertFalse(); 2061 return 2062 } 2063 try { 2064 let ret = usbManager.getFileDescriptor(PARAM_UNDEFINED); 2065 console.info(TAG, 'usb [param:undefined] getFileDescriptor ret : ', ret); 2066 expect(ret !== null).assertFalse(); 2067 } catch (err) { 2068 console.info(TAG, 'testGetFileDescriptorParamErr003 catch err code: ', 2069 err.code, ', message: ', err.message); 2070 expect(err.code).assertEqual(PARAM_ERRCODE); 2071 } 2072 }) 2073 2074 /** 2075 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7800 2076 * @tc.name : testGetFileDescriptorParamErr004 2077 * @tc.desc : Negative test: Param is null string "" 2078 * @tc.size : MediumTest 2079 * @tc.type : Function 2080 * @tc.level : Level 3 2081 */ 2082 it('testGetFileDescriptorParamErr004', 0, function () { 2083 console.info(TAG, 'usb testGetFileDescriptorParamErr004 begin'); 2084 if (!isDeviceConnected) { 2085 expect(isDeviceConnected).assertFalse(); 2086 return 2087 } 2088 try { 2089 let ret = usbManager.getFileDescriptor(PARAM_NULLSTRING); 2090 console.info(TAG, 'usb [param:""] getFileDescriptor ret : ', ret); 2091 expect(ret !== null).assertFalse(); 2092 } catch (err) { 2093 console.info(TAG, 'testGetFileDescriptorParamErr004 catch err code: ', 2094 err.code, ', message: ', err.message); 2095 expect(err.code).assertEqual(PARAM_ERRCODE); 2096 } 2097 }) 2098 2099 /** 2100 * @tc.number : SUB_USB_HostManager_JS_ParamErr_7900 2101 * @tc.name : testGetFileDescriptorParamErr005 2102 * @tc.desc : Negative test: pipe busNum is null 2103 * @tc.size : MediumTest 2104 * @tc.type : Function 2105 * @tc.level : Level 3 2106 */ 2107 it('testGetFileDescriptorParamErr005', 0, function () { 2108 console.info(TAG, 'usb testGetFileDescriptorParamErr005 begin'); 2109 if (!isDeviceConnected) { 2110 expect(isDeviceConnected).assertFalse(); 2111 return 2112 } 2113 try { 2114 gPipe.busNum = PARAM_NULL; 2115 let ret = usbManager.getFileDescriptor(gPipe); 2116 console.info(TAG, 'usb [busNum:null] getFileDescriptor ret : ', ret); 2117 expect(ret !== null).assertFalse(); 2118 } catch (err) { 2119 console.info(TAG, 'testGetFileDescriptorParamErr005 catch err code: ', 2120 err.code, ', message: ', err.message); 2121 expect(err.code).assertEqual(PARAM_ERRCODE); 2122 } 2123 }) 2124 2125 /** 2126 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8000 2127 * @tc.name : testGetFileDescriptorParamErr006 2128 * @tc.desc : Negative test: pipe busNum is undefined 2129 * @tc.size : MediumTest 2130 * @tc.type : Function 2131 * @tc.level : Level 3 2132 */ 2133 it('testGetFileDescriptorParamErr006', 0, function () { 2134 console.info(TAG, 'usb testGetFileDescriptorParamErr006 begin'); 2135 if (!isDeviceConnected) { 2136 expect(isDeviceConnected).assertFalse(); 2137 return 2138 } 2139 try { 2140 gPipe.busNum = PARAM_UNDEFINED; 2141 let ret = usbManager.getFileDescriptor(gPipe); 2142 console.info(TAG, 'usb [busNum:undefined] getFileDescriptor ret : ', ret); 2143 expect(ret !== null).assertFalse(); 2144 } catch (err) { 2145 console.info(TAG, 'testGetFileDescriptorParamErr006 catch err code: ', 2146 err.code, ', message: ', err.message); 2147 expect(err.code).assertEqual(PARAM_ERRCODE); 2148 } 2149 }) 2150 2151 /** 2152 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8100 2153 * @tc.name : testGetFileDescriptorParamErr007 2154 * @tc.desc : Negative test: pipe busNum is null string "" 2155 * @tc.size : MediumTest 2156 * @tc.type : Function 2157 * @tc.level : Level 3 2158 */ 2159 it('testGetFileDescriptorParamErr007', 0, function () { 2160 console.info(TAG, 'usb testGetFileDescriptorParamErr007 begin'); 2161 if (!isDeviceConnected) { 2162 expect(isDeviceConnected).assertFalse(); 2163 return 2164 } 2165 try { 2166 gPipe.busNum = PARAM_NULLSTRING; 2167 let ret = usbManager.getFileDescriptor(gPipe); 2168 console.info(TAG, 'usb [busNum:""] getFileDescriptor ret : ', ret); 2169 expect(ret !== null).assertFalse(); 2170 } catch (err) { 2171 console.info(TAG, 'testGetFileDescriptorParamErr007 catch err code: ', 2172 err.code, ', message: ', err.message); 2173 expect(err.code).assertEqual(PARAM_ERRCODE); 2174 } 2175 }) 2176 2177 /** 2178 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8200 2179 * @tc.name : testGetFileDescriptorParamErr008 2180 * @tc.desc : Negative test: pipe devAddress is null 2181 * @tc.size : MediumTest 2182 * @tc.type : Function 2183 * @tc.level : Level 3 2184 */ 2185 it('testGetFileDescriptorParamErr008', 0, function () { 2186 console.info(TAG, 'usb testGetFileDescriptorParamErr008 begin'); 2187 if (!isDeviceConnected) { 2188 expect(isDeviceConnected).assertFalse(); 2189 return 2190 } 2191 try { 2192 gPipe.devAddress = PARAM_NULL; 2193 let ret = usbManager.getFileDescriptor(gPipe); 2194 console.info(TAG, 'usb [devAddress:null] getFileDescriptor ret : ', ret); 2195 expect(ret !== null).assertFalse(); 2196 } catch (err) { 2197 console.info(TAG, 'testGetFileDescriptorParamErr008 catch err code: ', err.code, ', message: ', err.message); 2198 expect(err.code).assertEqual(PARAM_ERRCODE); 2199 } 2200 }) 2201 2202 /** 2203 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8300 2204 * @tc.name : testGetFileDescriptorParamErr009 2205 * @tc.desc : Negative test: pipe devAddress is undefined 2206 * @tc.size : MediumTest 2207 * @tc.type : Function 2208 * @tc.level : Level 3 2209 */ 2210 it('testGetFileDescriptorParamErr009', 0, function () { 2211 console.info(TAG, 'usb testGetFileDescriptorParamErr009 begin'); 2212 if (!isDeviceConnected) { 2213 expect(isDeviceConnected).assertFalse(); 2214 return 2215 } 2216 try { 2217 gPipe.devAddress = PARAM_UNDEFINED; 2218 let ret = usbManager.getFileDescriptor(gPipe); 2219 console.info(TAG, 'usb [devAddress:undefined] getFileDescriptor ret : ', ret); 2220 expect(ret !== null).assertFalse(); 2221 } catch (err) { 2222 console.info(TAG, 'testGetFileDescriptorParamErr009 catch err code: ', 2223 err.code, ', message: ', err.message); 2224 expect(err.code).assertEqual(PARAM_ERRCODE); 2225 } 2226 }) 2227 2228 /** 2229 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8400 2230 * @tc.name : testGetFileDescriptorParamErr010 2231 * @tc.desc : Negative test: devices devAddress is null string "" 2232 * @tc.size : MediumTest 2233 * @tc.type : Function 2234 * @tc.level : Level 3 2235 */ 2236 it('testGetFileDescriptorParamErr010', 0, function () { 2237 console.info(TAG, 'usb testGetFileDescriptorParamErr010 begin'); 2238 if (!isDeviceConnected) { 2239 expect(isDeviceConnected).assertFalse(); 2240 return 2241 } 2242 try { 2243 gPipe.devAddress = PARAM_NULLSTRING; 2244 let ret = usbManager.getFileDescriptor(gPipe); 2245 console.info(TAG, 'usb [devAddress:""] getFileDescriptor ret : ', ret); 2246 expect(ret !== null).assertFalse(); 2247 } catch (err) { 2248 console.info(TAG, 'testGetFileDescriptorParamErr010 catch err code: ', 2249 err.code, ', message: ', err.message); 2250 expect(err.code).assertEqual(PARAM_ERRCODE); 2251 } 2252 }) 2253 2254 /** 2255 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8500 2256 * @tc.name : testClaimInterfaceParamErr001 2257 * @tc.desc : Negative test: Param is null 2258 * @tc.size : MediumTest 2259 * @tc.type : Function 2260 * @tc.level : Level 3 2261 */ 2262 it('testClaimInterfaceParamErr001', 0, function () { 2263 console.info(TAG, 'usb testClaimInterfaceParamErr001 begin'); 2264 if (!isDeviceConnected) { 2265 expect(isDeviceConnected).assertFalse(); 2266 return 2267 } 2268 try { 2269 let ret = usbManager.claimInterface(PARAM_NULL); 2270 console.info(TAG, 'usb [param:null] claimInterface ret : ', ret); 2271 expect(ret !== null).assertFalse(); 2272 } catch (err) { 2273 console.info(TAG, 'testClaimInterfaceParamErr001 catch err code: ', err.code, ', message: ', err.message); 2274 expect(err.code).assertEqual(PARAM_ERRCODE); 2275 } 2276 }) 2277 2278 /** 2279 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8600 2280 * @tc.name : testClaimInterfaceParamErr002 2281 * @tc.desc : Negative test: Param is undefined 2282 * @tc.size : MediumTest 2283 * @tc.type : Function 2284 * @tc.level : Level 3 2285 */ 2286 it('testClaimInterfaceParamErr002', 0, function () { 2287 console.info(TAG, 'usb testClaimInterfaceParamErr002 begin'); 2288 if (!isDeviceConnected) { 2289 expect(isDeviceConnected).assertFalse(); 2290 return 2291 } 2292 try { 2293 let ret = usbManager.claimInterface(PARAM_UNDEFINED); 2294 console.info(TAG, 'usb [param:undefined] claimInterface ret : ', ret); 2295 expect(ret !== null).assertFalse(); 2296 } catch (err) { 2297 console.info(TAG, 'testClaimInterfaceParamErr002 catch err code: ', err.code, ', message: ', err.message); 2298 expect(err.code).assertEqual(PARAM_ERRCODE); 2299 } 2300 }) 2301 2302 /** 2303 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8700 2304 * @tc.name : testClaimInterfaceParamErr003 2305 * @tc.desc : Negative test: Param is null string "" 2306 * @tc.size : MediumTest 2307 * @tc.type : Function 2308 * @tc.level : Level 3 2309 */ 2310 it('testClaimInterfaceParamErr003', 0, function () { 2311 console.info(TAG, 'usb testClaimInterfaceParamErr003 begin'); 2312 if (!isDeviceConnected) { 2313 expect(isDeviceConnected).assertFalse(); 2314 return 2315 } 2316 try { 2317 let ret = usbManager.claimInterface(PARAM_NULLSTRING); 2318 console.info(TAG, 'usb [param:""] claimInterface ret : ', ret); 2319 expect(ret !== null).assertFalse(); 2320 } catch (err) { 2321 console.info(TAG, 'testClaimInterfaceParamErr003 catch err code: ', err.code, ', message: ', err.message); 2322 expect(err.code).assertEqual(PARAM_ERRCODE); 2323 } 2324 }) 2325 2326 /** 2327 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8800 2328 * @tc.name : testClaimInterfaceParamErr004 2329 * @tc.desc : Negative test: pipe busNum is null 2330 * @tc.size : MediumTest 2331 * @tc.type : Function 2332 * @tc.level : Level 3 2333 */ 2334 it('testClaimInterfaceParamErr004', 0, function () { 2335 console.info(TAG, 'usb testClaimInterfaceParamErr004 begin'); 2336 if (!isDeviceConnected) { 2337 expect(isDeviceConnected).assertFalse(); 2338 return 2339 } 2340 try { 2341 gPipe.busNum = PARAM_NULL; 2342 let tmpInterface = devices.configs[0].interfaces[0]; 2343 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2344 console.info(TAG, 'usb [busNum:null] claimInterface ret : ', ret); 2345 expect(ret !== null).assertFalse(); 2346 } catch (err) { 2347 console.info(TAG, 'testClaimInterfaceParamErr004 catch err code: ', err.code, ', message: ', err.message); 2348 expect(err.code).assertEqual(PARAM_ERRCODE); 2349 } 2350 }) 2351 2352 /** 2353 * @tc.number : SUB_USB_HostManager_JS_ParamErr_8900 2354 * @tc.name : testClaimInterfaceParamErr005 2355 * @tc.desc : Negative test: pipe busNum is undefined 2356 * @tc.size : MediumTest 2357 * @tc.type : Function 2358 * @tc.level : Level 3 2359 */ 2360 it('testClaimInterfaceParamErr005', 0, function () { 2361 console.info(TAG, 'usb testClaimInterfaceParamErr005 begin'); 2362 if (!isDeviceConnected) { 2363 expect(isDeviceConnected).assertFalse(); 2364 return 2365 } 2366 try { 2367 gPipe.busNum = PARAM_UNDEFINED; 2368 let tmpInterface = devices.configs[0].interfaces[0]; 2369 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2370 console.info(TAG, 'usb [busNum:undefined] claimInterface ret : ', ret); 2371 expect(ret !== null).assertFalse(); 2372 } catch (err) { 2373 console.info(TAG, 'testClaimInterfaceParamErr005 catch err code: ', err.code, ', message: ', err.message); 2374 expect(err.code).assertEqual(PARAM_ERRCODE); 2375 } 2376 }) 2377 2378 /** 2379 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9000 2380 * @tc.name : testClaimInterfaceParamErr006 2381 * @tc.desc : Negative test: pipe busNum is null string "" 2382 * @tc.size : MediumTest 2383 * @tc.type : Function 2384 * @tc.level : Level 3 2385 */ 2386 it('testClaimInterfaceParamErr006', 0, function () { 2387 console.info(TAG, 'usb testClaimInterfaceParamErr006 begin'); 2388 if (!isDeviceConnected) { 2389 expect(isDeviceConnected).assertFalse(); 2390 return 2391 } 2392 try { 2393 gPipe.busNum = PARAM_NULLSTRING; 2394 let tmpInterface = devices.configs[0].interfaces[0]; 2395 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2396 console.info(TAG, 'usb [busNum:""] claimInterface ret : ', ret); 2397 expect(ret !== null).assertFalse(); 2398 } catch (err) { 2399 console.info(TAG, 'testClaimInterfaceParamErr006 catch err code: ', err.code, ', message: ', err.message); 2400 expect(err.code).assertEqual(PARAM_ERRCODE); 2401 } 2402 }) 2403 2404 /** 2405 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9100 2406 * @tc.name : testClaimInterfaceParamErr007 2407 * @tc.desc : Negative test: pipe devAddress is null 2408 * @tc.size : MediumTest 2409 * @tc.type : Function 2410 * @tc.level : Level 3 2411 */ 2412 it('testClaimInterfaceParamErr007', 0, function () { 2413 console.info(TAG, 'usb testClaimInterfaceParamErr007 begin'); 2414 if (!isDeviceConnected) { 2415 expect(isDeviceConnected).assertFalse(); 2416 return 2417 } 2418 try { 2419 gPipe.devAddress = PARAM_NULL; 2420 let tmpInterface = devices.configs[0].interfaces[0]; 2421 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2422 console.info(TAG, 'usb [devAddress:null] claimInterface ret : ', ret); 2423 expect(ret !== null).assertFalse(); 2424 } catch (err) { 2425 console.info(TAG, 'testClaimInterfaceParamErr007 catch err code: ', err.code, ', message: ', err.message); 2426 expect(err.code).assertEqual(PARAM_ERRCODE); 2427 } 2428 }) 2429 2430 /** 2431 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9200 2432 * @tc.name : testClaimInterfaceParamErr008 2433 * @tc.desc : Negative test: pipe devAddress is undefined 2434 * @tc.size : MediumTest 2435 * @tc.type : Function 2436 * @tc.level : Level 3 2437 */ 2438 it('testClaimInterfaceParamErr008', 0, function () { 2439 console.info(TAG, 'usb testClaimInterfaceParamErr008 begin'); 2440 if (!isDeviceConnected) { 2441 expect(isDeviceConnected).assertFalse(); 2442 return 2443 } 2444 try { 2445 gPipe.devAddress = PARAM_UNDEFINED; 2446 let tmpInterface = devices.configs[0].interfaces[0]; 2447 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2448 console.info(TAG, 'usb [devAddress:undefined] claimInterface ret : ', ret); 2449 expect(ret !== null).assertFalse(); 2450 } catch (err) { 2451 console.info(TAG, 'testClaimInterfaceParamErr008 catch err code: ', err.code, ', message: ', err.message); 2452 expect(err.code).assertEqual(PARAM_ERRCODE); 2453 } 2454 }) 2455 2456 /** 2457 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9300 2458 * @tc.name : testClaimInterfaceParamErr009 2459 * @tc.desc : Negative test: pipe devAddress is null string "" 2460 * @tc.size : MediumTest 2461 * @tc.type : Function 2462 * @tc.level : Level 3 2463 */ 2464 it('testClaimInterfaceParamErr009', 0, function () { 2465 console.info(TAG, 'usb testClaimInterfaceParamErr009 begin'); 2466 if (!isDeviceConnected) { 2467 expect(isDeviceConnected).assertFalse(); 2468 return 2469 } 2470 try { 2471 gPipe.devAddress = PARAM_NULLSTRING; 2472 let tmpInterface = devices.configs[0].interfaces[0]; 2473 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2474 console.info(TAG, 'usb [devAddress:""] claimInterface ret : ', ret); 2475 expect(ret !== null).assertFalse(); 2476 } catch (err) { 2477 console.info(TAG, 'testClaimInterfaceParamErr009 catch err code: ', err.code, ', message: ', err.message); 2478 expect(err.code).assertEqual(PARAM_ERRCODE); 2479 } 2480 }) 2481 2482 /** 2483 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9400 2484 * @tc.name : testClaimInterfaceParamErr010 2485 * @tc.desc : Negative test: interfaces id is null 2486 * @tc.size : MediumTest 2487 * @tc.type : Function 2488 * @tc.level : Level 3 2489 */ 2490 it('testClaimInterfaceParamErr010', 0, function () { 2491 console.info(TAG, 'usb testClaimInterfaceParamErr010 begin'); 2492 if (!isDeviceConnected) { 2493 expect(isDeviceConnected).assertFalse(); 2494 return 2495 } 2496 try { 2497 gPipe.busNum = devices.busNum; 2498 gPipe.devAddress = devices.devAddress; 2499 let tmpInterface = devices.configs[0].interfaces[0]; 2500 tmpInterface.id = PARAM_NULL; 2501 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2502 console.info(TAG, 'usb [interfaces.id:null] claimInterface ret : ', ret); 2503 expect(ret !== null).assertFalse(); 2504 } catch (err) { 2505 console.info(TAG, 'testClaimInterfaceParamErr010 catch err code: ', err.code, ', message: ', err.message); 2506 expect(err.code).assertEqual(PARAM_ERRCODE); 2507 } 2508 }) 2509 2510 /** 2511 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9500 2512 * @tc.name : testClaimInterfaceParamErr011 2513 * @tc.desc : Negative test: interfaces id is undefined 2514 * @tc.size : MediumTest 2515 * @tc.type : Function 2516 * @tc.level : Level 3 2517 */ 2518 it('testClaimInterfaceParamErr011', 0, function () { 2519 console.info(TAG, 'usb testClaimInterfaceParamErr011 begin'); 2520 if (!isDeviceConnected) { 2521 expect(isDeviceConnected).assertFalse(); 2522 return 2523 } 2524 try { 2525 gPipe.busNum = devices.busNum; 2526 gPipe.devAddress = devices.devAddress; 2527 let tmpInterface = devices.configs[0].interfaces[0]; 2528 tmpInterface.id = PARAM_UNDEFINED; 2529 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2530 console.info(TAG, 'usb [interfaces.id:undefined] claimInterface ret : ', ret); 2531 expect(ret !== null).assertFalse(); 2532 } catch (err) { 2533 console.info(TAG, 'testClaimInterfaceParamErr011 catch err code: ', err.code, ', message: ', err.message); 2534 expect(err.code).assertEqual(PARAM_ERRCODE); 2535 } 2536 }) 2537 2538 /** 2539 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9600 2540 * @tc.name : testClaimInterfaceParamErr012 2541 * @tc.desc : Negative test: interfaces id is null string "" 2542 * @tc.size : MediumTest 2543 * @tc.type : Function 2544 * @tc.level : Level 3 2545 */ 2546 it('testClaimInterfaceParamErr012', 0, function () { 2547 console.info(TAG, 'usb testClaimInterfaceParamErr012 begin'); 2548 if (!isDeviceConnected) { 2549 expect(isDeviceConnected).assertFalse(); 2550 return 2551 } 2552 try { 2553 gPipe.busNum = devices.busNum; 2554 gPipe.devAddress = devices.devAddress; 2555 let tmpInterface = devices.configs[0].interfaces[0]; 2556 tmpInterface.id = PARAM_NULLSTRING; 2557 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2558 console.info(TAG, 'usb [interfaces.id:""] claimInterface ret : ', ret); 2559 expect(ret !== null).assertFalse(); 2560 } catch (err) { 2561 console.info(TAG, 'testClaimInterfaceParamErr012 catch err code: ', err.code, ', message: ', err.message); 2562 expect(err.code).assertEqual(PARAM_ERRCODE); 2563 } 2564 }) 2565 2566 /** 2567 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9700 2568 * @tc.name : testClaimInterfaceParamErr013 2569 * @tc.desc : Negative test: interfaces protocol is null 2570 * @tc.size : MediumTest 2571 * @tc.type : Function 2572 * @tc.level : Level 3 2573 */ 2574 it('testClaimInterfaceParamErr013', 0, function () { 2575 console.info(TAG, 'usb testClaimInterfaceParamErr013 begin'); 2576 if (!isDeviceConnected) { 2577 expect(isDeviceConnected).assertFalse(); 2578 return 2579 } 2580 try { 2581 gPipe.busNum = devices.busNum; 2582 gPipe.devAddress = devices.devAddress; 2583 let tmpInterface = devices.configs[0].interfaces[0]; 2584 tmpInterface.protocol = PARAM_NULL; 2585 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2586 console.info(TAG, 'usb [interfaces.protocol:null] claimInterface ret : ', ret); 2587 expect(ret !== null).assertFalse(); 2588 } catch (err) { 2589 console.info(TAG, 'testClaimInterfaceParamErr013 catch err code: ', err.code, ', message: ', err.message); 2590 expect(err.code).assertEqual(PARAM_ERRCODE); 2591 } 2592 }) 2593 2594 /** 2595 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9800 2596 * @tc.name : testClaimInterfaceParamErr014 2597 * @tc.desc : Negative test: interfaces protocol is undefined 2598 * @tc.size : MediumTest 2599 * @tc.type : Function 2600 * @tc.level : Level 3 2601 */ 2602 it('testClaimInterfaceParamErr014', 0, function () { 2603 console.info(TAG, 'usb testClaimInterfaceParamErr014 begin'); 2604 if (!isDeviceConnected) { 2605 expect(isDeviceConnected).assertFalse(); 2606 return 2607 } 2608 try { 2609 gPipe.busNum = devices.busNum; 2610 gPipe.devAddress = devices.devAddress; 2611 let tmpInterface = devices.configs[0].interfaces[0]; 2612 tmpInterface.protocol = PARAM_UNDEFINED; 2613 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2614 console.info(TAG, 'usb [interfaces.protocol:undefined] claimInterface ret : ', ret); 2615 expect(ret !== null).assertFalse(); 2616 } catch (err) { 2617 console.info(TAG, 'testClaimInterfaceParamErr014 catch err code: ', err.code, ', message: ', err.message); 2618 expect(err.code).assertEqual(PARAM_ERRCODE); 2619 } 2620 }) 2621 2622 /** 2623 * @tc.number : SUB_USB_HostManager_JS_ParamErr_9900 2624 * @tc.name : testClaimInterfaceParamErr015 2625 * @tc.desc : Negative test: interfaces protocol is null string "" 2626 * @tc.size : MediumTest 2627 * @tc.type : Function 2628 * @tc.level : Level 3 2629 */ 2630 it('testClaimInterfaceParamErr015', 0, function () { 2631 console.info(TAG, 'usb testClaimInterfaceParamErr015 begin'); 2632 if (!isDeviceConnected) { 2633 expect(isDeviceConnected).assertFalse(); 2634 return 2635 } 2636 try { 2637 gPipe.busNum = devices.busNum; 2638 gPipe.devAddress = devices.devAddress; 2639 let tmpInterface = devices.configs[0].interfaces[0]; 2640 tmpInterface.protocol = PARAM_NULLSTRING; 2641 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2642 console.info(TAG, 'usb [interfaces.protocol:""] claimInterface ret : ', ret); 2643 expect(ret !== null).assertFalse(); 2644 } catch (err) { 2645 console.info(TAG, 'testClaimInterfaceParamErr015 catch err code: ', err.code, ', message: ', err.message); 2646 expect(err.code).assertEqual(PARAM_ERRCODE); 2647 } 2648 }) 2649 2650 /** 2651 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0110 2652 * @tc.name : testClaimInterfaceParamErr016 2653 * @tc.desc : Negative test: interfaces clazz is null 2654 * @tc.size : MediumTest 2655 * @tc.type : Function 2656 * @tc.level : Level 3 2657 */ 2658 it('testClaimInterfaceParamErr016', 0, function () { 2659 console.info(TAG, 'usb testClaimInterfaceParamErr016 begin'); 2660 if (!isDeviceConnected) { 2661 expect(isDeviceConnected).assertFalse(); 2662 return 2663 } 2664 try { 2665 gPipe.busNum = devices.busNum; 2666 gPipe.devAddress = devices.devAddress; 2667 let tmpInterface = devices.configs[0].interfaces[0]; 2668 tmpInterface.clazz = PARAM_NULL; 2669 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2670 console.info(TAG, 'usb [interfaces.clazz:null] claimInterface ret : ', ret); 2671 expect(ret !== null).assertFalse(); 2672 } catch (err) { 2673 console.info(TAG, 'testClaimInterfaceParamErr016 catch err code: ', err.code, ', message: ', err.message); 2674 expect(err.code).assertEqual(PARAM_ERRCODE); 2675 } 2676 }) 2677 2678 /** 2679 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0120 2680 * @tc.name : testClaimInterfaceParamErr017 2681 * @tc.desc : Negative test: interfaces clazz is undefined 2682 * @tc.size : MediumTest 2683 * @tc.type : Function 2684 * @tc.level : Level 3 2685 */ 2686 it('testClaimInterfaceParamErr017', 0, function () { 2687 console.info(TAG, 'usb testClaimInterfaceParamErr017 begin'); 2688 if (!isDeviceConnected) { 2689 expect(isDeviceConnected).assertFalse(); 2690 return 2691 } 2692 try { 2693 gPipe.busNum = devices.busNum; 2694 gPipe.devAddress = devices.devAddress; 2695 let tmpInterface = devices.configs[0].interfaces[0]; 2696 tmpInterface.clazz = PARAM_UNDEFINED; 2697 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2698 console.info(TAG, 'usb [interfaces.clazz:undefined] claimInterface ret : ', ret); 2699 expect(ret !== null).assertFalse(); 2700 } catch (err) { 2701 console.info(TAG, 'testClaimInterfaceParamErr017 catch err code: ', err.code, ', message: ', err.message); 2702 expect(err.code).assertEqual(PARAM_ERRCODE); 2703 } 2704 }) 2705 2706 /** 2707 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0130 2708 * @tc.name : testClaimInterfaceParamErr018 2709 * @tc.desc : Negative test: interfaces clazz is null string "" 2710 * @tc.size : MediumTest 2711 * @tc.type : Function 2712 * @tc.level : Level 3 2713 */ 2714 it('testClaimInterfaceParamErr018', 0, function () { 2715 console.info(TAG, 'usb testClaimInterfaceParamErr018 begin'); 2716 if (!isDeviceConnected) { 2717 expect(isDeviceConnected).assertFalse(); 2718 return 2719 } 2720 try { 2721 gPipe.busNum = devices.busNum; 2722 gPipe.devAddress = devices.devAddress; 2723 let tmpInterface = devices.configs[0].interfaces[0]; 2724 tmpInterface.clazz = PARAM_NULLSTRING; 2725 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2726 console.info(TAG, 'usb [interfaces.clazz:""] claimInterface ret : ', ret); 2727 expect(ret !== null).assertFalse(); 2728 } catch (err) { 2729 console.info(TAG, 'testClaimInterfaceParamErr018 catch err code: ', err.code, ', message: ', err.message); 2730 expect(err.code).assertEqual(PARAM_ERRCODE); 2731 } 2732 }) 2733 2734 /** 2735 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0140 2736 * @tc.name : testClaimInterfaceParamErr019 2737 * @tc.desc : Negative test: interfaces name is null 2738 * @tc.size : MediumTest 2739 * @tc.type : Function 2740 * @tc.level : Level 3 2741 */ 2742 it('testClaimInterfaceParamErr019', 0, function () { 2743 console.info(TAG, 'usb testClaimInterfaceParamErr019 begin'); 2744 if (!isDeviceConnected) { 2745 expect(isDeviceConnected).assertFalse(); 2746 return 2747 } 2748 try { 2749 gPipe.busNum = devices.busNum; 2750 gPipe.devAddress = devices.devAddress; 2751 let tmpInterface = devices.configs[0].interfaces[0]; 2752 tmpInterface.name = PARAM_NULL; 2753 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2754 console.info(TAG, 'usb [interfaces.name:null] claimInterface ret : ', ret); 2755 expect(ret !== null).assertFalse(); 2756 } catch (err) { 2757 console.info(TAG, 'testClaimInterfaceParamErr019 catch err code: ', err.code, ', message: ', err.message); 2758 expect(err.code).assertEqual(PARAM_ERRCODE); 2759 } 2760 }) 2761 2762 /** 2763 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0150 2764 * @tc.name : testClaimInterfaceParamErr020 2765 * @tc.desc : Negative test: interfaces name is undefined 2766 * @tc.size : MediumTest 2767 * @tc.type : Function 2768 * @tc.level : Level 3 2769 */ 2770 it('testClaimInterfaceParamErr020', 0, function () { 2771 console.info(TAG, 'usb testClaimInterfaceParamErr020 begin'); 2772 if (!isDeviceConnected) { 2773 expect(isDeviceConnected).assertFalse(); 2774 return 2775 } 2776 try { 2777 gPipe.busNum = devices.busNum; 2778 gPipe.devAddress = devices.devAddress; 2779 let tmpInterface = devices.configs[0].interfaces[0]; 2780 tmpInterface.name = PARAM_UNDEFINED; 2781 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2782 console.info(TAG, 'usb [interfaces.name:undefined] claimInterface ret : ', ret); 2783 expect(ret !== null).assertFalse(); 2784 } catch (err) { 2785 console.info(TAG, 'testClaimInterfaceParamErr020 catch err code: ', err.code, ', message: ', err.message); 2786 expect(err.code).assertEqual(PARAM_ERRCODE); 2787 } 2788 }) 2789 2790 /** 2791 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0160 2792 * @tc.name : testClaimInterfaceParamErr021 2793 * @tc.desc : Negative test: interfaces name is number 2794 * @tc.size : MediumTest 2795 * @tc.type : Function 2796 * @tc.level : Level 3 2797 */ 2798 it('testClaimInterfaceParamErr021', 0, function () { 2799 console.info(TAG, 'usb testClaimInterfaceParamErr021 begin'); 2800 if (!isDeviceConnected) { 2801 expect(isDeviceConnected).assertFalse(); 2802 return 2803 } 2804 try { 2805 gPipe.busNum = devices.busNum; 2806 gPipe.devAddress = devices.devAddress; 2807 let tmpInterface = devices.configs[0].interfaces[0]; 2808 tmpInterface.name = PARAM_NUMBERTYPE; 2809 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2810 console.info(TAG, 'usb [interfaces.name:number_123] claimInterface ret : ', ret); 2811 expect(ret !== null).assertFalse(); 2812 } catch (err) { 2813 console.info(TAG, 'testClaimInterfaceParamErr021 catch err code: ', err.code, ', message: ', err.message); 2814 expect(err.code).assertEqual(PARAM_ERRCODE); 2815 } 2816 }) 2817 2818 /** 2819 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0170 2820 * @tc.name : testClaimInterfaceParamErr022 2821 * @tc.desc : Negative test: interfaces subClass is null 2822 * @tc.size : MediumTest 2823 * @tc.type : Function 2824 * @tc.level : Level 3 2825 */ 2826 it('testClaimInterfaceParamErr022', 0, function () { 2827 console.info(TAG, 'usb testClaimInterfaceParamErr022 begin'); 2828 if (!isDeviceConnected) { 2829 expect(isDeviceConnected).assertFalse(); 2830 return 2831 } 2832 try { 2833 gPipe.busNum = devices.busNum; 2834 gPipe.devAddress = devices.devAddress; 2835 let tmpInterface = devices.configs[0].interfaces[0]; 2836 tmpInterface.subClass = PARAM_NULL; 2837 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2838 console.info(TAG, 'usb [interfaces.subClass:null] claimInterface ret : ', ret); 2839 expect(ret !== null).assertFalse(); 2840 } catch (err) { 2841 console.info(TAG, 'testClaimInterfaceParamErr022 catch err code: ', err.code, ', message: ', err.message); 2842 expect(err.code).assertEqual(PARAM_ERRCODE); 2843 } 2844 }) 2845 2846 /** 2847 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0180 2848 * @tc.name : testClaimInterfaceParamErr023 2849 * @tc.desc : Negative test: interfaces subClass is undefined 2850 * @tc.size : MediumTest 2851 * @tc.type : Function 2852 * @tc.level : Level 3 2853 */ 2854 it('testClaimInterfaceParamErr023', 0, function () { 2855 console.info(TAG, 'usb testClaimInterfaceParamErr023 begin'); 2856 if (!isDeviceConnected) { 2857 expect(isDeviceConnected).assertFalse(); 2858 return 2859 } 2860 try { 2861 gPipe.busNum = devices.busNum; 2862 gPipe.devAddress = devices.devAddress; 2863 let tmpInterface = devices.configs[0].interfaces[0]; 2864 tmpInterface.subClass = PARAM_UNDEFINED; 2865 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2866 console.info(TAG, 'usb [interfaces.subClass:undefined] claimInterface ret : ', ret); 2867 expect(ret !== null).assertFalse(); 2868 } catch (err) { 2869 console.info(TAG, 'testClaimInterfaceParamErr023 catch err code: ', err.code, ', message: ', err.message); 2870 expect(err.code).assertEqual(PARAM_ERRCODE); 2871 } 2872 }) 2873 2874 /** 2875 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0190 2876 * @tc.name : testClaimInterfaceParamErr024 2877 * @tc.desc : Negative test: interfaces subClass is null string "" 2878 * @tc.size : MediumTest 2879 * @tc.type : Function 2880 * @tc.level : Level 3 2881 */ 2882 it('testClaimInterfaceParamErr024', 0, function () { 2883 console.info(TAG, 'usb testClaimInterfaceParamErr024 begin'); 2884 if (!isDeviceConnected) { 2885 expect(isDeviceConnected).assertFalse(); 2886 return 2887 } 2888 try { 2889 gPipe.busNum = devices.busNum; 2890 gPipe.devAddress = devices.devAddress; 2891 let tmpInterface = devices.configs[0].interfaces[0]; 2892 tmpInterface.subClass = PARAM_NULLSTRING; 2893 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2894 console.info(TAG, 'usb [interfaces.subClass:""] claimInterface ret : ', ret); 2895 expect(ret !== null).assertFalse(); 2896 } catch (err) { 2897 console.info(TAG, 'testClaimInterfaceParamErr024 catch err code: ', err.code, ', message: ', err.message); 2898 expect(err.code).assertEqual(PARAM_ERRCODE); 2899 } 2900 }) 2901 2902 /** 2903 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0210 2904 * @tc.name : testClaimInterfaceParamErr025 2905 * @tc.desc : Negative test: interfaces alternateSetting is null 2906 * @tc.size : MediumTest 2907 * @tc.type : Function 2908 * @tc.level : Level 3 2909 */ 2910 it('testClaimInterfaceParamErr025', 0, function () { 2911 console.info(TAG, 'usb testClaimInterfaceParamErr025 begin'); 2912 if (!isDeviceConnected) { 2913 expect(isDeviceConnected).assertFalse(); 2914 return 2915 } 2916 try { 2917 gPipe.busNum = devices.busNum; 2918 gPipe.devAddress = devices.devAddress; 2919 let tmpInterface = devices.configs[0].interfaces[0]; 2920 tmpInterface.alternateSetting = PARAM_NULL; 2921 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2922 console.info(TAG, 'usb [interfaces.alternateSetting:null] claimInterface ret : ', ret); 2923 expect(ret !== null).assertFalse(); 2924 } catch (err) { 2925 console.info(TAG, 'testClaimInterfaceParamErr025 catch err code: ', err.code, ', message: ', err.message); 2926 expect(err.code).assertEqual(PARAM_ERRCODE); 2927 } 2928 }) 2929 2930 /** 2931 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0220 2932 * @tc.name : testClaimInterfaceParamErr026 2933 * @tc.desc : Negative test: interfaces alternateSetting is undefined 2934 * @tc.size : MediumTest 2935 * @tc.type : Function 2936 * @tc.level : Level 3 2937 */ 2938 it('testClaimInterfaceParamErr026', 0, function () { 2939 console.info(TAG, 'usb testClaimInterfaceParamErr026 begin'); 2940 if (!isDeviceConnected) { 2941 expect(isDeviceConnected).assertFalse(); 2942 return 2943 } 2944 try { 2945 gPipe.busNum = devices.busNum; 2946 gPipe.devAddress = devices.devAddress; 2947 let tmpInterface = devices.configs[0].interfaces[0]; 2948 tmpInterface.alternateSetting = PARAM_UNDEFINED; 2949 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2950 console.info(TAG, 'usb [interfaces.alternateSetting:undefined] claimInterface ret : ', ret); 2951 expect(ret !== null).assertFalse(); 2952 } catch (err) { 2953 console.info(TAG, 'testClaimInterfaceParamErr026 catch err code: ', err.code, ', message: ', err.message); 2954 expect(err.code).assertEqual(PARAM_ERRCODE); 2955 } 2956 }) 2957 2958 /** 2959 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0230 2960 * @tc.name : testClaimInterfaceParamErr027 2961 * @tc.desc : Negative test: interfaces alternateSetting is null string "" 2962 * @tc.size : MediumTest 2963 * @tc.type : Function 2964 * @tc.level : Level 3 2965 */ 2966 it('testClaimInterfaceParamErr027', 0, function () { 2967 console.info(TAG, 'usb testClaimInterfaceParamErr027 begin'); 2968 if (!isDeviceConnected) { 2969 expect(isDeviceConnected).assertFalse(); 2970 return 2971 } 2972 try { 2973 gPipe.busNum = devices.busNum; 2974 gPipe.devAddress = devices.devAddress; 2975 let tmpInterface = devices.configs[0].interfaces[0]; 2976 tmpInterface.alternateSetting = PARAM_NULLSTRING; 2977 let ret = usbManager.claimInterface(gPipe, tmpInterface); 2978 console.info(TAG, 'usb [interfaces.alternateSetting:""] claimInterface ret : ', ret); 2979 expect(ret !== null).assertFalse(); 2980 } catch (err) { 2981 console.info(TAG, 'testClaimInterfaceParamErr027 catch err code: ', err.code, ', message: ', err.message); 2982 expect(err.code).assertEqual(PARAM_ERRCODE); 2983 } 2984 }) 2985 2986 /** 2987 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0240 2988 * @tc.name : testClaimInterfaceParamErr028 2989 * @tc.desc : Negative test: interfaces endpoints is null 2990 * @tc.size : MediumTest 2991 * @tc.type : Function 2992 * @tc.level : Level 3 2993 */ 2994 it('testClaimInterfaceParamErr028', 0, function () { 2995 console.info(TAG, 'usb testClaimInterfaceParamErr028 begin'); 2996 if (!isDeviceConnected) { 2997 expect(isDeviceConnected).assertFalse(); 2998 return 2999 } 3000 try { 3001 gPipe.busNum = devices.busNum; 3002 gPipe.devAddress = devices.devAddress; 3003 let tmpInterface = devices.configs[0].interfaces[0]; 3004 tmpInterface.endpoints = PARAM_NULL; 3005 let ret = usbManager.claimInterface(gPipe, tmpInterface); 3006 console.info(TAG, 'usb [interfaces.endpoints:null] claimInterface ret : ', ret); 3007 expect(ret !== null).assertFalse(); 3008 } catch (err) { 3009 console.info(TAG, 'testClaimInterfaceParamErr028 catch err code: ', err.code, ', message: ', err.message); 3010 expect(err.code).assertEqual(PARAM_ERRCODE); 3011 } 3012 }) 3013 3014 /** 3015 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0250 3016 * @tc.name : testClaimInterfaceParamErr029 3017 * @tc.desc : Negative test: interfaces endpoints is undefined 3018 * @tc.size : MediumTest 3019 * @tc.type : Function 3020 * @tc.level : Level 3 3021 */ 3022 it('testClaimInterfaceParamErr029', 0, function () { 3023 console.info(TAG, 'usb testClaimInterfaceParamErr029 begin'); 3024 if (!isDeviceConnected) { 3025 expect(isDeviceConnected).assertFalse(); 3026 return 3027 } 3028 try { 3029 gPipe.busNum = devices.busNum; 3030 gPipe.devAddress = devices.devAddress; 3031 let tmpInterface = devices.configs[0].interfaces[0]; 3032 tmpInterface.endpoints = PARAM_UNDEFINED; 3033 let ret = usbManager.claimInterface(gPipe, tmpInterface); 3034 console.info(TAG, 'usb [interfaces.endpoints:undefined] claimInterface ret : ', ret); 3035 expect(ret !== null).assertFalse(); 3036 } catch (err) { 3037 console.info(TAG, 'testClaimInterfaceParamErr029 catch err code: ', err.code, ', message: ', err.message); 3038 expect(err.code).assertEqual(PARAM_ERRCODE); 3039 } 3040 }) 3041 3042 /** 3043 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0260 3044 * @tc.name : testClaimInterfaceParamErr030 3045 * @tc.desc : Negative test: interfaces endpoints is null string "" 3046 * @tc.size : MediumTest 3047 * @tc.type : Function 3048 * @tc.level : Level 3 3049 */ 3050 it('testClaimInterfaceParamErr030', 0, function () { 3051 console.info(TAG, 'usb testClaimInterfaceParamErr030 begin'); 3052 if (!isDeviceConnected) { 3053 expect(isDeviceConnected).assertFalse(); 3054 return 3055 } 3056 try { 3057 gPipe.busNum = devices.busNum; 3058 gPipe.devAddress = devices.devAddress; 3059 let tmpInterface = devices.configs[0].interfaces[0]; 3060 tmpInterface.endpoints = PARAM_NULLSTRING; 3061 let ret = usbManager.claimInterface(gPipe, tmpInterface); 3062 console.info(TAG, 'usb [interfaces.endpoints:""] claimInterface ret : ', ret); 3063 expect(ret !== null).assertFalse(); 3064 } catch (err) { 3065 console.info(TAG, 'testClaimInterfaceParamErr030 catch err code: ', err.code, ', message: ', err.message); 3066 expect(err.code).assertEqual(PARAM_ERRCODE); 3067 } 3068 }) 3069 3070 /** 3071 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0270 3072 * @tc.name : testClaimInterfaceParamErr031 3073 * @tc.desc : Negative test: Enter four parameters 3074 * @tc.size : MediumTest 3075 * @tc.type : Function 3076 * @tc.level : Level 3 3077 */ 3078 it('testClaimInterfaceParamErr031', 0, function () { 3079 console.info(TAG, 'usb testClaimInterfaceParamErr031 begin'); 3080 if (!isDeviceConnected) { 3081 expect(isDeviceConnected).assertFalse(); 3082 return 3083 } 3084 getPipe('testClaimInterfaceParamErr031'); 3085 let tmpInterface = devices.configs[0].interfaces[0]; 3086 try { 3087 let ret = usbManager.claimInterface(gPipe, tmpInterface, true, gPipe); 3088 console.info(TAG, 'usb [Enter four param] claimInterface ret : ', ret); 3089 expect(ret).assertEqual(0); 3090 } catch (err) { 3091 console.info(TAG, 'testClaimInterfaceParamErr031 catch err code: ', err.code, ', message: ', err.message); 3092 expect(err !== null).assertFalse(); 3093 } 3094 toReleaseInterface('testClaimInterfaceParamErr031', tmpInterface); 3095 toClosePipe('testClaimInterfaceParamErr031'); 3096 }) 3097 3098 /** 3099 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0280 3100 * @tc.name : testClaimInterfaceParamErr032 3101 * @tc.desc : Negative test: iface is null 3102 * @tc.size : MediumTest 3103 * @tc.type : Function 3104 * @tc.level : Level 3 3105 */ 3106 it('testClaimInterfaceParamErr032', 0, function () { 3107 console.info(TAG, 'usb testClaimInterfaceParamErr032 begin'); 3108 if (!isDeviceConnected) { 3109 expect(isDeviceConnected).assertFalse(); 3110 return 3111 } 3112 try { 3113 gPipe.busNum = devices.busNum; 3114 gPipe.devAddress = devices.devAddress; 3115 let ret = usbManager.claimInterface(gPipe, PARAM_NULL); 3116 console.info(TAG, 'usb [iface:null] claimInterface ret : ', ret); 3117 expect(ret !== null).assertFalse(); 3118 } catch (err) { 3119 console.info(TAG, 'testClaimInterfaceParamErr032 catch err code: ', err.code, ', message: ', err.message); 3120 expect(err.code).assertEqual(PARAM_ERRCODE); 3121 } 3122 }) 3123 3124 /** 3125 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0290 3126 * @tc.name : testClaimInterfaceParamErr033 3127 * @tc.desc : Negative test: iface is undefined 3128 * @tc.size : MediumTest 3129 * @tc.type : Function 3130 * @tc.level : Level 3 3131 */ 3132 it('testClaimInterfaceParamErr033', 0, function () { 3133 console.info(TAG, 'usb testClaimInterfaceParamErr033 begin'); 3134 if (!isDeviceConnected) { 3135 expect(isDeviceConnected).assertFalse(); 3136 return 3137 } 3138 try { 3139 gPipe.busNum = devices.busNum; 3140 gPipe.devAddress = devices.devAddress; 3141 let ret = usbManager.claimInterface(gPipe, PARAM_UNDEFINED); 3142 console.info(TAG, 'usb [iface:undefined] claimInterface ret : ', ret); 3143 expect(ret !== null).assertFalse(); 3144 } catch (err) { 3145 console.info(TAG, 'testClaimInterfaceParamErr033 catch err code: ', err.code, ', message: ', err.message); 3146 expect(err.code).assertEqual(PARAM_ERRCODE); 3147 } 3148 }) 3149 3150 /** 3151 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0310 3152 * @tc.name : testClaimInterfaceParamErr034 3153 * @tc.desc : Negative test: iface is "" 3154 * @tc.size : MediumTest 3155 * @tc.type : Function 3156 * @tc.level : Level 3 3157 */ 3158 it('testClaimInterfaceParamErr034', 0, function () { 3159 console.info(TAG, 'usb testClaimInterfaceParamErr034 begin'); 3160 if (!isDeviceConnected) { 3161 expect(isDeviceConnected).assertFalse(); 3162 return 3163 } 3164 try { 3165 gPipe.busNum = devices.busNum; 3166 gPipe.devAddress = devices.devAddress; 3167 let ret = usbManager.claimInterface(gPipe, PARAM_NULLSTRING); 3168 console.info(TAG, 'usb [iface:""] claimInterface ret : ', ret); 3169 expect(ret !== null).assertFalse(); 3170 } catch (err) { 3171 console.info(TAG, 'testClaimInterfaceParamErr034 catch err code: ', err.code, ', message: ', err.message); 3172 expect(err.code).assertEqual(PARAM_ERRCODE); 3173 } 3174 }) 3175 3176 /** 3177 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0320 3178 * @tc.name : testClaimInterfaceParamErr035 3179 * @tc.desc : Negative test: pipe is null 3180 * @tc.size : MediumTest 3181 * @tc.type : Function 3182 * @tc.level : Level 3 3183 */ 3184 it('testClaimInterfaceParamErr035', 0, function () { 3185 console.info(TAG, 'usb testClaimInterfaceParamErr035 begin'); 3186 if (!isDeviceConnected) { 3187 expect(isDeviceConnected).assertFalse(); 3188 return 3189 } 3190 try { 3191 let tmpInterface = devices.configs[0].interfaces[0]; 3192 let ret = usbManager.claimInterface(PARAM_NULL, tmpInterface); 3193 console.info(TAG, 'usb [iface:null] claimInterface ret : ', ret); 3194 expect(ret !== null).assertFalse(); 3195 } catch (err) { 3196 console.info(TAG, 'testClaimInterfaceParamErr035 catch err code: ', err.code, ', message: ', err.message); 3197 expect(err.code).assertEqual(PARAM_ERRCODE); 3198 } 3199 }) 3200 3201 /** 3202 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0330 3203 * @tc.name : testClaimInterfaceParamErr036 3204 * @tc.desc : Negative test: pipe is undefined 3205 * @tc.size : MediumTest 3206 * @tc.type : Function 3207 * @tc.level : Level 3 3208 */ 3209 it('testClaimInterfaceParamErr036', 0, function () { 3210 console.info(TAG, 'usb testClaimInterfaceParamErr036 begin'); 3211 if (!isDeviceConnected) { 3212 expect(isDeviceConnected).assertFalse(); 3213 return 3214 } 3215 try { 3216 let tmpInterface = devices.configs[0].interfaces[0]; 3217 let ret = usbManager.claimInterface(PARAM_UNDEFINED, tmpInterface); 3218 console.info(TAG, 'usb [iface:undefined] claimInterface ret : ', ret); 3219 expect(ret !== null).assertFalse(); 3220 } catch (err) { 3221 console.info(TAG, 'testClaimInterfaceParamErr036 catch err code: ', err.code, ', message: ', err.message); 3222 expect(err.code).assertEqual(PARAM_ERRCODE); 3223 } 3224 }) 3225 3226 /** 3227 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0340 3228 * @tc.name : testClaimInterfaceParamErr037 3229 * @tc.desc : Negative test: pipe is "" 3230 * @tc.size : MediumTest 3231 * @tc.type : Function 3232 * @tc.level : Level 3 3233 */ 3234 it('testClaimInterfaceParamErr037', 0, function () { 3235 console.info(TAG, 'usb testClaimInterfaceParamErr037 begin'); 3236 if (!isDeviceConnected) { 3237 expect(isDeviceConnected).assertFalse(); 3238 return 3239 } 3240 try { 3241 let tmpInterface = devices.configs[0].interfaces[0]; 3242 let ret = usbManager.claimInterface(PARAM_NULLSTRING, tmpInterface); 3243 console.info(TAG, 'usb [iface:""] claimInterface ret : ', ret); 3244 expect(ret !== null).assertFalse(); 3245 } catch (err) { 3246 console.info(TAG, 'testClaimInterfaceParamErr037 catch err code: ', err.code, ', message: ', err.message); 3247 expect(err.code).assertEqual(PARAM_ERRCODE); 3248 } 3249 }) 3250 3251 /** 3252 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0350 3253 * @tc.name : testClaimInterfaceParamErr038 3254 * @tc.desc : Negative test: force is null string 3255 * @tc.size : MediumTest 3256 * @tc.type : Function 3257 * @tc.level : Level 3 3258 */ 3259 it('testClaimInterfaceParamErr038', 0, function () { 3260 console.info(TAG, 'usb testClaimInterfaceParamErr038 begin'); 3261 if (!isDeviceConnected) { 3262 expect(isDeviceConnected).assertFalse(); 3263 return 3264 } 3265 getPipe('testClaimInterfaceParamErr038'); 3266 let tmpInterface = devices.configs[0].interfaces[0]; 3267 try { 3268 let ret = usbManager.claimInterface(gPipe, tmpInterface, PARAM_NULLSTRING); 3269 console.info(TAG, 'usb [force:""] claimInterface ret : ', ret); 3270 expect(ret).assertEqual(0); 3271 } catch (err) { 3272 console.info(TAG, 'testClaimInterfaceParamErr038 catch err code: ', err.code, ', message: ', err.message); 3273 expect(err !== null).assertFalse(); 3274 } 3275 toReleaseInterface('testClaimInterfaceParamErr038', tmpInterface); 3276 toClosePipe('testClaimInterfaceParamErr038'); 3277 }) 3278 3279 /** 3280 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0360 3281 * @tc.name : testSetConfigurationParamErr001 3282 * @tc.desc : Negative test: Enter two parameters 3283 * @tc.size : MediumTest 3284 * @tc.type : Function 3285 * @tc.level : Level 3 3286 */ 3287 it('testSetConfigurationParamErr001', 0, function () { 3288 console.info(TAG, 'usb testSetConfigurationParamErr001 begin'); 3289 if (!isDeviceConnected) { 3290 expect(isDeviceConnected).assertFalse(); 3291 return 3292 } 3293 getPipe('testSetConfigurationParamErr001'); 3294 try { 3295 gPipe.busNum = devices.busNum; 3296 gPipe.devAddress = devices.devAddress; 3297 let tmpConfig = devices.configs[0]; 3298 let ret = usbManager.setConfiguration(gPipe, tmpConfig, gPipe); 3299 console.info(TAG, 'usb [Enter two parameters] setConfiguration ret : ', ret); 3300 expect(ret).assertEqual(0); 3301 } catch (err) { 3302 console.info(TAG, 'testSetConfigurationParamErr001 catch err code: ', err.code, ', message: ', err.message); 3303 expect(err !== null).assertFalse(); 3304 } 3305 toClosePipe('testSetConfigurationParamErr001'); 3306 }) 3307 3308 /** 3309 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0370 3310 * @tc.name : testSetConfigurationParamErr002 3311 * @tc.desc : Negative test: Param is null 3312 * @tc.size : MediumTest 3313 * @tc.type : Function 3314 * @tc.level : Level 3 3315 */ 3316 it('testSetConfigurationParamErr002', 0, function () { 3317 console.info(TAG, 'usb testSetConfigurationParamErr002 begin'); 3318 if (!isDeviceConnected) { 3319 expect(isDeviceConnected).assertFalse(); 3320 return 3321 } 3322 try { 3323 let ret = usbManager.setConfiguration(PARAM_NULL); 3324 console.info(TAG, 'usb [param:null] setConfiguration ret : ', ret); 3325 expect(ret !== null).assertFalse(); 3326 } catch (err) { 3327 console.info(TAG, 'testSetConfigurationParamErr002 catch err code: ', err.code, ', message: ', err.message); 3328 expect(err.code).assertEqual(PARAM_ERRCODE); 3329 } 3330 }) 3331 3332 /** 3333 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0380 3334 * @tc.name : testSetConfigurationParamErr003 3335 * @tc.desc : Negative test: Param is undefined 3336 * @tc.size : MediumTest 3337 * @tc.type : Function 3338 * @tc.level : Level 3 3339 */ 3340 it('testSetConfigurationParamErr003', 0, function () { 3341 console.info(TAG, 'usb testSetConfigurationParamErr003 begin'); 3342 if (!isDeviceConnected) { 3343 expect(isDeviceConnected).assertFalse(); 3344 return 3345 } 3346 try { 3347 let ret = usbManager.setConfiguration(PARAM_UNDEFINED); 3348 console.info(TAG, 'usb [param:undefined] setConfiguration ret : ', ret); 3349 expect(ret !== null).assertFalse(); 3350 } catch (err) { 3351 console.info(TAG, 'testSetConfigurationParamErr003 catch err code: ', err.code, ', message: ', err.message); 3352 expect(err.code).assertEqual(PARAM_ERRCODE); 3353 } 3354 }) 3355 3356 /** 3357 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0390 3358 * @tc.name : testSetConfigurationParamErr004 3359 * @tc.desc : Negative test: Param is "" 3360 * @tc.size : MediumTest 3361 * @tc.type : Function 3362 * @tc.level : Level 3 3363 */ 3364 it('testSetConfigurationParamErr004', 0, function () { 3365 console.info(TAG, 'usb testSetConfigurationParamErr004 begin'); 3366 if (!isDeviceConnected) { 3367 expect(isDeviceConnected).assertFalse(); 3368 return 3369 } 3370 try { 3371 let ret = usbManager.setConfiguration(PARAM_NULLSTRING); 3372 console.info(TAG, 'usb [param:""] setConfiguration ret : ', ret); 3373 expect(ret !== null).assertFalse(); 3374 } catch (err) { 3375 console.info(TAG, 'testSetConfigurationParamErr004 catch err code: ', err.code, ', message: ', err.message); 3376 expect(err.code).assertEqual(PARAM_ERRCODE); 3377 } 3378 }) 3379 3380 /** 3381 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0410 3382 * @tc.name : testSetConfigurationParamErr005 3383 * @tc.desc : Negative test: pipe is null 3384 * @tc.size : MediumTest 3385 * @tc.type : Function 3386 * @tc.level : Level 3 3387 */ 3388 it('testSetConfigurationParamErr005', 0, function () { 3389 console.info(TAG, 'usb testSetConfigurationParamErr005 begin'); 3390 if (!isDeviceConnected) { 3391 expect(isDeviceConnected).assertFalse(); 3392 return 3393 } 3394 try { 3395 let tmpConfig = devices.configs[0]; 3396 let ret = usbManager.setConfiguration(PARAM_NULL, tmpConfig); 3397 console.info(TAG, 'usb [pipe:null] setConfiguration ret : ', ret); 3398 expect(ret !== null).assertFalse(); 3399 } catch (err) { 3400 console.info(TAG, 'testSetConfigurationParamErr005 catch err code: ', err.code, ', message: ', err.message); 3401 expect(err.code).assertEqual(PARAM_ERRCODE); 3402 } 3403 }) 3404 3405 /** 3406 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0420 3407 * @tc.name : testSetConfigurationParamErr006 3408 * @tc.desc : Negative test: pipe is undefined 3409 * @tc.size : MediumTest 3410 * @tc.type : Function 3411 * @tc.level : Level 3 3412 */ 3413 it('testSetConfigurationParamErr006', 0, function () { 3414 console.info(TAG, 'usb testSetConfigurationParamErr006 begin'); 3415 if (!isDeviceConnected) { 3416 expect(isDeviceConnected).assertFalse(); 3417 return 3418 } 3419 try { 3420 let tmpConfig = devices.configs[0]; 3421 let ret = usbManager.setConfiguration(PARAM_UNDEFINED, tmpConfig); 3422 console.info(TAG, 'usb [pipe:undefined] setConfiguration ret : ', ret); 3423 expect(ret !== null).assertFalse(); 3424 } catch (err) { 3425 console.info(TAG, 'testSetConfigurationParamErr006 catch err code: ', err.code, ', message: ', err.message); 3426 expect(err.code).assertEqual(PARAM_ERRCODE); 3427 } 3428 }) 3429 3430 /** 3431 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0430 3432 * @tc.name : testSetConfigurationParamErr007 3433 * @tc.desc : Negative test: pipe is "" 3434 * @tc.size : MediumTest 3435 * @tc.type : Function 3436 * @tc.level : Level 3 3437 */ 3438 it('testSetConfigurationParamErr007', 0, function () { 3439 console.info(TAG, 'usb testSetConfigurationParamErr007 begin'); 3440 if (!isDeviceConnected) { 3441 expect(isDeviceConnected).assertFalse(); 3442 return 3443 } 3444 try { 3445 let tmpConfig = devices.configs[0]; 3446 let ret = usbManager.setConfiguration(PARAM_NULLSTRING, tmpConfig); 3447 console.info(TAG, 'usb [pipe:""] setConfiguration ret : ', ret); 3448 expect(ret !== null).assertFalse(); 3449 } catch (err) { 3450 console.info(TAG, 'testSetConfigurationParamErr007 catch err code: ', err.code, ', message: ', err.message); 3451 expect(err.code).assertEqual(PARAM_ERRCODE); 3452 } 3453 }) 3454 3455 /** 3456 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0440 3457 * @tc.name : testSetConfigurationParamErr008 3458 * @tc.desc : Negative test: config is null 3459 * @tc.size : MediumTest 3460 * @tc.type : Function 3461 * @tc.level : Level 3 3462 */ 3463 it('testSetConfigurationParamErr008', 0, function () { 3464 console.info(TAG, 'usb testSetConfigurationParamErr008 begin'); 3465 if (!isDeviceConnected) { 3466 expect(isDeviceConnected).assertFalse(); 3467 return 3468 } 3469 try { 3470 gPipe.busNum = devices.busNum; 3471 gPipe.devAddress = devices.devAddress; 3472 let ret = usbManager.setConfiguration(gPipe, PARAM_NULL); 3473 console.info(TAG, 'usb [config:null] setConfiguration ret : ', ret); 3474 expect(ret !== null).assertFalse(); 3475 } catch (err) { 3476 console.info(TAG, 'testSetConfigurationParamErr008 catch err code: ', err.code, ', message: ', err.message); 3477 expect(err.code).assertEqual(PARAM_ERRCODE); 3478 } 3479 }) 3480 3481 /** 3482 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0450 3483 * @tc.name : testSetConfigurationParamErr009 3484 * @tc.desc : Negative test: config is undefined 3485 * @tc.size : MediumTest 3486 * @tc.type : Function 3487 * @tc.level : Level 3 3488 */ 3489 it('testSetConfigurationParamErr009', 0, function () { 3490 console.info(TAG, 'usb testSetConfigurationParamErr009 begin'); 3491 if (!isDeviceConnected) { 3492 expect(isDeviceConnected).assertFalse(); 3493 return 3494 } 3495 try { 3496 gPipe.busNum = devices.busNum; 3497 gPipe.devAddress = devices.devAddress; 3498 let ret = usbManager.setConfiguration(gPipe, PARAM_UNDEFINED); 3499 console.info(TAG, 'usb [config:undefined] setConfiguration ret : ', ret); 3500 expect(ret !== null).assertFalse(); 3501 } catch (err) { 3502 console.info(TAG, 'testSetConfigurationParamErr009 catch err code: ', err.code, ', message: ', err.message); 3503 expect(err.code).assertEqual(PARAM_ERRCODE); 3504 } 3505 }) 3506 3507 /** 3508 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0460 3509 * @tc.name : testSetConfigurationParamErr010 3510 * @tc.desc : Negative test: config is "" 3511 * @tc.size : MediumTest 3512 * @tc.type : Function 3513 * @tc.level : Level 3 3514 */ 3515 it('testSetConfigurationParamErr010', 0, function () { 3516 console.info(TAG, 'usb testSetConfigurationParamErr010 begin'); 3517 if (!isDeviceConnected) { 3518 expect(isDeviceConnected).assertFalse(); 3519 return 3520 } 3521 try { 3522 gPipe.busNum = devices.busNum; 3523 gPipe.devAddress = devices.devAddress; 3524 let ret = usbManager.setConfiguration(gPipe, PARAM_NULLSTRING); 3525 console.info(TAG, 'usb [config:""] setConfiguration ret : ', ret); 3526 expect(ret !== null).assertFalse(); 3527 } catch (err) { 3528 console.info(TAG, 'testSetConfigurationParamErr010 catch err code: ', err.code, ', message: ', err.message); 3529 expect(err.code).assertEqual(PARAM_ERRCODE); 3530 } 3531 }) 3532 3533 /** 3534 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0470 3535 * @tc.name : testSetConfigurationParamErr011 3536 * @tc.desc : Negative test: config id is null 3537 * @tc.size : MediumTest 3538 * @tc.type : Function 3539 * @tc.level : Level 3 3540 */ 3541 it('testSetConfigurationParamErr011', 0, function () { 3542 console.info(TAG, 'usb testSetConfigurationParamErr011 begin'); 3543 if (!isDeviceConnected) { 3544 expect(isDeviceConnected).assertFalse(); 3545 return 3546 } 3547 try { 3548 gPipe.busNum = devices.busNum; 3549 gPipe.devAddress = devices.devAddress; 3550 let tmpConfig = devices.configs[0]; 3551 tmpConfig.id = PARAM_NULL; 3552 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3553 console.info(TAG, 'usb [config.id:null] setConfiguration ret : ', ret); 3554 expect(ret !== null).assertFalse(); 3555 } catch (err) { 3556 console.info(TAG, 'testSetConfigurationParamErr011 catch err code: ', err.code, ', message: ', err.message); 3557 expect(err.code).assertEqual(PARAM_ERRCODE); 3558 } 3559 }) 3560 3561 /** 3562 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0480 3563 * @tc.name : testSetConfigurationParamErr012 3564 * @tc.desc : Negative test: config id is undefined 3565 * @tc.size : MediumTest 3566 * @tc.type : Function 3567 * @tc.level : Level 3 3568 */ 3569 it('testSetConfigurationParamErr012', 0, function () { 3570 console.info(TAG, 'usb testSetConfigurationParamErr012 begin'); 3571 if (!isDeviceConnected) { 3572 expect(isDeviceConnected).assertFalse(); 3573 return 3574 } 3575 try { 3576 gPipe.busNum = devices.busNum; 3577 gPipe.devAddress = devices.devAddress; 3578 let tmpConfig = devices.configs[0]; 3579 tmpConfig.id = PARAM_UNDEFINED; 3580 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3581 console.info(TAG, 'usb [config.id:undefined] setConfiguration ret : ', ret); 3582 expect(ret !== null).assertFalse(); 3583 } catch (err) { 3584 console.info(TAG, 'testSetConfigurationParamErr012 catch err code: ', err.code, ', message: ', err.message); 3585 expect(err.code).assertEqual(PARAM_ERRCODE); 3586 } 3587 }) 3588 3589 /** 3590 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0490 3591 * @tc.name : testSetConfigurationParamErr013 3592 * @tc.desc : Negative test: config id is "" 3593 * @tc.size : MediumTest 3594 * @tc.type : Function 3595 * @tc.level : Level 3 3596 */ 3597 it('testSetConfigurationParamErr013', 0, function () { 3598 console.info(TAG, 'usb testSetConfigurationParamErr013 begin'); 3599 if (!isDeviceConnected) { 3600 expect(isDeviceConnected).assertFalse(); 3601 return 3602 } 3603 try { 3604 gPipe.busNum = devices.busNum; 3605 gPipe.devAddress = devices.devAddress; 3606 let tmpConfig = devices.configs[0]; 3607 tmpConfig.id = PARAM_NULLSTRING; 3608 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3609 console.info(TAG, 'usb [config.id:""] setConfiguration ret : ', ret); 3610 expect(ret !== null).assertFalse(); 3611 } catch (err) { 3612 console.info(TAG, 'testSetConfigurationParamErr013 catch err code: ', err.code, ', message: ', err.message); 3613 expect(err.code).assertEqual(PARAM_ERRCODE); 3614 } 3615 }) 3616 3617 /** 3618 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0510 3619 * @tc.name : testSetConfigurationParamErr014 3620 * @tc.desc : Negative test: config attributes is null 3621 * @tc.size : MediumTest 3622 * @tc.type : Function 3623 * @tc.level : Level 3 3624 */ 3625 it('testSetConfigurationParamErr014', 0, function () { 3626 console.info(TAG, 'usb testSetConfigurationParamErr014 begin'); 3627 if (!isDeviceConnected) { 3628 expect(isDeviceConnected).assertFalse(); 3629 return 3630 } 3631 try { 3632 gPipe.busNum = devices.busNum; 3633 gPipe.devAddress = devices.devAddress; 3634 let tmpConfig = devices.configs[0]; 3635 tmpConfig.attributes = PARAM_NULL; 3636 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3637 console.info(TAG, 'usb [config.attributes:null] setConfiguration ret : ', ret); 3638 expect(ret !== null).assertFalse(); 3639 } catch (err) { 3640 console.info(TAG, 'testSetConfigurationParamErr014 catch err code: ', err.code, ', message: ', err.message); 3641 expect(err.code).assertEqual(PARAM_ERRCODE); 3642 } 3643 }) 3644 3645 /** 3646 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0520 3647 * @tc.name : testSetConfigurationParamErr015 3648 * @tc.desc : Negative test: config attributes is undefined 3649 * @tc.size : MediumTest 3650 * @tc.type : Function 3651 * @tc.level : Level 3 3652 */ 3653 it('testSetConfigurationParamErr015', 0, function () { 3654 console.info(TAG, 'usb testSetConfigurationParamErr015 begin'); 3655 if (!isDeviceConnected) { 3656 expect(isDeviceConnected).assertFalse(); 3657 return 3658 } 3659 try { 3660 gPipe.busNum = devices.busNum; 3661 gPipe.devAddress = devices.devAddress; 3662 let tmpConfig = devices.configs[0]; 3663 tmpConfig.attributes = PARAM_UNDEFINED; 3664 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3665 console.info(TAG, 'usb [config.attributes:undefined] setConfiguration ret : ', ret); 3666 expect(ret !== null).assertFalse(); 3667 } catch (err) { 3668 console.info(TAG, 'testSetConfigurationParamErr015 catch err code: ', err.code, ', message: ', err.message); 3669 expect(err.code).assertEqual(PARAM_ERRCODE); 3670 } 3671 }) 3672 3673 /** 3674 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0530 3675 * @tc.name : testSetConfigurationParamErr016 3676 * @tc.desc : Negative test: config attributes is "" 3677 * @tc.size : MediumTest 3678 * @tc.type : Function 3679 * @tc.level : Level 3 3680 */ 3681 it('testSetConfigurationParamErr016', 0, function () { 3682 console.info(TAG, 'usb testSetConfigurationParamErr016 begin'); 3683 if (!isDeviceConnected) { 3684 expect(isDeviceConnected).assertFalse(); 3685 return 3686 } 3687 try { 3688 gPipe.busNum = devices.busNum; 3689 gPipe.devAddress = devices.devAddress; 3690 let tmpConfig = devices.configs[0]; 3691 tmpConfig.attributes = PARAM_NULLSTRING; 3692 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3693 console.info(TAG, 'usb [config.attributes:""] setConfiguration ret : ', ret); 3694 expect(ret !== null).assertFalse(); 3695 } catch (err) { 3696 console.info(TAG, 'testSetConfigurationParamErr016 catch err code: ', err.code, ', message: ', err.message); 3697 expect(err.code).assertEqual(PARAM_ERRCODE); 3698 } 3699 }) 3700 3701 /** 3702 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0540 3703 * @tc.name : testSetConfigurationParamErr017 3704 * @tc.desc : Negative test: config maxPower is null 3705 * @tc.size : MediumTest 3706 * @tc.type : Function 3707 * @tc.level : Level 3 3708 */ 3709 it('testSetConfigurationParamErr017', 0, function () { 3710 console.info(TAG, 'usb testSetConfigurationParamErr017 begin'); 3711 if (!isDeviceConnected) { 3712 expect(isDeviceConnected).assertFalse(); 3713 return 3714 } 3715 try { 3716 gPipe.busNum = devices.busNum; 3717 gPipe.devAddress = devices.devAddress; 3718 let tmpConfig = devices.configs[0]; 3719 tmpConfig.maxPower = PARAM_NULL; 3720 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3721 console.info(TAG, 'usb [config.maxPower:null] setConfiguration ret : ', ret); 3722 expect(ret !== null).assertFalse(); 3723 } catch (err) { 3724 console.info(TAG, 'testSetConfigurationParamErr017 catch err code: ', err.code, ', message: ', err.message); 3725 expect(err.code).assertEqual(PARAM_ERRCODE); 3726 } 3727 }) 3728 3729 /** 3730 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0550 3731 * @tc.name : testSetConfigurationParamErr018 3732 * @tc.desc : Negative test: config maxPower is undefined 3733 * @tc.size : MediumTest 3734 * @tc.type : Function 3735 * @tc.level : Level 3 3736 */ 3737 it('testSetConfigurationParamErr018', 0, function () { 3738 console.info(TAG, 'usb testSetConfigurationParamErr018 begin'); 3739 if (!isDeviceConnected) { 3740 expect(isDeviceConnected).assertFalse(); 3741 return 3742 } 3743 try { 3744 gPipe.busNum = devices.busNum; 3745 gPipe.devAddress = devices.devAddress; 3746 let tmpConfig = devices.configs[0]; 3747 tmpConfig.maxPower = PARAM_UNDEFINED; 3748 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3749 console.info(TAG, 'usb [config.maxPower:undefined] setConfiguration ret : ', ret); 3750 expect(ret !== null).assertFalse(); 3751 } catch (err) { 3752 console.info(TAG, 'testSetConfigurationParamErr018 catch err code: ', err.code, ', message: ', err.message); 3753 expect(err.code).assertEqual(PARAM_ERRCODE); 3754 } 3755 }) 3756 3757 /** 3758 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0560 3759 * @tc.name : testSetConfigurationParamErr019 3760 * @tc.desc : Negative test: config maxPower is "" 3761 * @tc.size : MediumTest 3762 * @tc.type : Function 3763 * @tc.level : Level 3 3764 */ 3765 it('testSetConfigurationParamErr019', 0, function () { 3766 console.info(TAG, 'usb testSetConfigurationParamErr019 begin'); 3767 if (!isDeviceConnected) { 3768 expect(isDeviceConnected).assertFalse(); 3769 return 3770 } 3771 try { 3772 gPipe.busNum = devices.busNum; 3773 gPipe.devAddress = devices.devAddress; 3774 let tmpConfig = devices.configs[0]; 3775 tmpConfig.maxPower = PARAM_NULLSTRING; 3776 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3777 console.info(TAG, 'usb [config.maxPower:""] setConfiguration ret : ', ret); 3778 expect(ret !== null).assertFalse(); 3779 } catch (err) { 3780 console.info(TAG, 'testSetConfigurationParamErr019 catch err code: ', err.code, ', message: ', err.message); 3781 expect(err.code).assertEqual(PARAM_ERRCODE); 3782 } 3783 }) 3784 3785 /** 3786 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0570 3787 * @tc.name : testSetConfigurationParamErr020 3788 * @tc.desc : Negative test: config name is null 3789 * @tc.size : MediumTest 3790 * @tc.type : Function 3791 * @tc.level : Level 3 3792 */ 3793 it('testSetConfigurationParamErr020', 0, function () { 3794 console.info(TAG, 'usb testSetConfigurationParamErr020 begin'); 3795 if (!isDeviceConnected) { 3796 expect(isDeviceConnected).assertFalse(); 3797 return 3798 } 3799 try { 3800 gPipe.busNum = devices.busNum; 3801 gPipe.devAddress = devices.devAddress; 3802 let tmpConfig = devices.configs[0]; 3803 tmpConfig.name = PARAM_NULL; 3804 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3805 console.info(TAG, 'usb [config.name:null] setConfiguration ret : ', ret); 3806 expect(ret !== null).assertFalse(); 3807 } catch (err) { 3808 console.info(TAG, 'testSetConfigurationParamErr020 catch err code: ', err.code, ', message: ', err.message); 3809 expect(err.code).assertEqual(PARAM_ERRCODE); 3810 } 3811 }) 3812 3813 /** 3814 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0580 3815 * @tc.name : testSetConfigurationParamErr021 3816 * @tc.desc : Negative test: config name is undefined 3817 * @tc.size : MediumTest 3818 * @tc.type : Function 3819 * @tc.level : Level 3 3820 */ 3821 it('testSetConfigurationParamErr021', 0, function () { 3822 console.info(TAG, 'usb testSetConfigurationParamErr021 begin'); 3823 if (!isDeviceConnected) { 3824 expect(isDeviceConnected).assertFalse(); 3825 return 3826 } 3827 try { 3828 gPipe.busNum = devices.busNum; 3829 gPipe.devAddress = devices.devAddress; 3830 let tmpConfig = devices.configs[0]; 3831 tmpConfig.name = PARAM_UNDEFINED; 3832 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3833 console.info(TAG, 'usb [config.name:undefined] setConfiguration ret : ', ret); 3834 expect(ret !== null).assertFalse(); 3835 } catch (err) { 3836 console.info(TAG, 'testSetConfigurationParamErr021 catch err code: ', err.code, ', message: ', err.message); 3837 expect(err.code).assertEqual(PARAM_ERRCODE); 3838 } 3839 }) 3840 3841 /** 3842 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0590 3843 * @tc.name : testSetConfigurationParamErr022 3844 * @tc.desc : Negative test: config name is 123 3845 * @tc.size : MediumTest 3846 * @tc.type : Function 3847 * @tc.level : Level 3 3848 */ 3849 it('testSetConfigurationParamErr022', 0, function () { 3850 console.info(TAG, 'usb testSetConfigurationParamErr022 begin'); 3851 if (!isDeviceConnected) { 3852 expect(isDeviceConnected).assertFalse(); 3853 return 3854 } 3855 try { 3856 gPipe.busNum = devices.busNum; 3857 gPipe.devAddress = devices.devAddress; 3858 let tmpConfig = devices.configs[0]; 3859 tmpConfig.name = PARAM_NUMBERTYPE; 3860 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3861 console.info(TAG, 'usb [config.name:""] setConfiguration ret : ', ret); 3862 expect(ret !== null).assertFalse(); 3863 } catch (err) { 3864 console.info(TAG, 'testSetConfigurationParamErr022 catch err code: ', err.code, ', message: ', err.message); 3865 expect(err.code).assertEqual(PARAM_ERRCODE); 3866 } 3867 }) 3868 3869 /** 3870 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0610 3871 * @tc.name : testSetConfigurationParamErr023 3872 * @tc.desc : Negative test: config isRemoteWakeup is null 3873 * @tc.size : MediumTest 3874 * @tc.type : Function 3875 * @tc.level : Level 3 3876 */ 3877 it('testSetConfigurationParamErr023', 0, function () { 3878 console.info(TAG, 'usb testSetConfigurationParamErr023 begin'); 3879 if (!isDeviceConnected) { 3880 expect(isDeviceConnected).assertFalse(); 3881 return 3882 } 3883 try { 3884 gPipe.busNum = devices.busNum; 3885 gPipe.devAddress = devices.devAddress; 3886 let tmpConfig = devices.configs[0]; 3887 tmpConfig.isRemoteWakeup = PARAM_NULL; 3888 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3889 console.info(TAG, 'usb [config.isRemoteWakeup:null] setConfiguration ret : ', ret); 3890 expect(ret !== null).assertFalse(); 3891 } catch (err) { 3892 console.info(TAG, 'testSetConfigurationParamErr023 catch err code: ', err.code, ', message: ', err.message); 3893 expect(err.code).assertEqual(PARAM_ERRCODE); 3894 } 3895 }) 3896 3897 /** 3898 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0620 3899 * @tc.name : testSetConfigurationParamErr024 3900 * @tc.desc : Negative test: config isRemoteWakeup is undefined 3901 * @tc.size : MediumTest 3902 * @tc.type : Function 3903 * @tc.level : Level 3 3904 */ 3905 it('testSetConfigurationParamErr024', 0, function () { 3906 console.info(TAG, 'usb testSetConfigurationParamErr024 begin'); 3907 if (!isDeviceConnected) { 3908 expect(isDeviceConnected).assertFalse(); 3909 return 3910 } 3911 try { 3912 gPipe.busNum = devices.busNum; 3913 gPipe.devAddress = devices.devAddress; 3914 let tmpConfig = devices.configs[0]; 3915 tmpConfig.isRemoteWakeup = PARAM_UNDEFINED; 3916 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3917 console.info(TAG, 'usb [config.isRemoteWakeup:undefined] setConfiguration ret : ', ret); 3918 expect(ret !== null).assertFalse(); 3919 } catch (err) { 3920 console.info(TAG, 'testSetConfigurationParamErr024 catch err code: ', err.code, ', message: ', err.message); 3921 expect(err.code).assertEqual(PARAM_ERRCODE); 3922 } 3923 }) 3924 3925 /** 3926 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0630 3927 * @tc.name : testSetConfigurationParamErr025 3928 * @tc.desc : Negative test: config isRemoteWakeup is "" 3929 * @tc.size : MediumTest 3930 * @tc.type : Function 3931 * @tc.level : Level 3 3932 */ 3933 it('testSetConfigurationParamErr025', 0, function () { 3934 console.info(TAG, 'usb testSetConfigurationParamErr025 begin'); 3935 if (!isDeviceConnected) { 3936 expect(isDeviceConnected).assertFalse(); 3937 return 3938 } 3939 try { 3940 gPipe.busNum = devices.busNum; 3941 gPipe.devAddress = devices.devAddress; 3942 let tmpConfig = devices.configs[0]; 3943 tmpConfig.isRemoteWakeup = PARAM_NULLSTRING; 3944 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3945 console.info(TAG, 'usb [config.isRemoteWakeup:""] setConfiguration ret : ', ret); 3946 expect(ret !== null).assertFalse(); 3947 } catch (err) { 3948 console.info(TAG, 'testSetConfigurationParamErr025 catch err code: ', err.code, ', message: ', err.message); 3949 expect(err.code).assertEqual(PARAM_ERRCODE); 3950 } 3951 }) 3952 3953 /** 3954 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0640 3955 * @tc.name : testSetConfigurationParamErr026 3956 * @tc.desc : Negative test: config isSelfPowered is null 3957 * @tc.size : MediumTest 3958 * @tc.type : Function 3959 * @tc.level : Level 3 3960 */ 3961 it('testSetConfigurationParamErr026', 0, function () { 3962 console.info(TAG, 'usb testSetConfigurationParamErr026 begin'); 3963 if (!isDeviceConnected) { 3964 expect(isDeviceConnected).assertFalse(); 3965 return 3966 } 3967 try { 3968 gPipe.busNum = devices.busNum; 3969 gPipe.devAddress = devices.devAddress; 3970 let tmpConfig = devices.configs[0]; 3971 tmpConfig.isSelfPowered = PARAM_NULL; 3972 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 3973 console.info(TAG, 'usb [config.isSelfPowered:null] setConfiguration ret : ', ret); 3974 expect(ret !== null).assertFalse(); 3975 } catch (err) { 3976 console.info(TAG, 'testSetConfigurationParamErr026 catch err code: ', err.code, ', message: ', err.message); 3977 expect(err.code).assertEqual(PARAM_ERRCODE); 3978 } 3979 }) 3980 3981 /** 3982 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0650 3983 * @tc.name : testSetConfigurationParamErr027 3984 * @tc.desc : Negative test: config isSelfPowered is undefined 3985 * @tc.size : MediumTest 3986 * @tc.type : Function 3987 * @tc.level : Level 3 3988 */ 3989 it('testSetConfigurationParamErr027', 0, function () { 3990 console.info(TAG, 'usb testSetConfigurationParamErr027 begin'); 3991 if (!isDeviceConnected) { 3992 expect(isDeviceConnected).assertFalse(); 3993 return 3994 } 3995 try { 3996 gPipe.busNum = devices.busNum; 3997 gPipe.devAddress = devices.devAddress; 3998 let tmpConfig = devices.configs[0]; 3999 tmpConfig.isSelfPowered = PARAM_UNDEFINED; 4000 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4001 console.info(TAG, 'usb [config.isSelfPowered:undefined] setConfiguration ret : ', ret); 4002 expect(ret !== null).assertFalse(); 4003 } catch (err) { 4004 console.info(TAG, 'testSetConfigurationParamErr027 catch err code: ', err.code, ', message: ', err.message); 4005 expect(err.code).assertEqual(PARAM_ERRCODE); 4006 } 4007 }) 4008 4009 /** 4010 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0660 4011 * @tc.name : testSetConfigurationParamErr028 4012 * @tc.desc : Negative test: config isSelfPowered is "" 4013 * @tc.size : MediumTest 4014 * @tc.type : Function 4015 * @tc.level : Level 3 4016 */ 4017 it('testSetConfigurationParamErr028', 0, function () { 4018 console.info(TAG, 'usb testSetConfigurationParamErr028 begin'); 4019 if (!isDeviceConnected) { 4020 expect(isDeviceConnected).assertFalse(); 4021 return 4022 } 4023 try { 4024 gPipe.busNum = devices.busNum; 4025 gPipe.devAddress = devices.devAddress; 4026 let tmpConfig = devices.configs[0]; 4027 tmpConfig.isSelfPowered = PARAM_NULLSTRING; 4028 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4029 console.info(TAG, 'usb [config.isSelfPowered:""] setConfiguration ret : ', ret); 4030 expect(ret !== null).assertFalse(); 4031 } catch (err) { 4032 console.info(TAG, 'testSetConfigurationParamErr028 catch err code: ', err.code, ', message: ', err.message); 4033 expect(err.code).assertEqual(PARAM_ERRCODE); 4034 } 4035 }) 4036 4037 /** 4038 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0670 4039 * @tc.name : testSetConfigurationParamErr029 4040 * @tc.desc : Negative test: config interfaces is null 4041 * @tc.size : MediumTest 4042 * @tc.type : Function 4043 * @tc.level : Level 3 4044 */ 4045 it('testSetConfigurationParamErr029', 0, function () { 4046 console.info(TAG, 'usb testSetConfigurationParamErr029 begin'); 4047 if (!isDeviceConnected) { 4048 expect(isDeviceConnected).assertFalse(); 4049 return 4050 } 4051 try { 4052 gPipe.busNum = devices.busNum; 4053 gPipe.devAddress = devices.devAddress; 4054 let tmpConfig = devices.configs[0]; 4055 tmpConfig.interfaces = PARAM_NULL; 4056 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4057 console.info(TAG, 'usb [config.interfaces:null] setConfiguration ret : ', ret); 4058 expect(ret !== null).assertFalse(); 4059 } catch (err) { 4060 console.info(TAG, 'testSetConfigurationParamErr029 catch err code: ', err.code, ', message: ', err.message); 4061 expect(err.code).assertEqual(PARAM_ERRCODE); 4062 } 4063 }) 4064 4065 /** 4066 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0680 4067 * @tc.name : testSetConfigurationParamErr030 4068 * @tc.desc : Negative test: config interfaces is undefined 4069 * @tc.size : MediumTest 4070 * @tc.type : Function 4071 * @tc.level : Level 3 4072 */ 4073 it('testSetConfigurationParamErr030', 0, function () { 4074 console.info(TAG, 'usb testSetConfigurationParamErr030 begin'); 4075 if (!isDeviceConnected) { 4076 expect(isDeviceConnected).assertFalse(); 4077 return 4078 } 4079 try { 4080 gPipe.busNum = devices.busNum; 4081 gPipe.devAddress = devices.devAddress; 4082 let tmpConfig = devices.configs[0]; 4083 tmpConfig.interfaces = PARAM_UNDEFINED; 4084 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4085 console.info(TAG, 'usb [config.interfaces:undefined] setConfiguration ret : ', ret); 4086 expect(ret !== null).assertFalse(); 4087 } catch (err) { 4088 console.info(TAG, 'testSetConfigurationParamErr030 catch err code: ', err.code, ', message: ', err.message); 4089 expect(err.code).assertEqual(PARAM_ERRCODE); 4090 } 4091 }) 4092 4093 /** 4094 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0690 4095 * @tc.name : testSetConfigurationParamErr031 4096 * @tc.desc : Negative test: config interfaces is "" 4097 * @tc.size : MediumTest 4098 * @tc.type : Function 4099 * @tc.level : Level 3 4100 */ 4101 it('testSetConfigurationParamErr031', 0, function () { 4102 console.info(TAG, 'usb testSetConfigurationParamErr031 begin'); 4103 if (!isDeviceConnected) { 4104 expect(isDeviceConnected).assertFalse(); 4105 return 4106 } 4107 try { 4108 gPipe.busNum = devices.busNum; 4109 gPipe.devAddress = devices.devAddress; 4110 let tmpConfig = devices.configs[0]; 4111 tmpConfig.interfaces = PARAM_NULLSTRING; 4112 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4113 console.info(TAG, 'usb [config.interfaces:""] setConfiguration ret : ', ret); 4114 expect(ret !== null).assertFalse(); 4115 } catch (err) { 4116 console.info(TAG, 'testSetConfigurationParamErr031 catch err code: ', err.code, ', message: ', err.message); 4117 expect(err.code).assertEqual(PARAM_ERRCODE); 4118 } 4119 }) 4120 4121 /** 4122 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0710 4123 * @tc.name : testSetConfigurationParamErr032 4124 * @tc.desc : Negative test: config isRemoteWakeup is 123 4125 * @tc.size : MediumTest 4126 * @tc.type : Function 4127 * @tc.level : Level 3 4128 */ 4129 it('testSetConfigurationParamErr032', 0, function () { 4130 console.info(TAG, 'usb testSetConfigurationParamErr032 begin'); 4131 if (!isDeviceConnected) { 4132 expect(isDeviceConnected).assertFalse(); 4133 return 4134 } 4135 try { 4136 gPipe.busNum = devices.busNum; 4137 gPipe.devAddress = devices.devAddress; 4138 let tmpConfig = devices.configs[0]; 4139 tmpConfig.isRemoteWakeup = PARAM_NUMBERTYPE; 4140 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4141 console.info(TAG, 'usb [config.isRemoteWakeup:123] setConfiguration ret : ', ret); 4142 expect(ret !== null).assertFalse(); 4143 } catch (err) { 4144 console.info(TAG, 'testSetConfigurationParamErr032 catch err code: ', err.code, ', message: ', err.message); 4145 expect(err.code).assertEqual(PARAM_ERRCODE); 4146 } 4147 }) 4148 4149 /** 4150 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0720 4151 * @tc.name : testSetConfigurationParamErr033 4152 * @tc.desc : Negative test: config isSelfPowered is 123 4153 * @tc.size : MediumTest 4154 * @tc.type : Function 4155 * @tc.level : Level 3 4156 */ 4157 it('testSetConfigurationParamErr033', 0, function () { 4158 console.info(TAG, 'usb testSetConfigurationParamErr033 begin'); 4159 if (!isDeviceConnected) { 4160 expect(isDeviceConnected).assertFalse(); 4161 return 4162 } 4163 try { 4164 gPipe.busNum = devices.busNum; 4165 gPipe.devAddress = devices.devAddress; 4166 let tmpConfig = devices.configs[0]; 4167 tmpConfig.isSelfPowered = PARAM_NUMBERTYPE; 4168 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4169 console.info(TAG, 'usb [config.isSelfPowered:123] setConfiguration ret : ', ret); 4170 expect(ret !== null).assertFalse(); 4171 } catch (err) { 4172 console.info(TAG, 'testSetConfigurationParamErr033 catch err code: ', err.code, ', message: ', err.message); 4173 expect(err.code).assertEqual(PARAM_ERRCODE); 4174 } 4175 }) 4176 4177 /** 4178 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0730 4179 * @tc.name : testSetConfigurationParamErr034 4180 * @tc.desc : Negative test: config interfaces is 123 4181 * @tc.size : MediumTest 4182 * @tc.type : Function 4183 * @tc.level : Level 3 4184 */ 4185 it('testSetConfigurationParamErr034', 0, function () { 4186 console.info(TAG, 'usb testSetConfigurationParamErr034 begin'); 4187 if (!isDeviceConnected) { 4188 expect(isDeviceConnected).assertFalse(); 4189 return 4190 } 4191 try { 4192 gPipe.busNum = devices.busNum; 4193 gPipe.devAddress = devices.devAddress; 4194 let tmpConfig = devices.configs[0]; 4195 tmpConfig.interfaces = PARAM_NUMBERTYPE; 4196 let ret = usbManager.setConfiguration(gPipe, tmpConfig); 4197 console.info(TAG, 'usb [config.interfaces:123] setConfiguration ret : ', ret); 4198 expect(ret !== null).assertFalse(); 4199 } catch (err) { 4200 console.info(TAG, 'testSetConfigurationParamErr034 catch err code: ', err.code, ', message: ', err.message); 4201 expect(err.code).assertEqual(PARAM_ERRCODE); 4202 } 4203 }) 4204 4205 /** 4206 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0740 4207 * @tc.name : testSetInterfaceParamErr001 4208 * @tc.desc : Negative test: Enter three parameters 4209 * @tc.size : MediumTest 4210 * @tc.type : Function 4211 * @tc.level : Level 3 4212 */ 4213 it('testSetInterfaceParamErr001', 0, function () { 4214 console.info(TAG, 'usb testSetInterfaceParamErr001 begin'); 4215 if (!isDeviceConnected) { 4216 expect(isDeviceConnected).assertFalse(); 4217 return 4218 } 4219 getPipe('testSetInterfaceParamErr001'); 4220 let tmpInterface = devices.configs[0].interfaces[0]; 4221 let isClaim = usbManager.claimInterface(gPipe, tmpInterface, true); 4222 expect(isClaim).assertEqual(0); 4223 try { 4224 let ret = usbManager.setInterface(gPipe, tmpInterface, gPipe); 4225 console.info(TAG, 'usb [Enter three parameters] setInterface ret : ', ret); 4226 expect(ret).assertEqual(0); 4227 } catch (err) { 4228 console.info(TAG, 'testSetInterfaceParamErr001 catch err code: ', err.code, ', message: ', err.message); 4229 expect(err !== null).assertFalse(); 4230 } 4231 toReleaseInterface('testSetInterfaceParamErr001', tmpInterface); 4232 toClosePipe('testSetInterfaceParamErr001'); 4233 }) 4234 4235 /** 4236 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0750 4237 * @tc.name : testSetInterfaceParamErr002 4238 * @tc.desc : Negative test: Param is null 4239 * @tc.size : MediumTest 4240 * @tc.type : Function 4241 * @tc.level : Level 3 4242 */ 4243 it('testSetInterfaceParamErr002', 0, function () { 4244 console.info(TAG, 'usb testSetInterfaceParamErr002 begin'); 4245 if (!isDeviceConnected) { 4246 expect(isDeviceConnected).assertFalse(); 4247 return 4248 } 4249 try { 4250 let ret = usbManager.setInterface(PARAM_NULL); 4251 console.info(TAG, 'usb [param:null] setInterface ret : ', ret); 4252 expect(ret !== null).assertFalse(); 4253 } catch (err) { 4254 console.info(TAG, 'testSetInterfaceParamErr002 catch err code: ', err.code, ', message: ', err.message); 4255 expect(err.code).assertEqual(PARAM_ERRCODE); 4256 } 4257 }) 4258 4259 /** 4260 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0760 4261 * @tc.name : testSetInterfaceParamErr003 4262 * @tc.desc : Negative test: Param is undefined 4263 * @tc.size : MediumTest 4264 * @tc.type : Function 4265 * @tc.level : Level 3 4266 */ 4267 it('testSetInterfaceParamErr003', 0, function () { 4268 console.info(TAG, 'usb testSetInterfaceParamErr003 begin'); 4269 if (!isDeviceConnected) { 4270 expect(isDeviceConnected).assertFalse(); 4271 return 4272 } 4273 try { 4274 let ret = usbManager.setInterface(PARAM_UNDEFINED); 4275 console.info(TAG, 'usb [param:undefined] setInterface ret : ', ret); 4276 expect(ret !== null).assertFalse(); 4277 } catch (err) { 4278 console.info(TAG, 'testSetInterfaceParamErr003 catch err code: ', err.code, ', message: ', err.message); 4279 expect(err.code).assertEqual(PARAM_ERRCODE); 4280 } 4281 }) 4282 4283 /** 4284 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0770 4285 * @tc.name : testSetInterfaceParamErr004 4286 * @tc.desc : Negative test: Param is "" 4287 * @tc.size : MediumTest 4288 * @tc.type : Function 4289 * @tc.level : Level 3 4290 */ 4291 it('testSetInterfaceParamErr004', 0, function () { 4292 console.info(TAG, 'usb testSetInterfaceParamErr004 begin'); 4293 if (!isDeviceConnected) { 4294 expect(isDeviceConnected).assertFalse(); 4295 return 4296 } 4297 try { 4298 let ret = usbManager.setInterface(PARAM_NULLSTRING); 4299 console.info(TAG, 'usb [param:""] setInterface ret : ', ret); 4300 expect(ret !== null).assertFalse(); 4301 } catch (err) { 4302 console.info(TAG, 'testSetInterfaceParamErr004 catch err code: ', err.code, ', message: ', err.message); 4303 expect(err.code).assertEqual(PARAM_ERRCODE); 4304 } 4305 }) 4306 4307 /** 4308 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0780 4309 * @tc.name : testSetInterfaceParamErr005 4310 * @tc.desc : Negative test: pipe is null 4311 * @tc.size : MediumTest 4312 * @tc.type : Function 4313 * @tc.level : Level 3 4314 */ 4315 it('testSetInterfaceParamErr005', 0, function () { 4316 console.info(TAG, 'usb testSetInterfaceParamErr005 begin'); 4317 if (!isDeviceConnected) { 4318 expect(isDeviceConnected).assertFalse(); 4319 return 4320 } 4321 try { 4322 let tmpInterface = devices.configs[0].interfaces[0]; 4323 let ret = usbManager.setInterface(PARAM_NULL, tmpInterface); 4324 console.info(TAG, 'usb [pipe:null] setInterface ret : ', ret); 4325 expect(ret !== null).assertFalse(); 4326 } catch (err) { 4327 console.info(TAG, 'testSetInterfaceParamErr005 catch err code: ', err.code, ', message: ', err.message); 4328 expect(err.code).assertEqual(PARAM_ERRCODE); 4329 } 4330 }) 4331 4332 /** 4333 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0790 4334 * @tc.name : testSetInterfaceParamErr006 4335 * @tc.desc : Negative test: pipe is undefined 4336 * @tc.size : MediumTest 4337 * @tc.type : Function 4338 * @tc.level : Level 3 4339 */ 4340 it('testSetInterfaceParamErr006', 0, function () { 4341 console.info(TAG, 'usb testSetInterfaceParamErr006 begin'); 4342 if (!isDeviceConnected) { 4343 expect(isDeviceConnected).assertFalse(); 4344 return 4345 } 4346 try { 4347 let tmpInterface = devices.configs[0].interfaces[0]; 4348 let ret = usbManager.setInterface(PARAM_UNDEFINED, tmpInterface); 4349 console.info(TAG, 'usb [pipe:undefined] setInterface ret : ', ret); 4350 expect(ret !== null).assertFalse(); 4351 } catch (err) { 4352 console.info(TAG, 'testSetInterfaceParamErr006 catch err code: ', err.code, ', message: ', err.message); 4353 expect(err.code).assertEqual(PARAM_ERRCODE); 4354 } 4355 }) 4356 4357 /** 4358 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0810 4359 * @tc.name : testSetInterfaceParamErr007 4360 * @tc.desc : Negative test: pipe is "" 4361 * @tc.size : MediumTest 4362 * @tc.type : Function 4363 * @tc.level : Level 3 4364 */ 4365 it('testSetInterfaceParamErr007', 0, function () { 4366 console.info(TAG, 'usb testSetInterfaceParamErr007 begin'); 4367 if (!isDeviceConnected) { 4368 expect(isDeviceConnected).assertFalse(); 4369 return 4370 } 4371 try { 4372 let tmpInterface = devices.configs[0].interfaces[0]; 4373 let ret = usbManager.setInterface(PARAM_NULLSTRING, tmpInterface); 4374 console.info(TAG, 'usb [pipe:""] setInterface ret : ', ret); 4375 expect(ret !== null).assertFalse(); 4376 } catch (err) { 4377 console.info(TAG, 'testSetInterfaceParamErr007 catch err code: ', err.code, ', message: ', err.message); 4378 expect(err.code).assertEqual(PARAM_ERRCODE); 4379 } 4380 }) 4381 4382 /** 4383 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0820 4384 * @tc.name : testSetInterfaceParamErr008 4385 * @tc.desc : Negative test: iface is null 4386 * @tc.size : MediumTest 4387 * @tc.type : Function 4388 * @tc.level : Level 3 4389 */ 4390 it('testSetInterfaceParamErr008', 0, function () { 4391 console.info(TAG, 'usb testSetInterfaceParamErr008 begin'); 4392 if (!isDeviceConnected) { 4393 expect(isDeviceConnected).assertFalse(); 4394 return 4395 } 4396 try { 4397 gPipe.busNum = devices.busNum; 4398 gPipe.devAddress = devices.devAddress; 4399 let ret = usbManager.setInterface(gPipe, PARAM_NULL); 4400 console.info(TAG, 'usb [iface:null] setInterface ret : ', ret); 4401 expect(ret !== null).assertFalse(); 4402 } catch (err) { 4403 console.info(TAG, 'testSetInterfaceParamErr008 catch err code: ', err.code, ', message: ', err.message); 4404 expect(err.code).assertEqual(PARAM_ERRCODE); 4405 } 4406 }) 4407 4408 /** 4409 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0830 4410 * @tc.name : testSetInterfaceParamErr009 4411 * @tc.desc : Negative test: iface is undefined 4412 * @tc.size : MediumTest 4413 * @tc.type : Function 4414 * @tc.level : Level 3 4415 */ 4416 it('testSetInterfaceParamErr009', 0, function () { 4417 console.info(TAG, 'usb testSetInterfaceParamErr009 begin'); 4418 if (!isDeviceConnected) { 4419 expect(isDeviceConnected).assertFalse(); 4420 return 4421 } 4422 try { 4423 gPipe.busNum = devices.busNum; 4424 gPipe.devAddress = devices.devAddress; 4425 let ret = usbManager.setInterface(gPipe, PARAM_UNDEFINED); 4426 console.info(TAG, 'usb [iface:undefined] setInterface ret : ', ret); 4427 expect(ret !== null).assertFalse(); 4428 } catch (err) { 4429 console.info(TAG, 'testSetInterfaceParamErr009 catch err code: ', err.code, ', message: ', err.message); 4430 expect(err.code).assertEqual(PARAM_ERRCODE); 4431 } 4432 }) 4433 4434 /** 4435 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0840 4436 * @tc.name : testSetInterfaceParamErr010 4437 * @tc.desc : Negative test: iface is "" 4438 * @tc.size : MediumTest 4439 * @tc.type : Function 4440 * @tc.level : Level 3 4441 */ 4442 it('testSetInterfaceParamErr010', 0, function () { 4443 console.info(TAG, 'usb testSetInterfaceParamErr010 begin'); 4444 if (!isDeviceConnected) { 4445 expect(isDeviceConnected).assertFalse(); 4446 return 4447 } 4448 try { 4449 gPipe.busNum = devices.busNum; 4450 gPipe.devAddress = devices.devAddress; 4451 let ret = usbManager.setInterface(gPipe, PARAM_NULLSTRING); 4452 console.info(TAG, 'usb [iface:""] setInterface ret : ', ret); 4453 expect(ret !== null).assertFalse(); 4454 } catch (err) { 4455 console.info(TAG, 'testSetInterfaceParamErr010 catch err code: ', err.code, ', message: ', err.message); 4456 expect(err.code).assertEqual(PARAM_ERRCODE); 4457 } 4458 }) 4459 4460 /** 4461 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0850 4462 * @tc.name : testSetInterfaceParamErr011 4463 * @tc.desc : Negative test: pipe busNum is null 4464 * @tc.size : MediumTest 4465 * @tc.type : Function 4466 * @tc.level : Level 3 4467 */ 4468 it('testSetInterfaceParamErr011', 0, function () { 4469 console.info(TAG, 'usb testSetInterfaceParamErr011 begin'); 4470 if (!isDeviceConnected) { 4471 expect(isDeviceConnected).assertFalse(); 4472 return 4473 } 4474 try { 4475 gPipe.busNum = PARAM_NULL; 4476 gPipe.devAddress = devices.devAddress; 4477 let tmpInterface = devices.configs[0].interfaces[0]; 4478 let ret = usbManager.setInterface(gPipe, tmpInterface); 4479 console.info(TAG, 'usb [gPipe.busNum:null] setInterface ret : ', ret); 4480 expect(ret !== null).assertFalse(); 4481 } catch (err) { 4482 console.info(TAG, 'testSetInterfaceParamErr011 catch err code: ', err.code, ', message: ', err.message); 4483 expect(err.code).assertEqual(PARAM_ERRCODE); 4484 } 4485 }) 4486 4487 /** 4488 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0860 4489 * @tc.name : testSetInterfaceParamErr012 4490 * @tc.desc : Negative test: pipe busNum is undefined 4491 * @tc.size : MediumTest 4492 * @tc.type : Function 4493 * @tc.level : Level 3 4494 */ 4495 it('testSetInterfaceParamErr012', 0, function () { 4496 console.info(TAG, 'usb testSetInterfaceParamErr012 begin'); 4497 if (!isDeviceConnected) { 4498 expect(isDeviceConnected).assertFalse(); 4499 return 4500 } 4501 try { 4502 gPipe.busNum = PARAM_UNDEFINED; 4503 gPipe.devAddress = devices.devAddress; 4504 let tmpInterface = devices.configs[0].interfaces[0]; 4505 let ret = usbManager.setInterface(gPipe, tmpInterface); 4506 console.info(TAG, 'usb [gPipe.busNum:undefined] setInterface ret : ', ret); 4507 expect(ret !== null).assertFalse(); 4508 } catch (err) { 4509 console.info(TAG, 'testSetInterfaceParamErr012 catch err code: ', err.code, ', message: ', err.message); 4510 expect(err.code).assertEqual(PARAM_ERRCODE); 4511 } 4512 }) 4513 4514 /** 4515 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0870 4516 * @tc.name : testSetInterfaceParamErr013 4517 * @tc.desc : Negative test: pipe busNum is "" 4518 * @tc.size : MediumTest 4519 * @tc.type : Function 4520 * @tc.level : Level 3 4521 */ 4522 it('testSetInterfaceParamErr013', 0, function () { 4523 console.info(TAG, 'usb testSetInterfaceParamErr013 begin'); 4524 if (!isDeviceConnected) { 4525 expect(isDeviceConnected).assertFalse(); 4526 return 4527 } 4528 try { 4529 gPipe.busNum = PARAM_NULLSTRING; 4530 gPipe.devAddress = devices.devAddress; 4531 let tmpInterface = devices.configs[0].interfaces[0]; 4532 let ret = usbManager.setInterface(gPipe, tmpInterface); 4533 console.info(TAG, 'usb [gPipe.busNum:""] setInterface ret : ', ret); 4534 expect(ret !== null).assertFalse(); 4535 } catch (err) { 4536 console.info(TAG, 'testSetInterfaceParamErr013 catch err code: ', err.code, ', message: ', err.message); 4537 expect(err.code).assertEqual(PARAM_ERRCODE); 4538 } 4539 }) 4540 4541 /** 4542 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0880 4543 * @tc.name : testSetInterfaceParamErr014 4544 * @tc.desc : Negative test: pipe devAddress is null 4545 * @tc.size : MediumTest 4546 * @tc.type : Function 4547 * @tc.level : Level 3 4548 */ 4549 it('testSetInterfaceParamErr014', 0, function () { 4550 console.info(TAG, 'usb testSetInterfaceParamErr014 begin'); 4551 if (!isDeviceConnected) { 4552 expect(isDeviceConnected).assertFalse(); 4553 return 4554 } 4555 try { 4556 gPipe.busNum = devices.busNum; 4557 gPipe.devAddress = PARAM_NULL; 4558 let tmpInterface = devices.configs[0].interfaces[0]; 4559 let ret = usbManager.setInterface(gPipe, tmpInterface); 4560 console.info(TAG, 'usb [gPipe.devAddress:null] setInterface ret : ', ret); 4561 expect(ret !== null).assertFalse(); 4562 } catch (err) { 4563 console.info(TAG, 'testSetInterfaceParamErr014 catch err code: ', err.code, ', message: ', err.message); 4564 expect(err.code).assertEqual(PARAM_ERRCODE); 4565 } 4566 }) 4567 4568 /** 4569 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0890 4570 * @tc.name : testSetInterfaceParamErr015 4571 * @tc.desc : Negative test: pipe devAddress is undefined 4572 * @tc.size : MediumTest 4573 * @tc.type : Function 4574 * @tc.level : Level 3 4575 */ 4576 it('testSetInterfaceParamErr015', 0, function () { 4577 console.info(TAG, 'usb testSetInterfaceParamErr015 begin'); 4578 if (!isDeviceConnected) { 4579 expect(isDeviceConnected).assertFalse(); 4580 return 4581 } 4582 try { 4583 gPipe.busNum = devices.busNum; 4584 gPipe.devAddress = PARAM_UNDEFINED; 4585 let tmpInterface = devices.configs[0].interfaces[0]; 4586 let ret = usbManager.setInterface(gPipe, tmpInterface); 4587 console.info(TAG, 'usb [gPipe.devAddress:undefined] setInterface ret : ', ret); 4588 expect(ret !== null).assertFalse(); 4589 } catch (err) { 4590 console.info(TAG, 'testSetInterfaceParamErr015 catch err code: ', err.code, ', message: ', err.message); 4591 expect(err.code).assertEqual(PARAM_ERRCODE); 4592 } 4593 }) 4594 4595 /** 4596 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0910 4597 * @tc.name : testSetInterfaceParamErr016 4598 * @tc.desc : Negative test: pipe devAddress is "" 4599 * @tc.size : MediumTest 4600 * @tc.type : Function 4601 * @tc.level : Level 3 4602 */ 4603 it('testSetInterfaceParamErr016', 0, function () { 4604 console.info(TAG, 'usb testSetInterfaceParamErr016 begin'); 4605 if (!isDeviceConnected) { 4606 expect(isDeviceConnected).assertFalse(); 4607 return 4608 } 4609 try { 4610 gPipe.busNum = devices.busNum; 4611 gPipe.devAddress = PARAM_NULLSTRING; 4612 let tmpInterface = devices.configs[0].interfaces[0]; 4613 let ret = usbManager.setInterface(gPipe, tmpInterface); 4614 console.info(TAG, 'usb [gPipe.devAddress:""] setInterface ret : ', ret); 4615 expect(ret !== null).assertFalse(); 4616 } catch (err) { 4617 console.info(TAG, 'testSetInterfaceParamErr016 catch err code: ', err.code, ', message: ', err.message); 4618 expect(err.code).assertEqual(PARAM_ERRCODE); 4619 } 4620 }) 4621 4622 /** 4623 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0920 4624 * @tc.name : testSetInterfaceParamErr017 4625 * @tc.desc : Negative test: interface id is null 4626 * @tc.size : MediumTest 4627 * @tc.type : Function 4628 * @tc.level : Level 3 4629 */ 4630 it('testSetInterfaceParamErr017', 0, function () { 4631 console.info(TAG, 'usb testSetInterfaceParamErr017 begin'); 4632 if (!isDeviceConnected) { 4633 expect(isDeviceConnected).assertFalse(); 4634 return 4635 } 4636 try { 4637 let tmpInterface = devices.configs[0].interfaces[0]; 4638 tmpInterface.id = PARAM_NULL; 4639 let ret = usbManager.setInterface(gPipe, tmpInterface); 4640 console.info(TAG, 'usb [interface.id:null] setInterface ret : ', ret); 4641 expect(ret !== null).assertFalse(); 4642 } catch (err) { 4643 console.info(TAG, 'testSetInterfaceParamErr017 catch err code: ', err.code, ', message: ', err.message); 4644 expect(err.code).assertEqual(PARAM_ERRCODE); 4645 } 4646 }) 4647 4648 /** 4649 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0930 4650 * @tc.name : testSetInterfaceParamErr018 4651 * @tc.desc : Negative test: interface id is undefined 4652 * @tc.size : MediumTest 4653 * @tc.type : Function 4654 * @tc.level : Level 3 4655 */ 4656 it('testSetInterfaceParamErr018', 0, function () { 4657 console.info(TAG, 'usb testSetInterfaceParamErr018 begin'); 4658 if (!isDeviceConnected) { 4659 expect(isDeviceConnected).assertFalse(); 4660 return 4661 } 4662 try { 4663 let tmpInterface = devices.configs[0].interfaces[0]; 4664 tmpInterface.id = PARAM_UNDEFINED; 4665 let ret = usbManager.setInterface(gPipe, tmpInterface); 4666 console.info(TAG, 'usb [interface.id:undefined] setInterface ret : ', ret); 4667 expect(ret !== null).assertFalse(); 4668 } catch (err) { 4669 console.info(TAG, 'testSetInterfaceParamErr018 catch err code: ', err.code, ', message: ', err.message); 4670 expect(err.code).assertEqual(PARAM_ERRCODE); 4671 } 4672 }) 4673 4674 /** 4675 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0940 4676 * @tc.name : testSetInterfaceParamErr019 4677 * @tc.desc : Negative test: interface id is "" 4678 * @tc.size : MediumTest 4679 * @tc.type : Function 4680 * @tc.level : Level 3 4681 */ 4682 it('testSetInterfaceParamErr019', 0, function () { 4683 console.info(TAG, 'usb testSetInterfaceParamErr019 begin'); 4684 if (!isDeviceConnected) { 4685 expect(isDeviceConnected).assertFalse(); 4686 return 4687 } 4688 try { 4689 let tmpInterface = devices.configs[0].interfaces[0]; 4690 tmpInterface.id = PARAM_NULLSTRING; 4691 let ret = usbManager.setInterface(gPipe, tmpInterface); 4692 console.info(TAG, 'usb [interface.id:""] setInterface ret : ', ret); 4693 expect(ret !== null).assertFalse(); 4694 } catch (err) { 4695 console.info(TAG, 'testSetInterfaceParamErr019 catch err code: ', err.code, ', message: ', err.message); 4696 expect(err.code).assertEqual(PARAM_ERRCODE); 4697 } 4698 }) 4699 4700 /** 4701 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0950 4702 * @tc.name : testSetInterfaceParamErr020 4703 * @tc.desc : Negative test: interface protocol is null 4704 * @tc.size : MediumTest 4705 * @tc.type : Function 4706 * @tc.level : Level 3 4707 */ 4708 it('testSetInterfaceParamErr020', 0, function () { 4709 console.info(TAG, 'usb testSetInterfaceParamErr020 begin'); 4710 if (!isDeviceConnected) { 4711 expect(isDeviceConnected).assertFalse(); 4712 return 4713 } 4714 try { 4715 let tmpInterface = devices.configs[0].interfaces[0]; 4716 tmpInterface.protocol = PARAM_NULL; 4717 let ret = usbManager.setInterface(gPipe, tmpInterface); 4718 console.info(TAG, 'usb [interface.protocol:null] setInterface ret : ', ret); 4719 expect(ret !== null).assertFalse(); 4720 } catch (err) { 4721 console.info(TAG, 'testSetInterfaceParamErr020 catch err code: ', err.code, ', message: ', err.message); 4722 expect(err.code).assertEqual(PARAM_ERRCODE); 4723 } 4724 }) 4725 4726 /** 4727 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0960 4728 * @tc.name : testSetInterfaceParamErr021 4729 * @tc.desc : Negative test: interface protocol is undefined 4730 * @tc.size : MediumTest 4731 * @tc.type : Function 4732 * @tc.level : Level 3 4733 */ 4734 it('testSetInterfaceParamErr021', 0, function () { 4735 console.info(TAG, 'usb testSetInterfaceParamErr021 begin'); 4736 if (!isDeviceConnected) { 4737 expect(isDeviceConnected).assertFalse(); 4738 return 4739 } 4740 try { 4741 let tmpInterface = devices.configs[0].interfaces[0]; 4742 tmpInterface.protocol = PARAM_UNDEFINED; 4743 let ret = usbManager.setInterface(gPipe, tmpInterface); 4744 console.info(TAG, 'usb [interface.protocol:undefined] setInterface ret : ', ret); 4745 expect(ret !== null).assertFalse(); 4746 } catch (err) { 4747 console.info(TAG, 'testSetInterfaceParamErr021 catch err code: ', err.code, ', message: ', err.message); 4748 expect(err.code).assertEqual(PARAM_ERRCODE); 4749 } 4750 }) 4751 4752 /** 4753 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0970 4754 * @tc.name : testSetInterfaceParamErr022 4755 * @tc.desc : Negative test: interface protocol is "" 4756 * @tc.size : MediumTest 4757 * @tc.type : Function 4758 * @tc.level : Level 3 4759 */ 4760 it('testSetInterfaceParamErr022', 0, function () { 4761 console.info(TAG, 'usb testSetInterfaceParamErr022 begin'); 4762 if (!isDeviceConnected) { 4763 expect(isDeviceConnected).assertFalse(); 4764 return 4765 } 4766 try { 4767 let tmpInterface = devices.configs[0].interfaces[0]; 4768 tmpInterface.protocol = PARAM_NULLSTRING; 4769 let ret = usbManager.setInterface(gPipe, tmpInterface); 4770 console.info(TAG, 'usb [interface.protocol:""] setInterface ret : ', ret); 4771 expect(ret !== null).assertFalse(); 4772 } catch (err) { 4773 console.info(TAG, 'testSetInterfaceParamErr022 catch err code: ', err.code, ', message: ', err.message); 4774 expect(err.code).assertEqual(PARAM_ERRCODE); 4775 } 4776 }) 4777 4778 /** 4779 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0980 4780 * @tc.name : testSetInterfaceParamErr023 4781 * @tc.desc : Negative test: interface clazz is null 4782 * @tc.size : MediumTest 4783 * @tc.type : Function 4784 * @tc.level : Level 3 4785 */ 4786 it('testSetInterfaceParamErr023', 0, function () { 4787 console.info(TAG, 'usb testSetInterfaceParamErr023 begin'); 4788 if (!isDeviceConnected) { 4789 expect(isDeviceConnected).assertFalse(); 4790 return 4791 } 4792 try { 4793 let tmpInterface = devices.configs[0].interfaces[0]; 4794 tmpInterface.clazz = PARAM_NULL; 4795 let ret = usbManager.setInterface(gPipe, tmpInterface); 4796 console.info(TAG, 'usb [interface.clazz:null] setInterface ret : ', ret); 4797 expect(ret !== null).assertFalse(); 4798 } catch (err) { 4799 console.info(TAG, 'testSetInterfaceParamErr023 catch err code: ', err.code, ', message: ', err.message); 4800 expect(err.code).assertEqual(PARAM_ERRCODE); 4801 } 4802 }) 4803 4804 /** 4805 * @tc.number : SUB_USB_HostManager_JS_ParamErr_0990 4806 * @tc.name : testSetInterfaceParamErr024 4807 * @tc.desc : Negative test: interface clazz is undefined 4808 * @tc.size : MediumTest 4809 * @tc.type : Function 4810 * @tc.level : Level 3 4811 */ 4812 it('testSetInterfaceParamErr024', 0, function () { 4813 console.info(TAG, 'usb testSetInterfaceParamErr024 begin'); 4814 if (!isDeviceConnected) { 4815 expect(isDeviceConnected).assertFalse(); 4816 return 4817 } 4818 try { 4819 let tmpInterface = devices.configs[0].interfaces[0]; 4820 tmpInterface.clazz = PARAM_UNDEFINED; 4821 let ret = usbManager.setInterface(gPipe, tmpInterface); 4822 console.info(TAG, 'usb [interface.clazz:undefined] setInterface ret : ', ret); 4823 expect(ret !== null).assertFalse(); 4824 } catch (err) { 4825 console.info(TAG, 'testSetInterfaceParamErr024 catch err code: ', err.code, ', message: ', err.message); 4826 expect(err.code).assertEqual(PARAM_ERRCODE); 4827 } 4828 }) 4829 4830 /** 4831 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1010 4832 * @tc.name : testSetInterfaceParamErr025 4833 * @tc.desc : Negative test: interface clazz is "" 4834 * @tc.size : MediumTest 4835 * @tc.type : Function 4836 * @tc.level : Level 3 4837 */ 4838 it('testSetInterfaceParamErr025', 0, function () { 4839 console.info(TAG, 'usb testSetInterfaceParamErr025 begin'); 4840 if (!isDeviceConnected) { 4841 expect(isDeviceConnected).assertFalse(); 4842 return 4843 } 4844 try { 4845 let tmpInterface = devices.configs[0].interfaces[0]; 4846 tmpInterface.clazz = PARAM_NULLSTRING; 4847 let ret = usbManager.setInterface(gPipe, tmpInterface); 4848 console.info(TAG, 'usb [interface.clazz:""] setInterface ret : ', ret); 4849 expect(ret !== null).assertFalse(); 4850 } catch (err) { 4851 console.info(TAG, 'testSetInterfaceParamErr025 catch err code: ', err.code, ', message: ', err.message); 4852 expect(err.code).assertEqual(PARAM_ERRCODE); 4853 } 4854 }) 4855 4856 /** 4857 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1020 4858 * @tc.name : testSetInterfaceParamErr026 4859 * @tc.desc : Negative test: interface subClass is null 4860 * @tc.size : MediumTest 4861 * @tc.type : Function 4862 * @tc.level : Level 3 4863 */ 4864 it('testSetInterfaceParamErr026', 0, function () { 4865 console.info(TAG, 'usb testSetInterfaceParamErr026 begin'); 4866 if (!isDeviceConnected) { 4867 expect(isDeviceConnected).assertFalse(); 4868 return 4869 } 4870 try { 4871 let tmpInterface = devices.configs[0].interfaces[0]; 4872 tmpInterface.subClass = PARAM_NULL; 4873 let ret = usbManager.setInterface(gPipe, tmpInterface); 4874 console.info(TAG, 'usb [interface.subClass:null] setInterface ret : ', ret); 4875 expect(ret !== null).assertFalse(); 4876 } catch (err) { 4877 console.info(TAG, 'testSetInterfaceParamErr026 catch err code: ', err.code, ', message: ', err.message); 4878 expect(err.code).assertEqual(PARAM_ERRCODE); 4879 } 4880 }) 4881 4882 /** 4883 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1030 4884 * @tc.name : testSetInterfaceParamErr027 4885 * @tc.desc : Negative test: interface subClass is undefined 4886 * @tc.size : MediumTest 4887 * @tc.type : Function 4888 * @tc.level : Level 3 4889 */ 4890 it('testSetInterfaceParamErr027', 0, function () { 4891 console.info(TAG, 'usb testSetInterfaceParamErr027 begin'); 4892 if (!isDeviceConnected) { 4893 expect(isDeviceConnected).assertFalse(); 4894 return 4895 } 4896 try { 4897 let tmpInterface = devices.configs[0].interfaces[0]; 4898 tmpInterface.subClass = PARAM_UNDEFINED; 4899 let ret = usbManager.setInterface(gPipe, tmpInterface); 4900 console.info(TAG, 'usb [interface.subClass:undefined] setInterface ret : ', ret); 4901 expect(ret !== null).assertFalse(); 4902 } catch (err) { 4903 console.info(TAG, 'testSetInterfaceParamErr027 catch err code: ', err.code, ', message: ', err.message); 4904 expect(err.code).assertEqual(PARAM_ERRCODE); 4905 } 4906 }) 4907 4908 /** 4909 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1040 4910 * @tc.name : testSetInterfaceParamErr028 4911 * @tc.desc : Negative test: interface subClass is "" 4912 * @tc.size : MediumTest 4913 * @tc.type : Function 4914 * @tc.level : Level 3 4915 */ 4916 it('testSetInterfaceParamErr028', 0, function () { 4917 console.info(TAG, 'usb testSetInterfaceParamErr028 begin'); 4918 if (!isDeviceConnected) { 4919 expect(isDeviceConnected).assertFalse(); 4920 return 4921 } 4922 try { 4923 let tmpInterface = devices.configs[0].interfaces[0]; 4924 tmpInterface.subClass = PARAM_NULLSTRING; 4925 let ret = usbManager.setInterface(gPipe, tmpInterface); 4926 console.info(TAG, 'usb [interface.subClass:""] setInterface ret : ', ret); 4927 expect(ret !== null).assertFalse(); 4928 } catch (err) { 4929 console.info(TAG, 'testSetInterfaceParamErr028 catch err code: ', err.code, ', message: ', err.message); 4930 expect(err.code).assertEqual(PARAM_ERRCODE); 4931 } 4932 }) 4933 4934 /** 4935 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1050 4936 * @tc.name : testSetInterfaceParamErr029 4937 * @tc.desc : Negative test: interface alternateSetting is null 4938 * @tc.size : MediumTest 4939 * @tc.type : Function 4940 * @tc.level : Level 3 4941 */ 4942 it('testSetInterfaceParamErr029', 0, function () { 4943 console.info(TAG, 'usb testSetInterfaceParamErr029 begin'); 4944 if (!isDeviceConnected) { 4945 expect(isDeviceConnected).assertFalse(); 4946 return 4947 } 4948 try { 4949 let tmpInterface = devices.configs[0].interfaces[0]; 4950 tmpInterface.alternateSetting = PARAM_NULL; 4951 let ret = usbManager.setInterface(gPipe, tmpInterface); 4952 console.info(TAG, 'usb [interface.alternateSetting:null] setInterface ret : ', ret); 4953 expect(ret !== null).assertFalse(); 4954 } catch (err) { 4955 console.info(TAG, 'testSetInterfaceParamErr029 catch err code: ', err.code, ', message: ', err.message); 4956 expect(err.code).assertEqual(PARAM_ERRCODE); 4957 } 4958 }) 4959 4960 /** 4961 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1060 4962 * @tc.name : testSetInterfaceParamErr030 4963 * @tc.desc : Negative test: interface alternateSetting is undefined 4964 * @tc.size : MediumTest 4965 * @tc.type : Function 4966 * @tc.level : Level 3 4967 */ 4968 it('testSetInterfaceParamErr030', 0, function () { 4969 console.info(TAG, 'usb testSetInterfaceParamErr030 begin'); 4970 if (!isDeviceConnected) { 4971 expect(isDeviceConnected).assertFalse(); 4972 return 4973 } 4974 try { 4975 let tmpInterface = devices.configs[0].interfaces[0]; 4976 tmpInterface.alternateSetting = PARAM_UNDEFINED; 4977 let ret = usbManager.setInterface(gPipe, tmpInterface); 4978 console.info(TAG, 'usb [interface.alternateSetting:undefined] setInterface ret : ', ret); 4979 expect(ret !== null).assertFalse(); 4980 } catch (err) { 4981 console.info(TAG, 'testSetInterfaceParamErr030 catch err code: ', err.code, ', message: ', err.message); 4982 expect(err.code).assertEqual(PARAM_ERRCODE); 4983 } 4984 }) 4985 4986 /** 4987 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1070 4988 * @tc.name : testSetInterfaceParamErr031 4989 * @tc.desc : Negative test: interface alternateSetting is "" 4990 * @tc.size : MediumTest 4991 * @tc.type : Function 4992 * @tc.level : Level 3 4993 */ 4994 it('testSetInterfaceParamErr031', 0, function () { 4995 console.info(TAG, 'usb testSetInterfaceParamErr031 begin'); 4996 if (!isDeviceConnected) { 4997 expect(isDeviceConnected).assertFalse(); 4998 return 4999 } 5000 try { 5001 let tmpInterface = devices.configs[0].interfaces[0]; 5002 tmpInterface.alternateSetting = PARAM_NULLSTRING; 5003 let ret = usbManager.setInterface(gPipe, tmpInterface); 5004 console.info(TAG, 'usb [interface.alternateSetting:""] setInterface ret : ', ret); 5005 expect(ret !== null).assertFalse(); 5006 } catch (err) { 5007 console.info(TAG, 'testSetInterfaceParamErr031 catch err code: ', err.code, ', message: ', err.message); 5008 expect(err.code).assertEqual(PARAM_ERRCODE); 5009 } 5010 }) 5011 5012 /** 5013 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1080 5014 * @tc.name : testSetInterfaceParamErr032 5015 * @tc.desc : Negative test: interface name is null 5016 * @tc.size : MediumTest 5017 * @tc.type : Function 5018 * @tc.level : Level 3 5019 */ 5020 it('testSetInterfaceParamErr032', 0, function () { 5021 console.info(TAG, 'usb testSetInterfaceParamErr032 begin'); 5022 if (!isDeviceConnected) { 5023 expect(isDeviceConnected).assertFalse(); 5024 return 5025 } 5026 try { 5027 let tmpInterface = devices.configs[0].interfaces[0]; 5028 tmpInterface.name = PARAM_NULL; 5029 let ret = usbManager.setInterface(gPipe, tmpInterface); 5030 console.info(TAG, 'usb [interface.name:null] setInterface ret : ', ret); 5031 expect(ret !== null).assertFalse(); 5032 } catch (err) { 5033 console.info(TAG, 'testSetInterfaceParamErr032 catch err code: ', err.code, ', message: ', err.message); 5034 expect(err.code).assertEqual(PARAM_ERRCODE); 5035 } 5036 }) 5037 5038 /** 5039 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1090 5040 * @tc.name : testSetInterfaceParamErr033 5041 * @tc.desc : Negative test: interface name is undefined 5042 * @tc.size : MediumTest 5043 * @tc.type : Function 5044 * @tc.level : Level 3 5045 */ 5046 it('testSetInterfaceParamErr033', 0, function () { 5047 console.info(TAG, 'usb testSetInterfaceParamErr033 begin'); 5048 if (!isDeviceConnected) { 5049 expect(isDeviceConnected).assertFalse(); 5050 return 5051 } 5052 try { 5053 let tmpInterface = devices.configs[0].interfaces[0]; 5054 tmpInterface.name = PARAM_UNDEFINED; 5055 let ret = usbManager.setInterface(gPipe, tmpInterface); 5056 console.info(TAG, 'usb [interface.name:undefined] setInterface ret : ', ret); 5057 expect(ret !== null).assertFalse(); 5058 } catch (err) { 5059 console.info(TAG, 'testSetInterfaceParamErr033 catch err code: ', err.code, ', message: ', err.message); 5060 expect(err.code).assertEqual(PARAM_ERRCODE); 5061 } 5062 }) 5063 5064 /** 5065 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1110 5066 * @tc.name : testSetInterfaceParamErr034 5067 * @tc.desc : Negative test: interface name is 123 5068 * @tc.size : MediumTest 5069 * @tc.type : Function 5070 * @tc.level : Level 3 5071 */ 5072 it('testSetInterfaceParamErr034', 0, function () { 5073 console.info(TAG, 'usb testSetInterfaceParamErr034 begin'); 5074 if (!isDeviceConnected) { 5075 expect(isDeviceConnected).assertFalse(); 5076 return 5077 } 5078 try { 5079 let tmpInterface = devices.configs[0].interfaces[0]; 5080 tmpInterface.name = PARAM_NUMBERTYPE; 5081 let ret = usbManager.setInterface(gPipe, tmpInterface); 5082 console.info(TAG, 'usb [interface.name:123] setInterface ret : ', ret); 5083 expect(ret !== null).assertFalse(); 5084 } catch (err) { 5085 console.info(TAG, 'testSetInterfaceParamErr034 catch err code: ', err.code, ', message: ', err.message); 5086 expect(err.code).assertEqual(PARAM_ERRCODE); 5087 } 5088 }) 5089 5090 /** 5091 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1120 5092 * @tc.name : testSetInterfaceParamErr035 5093 * @tc.desc : Negative test: interface endpoints is null 5094 * @tc.size : MediumTest 5095 * @tc.type : Function 5096 * @tc.level : Level 3 5097 */ 5098 it('testSetInterfaceParamErr035', 0, function () { 5099 console.info(TAG, 'usb testSetInterfaceParamErr035 begin'); 5100 if (!isDeviceConnected) { 5101 expect(isDeviceConnected).assertFalse(); 5102 return 5103 } 5104 try { 5105 let tmpInterface = devices.configs[0].interfaces[0]; 5106 tmpInterface.endpoints = PARAM_NULL; 5107 let ret = usbManager.setInterface(gPipe, tmpInterface); 5108 console.info(TAG, 'usb [interface.endpoints:null] setInterface ret : ', ret); 5109 expect(ret !== null).assertFalse(); 5110 } catch (err) { 5111 console.info(TAG, 'testSetInterfaceParamErr035 catch err code: ', err.code, ', message: ', err.message); 5112 expect(err.code).assertEqual(PARAM_ERRCODE); 5113 } 5114 }) 5115 5116 /** 5117 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1130 5118 * @tc.name : testSetInterfaceParamErr036 5119 * @tc.desc : Negative test: interface endpoints is undefined 5120 * @tc.size : MediumTest 5121 * @tc.type : Function 5122 * @tc.level : Level 3 5123 */ 5124 it('testSetInterfaceParamErr036', 0, function () { 5125 console.info(TAG, 'usb testSetInterfaceParamErr036 begin'); 5126 if (!isDeviceConnected) { 5127 expect(isDeviceConnected).assertFalse(); 5128 return 5129 } 5130 try { 5131 let tmpInterface = devices.configs[0].interfaces[0]; 5132 tmpInterface.endpoints = PARAM_UNDEFINED; 5133 let ret = usbManager.setInterface(gPipe, tmpInterface); 5134 console.info(TAG, 'usb [interface.endpoints:undefined] setInterface ret : ', ret); 5135 expect(ret !== null).assertFalse(); 5136 } catch (err) { 5137 console.info(TAG, 'testSetInterfaceParamErr036 catch err code: ', err.code, ', message: ', err.message); 5138 expect(err.code).assertEqual(PARAM_ERRCODE); 5139 } 5140 }) 5141 5142 /** 5143 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1140 5144 * @tc.name : testSetInterfaceParamErr037 5145 * @tc.desc : Negative test: interface endpoints is "" 5146 * @tc.size : MediumTest 5147 * @tc.type : Function 5148 * @tc.level : Level 3 5149 */ 5150 it('testSetInterfaceParamErr037', 0, function () { 5151 console.info(TAG, 'usb testSetInterfaceParamErr037 begin'); 5152 if (!isDeviceConnected) { 5153 expect(isDeviceConnected).assertFalse(); 5154 return 5155 } 5156 try { 5157 let tmpInterface = devices.configs[0].interfaces[0]; 5158 tmpInterface.endpoints = PARAM_NULLSTRING; 5159 let ret = usbManager.setInterface(gPipe, tmpInterface); 5160 console.info(TAG, 'usb [interface.endpoints:""] setInterface ret : ', ret); 5161 expect(ret !== null).assertFalse(); 5162 } catch (err) { 5163 console.info(TAG, 'testSetInterfaceParamErr037 catch err code: ', err.code, ', message: ', err.message); 5164 expect(err.code).assertEqual(PARAM_ERRCODE); 5165 } 5166 }) 5167 5168 /** 5169 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1150 5170 * @tc.name : testReleaseInterfaceParamErr001 5171 * @tc.desc : Negative test: Enter three parameters 5172 * @tc.size : MediumTest 5173 * @tc.type : Function 5174 * @tc.level : Level 3 5175 */ 5176 it('testReleaseInterfaceParamErr001', 0, function () { 5177 console.info(TAG, 'usb testReleaseInterfaceParamErr001 begin'); 5178 if (!isDeviceConnected) { 5179 expect(isDeviceConnected).assertFalse(); 5180 return 5181 } 5182 getPipe('testReleaseInterfaceParamErr001'); 5183 let tmpInterface = devices.configs[0].interfaces[0]; 5184 let isClaim = usbManager.claimInterface(gPipe, tmpInterface, true); 5185 expect(isClaim).assertEqual(0); 5186 try { 5187 let ret = usbManager.releaseInterface(gPipe, tmpInterface, gPipe); 5188 console.info(TAG, 'usb [Enter three parameters] releaseInterface ret : ', ret); 5189 expect(ret).assertEqual(0); 5190 } catch (err) { 5191 console.info(TAG, 'testReleaseInterfaceParamErr001 catch err code: ', err.code, ', message: ', err.message); 5192 expect(err !== null).assertFalse(); 5193 } 5194 toClosePipe('testReleaseInterfaceParamErr001'); 5195 }) 5196 5197 /** 5198 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1160 5199 * @tc.name : testReleaseInterfaceParamErr002 5200 * @tc.desc : Negative test: Param is null 5201 * @tc.size : MediumTest 5202 * @tc.type : Function 5203 * @tc.level : Level 3 5204 */ 5205 it('testReleaseInterfaceParamErr002', 0, function () { 5206 console.info(TAG, 'usb testReleaseInterfaceParamErr002 begin'); 5207 if (!isDeviceConnected) { 5208 expect(isDeviceConnected).assertFalse(); 5209 return 5210 } 5211 try { 5212 let ret = usbManager.releaseInterface(PARAM_NULL); 5213 console.info(TAG, 'usb [param:null] releaseInterface ret : ', ret); 5214 expect(ret !== null).assertFalse(); 5215 } catch (err) { 5216 console.info(TAG, 'testReleaseInterfaceParamErr002 catch err code: ', err.code, ', message: ', err.message); 5217 expect(err.code).assertEqual(PARAM_ERRCODE); 5218 } 5219 }) 5220 5221 /** 5222 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1170 5223 * @tc.name : testReleaseInterfaceParamErr003 5224 * @tc.desc : Negative test: Param is undefined 5225 * @tc.size : MediumTest 5226 * @tc.type : Function 5227 * @tc.level : Level 3 5228 */ 5229 it('testReleaseInterfaceParamErr003', 0, function () { 5230 console.info(TAG, 'usb testReleaseInterfaceParamErr003 begin'); 5231 if (!isDeviceConnected) { 5232 expect(isDeviceConnected).assertFalse(); 5233 return 5234 } 5235 try { 5236 let ret = usbManager.releaseInterface(PARAM_UNDEFINED); 5237 console.info(TAG, 'usb [param:undefined] releaseInterface ret : ', ret); 5238 expect(ret !== null).assertFalse(); 5239 } catch (err) { 5240 console.info(TAG, 'testReleaseInterfaceParamErr003 catch err code: ', err.code, ', message: ', err.message); 5241 expect(err.code).assertEqual(PARAM_ERRCODE); 5242 } 5243 }) 5244 5245 /** 5246 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1180 5247 * @tc.name : testReleaseInterfaceParamErr004 5248 * @tc.desc : Negative test: Param is "" 5249 * @tc.size : MediumTest 5250 * @tc.type : Function 5251 * @tc.level : Level 3 5252 */ 5253 it('testReleaseInterfaceParamErr004', 0, function () { 5254 console.info(TAG, 'usb testReleaseInterfaceParamErr004 begin'); 5255 if (!isDeviceConnected) { 5256 expect(isDeviceConnected).assertFalse(); 5257 return 5258 } 5259 try { 5260 let ret = usbManager.releaseInterface(PARAM_NULLSTRING); 5261 console.info(TAG, 'usb [param:""] releaseInterface ret : ', ret); 5262 expect(ret !== null).assertFalse(); 5263 } catch (err) { 5264 console.info(TAG, 'testReleaseInterfaceParamErr004 catch err code: ', err.code, ', message: ', err.message); 5265 expect(err.code).assertEqual(PARAM_ERRCODE); 5266 } 5267 }) 5268 5269 /** 5270 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1190 5271 * @tc.name : testReleaseInterfaceParamErr005 5272 * @tc.desc : Negative test: pipe is null 5273 * @tc.size : MediumTest 5274 * @tc.type : Function 5275 * @tc.level : Level 3 5276 */ 5277 it('testReleaseInterfaceParamErr005', 0, function () { 5278 console.info(TAG, 'usb testReleaseInterfaceParamErr005 begin'); 5279 if (!isDeviceConnected) { 5280 expect(isDeviceConnected).assertFalse(); 5281 return 5282 } 5283 try { 5284 let tmpInterface = devices.configs[0].interfaces[0]; 5285 let ret = usbManager.releaseInterface(PARAM_NULL, tmpInterface); 5286 console.info(TAG, 'usb [pipe:null] releaseInterface ret : ', ret); 5287 expect(ret !== null).assertFalse(); 5288 } catch (err) { 5289 console.info(TAG, 'testReleaseInterfaceParamErr005 catch err code: ', err.code, ', message: ', err.message); 5290 expect(err.code).assertEqual(PARAM_ERRCODE); 5291 } 5292 }) 5293 5294 /** 5295 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1210 5296 * @tc.name : testReleaseInterfaceParamErr006 5297 * @tc.desc : Negative test: pipe is undefined 5298 * @tc.size : MediumTest 5299 * @tc.type : Function 5300 * @tc.level : Level 3 5301 */ 5302 it('testReleaseInterfaceParamErr006', 0, function () { 5303 console.info(TAG, 'usb testReleaseInterfaceParamErr006 begin'); 5304 if (!isDeviceConnected) { 5305 expect(isDeviceConnected).assertFalse(); 5306 return 5307 } 5308 try { 5309 let tmpInterface = devices.configs[0].interfaces[0]; 5310 let ret = usbManager.releaseInterface(PARAM_UNDEFINED, tmpInterface); 5311 console.info(TAG, 'usb [pipe:undefined] releaseInterface ret : ', ret); 5312 expect(ret !== null).assertFalse(); 5313 } catch (err) { 5314 console.info(TAG, 'testReleaseInterfaceParamErr006 catch err code: ', err.code, ', message: ', err.message); 5315 expect(err.code).assertEqual(PARAM_ERRCODE); 5316 } 5317 }) 5318 5319 /** 5320 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1220 5321 * @tc.name : testReleaseInterfaceParamErr007 5322 * @tc.desc : Negative test: pipe is "" 5323 * @tc.size : MediumTest 5324 * @tc.type : Function 5325 * @tc.level : Level 3 5326 */ 5327 it('testReleaseInterfaceParamErr007', 0, function () { 5328 console.info(TAG, 'usb testReleaseInterfaceParamErr007 begin'); 5329 if (!isDeviceConnected) { 5330 expect(isDeviceConnected).assertFalse(); 5331 return 5332 } 5333 try { 5334 let tmpInterface = devices.configs[0].interfaces[0]; 5335 let ret = usbManager.releaseInterface(PARAM_NULLSTRING, tmpInterface); 5336 console.info(TAG, 'usb [pipe:""] releaseInterface ret : ', ret); 5337 expect(ret !== null).assertFalse(); 5338 } catch (err) { 5339 console.info(TAG, 'testReleaseInterfaceParamErr007 catch err code: ', err.code, ', message: ', err.message); 5340 expect(err.code).assertEqual(PARAM_ERRCODE); 5341 } 5342 }) 5343 5344 /** 5345 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1230 5346 * @tc.name : testReleaseInterfaceParamErr008 5347 * @tc.desc : Negative test: interface is null 5348 * @tc.size : MediumTest 5349 * @tc.type : Function 5350 * @tc.level : Level 3 5351 */ 5352 it('testReleaseInterfaceParamErr008', 0, function () { 5353 console.info(TAG, 'usb testReleaseInterfaceParamErr008 begin'); 5354 if (!isDeviceConnected) { 5355 expect(isDeviceConnected).assertFalse(); 5356 return 5357 } 5358 try { 5359 gPipe.busNum = devices.busNum; 5360 gPipe.devAddress = devices.devAddress; 5361 let ret = usbManager.releaseInterface(gPipe, PARAM_NULL); 5362 console.info(TAG, 'usb [interface:null] releaseInterface ret : ', ret); 5363 expect(ret !== null).assertFalse(); 5364 } catch (err) { 5365 console.info(TAG, 'testReleaseInterfaceParamErr008 catch err code: ', err.code, ', message: ', err.message); 5366 expect(err.code).assertEqual(PARAM_ERRCODE); 5367 } 5368 }) 5369 5370 /** 5371 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1240 5372 * @tc.name : testReleaseInterfaceParamErr009 5373 * @tc.desc : Negative test: interface is undefined 5374 * @tc.size : MediumTest 5375 * @tc.type : Function 5376 * @tc.level : Level 3 5377 */ 5378 it('testReleaseInterfaceParamErr009', 0, function () { 5379 console.info(TAG, 'usb testReleaseInterfaceParamErr009 begin'); 5380 if (!isDeviceConnected) { 5381 expect(isDeviceConnected).assertFalse(); 5382 return 5383 } 5384 try { 5385 gPipe.busNum = devices.busNum; 5386 gPipe.devAddress = devices.devAddress; 5387 let ret = usbManager.releaseInterface(gPipe, PARAM_UNDEFINED); 5388 console.info(TAG, 'usb [interface:undefined] releaseInterface ret : ', ret); 5389 expect(ret !== null).assertFalse(); 5390 } catch (err) { 5391 console.info(TAG, 'testReleaseInterfaceParamErr009 catch err code: ', err.code, ', message: ', err.message); 5392 expect(err.code).assertEqual(PARAM_ERRCODE); 5393 } 5394 }) 5395 5396 /** 5397 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1250 5398 * @tc.name : testReleaseInterfaceParamErr010 5399 * @tc.desc : Negative test: interface is "" 5400 * @tc.size : MediumTest 5401 * @tc.type : Function 5402 * @tc.level : Level 3 5403 */ 5404 it('testReleaseInterfaceParamErr010', 0, function () { 5405 console.info(TAG, 'usb testReleaseInterfaceParamErr010 begin'); 5406 if (!isDeviceConnected) { 5407 expect(isDeviceConnected).assertFalse(); 5408 return 5409 } 5410 try { 5411 gPipe.busNum = devices.busNum; 5412 gPipe.devAddress = devices.devAddress; 5413 let ret = usbManager.releaseInterface(gPipe, PARAM_NULLSTRING); 5414 console.info(TAG, 'usb [interface:""] releaseInterface ret : ', ret); 5415 expect(ret !== null).assertFalse(); 5416 } catch (err) { 5417 console.info(TAG, 'testReleaseInterfaceParamErr010 catch err code: ', err.code, ', message: ', err.message); 5418 expect(err.code).assertEqual(PARAM_ERRCODE); 5419 } 5420 }) 5421 5422 /** 5423 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1260 5424 * @tc.name : testReleaseInterfaceParamErr011 5425 * @tc.desc : Negative test: pipe busNum is null 5426 * @tc.size : MediumTest 5427 * @tc.type : Function 5428 * @tc.level : Level 3 5429 */ 5430 it('testReleaseInterfaceParamErr011', 0, function () { 5431 console.info(TAG, 'usb testReleaseInterfaceParamErr011 begin'); 5432 if (!isDeviceConnected) { 5433 expect(isDeviceConnected).assertFalse(); 5434 return 5435 } 5436 try { 5437 gPipe.busNum = PARAM_NULL; 5438 gPipe.devAddress = devices.devAddress; 5439 let tmpInterface = devices.configs[0].interfaces[0]; 5440 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5441 console.info(TAG, 'usb [busNum:null] releaseInterface ret : ', ret); 5442 expect(ret !== null).assertFalse(); 5443 } catch (err) { 5444 console.info(TAG, 'testReleaseInterfaceParamErr011 catch err code: ', err.code, ', message: ', err.message); 5445 expect(err.code).assertEqual(PARAM_ERRCODE); 5446 } 5447 }) 5448 5449 /** 5450 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1270 5451 * @tc.name : testReleaseInterfaceParamErr012 5452 * @tc.desc : Negative test: pipe busNum is undefined 5453 * @tc.size : MediumTest 5454 * @tc.type : Function 5455 * @tc.level : Level 3 5456 */ 5457 it('testReleaseInterfaceParamErr012', 0, function () { 5458 console.info(TAG, 'usb testReleaseInterfaceParamErr012 begin'); 5459 if (!isDeviceConnected) { 5460 expect(isDeviceConnected).assertFalse(); 5461 return 5462 } 5463 try { 5464 gPipe.busNum = PARAM_UNDEFINED; 5465 gPipe.devAddress = devices.devAddress; 5466 let tmpInterface = devices.configs[0].interfaces[0]; 5467 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5468 console.info(TAG, 'usb [busNum:undefined] releaseInterface ret : ', ret); 5469 expect(ret !== null).assertFalse(); 5470 } catch (err) { 5471 console.info(TAG, 'testReleaseInterfaceParamErr012 catch err code: ', err.code, ', message: ', err.message); 5472 expect(err.code).assertEqual(PARAM_ERRCODE); 5473 } 5474 }) 5475 5476 /** 5477 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1280 5478 * @tc.name : testReleaseInterfaceParamErr013 5479 * @tc.desc : Negative test: pipe busNum is "" 5480 * @tc.size : MediumTest 5481 * @tc.type : Function 5482 * @tc.level : Level 3 5483 */ 5484 it('testReleaseInterfaceParamErr013', 0, function () { 5485 console.info(TAG, 'usb testReleaseInterfaceParamErr013 begin'); 5486 if (!isDeviceConnected) { 5487 expect(isDeviceConnected).assertFalse(); 5488 return 5489 } 5490 try { 5491 gPipe.busNum = PARAM_NULLSTRING; 5492 gPipe.devAddress = devices.devAddress; 5493 let tmpInterface = devices.configs[0].interfaces[0]; 5494 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5495 console.info(TAG, 'usb [busNum:""] releaseInterface ret : ', ret); 5496 expect(ret !== null).assertFalse(); 5497 } catch (err) { 5498 console.info(TAG, 'testReleaseInterfaceParamErr013 catch err code: ', err.code, ', message: ', err.message); 5499 expect(err.code).assertEqual(PARAM_ERRCODE); 5500 } 5501 }) 5502 5503 /** 5504 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1290 5505 * @tc.name : testReleaseInterfaceParamErr014 5506 * @tc.desc : Negative test: pipe devAddress is null 5507 * @tc.size : MediumTest 5508 * @tc.type : Function 5509 * @tc.level : Level 3 5510 */ 5511 it('testReleaseInterfaceParamErr014', 0, function () { 5512 console.info(TAG, 'usb testReleaseInterfaceParamErr014 begin'); 5513 if (!isDeviceConnected) { 5514 expect(isDeviceConnected).assertFalse(); 5515 return 5516 } 5517 try { 5518 gPipe.busNum = devices.busNum; 5519 gPipe.devAddress = PARAM_NULL; 5520 let tmpInterface = devices.configs[0].interfaces[0]; 5521 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5522 console.info(TAG, 'usb [devAddress:null] releaseInterface ret : ', ret); 5523 expect(ret !== null).assertFalse(); 5524 } catch (err) { 5525 console.info(TAG, 'testReleaseInterfaceParamErr014 catch err code: ', err.code, ', message: ', err.message); 5526 expect(err.code).assertEqual(PARAM_ERRCODE); 5527 } 5528 }) 5529 5530 /** 5531 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1310 5532 * @tc.name : testReleaseInterfaceParamErr015 5533 * @tc.desc : Negative test: pipe devAddress is undefined 5534 * @tc.size : MediumTest 5535 * @tc.type : Function 5536 * @tc.level : Level 3 5537 */ 5538 it('testReleaseInterfaceParamErr015', 0, function () { 5539 console.info(TAG, 'usb testReleaseInterfaceParamErr015 begin'); 5540 if (!isDeviceConnected) { 5541 expect(isDeviceConnected).assertFalse(); 5542 return 5543 } 5544 try { 5545 gPipe.busNum = devices.busNum; 5546 gPipe.devAddress = PARAM_UNDEFINED; 5547 let tmpInterface = devices.configs[0].interfaces[0]; 5548 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5549 console.info(TAG, 'usb [devAddress:undefined] releaseInterface ret : ', ret); 5550 expect(ret !== null).assertFalse(); 5551 } catch (err) { 5552 console.info(TAG, 'testReleaseInterfaceParamErr015 catch err code: ', err.code, ', message: ', err.message); 5553 expect(err.code).assertEqual(PARAM_ERRCODE); 5554 } 5555 }) 5556 5557 /** 5558 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1320 5559 * @tc.name : testReleaseInterfaceParamErr016 5560 * @tc.desc : Negative test: pipe devAddress is "" 5561 * @tc.size : MediumTest 5562 * @tc.type : Function 5563 * @tc.level : Level 3 5564 */ 5565 it('testReleaseInterfaceParamErr016', 0, function () { 5566 console.info(TAG, 'usb testReleaseInterfaceParamErr016 begin'); 5567 if (!isDeviceConnected) { 5568 expect(isDeviceConnected).assertFalse(); 5569 return 5570 } 5571 try { 5572 gPipe.busNum = devices.busNum; 5573 gPipe.devAddress = PARAM_NULLSTRING; 5574 let tmpInterface = devices.configs[0].interfaces[0]; 5575 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5576 console.info(TAG, 'usb [devAddress:""] releaseInterface ret : ', ret); 5577 expect(ret !== null).assertFalse(); 5578 } catch (err) { 5579 console.info(TAG, 'testReleaseInterfaceParamErr016 catch err code: ', err.code, ', message: ', err.message); 5580 expect(err.code).assertEqual(PARAM_ERRCODE); 5581 } 5582 }) 5583 5584 /** 5585 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1330 5586 * @tc.name : testReleaseInterfaceParamErr017 5587 * @tc.desc : Negative test: interface id is null 5588 * @tc.size : MediumTest 5589 * @tc.type : Function 5590 * @tc.level : Level 3 5591 */ 5592 it('testReleaseInterfaceParamErr017', 0, function () { 5593 console.info(TAG, 'usb testReleaseInterfaceParamErr017 begin'); 5594 if (!isDeviceConnected) { 5595 expect(isDeviceConnected).assertFalse(); 5596 return 5597 } 5598 try { 5599 gPipe.busNum = devices.busNum; 5600 gPipe.devAddress = devices.devAddress; 5601 let tmpInterface = devices.configs[0].interfaces[0]; 5602 tmpInterface.id = PARAM_NULL; 5603 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5604 console.info(TAG, 'usb [interface.id:null] releaseInterface ret : ', ret); 5605 expect(ret !== null).assertFalse(); 5606 } catch (err) { 5607 console.info(TAG, 'testReleaseInterfaceParamErr017 catch err code: ', err.code, ', message: ', err.message); 5608 expect(err.code).assertEqual(PARAM_ERRCODE); 5609 } 5610 }) 5611 5612 /** 5613 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1340 5614 * @tc.name : testReleaseInterfaceParamErr018 5615 * @tc.desc : Negative test: interface id is undefined 5616 * @tc.size : MediumTest 5617 * @tc.type : Function 5618 * @tc.level : Level 3 5619 */ 5620 it('testReleaseInterfaceParamErr018', 0, function () { 5621 console.info(TAG, 'usb testReleaseInterfaceParamErr018 begin'); 5622 if (!isDeviceConnected) { 5623 expect(isDeviceConnected).assertFalse(); 5624 return 5625 } 5626 try { 5627 gPipe.busNum = devices.busNum; 5628 gPipe.devAddress = devices.devAddress; 5629 let tmpInterface = devices.configs[0].interfaces[0]; 5630 tmpInterface.id = PARAM_UNDEFINED; 5631 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5632 console.info(TAG, 'usb [interface.id:undefined] releaseInterface ret : ', ret); 5633 expect(ret !== null).assertFalse(); 5634 } catch (err) { 5635 console.info(TAG, 'testReleaseInterfaceParamErr018 catch err code: ', err.code, ', message: ', err.message); 5636 expect(err.code).assertEqual(PARAM_ERRCODE); 5637 } 5638 }) 5639 5640 /** 5641 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1350 5642 * @tc.name : testReleaseInterfaceParamErr019 5643 * @tc.desc : Negative test: interface id is "" 5644 * @tc.size : MediumTest 5645 * @tc.type : Function 5646 * @tc.level : Level 3 5647 */ 5648 it('testReleaseInterfaceParamErr019', 0, function () { 5649 console.info(TAG, 'usb testReleaseInterfaceParamErr019 begin'); 5650 if (!isDeviceConnected) { 5651 expect(isDeviceConnected).assertFalse(); 5652 return 5653 } 5654 try { 5655 gPipe.busNum = devices.busNum; 5656 gPipe.devAddress = devices.devAddress; 5657 let tmpInterface = devices.configs[0].interfaces[0]; 5658 tmpInterface.id = PARAM_NULLSTRING; 5659 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5660 console.info(TAG, 'usb [interface.id:""] releaseInterface ret : ', ret); 5661 expect(ret !== null).assertFalse(); 5662 } catch (err) { 5663 console.info(TAG, 'testReleaseInterfaceParamErr019 catch err code: ', err.code, ', message: ', err.message); 5664 expect(err.code).assertEqual(PARAM_ERRCODE); 5665 } 5666 }) 5667 5668 /** 5669 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1360 5670 * @tc.name : testReleaseInterfaceParamErr020 5671 * @tc.desc : Negative test: interface name is null 5672 * @tc.size : MediumTest 5673 * @tc.type : Function 5674 * @tc.level : Level 3 5675 */ 5676 it('testReleaseInterfaceParamErr020', 0, function () { 5677 console.info(TAG, 'usb testReleaseInterfaceParamErr020 begin'); 5678 if (!isDeviceConnected) { 5679 expect(isDeviceConnected).assertFalse(); 5680 return 5681 } 5682 try { 5683 gPipe.busNum = devices.busNum; 5684 gPipe.devAddress = devices.devAddress; 5685 let tmpInterface = devices.configs[0].interfaces[0]; 5686 tmpInterface.name = PARAM_NULL; 5687 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5688 console.info(TAG, 'usb [interface.name:null] releaseInterface ret : ', ret); 5689 expect(ret !== null).assertFalse(); 5690 } catch (err) { 5691 console.info(TAG, 'testReleaseInterfaceParamErr020 catch err code: ', err.code, ', message: ', err.message); 5692 expect(err.code).assertEqual(PARAM_ERRCODE); 5693 } 5694 }) 5695 5696 /** 5697 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1370 5698 * @tc.name : testReleaseInterfaceParamErr021 5699 * @tc.desc : Negative test: interface name is undefined 5700 * @tc.size : MediumTest 5701 * @tc.type : Function 5702 * @tc.level : Level 3 5703 */ 5704 it('testReleaseInterfaceParamErr021', 0, function () { 5705 console.info(TAG, 'usb testReleaseInterfaceParamErr021 begin'); 5706 if (!isDeviceConnected) { 5707 expect(isDeviceConnected).assertFalse(); 5708 return 5709 } 5710 try { 5711 gPipe.busNum = devices.busNum; 5712 gPipe.devAddress = devices.devAddress; 5713 let tmpInterface = devices.configs[0].interfaces[0]; 5714 tmpInterface.name = PARAM_UNDEFINED; 5715 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5716 console.info(TAG, 'usb [interface.name:undefined] releaseInterface ret : ', ret); 5717 expect(ret !== null).assertFalse(); 5718 } catch (err) { 5719 console.info(TAG, 'testReleaseInterfaceParamErr021 catch err code: ', err.code, ', message: ', err.message); 5720 expect(err.code).assertEqual(PARAM_ERRCODE); 5721 } 5722 }) 5723 5724 /** 5725 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1380 5726 * @tc.name : testReleaseInterfaceParamErr022 5727 * @tc.desc : Negative test: interface name is 123 5728 * @tc.size : MediumTest 5729 * @tc.type : Function 5730 * @tc.level : Level 3 5731 */ 5732 it('testReleaseInterfaceParamErr022', 0, function () { 5733 console.info(TAG, 'usb testReleaseInterfaceParamErr022 begin'); 5734 if (!isDeviceConnected) { 5735 expect(isDeviceConnected).assertFalse(); 5736 return 5737 } 5738 try { 5739 gPipe.busNum = devices.busNum; 5740 gPipe.devAddress = devices.devAddress; 5741 let tmpInterface = devices.configs[0].interfaces[0]; 5742 tmpInterface.name = PARAM_NUMBERTYPE; 5743 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5744 console.info(TAG, 'usb [name:123] releaseInterface ret : ', ret); 5745 expect(ret !== null).assertFalse(); 5746 } catch (err) { 5747 console.info(TAG, 'testReleaseInterfaceParamErr022 catch err code: ', err.code, ', message: ', err.message); 5748 expect(err.code).assertEqual(PARAM_ERRCODE); 5749 } 5750 }) 5751 5752 /** 5753 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1390 5754 * @tc.name : testReleaseInterfaceParamErr023 5755 * @tc.desc : Negative test: interface protocol is null 5756 * @tc.size : MediumTest 5757 * @tc.type : Function 5758 * @tc.level : Level 3 5759 */ 5760 it('testReleaseInterfaceParamErr023', 0, function () { 5761 console.info(TAG, 'usb testReleaseInterfaceParamErr023 begin'); 5762 if (!isDeviceConnected) { 5763 expect(isDeviceConnected).assertFalse(); 5764 return 5765 } 5766 try { 5767 gPipe.busNum = devices.busNum; 5768 gPipe.devAddress = devices.devAddress; 5769 let tmpInterface = devices.configs[0].interfaces[0]; 5770 tmpInterface.protocol = PARAM_NULL; 5771 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5772 console.info(TAG, 'usb [interface.protocol:null] releaseInterface ret : ', ret); 5773 expect(ret !== null).assertFalse(); 5774 } catch (err) { 5775 console.info(TAG, 'testReleaseInterfaceParamErr023 catch err code: ', err.code, ', message: ', err.message); 5776 expect(err.code).assertEqual(PARAM_ERRCODE); 5777 } 5778 }) 5779 5780 /** 5781 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1410 5782 * @tc.name : testReleaseInterfaceParamErr024 5783 * @tc.desc : Negative test: interface protocol is undefined 5784 * @tc.size : MediumTest 5785 * @tc.type : Function 5786 * @tc.level : Level 3 5787 */ 5788 it('testReleaseInterfaceParamErr024', 0, function () { 5789 console.info(TAG, 'usb testReleaseInterfaceParamErr024 begin'); 5790 if (!isDeviceConnected) { 5791 expect(isDeviceConnected).assertFalse(); 5792 return 5793 } 5794 try { 5795 gPipe.busNum = devices.busNum; 5796 gPipe.devAddress = devices.devAddress; 5797 let tmpInterface = devices.configs[0].interfaces[0]; 5798 tmpInterface.protocol = PARAM_UNDEFINED; 5799 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5800 console.info(TAG, 'usb [interface.protocol:undefined] releaseInterface ret : ', ret); 5801 expect(ret !== null).assertFalse(); 5802 } catch (err) { 5803 console.info(TAG, 'testReleaseInterfaceParamErr024 catch err code: ', err.code, ', message: ', err.message); 5804 expect(err.code).assertEqual(PARAM_ERRCODE); 5805 } 5806 }) 5807 5808 /** 5809 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1420 5810 * @tc.name : testReleaseInterfaceParamErr025 5811 * @tc.desc : Negative test: interface protocol is "" 5812 * @tc.size : MediumTest 5813 * @tc.type : Function 5814 * @tc.level : Level 3 5815 */ 5816 it('testReleaseInterfaceParamErr025', 0, function () { 5817 console.info(TAG, 'usb testReleaseInterfaceParamErr025 begin'); 5818 if (!isDeviceConnected) { 5819 expect(isDeviceConnected).assertFalse(); 5820 return 5821 } 5822 try { 5823 gPipe.busNum = devices.busNum; 5824 gPipe.devAddress = devices.devAddress; 5825 let tmpInterface = devices.configs[0].interfaces[0]; 5826 tmpInterface.protocol = PARAM_NULLSTRING; 5827 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5828 console.info(TAG, 'usb [interface.protocol:""] releaseInterface ret : ', ret); 5829 expect(ret !== null).assertFalse(); 5830 } catch (err) { 5831 console.info(TAG, 'testReleaseInterfaceParamErr025 catch err code: ', err.code, ', message: ', err.message); 5832 expect(err.code).assertEqual(PARAM_ERRCODE); 5833 } 5834 }) 5835 5836 /** 5837 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1430 5838 * @tc.name : testReleaseInterfaceParamErr026 5839 * @tc.desc : Negative test: interface clazz is null 5840 * @tc.size : MediumTest 5841 * @tc.type : Function 5842 * @tc.level : Level 3 5843 */ 5844 it('testReleaseInterfaceParamErr026', 0, function () { 5845 console.info(TAG, 'usb testReleaseInterfaceParamErr026 begin'); 5846 if (!isDeviceConnected) { 5847 expect(isDeviceConnected).assertFalse(); 5848 return 5849 } 5850 try { 5851 gPipe.busNum = devices.busNum; 5852 gPipe.devAddress = devices.devAddress; 5853 let tmpInterface = devices.configs[0].interfaces[0]; 5854 tmpInterface.clazz = PARAM_NULL; 5855 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5856 console.info(TAG, 'usb [interface.clazz:null] releaseInterface ret : ', ret); 5857 expect(ret !== null).assertFalse(); 5858 } catch (err) { 5859 console.info(TAG, 'testReleaseInterfaceParamErr026 catch err code: ', err.code, ', message: ', err.message); 5860 expect(err.code).assertEqual(PARAM_ERRCODE); 5861 } 5862 }) 5863 5864 /** 5865 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1440 5866 * @tc.name : testReleaseInterfaceParamErr027 5867 * @tc.desc : Negative test: interface clazz is undefined 5868 * @tc.size : MediumTest 5869 * @tc.type : Function 5870 * @tc.level : Level 3 5871 */ 5872 it('testReleaseInterfaceParamErr027', 0, function () { 5873 console.info(TAG, 'usb testReleaseInterfaceParamErr027 begin'); 5874 if (!isDeviceConnected) { 5875 expect(isDeviceConnected).assertFalse(); 5876 return 5877 } 5878 try { 5879 gPipe.busNum = devices.busNum; 5880 gPipe.devAddress = devices.devAddress; 5881 let tmpInterface = devices.configs[0].interfaces[0]; 5882 tmpInterface.clazz = PARAM_UNDEFINED; 5883 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5884 console.info(TAG, 'usb [interface.clazz:undefined] releaseInterface ret : ', ret); 5885 expect(ret !== null).assertFalse(); 5886 } catch (err) { 5887 console.info(TAG, 'testReleaseInterfaceParamErr027 catch err code: ', err.code, ', message: ', err.message); 5888 expect(err.code).assertEqual(PARAM_ERRCODE); 5889 } 5890 }) 5891 5892 /** 5893 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1450 5894 * @tc.name : testReleaseInterfaceParamErr028 5895 * @tc.desc : Negative test: interface clazz is "" 5896 * @tc.size : MediumTest 5897 * @tc.type : Function 5898 * @tc.level : Level 3 5899 */ 5900 it('testReleaseInterfaceParamErr028', 0, function () { 5901 console.info(TAG, 'usb testReleaseInterfaceParamErr028 begin'); 5902 if (!isDeviceConnected) { 5903 expect(isDeviceConnected).assertFalse(); 5904 return 5905 } 5906 try { 5907 gPipe.busNum = devices.busNum; 5908 gPipe.devAddress = devices.devAddress; 5909 let tmpInterface = devices.configs[0].interfaces[0]; 5910 tmpInterface.clazz = PARAM_NULLSTRING; 5911 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5912 console.info(TAG, 'usb [interface.clazz:""] releaseInterface ret : ', ret); 5913 expect(ret !== null).assertFalse(); 5914 } catch (err) { 5915 console.info(TAG, 'testReleaseInterfaceParamErr028 catch err code: ', err.code, ', message: ', err.message); 5916 expect(err.code).assertEqual(PARAM_ERRCODE); 5917 } 5918 }) 5919 5920 /** 5921 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1460 5922 * @tc.name : testReleaseInterfaceParamErr029 5923 * @tc.desc : Negative test: interface subClass is null 5924 * @tc.size : MediumTest 5925 * @tc.type : Function 5926 * @tc.level : Level 3 5927 */ 5928 it('testReleaseInterfaceParamErr029', 0, function () { 5929 console.info(TAG, 'usb testReleaseInterfaceParamErr029 begin'); 5930 if (!isDeviceConnected) { 5931 expect(isDeviceConnected).assertFalse(); 5932 return 5933 } 5934 try { 5935 gPipe.busNum = devices.busNum; 5936 gPipe.devAddress = devices.devAddress; 5937 let tmpInterface = devices.configs[0].interfaces[0]; 5938 tmpInterface.subClass = PARAM_NULL; 5939 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5940 console.info(TAG, 'usb [interface.subClass:null] releaseInterface ret : ', ret); 5941 expect(ret !== null).assertFalse(); 5942 } catch (err) { 5943 console.info(TAG, 'testReleaseInterfaceParamErr029 catch err code: ', err.code, ', message: ', err.message); 5944 expect(err.code).assertEqual(PARAM_ERRCODE); 5945 } 5946 }) 5947 5948 /** 5949 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1470 5950 * @tc.name : testReleaseInterfaceParamErr030 5951 * @tc.desc : Negative test: interface subClass is undefined 5952 * @tc.size : MediumTest 5953 * @tc.type : Function 5954 * @tc.level : Level 3 5955 */ 5956 it('testReleaseInterfaceParamErr030', 0, function () { 5957 console.info(TAG, 'usb testReleaseInterfaceParamErr030 begin'); 5958 if (!isDeviceConnected) { 5959 expect(isDeviceConnected).assertFalse(); 5960 return 5961 } 5962 try { 5963 gPipe.busNum = devices.busNum; 5964 gPipe.devAddress = devices.devAddress; 5965 let tmpInterface = devices.configs[0].interfaces[0]; 5966 tmpInterface.subClass = PARAM_UNDEFINED; 5967 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5968 console.info(TAG, 'usb [interface.subClass:undefined] releaseInterface ret : ', ret); 5969 expect(ret !== null).assertFalse(); 5970 } catch (err) { 5971 console.info(TAG, 'testReleaseInterfaceParamErr030 catch err code: ', err.code, ', message: ', err.message); 5972 expect(err.code).assertEqual(PARAM_ERRCODE); 5973 } 5974 }) 5975 5976 /** 5977 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1480 5978 * @tc.name : testReleaseInterfaceParamErr031 5979 * @tc.desc : Negative test: interface subClass is "" 5980 * @tc.size : MediumTest 5981 * @tc.type : Function 5982 * @tc.level : Level 3 5983 */ 5984 it('testReleaseInterfaceParamErr031', 0, function () { 5985 console.info(TAG, 'usb testReleaseInterfaceParamErr031 begin'); 5986 if (!isDeviceConnected) { 5987 expect(isDeviceConnected).assertFalse(); 5988 return 5989 } 5990 try { 5991 gPipe.busNum = devices.busNum; 5992 gPipe.devAddress = devices.devAddress; 5993 let tmpInterface = devices.configs[0].interfaces[0]; 5994 tmpInterface.subClass = PARAM_NULLSTRING; 5995 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 5996 console.info(TAG, 'usb [interface.subClass:""] releaseInterface ret : ', ret); 5997 expect(ret !== null).assertFalse(); 5998 } catch (err) { 5999 console.info(TAG, 'testReleaseInterfaceParamErr031 catch err code: ', err.code, ', message: ', err.message); 6000 expect(err.code).assertEqual(PARAM_ERRCODE); 6001 } 6002 }) 6003 6004 /** 6005 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1490 6006 * @tc.name : testReleaseInterfaceParamErr032 6007 * @tc.desc : Negative test: interface alternateSetting is null 6008 * @tc.size : MediumTest 6009 * @tc.type : Function 6010 * @tc.level : Level 3 6011 */ 6012 it('testReleaseInterfaceParamErr032', 0, function () { 6013 console.info(TAG, 'usb testReleaseInterfaceParamErr032 begin'); 6014 if (!isDeviceConnected) { 6015 expect(isDeviceConnected).assertFalse(); 6016 return 6017 } 6018 try { 6019 gPipe.busNum = devices.busNum; 6020 gPipe.devAddress = devices.devAddress; 6021 let tmpInterface = devices.configs[0].interfaces[0]; 6022 tmpInterface.alternateSetting = PARAM_NULL; 6023 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 6024 console.info(TAG, 'usb [interface.alternateSetting:null] releaseInterface ret : ', ret); 6025 expect(ret !== null).assertFalse(); 6026 } catch (err) { 6027 console.info(TAG, 'testReleaseInterfaceParamErr032 catch err code: ', err.code, ', message: ', err.message); 6028 expect(err.code).assertEqual(PARAM_ERRCODE); 6029 } 6030 }) 6031 6032 /** 6033 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1510 6034 * @tc.name : testReleaseInterfaceParamErr033 6035 * @tc.desc : Negative test: interface alternateSetting is undefined 6036 * @tc.size : MediumTest 6037 * @tc.type : Function 6038 * @tc.level : Level 3 6039 */ 6040 it('testReleaseInterfaceParamErr033', 0, function () { 6041 console.info(TAG, 'usb testReleaseInterfaceParamErr033 begin'); 6042 if (!isDeviceConnected) { 6043 expect(isDeviceConnected).assertFalse(); 6044 return 6045 } 6046 try { 6047 gPipe.busNum = devices.busNum; 6048 gPipe.devAddress = devices.devAddress; 6049 let tmpInterface = devices.configs[0].interfaces[0]; 6050 tmpInterface.alternateSetting = PARAM_UNDEFINED; 6051 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 6052 console.info(TAG, 'usb [interface.alternateSetting:undefined] releaseInterface ret : ', ret); 6053 expect(ret !== null).assertFalse(); 6054 } catch (err) { 6055 console.info(TAG, 'testReleaseInterfaceParamErr033 catch err code: ', err.code, ', message: ', err.message); 6056 expect(err.code).assertEqual(PARAM_ERRCODE); 6057 } 6058 }) 6059 6060 /** 6061 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1520 6062 * @tc.name : testReleaseInterfaceParamErr034 6063 * @tc.desc : Negative test: interface alternateSetting is "" 6064 * @tc.size : MediumTest 6065 * @tc.type : Function 6066 * @tc.level : Level 3 6067 */ 6068 it('testReleaseInterfaceParamErr034', 0, function () { 6069 console.info(TAG, 'usb testReleaseInterfaceParamErr034 begin'); 6070 if (!isDeviceConnected) { 6071 expect(isDeviceConnected).assertFalse(); 6072 return 6073 } 6074 try { 6075 gPipe.busNum = devices.busNum; 6076 gPipe.devAddress = devices.devAddress; 6077 let tmpInterface = devices.configs[0].interfaces[0]; 6078 tmpInterface.alternateSetting = PARAM_NULLSTRING; 6079 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 6080 console.info(TAG, 'usb [interface.alternateSetting:""] releaseInterface ret : ', ret); 6081 expect(ret !== null).assertFalse(); 6082 } catch (err) { 6083 console.info(TAG, 'testReleaseInterfaceParamErr034 catch err code: ', err.code, ', message: ', err.message); 6084 expect(err.code).assertEqual(PARAM_ERRCODE); 6085 } 6086 }) 6087 6088 /** 6089 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1530 6090 * @tc.name : testReleaseInterfaceParamErr035 6091 * @tc.desc : Negative test: interface endpoints is null 6092 * @tc.size : MediumTest 6093 * @tc.type : Function 6094 * @tc.level : Level 3 6095 */ 6096 it('testReleaseInterfaceParamErr035', 0, function () { 6097 console.info(TAG, 'usb testReleaseInterfaceParamErr035 begin'); 6098 if (!isDeviceConnected) { 6099 expect(isDeviceConnected).assertFalse(); 6100 return 6101 } 6102 try { 6103 gPipe.busNum = devices.busNum; 6104 gPipe.devAddress = devices.devAddress; 6105 let tmpInterface = devices.configs[0].interfaces[0]; 6106 tmpInterface.endpoints = PARAM_NULL; 6107 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 6108 console.info(TAG, 'usb [interface.endpoints:null] releaseInterface ret : ', ret); 6109 expect(ret !== null).assertFalse(); 6110 } catch (err) { 6111 console.info(TAG, 'testReleaseInterfaceParamErr035 catch err code: ', err.code, ', message: ', err.message); 6112 expect(err.code).assertEqual(PARAM_ERRCODE); 6113 } 6114 }) 6115 6116 /** 6117 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1540 6118 * @tc.name : testReleaseInterfaceParamErr036 6119 * @tc.desc : Negative test: interface endpoints is undefined 6120 * @tc.size : MediumTest 6121 * @tc.type : Function 6122 * @tc.level : Level 3 6123 */ 6124 it('testReleaseInterfaceParamErr036', 0, function () { 6125 console.info(TAG, 'usb testReleaseInterfaceParamErr036 begin'); 6126 if (!isDeviceConnected) { 6127 expect(isDeviceConnected).assertFalse(); 6128 return 6129 } 6130 try { 6131 gPipe.busNum = devices.busNum; 6132 gPipe.devAddress = devices.devAddress; 6133 let tmpInterface = devices.configs[0].interfaces[0]; 6134 tmpInterface.endpoints = PARAM_UNDEFINED; 6135 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 6136 console.info(TAG, 'usb [interface.endpoints:undefined] releaseInterface ret : ', ret); 6137 expect(ret !== null).assertFalse(); 6138 } catch (err) { 6139 console.info(TAG, 'testReleaseInterfaceParamErr036 catch err code: ', err.code, ', message: ', err.message); 6140 expect(err.code).assertEqual(PARAM_ERRCODE); 6141 } 6142 }) 6143 6144 /** 6145 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1550 6146 * @tc.name : testReleaseInterfaceParamErr037 6147 * @tc.desc : Negative test: interface endpoints is "" 6148 * @tc.size : MediumTest 6149 * @tc.type : Function 6150 * @tc.level : Level 3 6151 */ 6152 it('testReleaseInterfaceParamErr037', 0, function () { 6153 console.info(TAG, 'usb testReleaseInterfaceParamErr037 begin'); 6154 if (!isDeviceConnected) { 6155 expect(isDeviceConnected).assertFalse(); 6156 return 6157 } 6158 try { 6159 gPipe.busNum = devices.busNum; 6160 gPipe.devAddress = devices.devAddress; 6161 let tmpInterface = devices.configs[0].interfaces[0]; 6162 tmpInterface.endpoints = PARAM_NULLSTRING; 6163 let ret = usbManager.releaseInterface(gPipe, tmpInterface); 6164 console.info(TAG, 'usb [interface.endpoints:""] releaseInterface ret : ', ret); 6165 expect(ret !== null).assertFalse(); 6166 } catch (err) { 6167 console.info(TAG, 'testReleaseInterfaceParamErr037 catch err code: ', err.code, ', message: ', err.message); 6168 expect(err.code).assertEqual(PARAM_ERRCODE); 6169 } 6170 }) 6171 6172 /** 6173 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1560 6174 * @tc.name : testBulkTransferParamErr001 6175 * @tc.desc : Negative test: Param is null 6176 * @tc.size : MediumTest 6177 * @tc.type : Function 6178 * @tc.level : Level 3 6179 */ 6180 it('testBulkTransferParamErr001', 0, function () { 6181 console.info(TAG, 'usb testBulkTransferParamErr001 begin'); 6182 if (!isDeviceConnected) { 6183 expect(isDeviceConnected).assertFalse(); 6184 return 6185 } 6186 try { 6187 let ret = usbManager.bulkTransfer(PARAM_NULL); 6188 console.info(TAG, 'usb [param:null] bulkTransfer ret : ', ret); 6189 expect(ret !== null).assertFalse(); 6190 } catch (err) { 6191 console.info(TAG, 'testBulkTransferParamErr001 catch err code: ', err.code, ', message: ', err.message); 6192 expect(err.code).assertEqual(PARAM_ERRCODE); 6193 } 6194 }) 6195 6196 /** 6197 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1570 6198 * @tc.name : testBulkTransferParamErr002 6199 * @tc.desc : Negative test: Param is undefined 6200 * @tc.size : MediumTest 6201 * @tc.type : Function 6202 * @tc.level : Level 3 6203 */ 6204 it('testBulkTransferParamErr002', 0, function () { 6205 console.info(TAG, 'usb testBulkTransferParamErr002 begin'); 6206 if (!isDeviceConnected) { 6207 expect(isDeviceConnected).assertFalse(); 6208 return 6209 } 6210 try { 6211 let ret = usbManager.bulkTransfer(PARAM_UNDEFINED); 6212 console.info(TAG, 'usb [param:undefined] bulkTransfer ret : ', ret); 6213 expect(ret !== null).assertFalse(); 6214 } catch (err) { 6215 console.info(TAG, 'testBulkTransferParamErr002 catch err code: ', err.code, ', message: ', err.message); 6216 expect(err.code).assertEqual(PARAM_ERRCODE); 6217 } 6218 }) 6219 6220 /** 6221 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1580 6222 * @tc.name : testBulkTransferParamErr003 6223 * @tc.desc : Negative test: Param is "" 6224 * @tc.size : MediumTest 6225 * @tc.type : Function 6226 * @tc.level : Level 3 6227 */ 6228 it('testBulkTransferParamErr003', 0, function () { 6229 console.info(TAG, 'usb testBulkTransferParamErr003 begin'); 6230 if (!isDeviceConnected) { 6231 expect(isDeviceConnected).assertFalse(); 6232 return 6233 } 6234 try { 6235 let ret = usbManager.bulkTransfer(PARAM_NULLSTRING); 6236 console.info(TAG, 'usb [param:""] bulkTransfer ret : ', ret); 6237 expect(ret !== null).assertFalse(); 6238 } catch (err) { 6239 console.info(TAG, 'testBulkTransferParamErr003 catch err code: ', err.code, ', message: ', err.message); 6240 expect(err.code).assertEqual(PARAM_ERRCODE); 6241 } 6242 }) 6243 6244 /** 6245 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1590 6246 * @tc.name : testBulkTransferParamErr004 6247 * @tc.desc : Negative test: pipe is null 6248 * @tc.size : MediumTest 6249 * @tc.type : Function 6250 * @tc.level : Level 3 6251 */ 6252 it('testBulkTransferParamErr004', 0, function () { 6253 console.info(TAG, 'usb testBulkTransferParamErr004 begin'); 6254 if (!isDeviceConnected) { 6255 expect(isDeviceConnected).assertFalse(); 6256 return 6257 } 6258 try { 6259 let tmpInterface = devices.configs[0].interfaces[0].endpoints[0]; 6260 let buffer = new Uint8Array(128); 6261 let ret = usbManager.bulkTransfer(PARAM_NULL, tmpInterface, buffer); 6262 console.info(TAG, 'usb [pipe:null] bulkTransfer ret : ', ret); 6263 expect(ret !== null).assertFalse(); 6264 } catch (err) { 6265 console.info(TAG, 'testBulkTransferParamErr004 catch err code: ', err.code, ', message: ', err.message); 6266 expect(err.code).assertEqual(PARAM_ERRCODE); 6267 } 6268 }) 6269 6270 /** 6271 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1610 6272 * @tc.name : testBulkTransferParamErr005 6273 * @tc.desc : Negative test: pipe is undefined 6274 * @tc.size : MediumTest 6275 * @tc.type : Function 6276 * @tc.level : Level 3 6277 */ 6278 it('testBulkTransferParamErr005', 0, function () { 6279 console.info(TAG, 'usb testBulkTransferParamErr005 begin'); 6280 if (!isDeviceConnected) { 6281 expect(isDeviceConnected).assertFalse(); 6282 return 6283 } 6284 try { 6285 let tmpInterface = devices.configs[0].interfaces[0].endpoints[0]; 6286 let buffer = new Uint8Array(128); 6287 let ret = usbManager.bulkTransfer(PARAM_UNDEFINED, tmpInterface, buffer); 6288 console.info(TAG, 'usb [pipe:undefined] bulkTransfer ret : ', ret); 6289 expect(ret !== null).assertFalse(); 6290 } catch (err) { 6291 console.info(TAG, 'testBulkTransferParamErr005 catch err code: ', err.code, ', message: ', err.message); 6292 expect(err.code).assertEqual(PARAM_ERRCODE); 6293 } 6294 }) 6295 6296 /** 6297 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1620 6298 * @tc.name : testBulkTransferParamErr006 6299 * @tc.desc : Negative test: pipe is "" 6300 * @tc.size : MediumTest 6301 * @tc.type : Function 6302 * @tc.level : Level 3 6303 */ 6304 it('testBulkTransferParamErr006', 0, function () { 6305 console.info(TAG, 'usb testBulkTransferParamErr006 begin'); 6306 if (!isDeviceConnected) { 6307 expect(isDeviceConnected).assertFalse(); 6308 return 6309 } 6310 try { 6311 let tmpInterface = devices.configs[0].interfaces[0].endpoints[0]; 6312 let buffer = new Uint8Array(128); 6313 let ret = usbManager.bulkTransfer(PARAM_NULLSTRING, tmpInterface, buffer); 6314 console.info(TAG, 'usb [pipe:""] bulkTransfer ret : ', ret); 6315 expect(ret !== null).assertFalse(); 6316 } catch (err) { 6317 console.info(TAG, 'testBulkTransferParamErr006 catch err code: ', err.code, ', message: ', err.message); 6318 expect(err.code).assertEqual(PARAM_ERRCODE); 6319 } 6320 }) 6321 6322 /** 6323 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1630 6324 * @tc.name : testBulkTransferParamErr007 6325 * @tc.desc : Negative test: endpoint is null 6326 * @tc.size : MediumTest 6327 * @tc.type : Function 6328 * @tc.level : Level 3 6329 */ 6330 it('testBulkTransferParamErr007', 0, function () { 6331 console.info(TAG, 'usb testBulkTransferParamErr007 begin'); 6332 if (!isDeviceConnected) { 6333 expect(isDeviceConnected).assertFalse(); 6334 return 6335 } 6336 try { 6337 gPipe.busNum = devices.busNum; 6338 gPipe.devAddress = devices.devAddress; 6339 let buffer = new Uint8Array(128); 6340 let ret = usbManager.bulkTransfer(gPipe, PARAM_NULL, buffer); 6341 console.info(TAG, 'usb [endpoint:null] bulkTransfer ret : ', ret); 6342 expect(ret !== null).assertFalse(); 6343 } catch (err) { 6344 console.info(TAG, 'testBulkTransferParamErr007 catch err code: ', err.code, ', message: ', err.message); 6345 expect(err.code).assertEqual(PARAM_ERRCODE); 6346 } 6347 }) 6348 6349 /** 6350 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1640 6351 * @tc.name : testBulkTransferParamErr008 6352 * @tc.desc : Negative test: endpoint is undefined 6353 * @tc.size : MediumTest 6354 * @tc.type : Function 6355 * @tc.level : Level 3 6356 */ 6357 it('testBulkTransferParamErr008', 0, function () { 6358 console.info(TAG, 'usb testBulkTransferParamErr008 begin'); 6359 if (!isDeviceConnected) { 6360 expect(isDeviceConnected).assertFalse(); 6361 return 6362 } 6363 try { 6364 gPipe.busNum = devices.busNum; 6365 gPipe.devAddress = devices.devAddress; 6366 let buffer = new Uint8Array(128); 6367 let ret = usbManager.bulkTransfer(gPipe, PARAM_UNDEFINED, buffer); 6368 console.info(TAG, 'usb [endpoint:undefined] bulkTransfer ret : ', ret); 6369 expect(ret !== null).assertFalse(); 6370 } catch (err) { 6371 console.info(TAG, 'testBulkTransferParamErr008 catch err code: ', err.code, ', message: ', err.message); 6372 expect(err.code).assertEqual(PARAM_ERRCODE); 6373 } 6374 }) 6375 6376 /** 6377 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1650 6378 * @tc.name : testBulkTransferParamErr009 6379 * @tc.desc : Negative test: endpoint is "" 6380 * @tc.size : MediumTest 6381 * @tc.type : Function 6382 * @tc.level : Level 3 6383 */ 6384 it('testBulkTransferParamErr009', 0, function () { 6385 console.info(TAG, 'usb testBulkTransferParamErr009 begin'); 6386 if (!isDeviceConnected) { 6387 expect(isDeviceConnected).assertFalse(); 6388 return 6389 } 6390 try { 6391 gPipe.busNum = devices.busNum; 6392 gPipe.devAddress = devices.devAddress; 6393 let buffer = new Uint8Array(128); 6394 let ret = usbManager.bulkTransfer(gPipe, PARAM_NULLSTRING, buffer); 6395 console.info(TAG, 'usb [endpoint:""] bulkTransfer ret : ', ret); 6396 expect(ret !== null).assertFalse(); 6397 } catch (err) { 6398 console.info(TAG, 'testBulkTransferParamErr009 catch err code: ', err.code, ', message: ', err.message); 6399 expect(err.code).assertEqual(PARAM_ERRCODE); 6400 } 6401 }) 6402 6403 /** 6404 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1660 6405 * @tc.name : testBulkTransferParamErr010 6406 * @tc.desc : Negative test: buffer is null 6407 * @tc.size : MediumTest 6408 * @tc.type : Function 6409 * @tc.level : Level 3 6410 */ 6411 it('testBulkTransferParamErr010', 0, function () { 6412 console.info(TAG, 'usb testBulkTransferParamErr010 begin'); 6413 if (!isDeviceConnected) { 6414 expect(isDeviceConnected).assertFalse(); 6415 return 6416 } 6417 try { 6418 gPipe.busNum = devices.busNum; 6419 gPipe.devAddress = devices.devAddress; 6420 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6421 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, PARAM_NULL); 6422 console.info(TAG, 'usb [buffer:null] bulkTransfer ret : ', ret); 6423 expect(ret !== null).assertFalse(); 6424 } catch (err) { 6425 console.info(TAG, 'testBulkTransferParamErr010 catch err code: ', err.code, ', message: ', err.message); 6426 expect(err.code).assertEqual(PARAM_ERRCODE); 6427 } 6428 }) 6429 6430 /** 6431 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1670 6432 * @tc.name : testBulkTransferParamErr011 6433 * @tc.desc : Negative test: buffer is undefined 6434 * @tc.size : MediumTest 6435 * @tc.type : Function 6436 * @tc.level : Level 3 6437 */ 6438 it('testBulkTransferParamErr011', 0, function () { 6439 console.info(TAG, 'usb testBulkTransferParamErr011 begin'); 6440 if (!isDeviceConnected) { 6441 expect(isDeviceConnected).assertFalse(); 6442 return 6443 } 6444 try { 6445 gPipe.busNum = devices.busNum; 6446 gPipe.devAddress = devices.devAddress; 6447 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6448 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, PARAM_UNDEFINED); 6449 console.info(TAG, 'usb [buffer:undefined] bulkTransfer ret : ', ret); 6450 expect(ret !== null).assertFalse(); 6451 } catch (err) { 6452 console.info(TAG, 'testBulkTransferParamErr011 catch err code: ', err.code, ', message: ', err.message); 6453 expect(err.code).assertEqual(PARAM_ERRCODE); 6454 } 6455 }) 6456 6457 /** 6458 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1680 6459 * @tc.name : testBulkTransferParamErr012 6460 * @tc.desc : Negative test: buffer is "" 6461 * @tc.size : MediumTest 6462 * @tc.type : Function 6463 * @tc.level : Level 3 6464 */ 6465 it('testBulkTransferParamErr012', 0, function () { 6466 console.info(TAG, 'usb testBulkTransferParamErr012 begin'); 6467 if (!isDeviceConnected) { 6468 expect(isDeviceConnected).assertFalse(); 6469 return 6470 } 6471 try { 6472 gPipe.busNum = devices.busNum; 6473 gPipe.devAddress = devices.devAddress; 6474 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6475 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, PARAM_NULLSTRING); 6476 console.info(TAG, 'usb [buffer:""] bulkTransfer ret : ', ret); 6477 expect(ret !== null).assertFalse(); 6478 } catch (err) { 6479 console.info(TAG, 'testBulkTransferParamErr012 catch err code: ', err.code, ', message: ', err.message); 6480 expect(err.code).assertEqual(PARAM_ERRCODE); 6481 } 6482 }) 6483 6484 /** 6485 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1690 6486 * @tc.name : testBulkTransferParamErr013 6487 * @tc.desc : Negative test: pipe busNum is null 6488 * @tc.size : MediumTest 6489 * @tc.type : Function 6490 * @tc.level : Level 3 6491 */ 6492 it('testBulkTransferParamErr013', 0, function () { 6493 console.info(TAG, 'usb testBulkTransferParamErr013 begin'); 6494 if (!isDeviceConnected) { 6495 expect(isDeviceConnected).assertFalse(); 6496 return 6497 } 6498 try { 6499 gPipe.busNum = PARAM_NULL; 6500 gPipe.devAddress = devices.devAddress; 6501 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6502 let buffer = new Uint8Array(128); 6503 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6504 console.info(TAG, 'usb [busNum:null] bulkTransfer ret : ', ret); 6505 expect(ret !== null).assertFalse(); 6506 } catch (err) { 6507 console.info(TAG, 'testBulkTransferParamErr013 catch err code: ', err.code, ', message: ', err.message); 6508 expect(err.code).assertEqual(PARAM_ERRCODE); 6509 } 6510 }) 6511 6512 /** 6513 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1710 6514 * @tc.name : testBulkTransferParamErr014 6515 * @tc.desc : Negative test: pipe busNum is undefined 6516 * @tc.size : MediumTest 6517 * @tc.type : Function 6518 * @tc.level : Level 3 6519 */ 6520 it('testBulkTransferParamErr014', 0, function () { 6521 console.info(TAG, 'usb testBulkTransferParamErr014 begin'); 6522 if (!isDeviceConnected) { 6523 expect(isDeviceConnected).assertFalse(); 6524 return 6525 } 6526 try { 6527 gPipe.busNum = PARAM_UNDEFINED; 6528 gPipe.devAddress = devices.devAddress; 6529 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6530 let buffer = new Uint8Array(128); 6531 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6532 console.info(TAG, 'usb [busNum:undefined] bulkTransfer ret : ', ret); 6533 expect(ret !== null).assertFalse(); 6534 } catch (err) { 6535 console.info(TAG, 'testBulkTransferParamErr014 catch err code: ', err.code, ', message: ', err.message); 6536 expect(err.code).assertEqual(PARAM_ERRCODE); 6537 } 6538 }) 6539 6540 /** 6541 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1720 6542 * @tc.name : testBulkTransferParamErr015 6543 * @tc.desc : Negative test: pipe busNum is "" 6544 * @tc.size : MediumTest 6545 * @tc.type : Function 6546 * @tc.level : Level 3 6547 */ 6548 it('testBulkTransferParamErr015', 0, function () { 6549 console.info(TAG, 'usb testBulkTransferParamErr015 begin'); 6550 if (!isDeviceConnected) { 6551 expect(isDeviceConnected).assertFalse(); 6552 return 6553 } 6554 try { 6555 gPipe.busNum = PARAM_NULLSTRING; 6556 gPipe.devAddress = devices.devAddress; 6557 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6558 let buffer = new Uint8Array(128); 6559 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6560 console.info(TAG, 'usb [busNum:""] bulkTransfer ret : ', ret); 6561 expect(ret !== null).assertFalse(); 6562 } catch (err) { 6563 console.info(TAG, 'testBulkTransferParamErr015 catch err code: ', err.code, ', message: ', err.message); 6564 expect(err.code).assertEqual(PARAM_ERRCODE); 6565 } 6566 }) 6567 6568 /** 6569 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1730 6570 * @tc.name : testBulkTransferParamErr016 6571 * @tc.desc : Negative test: pipe devAddress is null 6572 * @tc.size : MediumTest 6573 * @tc.type : Function 6574 * @tc.level : Level 3 6575 */ 6576 it('testBulkTransferParamErr016', 0, function () { 6577 console.info(TAG, 'usb testBulkTransferParamErr016 begin'); 6578 if (!isDeviceConnected) { 6579 expect(isDeviceConnected).assertFalse(); 6580 return 6581 } 6582 try { 6583 gPipe.busNum = devices.busNum; 6584 gPipe.devAddress = PARAM_NULL; 6585 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6586 let buffer = new Uint8Array(128); 6587 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6588 console.info(TAG, 'usb [devAddress:null] bulkTransfer ret : ', ret); 6589 expect(ret !== null).assertFalse(); 6590 } catch (err) { 6591 console.info(TAG, 'testBulkTransferParamErr016 catch err code: ', err.code, ', message: ', err.message); 6592 expect(err.code).assertEqual(PARAM_ERRCODE); 6593 } 6594 }) 6595 6596 /** 6597 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1740 6598 * @tc.name : testBulkTransferParamErr017 6599 * @tc.desc : Negative test: pipe devAddress is undefined 6600 * @tc.size : MediumTest 6601 * @tc.type : Function 6602 * @tc.level : Level 3 6603 */ 6604 it('testBulkTransferParamErr017', 0, function () { 6605 console.info(TAG, 'usb testBulkTransferParamErr017 begin'); 6606 if (!isDeviceConnected) { 6607 expect(isDeviceConnected).assertFalse(); 6608 return 6609 } 6610 try { 6611 gPipe.busNum = devices.busNum; 6612 gPipe.devAddress = PARAM_UNDEFINED; 6613 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6614 let buffer = new Uint8Array(128); 6615 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6616 console.info(TAG, 'usb [devAddress:undefined] bulkTransfer ret : ', ret); 6617 expect(ret !== null).assertFalse(); 6618 } catch (err) { 6619 console.info(TAG, 'testBulkTransferParamErr017 catch err code: ', err.code, ', message: ', err.message); 6620 expect(err.code).assertEqual(PARAM_ERRCODE); 6621 } 6622 }) 6623 6624 /** 6625 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1750 6626 * @tc.name : testBulkTransferParamErr018 6627 * @tc.desc : Negative test: pipe devAddress is "" 6628 * @tc.size : MediumTest 6629 * @tc.type : Function 6630 * @tc.level : Level 3 6631 */ 6632 it('testBulkTransferParamErr018', 0, function () { 6633 console.info(TAG, 'usb testBulkTransferParamErr018 begin'); 6634 if (!isDeviceConnected) { 6635 expect(isDeviceConnected).assertFalse(); 6636 return 6637 } 6638 try { 6639 gPipe.busNum = devices.busNum; 6640 gPipe.devAddress = PARAM_NULLSTRING; 6641 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6642 let buffer = new Uint8Array(128); 6643 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6644 console.info(TAG, 'usb [devAddress:""] bulkTransfer ret : ', ret); 6645 expect(ret !== null).assertFalse(); 6646 } catch (err) { 6647 console.info(TAG, 'testBulkTransferParamErr018 catch err code: ', err.code, ', message: ', err.message); 6648 expect(err.code).assertEqual(PARAM_ERRCODE); 6649 } 6650 }) 6651 6652 /** 6653 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1760 6654 * @tc.name : testBulkTransferParamErr019 6655 * @tc.desc : Negative test: endpoint address is null 6656 * @tc.size : MediumTest 6657 * @tc.type : Function 6658 * @tc.level : Level 3 6659 */ 6660 it('testBulkTransferParamErr019', 0, function () { 6661 console.info(TAG, 'usb testBulkTransferParamErr019 begin'); 6662 if (!isDeviceConnected) { 6663 expect(isDeviceConnected).assertFalse(); 6664 return 6665 } 6666 try { 6667 gPipe.busNum = devices.busNum; 6668 gPipe.devAddress = devices.devAddress; 6669 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6670 let buffer = new Uint8Array(128); 6671 tmpEndpoints.address = PARAM_NULL; 6672 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6673 console.info(TAG, 'usb [endpoint.address:null] bulkTransfer ret : ', ret); 6674 expect(ret !== null).assertFalse(); 6675 } catch (err) { 6676 console.info(TAG, 'testBulkTransferParamErr019 catch err code: ', err.code, ', message: ', err.message); 6677 expect(err.code).assertEqual(PARAM_ERRCODE); 6678 } 6679 }) 6680 6681 /** 6682 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1770 6683 * @tc.name : testBulkTransferParamErr020 6684 * @tc.desc : Negative test: endpoint address is undefined 6685 * @tc.size : MediumTest 6686 * @tc.type : Function 6687 * @tc.level : Level 3 6688 */ 6689 it('testBulkTransferParamErr020', 0, function () { 6690 console.info(TAG, 'usb testBulkTransferParamErr020 begin'); 6691 if (!isDeviceConnected) { 6692 expect(isDeviceConnected).assertFalse(); 6693 return 6694 } 6695 try { 6696 gPipe.busNum = devices.busNum; 6697 gPipe.devAddress = devices.devAddress; 6698 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6699 let buffer = new Uint8Array(128); 6700 tmpEndpoints.address = PARAM_UNDEFINED; 6701 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6702 console.info(TAG, 'usb [endpoint.address:undefined] bulkTransfer ret : ', ret); 6703 expect(ret !== null).assertFalse(); 6704 } catch (err) { 6705 console.info(TAG, 'testBulkTransferParamErr020 catch err code: ', err.code, ', message: ', err.message); 6706 expect(err.code).assertEqual(PARAM_ERRCODE); 6707 } 6708 }) 6709 6710 /** 6711 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1780 6712 * @tc.name : testBulkTransferParamErr021 6713 * @tc.desc : Negative test: endpoint address is "" 6714 * @tc.size : MediumTest 6715 * @tc.type : Function 6716 * @tc.level : Level 3 6717 */ 6718 it('testBulkTransferParamErr021', 0, function () { 6719 console.info(TAG, 'usb testBulkTransferParamErr021 begin'); 6720 if (!isDeviceConnected) { 6721 expect(isDeviceConnected).assertFalse(); 6722 return 6723 } 6724 try { 6725 gPipe.busNum = devices.busNum; 6726 gPipe.devAddress = devices.devAddress; 6727 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6728 let buffer = new Uint8Array(128); 6729 tmpEndpoints.address = PARAM_NULLSTRING; 6730 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6731 console.info(TAG, 'usb [endpoint.address:""] bulkTransfer ret : ', ret); 6732 expect(ret !== null).assertFalse(); 6733 } catch (err) { 6734 console.info(TAG, 'testBulkTransferParamErr021 catch err code: ', err.code, ', message: ', err.message); 6735 expect(err.code).assertEqual(PARAM_ERRCODE); 6736 } 6737 }) 6738 6739 /** 6740 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1790 6741 * @tc.name : testBulkTransferParamErr022 6742 * @tc.desc : Negative test: endpoint number is null 6743 * @tc.size : MediumTest 6744 * @tc.type : Function 6745 * @tc.level : Level 3 6746 */ 6747 it('testBulkTransferParamErr022', 0, function () { 6748 console.info(TAG, 'usb testBulkTransferParamErr022 begin'); 6749 if (!isDeviceConnected) { 6750 expect(isDeviceConnected).assertFalse(); 6751 return 6752 } 6753 try { 6754 gPipe.busNum = devices.busNum; 6755 gPipe.devAddress = devices.devAddress; 6756 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6757 let buffer = new Uint8Array(128); 6758 tmpEndpoints.number = PARAM_NULL; 6759 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6760 console.info(TAG, 'usb [endpoint.number:null] bulkTransfer ret : ', JSON.stringify(ret)); 6761 expect(ret !== null).assertFalse(); 6762 } catch (err) { 6763 console.info(TAG, 'testBulkTransferParamErr022 catch err code: ', err.code, ', message: ', err.message); 6764 expect(err.code).assertEqual(PARAM_ERRCODE); 6765 } 6766 }) 6767 6768 /** 6769 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1810 6770 * @tc.name : testBulkTransferParamErr023 6771 * @tc.desc : Negative test: endpoint number is undefined 6772 * @tc.size : MediumTest 6773 * @tc.type : Function 6774 * @tc.level : Level 3 6775 */ 6776 it('testBulkTransferParamErr023', 0, function () { 6777 console.info(TAG, 'usb testBulkTransferParamErr023 begin'); 6778 if (!isDeviceConnected) { 6779 expect(isDeviceConnected).assertFalse(); 6780 return 6781 } 6782 try { 6783 gPipe.busNum = devices.busNum; 6784 gPipe.devAddress = devices.devAddress; 6785 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6786 let buffer = new Uint8Array(128); 6787 tmpEndpoints.number = PARAM_UNDEFINED; 6788 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6789 console.info(TAG, 'usb [endpoint.number:undefined] bulkTransfer ret : ', ret); 6790 expect(ret !== null).assertFalse(); 6791 } catch (err) { 6792 console.info(TAG, 'testBulkTransferParamErr023 catch err code: ', err.code, ', message: ', err.message); 6793 expect(err.code).assertEqual(PARAM_ERRCODE); 6794 } 6795 }) 6796 6797 /** 6798 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1820 6799 * @tc.name : testBulkTransferParamErr024 6800 * @tc.desc : Negative test: endpoint number is "" 6801 * @tc.size : MediumTest 6802 * @tc.type : Function 6803 * @tc.level : Level 3 6804 */ 6805 it('testBulkTransferParamErr024', 0, function () { 6806 console.info(TAG, 'usb testBulkTransferParamErr024 begin'); 6807 if (!isDeviceConnected) { 6808 expect(isDeviceConnected).assertFalse(); 6809 return 6810 } 6811 try { 6812 gPipe.busNum = devices.busNum; 6813 gPipe.devAddress = devices.devAddress; 6814 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6815 let buffer = new Uint8Array(128); 6816 tmpEndpoints.number = PARAM_NULLSTRING; 6817 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6818 console.info(TAG, 'usb [endpoint.number:""] bulkTransfer ret : ', ret); 6819 expect(ret !== null).assertFalse(); 6820 } catch (err) { 6821 console.info(TAG, 'testBulkTransferParamErr024 catch err code: ', err.code, ', message: ', err.message); 6822 expect(err.code).assertEqual(PARAM_ERRCODE); 6823 } 6824 }) 6825 6826 /** 6827 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1830 6828 * @tc.name : testBulkTransferParamErr025 6829 * @tc.desc : Negative test: endpoint type is null 6830 * @tc.size : MediumTest 6831 * @tc.type : Function 6832 * @tc.level : Level 3 6833 */ 6834 it('testBulkTransferParamErr025', 0, function () { 6835 console.info(TAG, 'usb testBulkTransferParamErr025 begin'); 6836 if (!isDeviceConnected) { 6837 expect(isDeviceConnected).assertFalse(); 6838 return 6839 } 6840 try { 6841 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6842 let buffer = new Uint8Array(128); 6843 tmpEndpoints.type = PARAM_NULL; 6844 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6845 console.info(TAG, 'usb [endpoint.type:null] bulkTransfer ret : ', ret); 6846 expect(ret !== null).assertFalse(); 6847 } catch (err) { 6848 console.info(TAG, 'testBulkTransferParamErr025 catch err code: ', err.code, ', message: ', err.message); 6849 expect(err.code).assertEqual(PARAM_ERRCODE); 6850 } 6851 }) 6852 6853 /** 6854 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1840 6855 * @tc.name : testBulkTransferParamErr026 6856 * @tc.desc : Negative test: endpoint type is undefined 6857 * @tc.size : MediumTest 6858 * @tc.type : Function 6859 * @tc.level : Level 3 6860 */ 6861 it('testBulkTransferParamErr026', 0, function () { 6862 console.info(TAG, 'usb testBulkTransferParamErr026 begin'); 6863 if (!isDeviceConnected) { 6864 expect(isDeviceConnected).assertFalse(); 6865 return 6866 } 6867 try { 6868 gPipe.busNum = devices.busNum; 6869 gPipe.devAddress = devices.devAddress; 6870 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6871 let buffer = new Uint8Array(128); 6872 tmpEndpoints.type = PARAM_UNDEFINED; 6873 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6874 console.info(TAG, 'usb [endpoint.type:undefined] bulkTransfer ret : ', ret); 6875 expect(ret !== null).assertFalse(); 6876 } catch (err) { 6877 console.info(TAG, 'testBulkTransferParamErr026 catch err code: ', err.code, ', message: ', err.message); 6878 expect(err.code).assertEqual(PARAM_ERRCODE); 6879 } 6880 }) 6881 6882 /** 6883 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1850 6884 * @tc.name : testBulkTransferParamErr027 6885 * @tc.desc : Negative test: endpoint type is "" 6886 * @tc.size : MediumTest 6887 * @tc.type : Function 6888 * @tc.level : Level 3 6889 */ 6890 it('testBulkTransferParamErr027', 0, function () { 6891 console.info(TAG, 'usb testBulkTransferParamErr027 begin'); 6892 if (!isDeviceConnected) { 6893 expect(isDeviceConnected).assertFalse(); 6894 return 6895 } 6896 try { 6897 gPipe.busNum = devices.busNum; 6898 gPipe.devAddress = devices.devAddress; 6899 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6900 let buffer = new Uint8Array(128); 6901 tmpEndpoints.type = PARAM_NULLSTRING; 6902 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6903 console.info(TAG, 'usb [endpoint.type:""] bulkTransfer ret : ', ret); 6904 expect(ret !== null).assertFalse(); 6905 } catch (err) { 6906 console.info(TAG, 'testBulkTransferParamErr027 catch err code: ', err.code, ', message: ', err.message); 6907 expect(err.code).assertEqual(PARAM_ERRCODE); 6908 } 6909 }) 6910 6911 /** 6912 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1860 6913 * @tc.name : testBulkTransferParamErr028 6914 * @tc.desc : Negative test: endpoint attributes is null 6915 * @tc.size : MediumTest 6916 * @tc.type : Function 6917 * @tc.level : Level 3 6918 */ 6919 it('testBulkTransferParamErr028', 0, function () { 6920 console.info(TAG, 'usb testBulkTransferParamErr028 begin'); 6921 if (!isDeviceConnected) { 6922 expect(isDeviceConnected).assertFalse(); 6923 return 6924 } 6925 try { 6926 gPipe.busNum = devices.busNum; 6927 gPipe.devAddress = devices.devAddress; 6928 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6929 let buffer = new Uint8Array(128); 6930 tmpEndpoints.attributes = PARAM_NULL; 6931 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6932 console.info(TAG, 'usb [endpoint.attributes:null] bulkTransfer ret : ', ret); 6933 expect(ret !== null).assertFalse(); 6934 } catch (err) { 6935 console.info(TAG, 'testBulkTransferParamErr028 catch err code: ', err.code, ', message: ', err.message); 6936 expect(err.code).assertEqual(PARAM_ERRCODE); 6937 } 6938 }) 6939 6940 /** 6941 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1870 6942 * @tc.name : testBulkTransferParamErr029 6943 * @tc.desc : Negative test: endpoint attributes is undefined 6944 * @tc.size : MediumTest 6945 * @tc.type : Function 6946 * @tc.level : Level 3 6947 */ 6948 it('testBulkTransferParamErr029', 0, function () { 6949 console.info(TAG, 'usb testBulkTransferParamErr029 begin'); 6950 if (!isDeviceConnected) { 6951 expect(isDeviceConnected).assertFalse(); 6952 return 6953 } 6954 try { 6955 gPipe.busNum = devices.busNum; 6956 gPipe.devAddress = devices.devAddress; 6957 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6958 let buffer = new Uint8Array(128); 6959 tmpEndpoints.attributes = PARAM_UNDEFINED; 6960 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6961 console.info(TAG, 'usb [endpoint.attributes:undefined] bulkTransfer ret : ', ret); 6962 expect(ret !== null).assertFalse(); 6963 } catch (err) { 6964 console.info(TAG, 'testBulkTransferParamErr029 catch err code: ', err.code, ', message: ', err.message); 6965 expect(err.code).assertEqual(PARAM_ERRCODE); 6966 } 6967 }) 6968 6969 /** 6970 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1880 6971 * @tc.name : testBulkTransferParamErr030 6972 * @tc.desc : Negative test: endpoint attributes is "" 6973 * @tc.size : MediumTest 6974 * @tc.type : Function 6975 * @tc.level : Level 3 6976 */ 6977 it('testBulkTransferParamErr030', 0, function () { 6978 console.info(TAG, 'usb testBulkTransferParamErr030 begin'); 6979 if (!isDeviceConnected) { 6980 expect(isDeviceConnected).assertFalse(); 6981 return 6982 } 6983 try { 6984 gPipe.busNum = devices.busNum; 6985 gPipe.devAddress = devices.devAddress; 6986 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 6987 let buffer = new Uint8Array(128); 6988 tmpEndpoints.attributes = PARAM_NULLSTRING; 6989 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 6990 console.info(TAG, 'usb [endpoint.attributes:""] bulkTransfer ret : ', ret); 6991 expect(ret !== null).assertFalse(); 6992 } catch (err) { 6993 console.info(TAG, 'testBulkTransferParamErr030 catch err code: ', err.code, ', message: ', err.message); 6994 expect(err.code).assertEqual(PARAM_ERRCODE); 6995 } 6996 }) 6997 6998 /** 6999 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1890 7000 * @tc.name : testBulkTransferParamErr031 7001 * @tc.desc : Negative test: endpoint interval is null 7002 * @tc.size : MediumTest 7003 * @tc.type : Function 7004 * @tc.level : Level 3 7005 */ 7006 it('testBulkTransferParamErr031', 0, function () { 7007 console.info(TAG, 'usb testBulkTransferParamErr031 begin'); 7008 if (!isDeviceConnected) { 7009 expect(isDeviceConnected).assertFalse(); 7010 return 7011 } 7012 try { 7013 gPipe.busNum = devices.busNum; 7014 gPipe.devAddress = devices.devAddress; 7015 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 7016 let buffer = new Uint8Array(128); 7017 tmpEndpoints.interval = PARAM_NULL; 7018 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 7019 console.info(TAG, 'usb [endpoint.interval:null] bulkTransfer ret : ', ret); 7020 expect(ret !== null).assertFalse(); 7021 } catch (err) { 7022 console.info(TAG, 'testBulkTransferParamErr031 catch err code: ', err.code, ', message: ', err.message); 7023 expect(err.code).assertEqual(PARAM_ERRCODE); 7024 } 7025 }) 7026 7027 /** 7028 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1910 7029 * @tc.name : testBulkTransferParamErr032 7030 * @tc.desc : Negative test: endpoint interval is undefined 7031 * @tc.size : MediumTest 7032 * @tc.type : Function 7033 * @tc.level : Level 3 7034 */ 7035 it('testBulkTransferParamErr032', 0, function () { 7036 console.info(TAG, 'usb testBulkTransferParamErr032 begin'); 7037 if (!isDeviceConnected) { 7038 expect(isDeviceConnected).assertFalse(); 7039 return 7040 } 7041 try { 7042 gPipe.busNum = devices.busNum; 7043 gPipe.devAddress = devices.devAddress; 7044 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 7045 let buffer = new Uint8Array(128); 7046 tmpEndpoints.interval = PARAM_UNDEFINED; 7047 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 7048 console.info(TAG, 'usb [endpoint.interval:undefined] bulkTransfer ret : ', ret); 7049 expect(ret !== null).assertFalse(); 7050 } catch (err) { 7051 console.info(TAG, 'testBulkTransferParamErr032 catch err code: ', err.code, ', message: ', err.message); 7052 expect(err.code).assertEqual(PARAM_ERRCODE); 7053 } 7054 }) 7055 7056 /** 7057 * @tc.number : SUB_USB_HostManager_JS_ParamErr_1920 7058 * @tc.name : testBulkTransferParamErr033 7059 * @tc.desc : Negative test: endpoint interval is "" 7060 * @tc.size : MediumTest 7061 * @tc.type : Function 7062 * @tc.level : Level 3 7063 */ 7064 it('testBulkTransferParamErr033', 0, function () { 7065 console.info(TAG, 'usb testBulkTransferParamErr033 begin'); 7066 if (!isDeviceConnected) { 7067 expect(isDeviceConnected).assertFalse(); 7068 return 7069 } 7070 try { 7071 gPipe.busNum = devices.busNum; 7072 gPipe.devAddress = devices.devAddress; 7073 let tmpEndpoints = devices.configs[0].interfaces[0].endpoints[0]; 7074 let buffer = new Uint8Array(128); 7075 tmpEndpoints.interval = PARAM_NULLSTRING; 7076 let ret = usbManager.bulkTransfer(gPipe, tmpEndpoints, buffer); 7077 console.info(TAG, 'usb [endpoint.interval:""] bulkTransfer ret : ', ret); 7078 expect(ret !== null).assertFalse(); 7079 } catch (err) { 7080 console.info(TAG, 'testBulkTransferParamErr033 catch err code: ', err.code, ', message: ', err.message); 7081 expect(err.code).assertEqual(PARAM_ERRCODE); 7082 } 7083 }) 7084 7085}) 7086} 7087