1/* 2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import usbManager from '@ohos.usbManager'; 17import { UiDriver, BY } from '@ohos.UiTest'; 18import CheckEmptyUtils from './CheckEmptyUtils.js'; 19import EventConstants from './EventConstants.js'; 20import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect, TestType, Size, Level } from '@ohos/hypium'; 21 22 23export default function UsbApiTransferCompatJsunitTest() { 24describe('UsbApiTransferCompatJsunitTest', function () { 25 26 const TAG = "[UsbApiTransferCompatJsunitTest]"; 27 const PARAM_NULLSTRING = ""; 28 let gDeviceList; 29 let devices; 30 let testParam; 31 let gPipe; 32 let tmpPipe = { 33 busNum: null, 34 devAddress: null 35 }; 36 let isDeviceConnected; 37 function deviceConnected() { 38 if (gDeviceList.length > 0) { 39 console.info(TAG, "Test USB device is connected"); 40 return true; 41 } 42 console.info(TAG, "Test USB device is not connected"); 43 return false; 44 } 45 46 beforeAll(async function () { 47 console.log(TAG, '*************Usb Unit UsbApiTransferCompatJsunitTest Begin*************'); 48 const Version = usbManager.getVersion(); 49 console.info(TAG, 'usb unit begin test getversion :' + Version); 50 51 // version > 17 host currentMode = 2 device currentMode = 1 52 gDeviceList = usbManager.getDevices(); 53 isDeviceConnected = deviceConnected(); 54 if (isDeviceConnected) { 55 let hasRight = usbManager.hasRight(gDeviceList[0].name); 56 if (!hasRight) { 57 console.info(TAG, `beforeAll: usb requestRight start`); 58 await getPermission(); 59 CheckEmptyUtils.sleep(1000); 60 await driveFn(); 61 CheckEmptyUtils.sleep(1000); 62 } 63 devices = gDeviceList[0]; 64 tmpPipe.busNum = devices.busNum; 65 tmpPipe.devAddress = devices.devAddress; 66 console.info(TAG, 'beforeAll usb unit connectDevice gPipe ret : ' + JSON.stringify(gPipe)); 67 } 68 }) 69 70 beforeEach(function () { 71 console.info(TAG, 'beforeEach: *************Usb Unit Test CaseEx*************'); 72 gDeviceList = usbManager.getDevices(); 73 if (isDeviceConnected) { 74 devices = gDeviceList[0]; 75 console.info(TAG, 'beforeEach return devices : ' + JSON.stringify(devices)); 76 gPipe = usbManager.connectDevice(devices); 77 console.info(TAG, 'beforeEach return gPipe : ' + JSON.stringify(gPipe)); 78 testParam = getTransferTestParam(); 79 console.info(TAG, 'beforeEach return testParam : ' + JSON.stringify(testParam)); 80 } 81 82 }) 83 84 afterEach(function () { 85 console.info(TAG, 'afterEach: *************Usb Unit Test CaseEx*************'); 86 devices = null; 87 testParam = null; 88 gPipe = null; 89 console.info(TAG, 'afterEach return devices : ' + JSON.stringify(devices)); 90 console.info(TAG, 'afterEach return testParam : ' + JSON.stringify(testParam)); 91 console.info(TAG, 'afterEach return gPipe : ' + JSON.stringify(gPipe)); 92 }) 93 94 afterAll(function () { 95 console.log(TAG, '*************Usb Unit UsbApiTransferCompatJsunitTest End*************'); 96 }) 97 98 async function driveFn() { 99 console.info('**************driveFn**************'); 100 try { 101 let driver = await UiDriver.create(); 102 console.info(TAG, ` come in driveFn`); 103 console.info(TAG, `driver is ${JSON.stringify(driver)}`); 104 CheckEmptyUtils.sleep(1000); 105 let button = await driver.findComponent(BY.text('允许')); 106 console.info(TAG, `button is ${JSON.stringify(button)}`); 107 CheckEmptyUtils.sleep(1000); 108 await button.click(); 109 } catch (err) { 110 console.info(TAG, 'err is ' + err); 111 return; 112 } 113 } 114 115 async function getPermission() { 116 console.info('**************getPermission**************'); 117 try { 118 usbManager.requestRight(gDeviceList[0].name).then(hasRight => { 119 console.info(TAG, `usb requestRight success, hasRight: ${hasRight}`); 120 }) 121 } catch (err) { 122 console.info(TAG, `usb getPermission to requestRight hasRight fail: `, err); 123 return 124 } 125 } 126 127 function findInitPoint(testParam, j) { 128 var bfind = false; 129 for (var k = 0; k < testParam.config.interfaces[j].endpoints.length; k++) { 130 var endpoint = testParam.config.interfaces[j].endpoints[k]; 131 if (endpoint.type == EventConstants.USB_ENDPOINT_XFER_BULK) { 132 bfind = true 133 if (endpoint.direction == usbManager.USB_REQUEST_DIR_TO_DEVICE) { 134 testParam.maxOutSize = endpoint.maxPacketSize; 135 testParam.outEndpoint = endpoint; 136 } else if (endpoint.direction == usbManager.USB_REQUEST_DIR_FROM_DEVICE) { 137 testParam.maxInSize = endpoint.maxPacketSize; 138 testParam.inEndpoint = endpoint; 139 } 140 } 141 } 142 if (bfind) { 143 testParam.interface = testParam.config.interfaces[j]; 144 return bfind; 145 } 146 return false; 147 } 148 149 function getFlag(testParam, j) { 150 if (testParam.config.interfaces[j].endpoints.length == 0) { 151 return false; 152 } 153 154 if (testParam.config.interfaces[j].clazz != 10 || 155 testParam.config.interfaces[j].subClass != 0 || 156 testParam.config.interfaces[j].protocol != 2) { 157 return false; 158 } 159 return true; 160 } 161 162 function initPoint(testParam) { 163 for (var j = 0; j < testParam.config.interfaces.length; j++) { 164 if (getFlag(testParam, j) == true) { 165 if (findInitPoint(testParam, j) == true) { 166 break 167 } 168 } 169 } 170 } 171 172 // Prefabrication transmission related parameters 173 function getTransferTestParam() { 174 testParam = { 175 config: null, 176 device: null, 177 pip: null, 178 inEndpoint: null, 179 interface: null, 180 outEndpoint: null, 181 usbRequest: null, 182 sendData: '', 183 isClaimed: 0, 184 maxInSize: 1024, 185 maxOutSize: 1024 186 } 187 188 console.info(TAG, 'usb case gDeviceList.length: ' + gDeviceList.length); 189 for (var i = 0; i < gDeviceList.length; i++) { 190 testParam.device = gDeviceList[i]; 191 testParam.config = testParam.device.configs[0]; 192 testParam.pip = gPipe; 193 initPoint(testParam); 194 } 195 return testParam; 196 } 197 198 function getControlTransferParam(iReqType, iReq, iValue, iIndex, iLength) { 199 let tmpUint8Array = new Uint8Array(512); 200 201 let requestparam = { 202 bmRequestType: iReqType, 203 bRequest: iReq, 204 wValue: iValue, 205 wIndex: iIndex, 206 wLength: iLength, 207 data: tmpUint8Array 208 } 209 return requestparam; 210 } 211 212 function toClaimInterface(testCaseName, pip, tInterface) { 213 let ret = usbManager.claimInterface(pip, tInterface, true); 214 console.info(TAG, `usb ${testCaseName} claimInterface ret: ${ret}`); 215 expect(ret).assertEqual(0); 216 } 217 218 function toReleaseInterface(testCaseName) { 219 gDeviceList = usbManager.getDevices(); 220 testParam = getTransferTestParam(); 221 let ret = usbManager.releaseInterface(tmpPipe, testParam.interface); 222 console.info(TAG, `usb ${testCaseName} releaseInterface ret: ${ret}`); 223 expect(ret).assertEqual(0); 224 } 225 226 function getTransfersParam(gPipe, flagsValue, endpointValue, 227 typeValue, timeOutValue) { 228 let transferParams = { 229 devPipe: gPipe, 230 flags: flagsValue, 231 endpoint: endpointValue, 232 type: typeValue, 233 timeout: timeOutValue, 234 length: 10, 235 callback: () => {}, 236 userData: new Uint8Array(10), 237 buffer: new Uint8Array(10), 238 isoPacketCount: 0, 239 }; 240 return transferParams; 241 } 242 243 /** 244 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1000 245 * @tc.name : testBulkTransferCompat001 246 * @tc.desc : Negative test: send data, pipe busNum +1000 247 * @tc.size : MediumTest 248 * @tc.type : Function 249 * @tc.level : Level 0 250 */ 251 it('testBulkTransferCompat001', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL0, async function () { 252 console.info(TAG, 'usb testBulkTransferCompat001 begin'); 253 if (!isDeviceConnected) { 254 expect(isDeviceConnected).assertFalse(); 255 return 256 } 257 258 if (testParam.interface == null || testParam.outEndpoint == null) { 259 expect(testParam.interface == null).assertFalse(); 260 expect(testParam.outEndpoint == null).assertFalse(); 261 return 262 } 263 264 toClaimInterface('testBulkTransferCompat001', testParam.pip, testParam.interface); 265 testParam.sendData = 'send time 13213213 wzy 03'; 266 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 267 testParam.pip.busNum = testParam.pip.busNum + 1000; 268 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 269 console.info(TAG, 'usb [', testParam.pip.busNum, '] bulkTransfer send ret: ' + data); 270 expect(data).assertEqual(-1); 271 }).catch (error => { 272 console.info(TAG, 'usb testBulkTransferCompat001 send error : ' + JSON.stringify(error)); 273 expect(error !== null).assertFalse(); 274 }); 275 toReleaseInterface('testBulkTransferCompat001'); 276 }) 277 278 /** 279 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1100 280 * @tc.name : testBulkTransferCompat002 281 * @tc.desc : Negative test: send data, pipe devAddress +1000 282 * @tc.size : MediumTest 283 * @tc.type : Function 284 * @tc.level : Level 3 285 */ 286 it('testBulkTransferCompat002', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 287 console.info(TAG, 'usb testBulkTransferCompat002 begin'); 288 if (!isDeviceConnected) { 289 expect(isDeviceConnected).assertFalse(); 290 return 291 } 292 293 if (testParam.interface == null || testParam.outEndpoint == null) { 294 expect(testParam.interface == null).assertFalse(); 295 expect(testParam.outEndpoint == null).assertFalse(); 296 return 297 } 298 299 toClaimInterface('testBulkTransferCompat002', testParam.pip, testParam.interface); 300 testParam.sendData = 'send time 13213213 wzy 03'; 301 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 302 testParam.pip.devAddress = testParam.pip.devAddress + 1000; 303 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 304 console.info(TAG, 'usb [', testParam.pip.devAddress, '] bulkTransfer send ret: ' + data); 305 expect(data).assertEqual(-1); 306 }).catch (error => { 307 console.info(TAG, 'usb testBulkTransferCompat002 send error : ' + JSON.stringify(error)); 308 expect(error !== null).assertFalse(); 309 }); 310 toReleaseInterface('testBulkTransferCompat002'); 311 }) 312 313 /** 314 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1200 315 * @tc.name : testBulkTransferCompat003 316 * @tc.desc : Negative test: send data, pipe busNum -1 317 * @tc.size : MediumTest 318 * @tc.type : Function 319 * @tc.level : Level 3 320 */ 321 it('testBulkTransferCompat003', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 322 console.info(TAG, 'usb testBulkTransferCompat003 begin'); 323 if (!isDeviceConnected) { 324 expect(isDeviceConnected).assertFalse(); 325 return 326 } 327 328 if (testParam.interface == null || testParam.outEndpoint == null) { 329 expect(testParam.interface == null).assertFalse(); 330 expect(testParam.outEndpoint == null).assertFalse(); 331 return 332 } 333 334 toClaimInterface('testBulkTransferCompat003', testParam.pip, testParam.interface); 335 testParam.sendData = 'send time 13213213 wzy 03'; 336 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 337 testParam.pip.busNum = -1; 338 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 339 console.info(TAG, 'usb [', testParam.pip.busNum, '] bulkTransfer send ret: ' + data); 340 expect(data).assertEqual(-1); 341 }).catch (error => { 342 console.info(TAG, 'usb testBulkTransferCompat003 send error : ' + JSON.stringify(error)); 343 expect(error !== null).assertFalse(); 344 }); 345 toReleaseInterface('testBulkTransferCompat003'); 346 }) 347 348 /** 349 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1300 350 * @tc.name : testBulkTransferCompat004 351 * @tc.desc : Negative test: send data, pipe devAddress -1 352 * @tc.size : MediumTest 353 * @tc.type : Function 354 * @tc.level : Level 3 355 */ 356 it('testBulkTransferCompat004', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 357 console.info(TAG, 'usb testBulkTransferCompat004 begin'); 358 if (!isDeviceConnected) { 359 expect(isDeviceConnected).assertFalse(); 360 return 361 } 362 363 if (testParam.interface == null || testParam.outEndpoint == null) { 364 expect(testParam.interface == null).assertFalse(); 365 expect(testParam.outEndpoint == null).assertFalse(); 366 return 367 } 368 369 toClaimInterface('testBulkTransferCompat004', testParam.pip, testParam.interface); 370 testParam.sendData = 'send time 13213213 wzy 03'; 371 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 372 testParam.pip.devAddress = -1; 373 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 374 console.info(TAG, 'usb [', testParam.pip.devAddress, '] bulkTransfer send ret: ' + data); 375 expect(data).assertEqual(-1); 376 }).catch (error => { 377 console.info(TAG, 'usb testBulkTransferCompat004 send error : ' + JSON.stringify(error)); 378 expect(error !== null).assertFalse(); 379 }); 380 toReleaseInterface('testBulkTransferCompat004'); 381 }) 382 383 /** 384 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1400 385 * @tc.name : testBulkTransferCompat005 386 * @tc.desc : Negative test: send data, endpoint address +10 387 * @tc.size : MediumTest 388 * @tc.type : Function 389 * @tc.level : Level 3 390 */ 391 it('testBulkTransferCompat005', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 392 console.info(TAG, 'usb testBulkTransferCompat005 begin'); 393 if (!isDeviceConnected) { 394 expect(isDeviceConnected).assertFalse(); 395 return 396 } 397 398 if (testParam.interface == null || testParam.outEndpoint == null) { 399 expect(testParam.interface == null).assertFalse(); 400 expect(testParam.outEndpoint == null).assertFalse(); 401 return 402 } 403 404 toClaimInterface('testBulkTransferCompat005', testParam.pip, testParam.interface); 405 testParam.sendData = 'send time 13213213 wzy 03'; 406 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 407 testParam.outEndpoint.address = testParam.outEndpoint.address + 10; 408 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 409 console.info(TAG, 'usb [', testParam.outEndpoint.address, '] bulkTransfer send ret: ' + data); 410 expect(data).assertEqual(-1); 411 }).catch (error => { 412 console.info(TAG, 'usb testBulkTransferCompat005 send error : ' + JSON.stringify(error)); 413 expect(error !== null).assertFalse(); 414 }); 415 toReleaseInterface('testBulkTransferCompat005'); 416 }) 417 418 /** 419 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1500 420 * @tc.name : testBulkTransferCompat006 421 * @tc.desc : Negative test: send data, endpoint number +10 422 * @tc.size : MediumTest 423 * @tc.type : Function 424 * @tc.level : Level 3 425 */ 426 it('testBulkTransferCompat006', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 427 console.info(TAG, 'usb testBulkTransferCompat006 begin'); 428 if (!isDeviceConnected) { 429 expect(isDeviceConnected).assertFalse(); 430 return 431 } 432 433 if (testParam.interface == null || testParam.outEndpoint == null) { 434 expect(testParam.interface == null).assertFalse(); 435 expect(testParam.outEndpoint == null).assertFalse(); 436 return 437 } 438 439 toClaimInterface('testBulkTransferCompat006', testParam.pip, testParam.interface); 440 testParam.sendData = 'send time 13213213 wzy 03'; 441 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 442 testParam.outEndpoint.number = testParam.outEndpoint.number + 10; 443 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 444 console.info(TAG, 'usb [', testParam.outEndpoint.number, '] bulkTransfer send ret: ' + data); 445 expect(data >= 0).assertTrue(); 446 }).catch (error => { 447 console.info(TAG, 'usb testBulkTransferCompat006 send error : ' + JSON.stringify(error)); 448 expect(error !== null).assertFalse(); 449 }); 450 toReleaseInterface('testBulkTransferCompat006'); 451 }) 452 453 /** 454 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1600 455 * @tc.name : testBulkTransferCompat007 456 * @tc.desc : Negative test: send data, endpoint type +10 457 * @tc.size : MediumTest 458 * @tc.type : Function 459 * @tc.level : Level 3 460 */ 461 it('testBulkTransferCompat007', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 462 console.info(TAG, 'usb testBulkTransferCompat007 begin'); 463 if (!isDeviceConnected) { 464 expect(isDeviceConnected).assertFalse(); 465 return 466 } 467 468 if (testParam.interface == null || testParam.outEndpoint == null) { 469 expect(testParam.interface == null).assertFalse(); 470 expect(testParam.outEndpoint == null).assertFalse(); 471 return 472 } 473 474 toClaimInterface('testBulkTransferCompat007', testParam.pip, testParam.interface); 475 testParam.sendData = 'send time 13213213 wzy 03'; 476 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 477 testParam.outEndpoint.type = testParam.outEndpoint.type + 10; 478 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 479 console.info(TAG, 'usb [', testParam.outEndpoint.type, '] bulkTransfer send ret: ' + data); 480 expect(data >= 0).assertTrue(); 481 }).catch (error => { 482 console.info(TAG, 'usb testBulkTransferCompat007 send error : ' + JSON.stringify(error)); 483 expect(error !== null).assertFalse(); 484 }); 485 toReleaseInterface('testBulkTransferCompat007'); 486 }) 487 488 /** 489 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1700 490 * @tc.name : testBulkTransferCompat008 491 * @tc.desc : Negative test: send data, endpoint address -1 492 * @tc.size : MediumTest 493 * @tc.type : Function 494 * @tc.level : Level 3 495 */ 496 it('testBulkTransferCompat008', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 497 console.info(TAG, 'usb testBulkTransferCompat008 begin'); 498 if (!isDeviceConnected) { 499 expect(isDeviceConnected).assertFalse(); 500 return 501 } 502 503 if (testParam.interface == null || testParam.outEndpoint == null) { 504 expect(testParam.interface == null).assertFalse(); 505 expect(testParam.outEndpoint == null).assertFalse(); 506 return 507 } 508 509 toClaimInterface('testBulkTransferCompat008', testParam.pip, testParam.interface); 510 testParam.sendData = 'send time 13213213 wzy 03'; 511 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 512 testParam.outEndpoint.address = -1; 513 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 514 console.info(TAG, 'usb [', testParam.outEndpoint.address, '] bulkTransfer send ret: ' + data); 515 expect(data).assertEqual(-1); 516 }).catch (error => { 517 console.info(TAG, 'usb testBulkTransferCompat008 send error : ' + JSON.stringify(error)); 518 expect(error !== null).assertFalse(); 519 }); 520 toReleaseInterface('testBulkTransferCompat008'); 521 }) 522 523 /** 524 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1800 525 * @tc.name : testBulkTransferCompat009 526 * @tc.desc : Negative test: send data, endpoint number -1 527 * @tc.size : MediumTest 528 * @tc.type : Function 529 * @tc.level : Level 3 530 */ 531 it('testBulkTransferCompat009', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 532 console.info(TAG, 'usb testBulkTransferCompat009 begin'); 533 if (!isDeviceConnected) { 534 expect(isDeviceConnected).assertFalse(); 535 return 536 } 537 538 if (testParam.interface == null || testParam.outEndpoint == null) { 539 expect(testParam.interface == null).assertFalse(); 540 expect(testParam.outEndpoint == null).assertFalse(); 541 return 542 } 543 544 toClaimInterface('testBulkTransferCompat009', testParam.pip, testParam.interface); 545 testParam.sendData = 'send time 13213213 wzy 03'; 546 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 547 testParam.outEndpoint.number = -1; 548 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 549 console.info(TAG, 'usb [', testParam.outEndpoint.number, '] bulkTransfer send ret: ' + data); 550 expect(data >= 0).assertTrue(); 551 }).catch (error => { 552 console.info(TAG, 'usb testBulkTransferCompat009 send error : ' + JSON.stringify(error)); 553 expect(error !== null).assertFalse(); 554 }); 555 toReleaseInterface('testBulkTransferCompat009'); 556 }) 557 558 /** 559 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_1900 560 * @tc.name : testBulkTransferCompat010 561 * @tc.desc : Negative test: send data, endpoint type -1 562 * @tc.size : MediumTest 563 * @tc.type : Function 564 * @tc.level : Level 3 565 */ 566 it('testBulkTransferCompat010', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 567 console.info(TAG, 'usb testBulkTransferCompat010 begin'); 568 if (!isDeviceConnected) { 569 expect(isDeviceConnected).assertFalse(); 570 return 571 } 572 573 if (testParam.interface == null || testParam.outEndpoint == null) { 574 expect(testParam.interface == null).assertFalse(); 575 expect(testParam.outEndpoint == null).assertFalse(); 576 return 577 } 578 579 toClaimInterface('testBulkTransferCompat010', testParam.pip, testParam.interface); 580 testParam.sendData = 'send time 13213213 wzy 03'; 581 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 582 testParam.outEndpoint.type = -1; 583 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 584 console.info(TAG, 'usb [', testParam.outEndpoint.type, '] bulkTransfer send ret: ' + data); 585 expect(data >= 0).assertTrue(); 586 }).catch (error => { 587 console.info(TAG, 'usb testBulkTransferCompat010 send error : ' + JSON.stringify(error)); 588 expect(error !== null).assertFalse(); 589 }); 590 toReleaseInterface('testBulkTransferCompat010'); 591 }) 592 593 /** 594 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2000 595 * @tc.name : testBulkTransferCompat011 596 * @tc.desc : Negative test: send data, endpoint attributes +10 597 * @tc.size : MediumTest 598 * @tc.type : Function 599 * @tc.level : Level 3 600 */ 601 it('testBulkTransferCompat011', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 602 console.info(TAG, 'usb testBulkTransferCompat011 begin'); 603 if (!isDeviceConnected) { 604 expect(isDeviceConnected).assertFalse(); 605 return 606 } 607 608 if (testParam.interface == null || testParam.outEndpoint == null) { 609 expect(testParam.interface == null).assertFalse(); 610 expect(testParam.outEndpoint == null).assertFalse(); 611 return 612 } 613 614 toClaimInterface('testBulkTransferCompat011', testParam.pip, testParam.interface); 615 testParam.sendData = 'send time 13213213 wzy 03'; 616 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 617 testParam.outEndpoint.attributes = testParam.outEndpoint.attributes + 10; 618 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 619 console.info(TAG, 'usb [', testParam.outEndpoint.attributes, '] bulkTransfer send ret: ' + data); 620 expect(data >= 0).assertTrue(); 621 }).catch (error => { 622 console.info(TAG, 'usb testBulkTransferCompat011 send error : ' + JSON.stringify(error)); 623 expect(error !== null).assertFalse(); 624 }); 625 toReleaseInterface('testBulkTransferCompat011'); 626 }) 627 628 /** 629 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2100 630 * @tc.name : testBulkTransferCompat012 631 * @tc.desc : Negative test: send data, endpoint attributes -1 632 * @tc.size : MediumTest 633 * @tc.type : Function 634 * @tc.level : Level 3 635 */ 636 it('testBulkTransferCompat012', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 637 console.info(TAG, 'usb testBulkTransferCompat012 begin'); 638 if (!isDeviceConnected) { 639 expect(isDeviceConnected).assertFalse(); 640 return 641 } 642 643 if (testParam.interface == null || testParam.outEndpoint == null) { 644 expect(testParam.interface == null).assertFalse(); 645 expect(testParam.outEndpoint == null).assertFalse(); 646 return 647 } 648 649 toClaimInterface('testBulkTransferCompat012', testParam.pip, testParam.interface); 650 testParam.sendData = 'send time 13213213 wzy 03'; 651 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 652 testParam.outEndpoint.attributes = -1; 653 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 654 console.info(TAG, 'usb [', testParam.outEndpoint.attributes, '] bulkTransfer send ret: ' + data); 655 expect(data >= 0).assertTrue(); 656 }).catch (error => { 657 console.info(TAG, 'usb testBulkTransferCompat012 send error : ' + JSON.stringify(error)); 658 expect(error !== null).assertFalse(); 659 }); 660 toReleaseInterface('testBulkTransferCompat012'); 661 }) 662 663 /** 664 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2200 665 * @tc.name : testBulkTransferCompat013 666 * @tc.desc : Negative test: send data, endpoint interval +10 667 * @tc.size : MediumTest 668 * @tc.type : Function 669 * @tc.level : Level 3 670 */ 671 it('testBulkTransferCompat013', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 672 console.info(TAG, 'usb testBulkTransferCompat013 begin'); 673 if (!isDeviceConnected) { 674 expect(isDeviceConnected).assertFalse(); 675 return 676 } 677 678 if (testParam.interface == null || testParam.outEndpoint == null) { 679 expect(testParam.interface == null).assertFalse(); 680 expect(testParam.outEndpoint == null).assertFalse(); 681 return 682 } 683 684 toClaimInterface('testBulkTransferCompat013', testParam.pip, testParam.interface); 685 testParam.sendData = 'send time 13213213 wzy 03'; 686 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 687 testParam.outEndpoint.interval = testParam.outEndpoint.interval + 10; 688 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 689 console.info(TAG, 'usb [', testParam.outEndpoint.interval, '] bulkTransfer send ret: ' + data); 690 expect(data >= 0).assertTrue(); 691 }).catch (error => { 692 console.info(TAG, 'usb testBulkTransferCompat013 send error : ' + JSON.stringify(error)); 693 expect(error !== null).assertFalse(); 694 }); 695 toReleaseInterface('testBulkTransferCompat013'); 696 }) 697 698 /** 699 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2300 700 * @tc.name : testBulkTransferCompat014 701 * @tc.desc : Negative test: send data, endpoint interval -1 702 * @tc.size : MediumTest 703 * @tc.type : Function 704 * @tc.level : Level 3 705 */ 706 it('testBulkTransferCompat014', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 707 console.info(TAG, 'usb testBulkTransferCompat014 begin'); 708 if (!isDeviceConnected) { 709 expect(isDeviceConnected).assertFalse(); 710 return 711 } 712 713 if (testParam.interface == null || testParam.outEndpoint == null) { 714 expect(testParam.interface == null).assertFalse(); 715 expect(testParam.outEndpoint == null).assertFalse(); 716 return 717 } 718 719 toClaimInterface('testBulkTransferCompat014', testParam.pip, testParam.interface); 720 testParam.sendData = 'send time 13213213 wzy 03'; 721 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 722 testParam.outEndpoint.interval = -1; 723 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 724 console.info(TAG, 'usb [', testParam.outEndpoint.interval, '] bulkTransfer send ret: ' + data); 725 expect(data >= 0).assertTrue(); 726 }).catch (error => { 727 console.info(TAG, 'usb testBulkTransferCompat014 send error : ' + JSON.stringify(error)); 728 expect(error !== null).assertFalse(); 729 }); 730 toReleaseInterface('testBulkTransferCompat014'); 731 }) 732 733 /** 734 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2400 735 * @tc.name : testBulkTransferCompat015 736 * @tc.desc : Negative test: send data, endpoint maxPacketSize +10 737 * @tc.size : MediumTest 738 * @tc.type : Function 739 * @tc.level : Level 3 740 */ 741 it('testBulkTransferCompat015', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 742 console.info(TAG, 'usb testBulkTransferCompat015 begin'); 743 if (!isDeviceConnected) { 744 expect(isDeviceConnected).assertFalse(); 745 return 746 } 747 748 if (testParam.interface == null || testParam.outEndpoint == null) { 749 expect(testParam.interface == null).assertFalse(); 750 expect(testParam.outEndpoint == null).assertFalse(); 751 return 752 } 753 754 toClaimInterface('testBulkTransferCompat015', testParam.pip, testParam.interface); 755 testParam.sendData = 'send time 13213213 wzy 03'; 756 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 757 testParam.outEndpoint.maxPacketSize = testParam.outEndpoint.maxPacketSize + 10; 758 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 759 console.info(TAG, 'usb [', testParam.outEndpoint.maxPacketSize, '] bulkTransfer send ret: ' + data); 760 expect(data >= 0).assertTrue(); 761 }).catch (error => { 762 console.info(TAG, 'usb testBulkTransferCompat015 send error : ' + JSON.stringify(error)); 763 expect(error !== null).assertFalse(); 764 }); 765 toReleaseInterface('testBulkTransferCompat015'); 766 }) 767 768 /** 769 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2500 770 * @tc.name : testBulkTransferCompat016 771 * @tc.desc : Negative test: send data, endpoint maxPacketSize -1 772 * @tc.size : MediumTest 773 * @tc.type : Function 774 * @tc.level : Level 3 775 */ 776 it('testBulkTransferCompat016', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 777 console.info(TAG, 'usb testBulkTransferCompat016 begin'); 778 if (!isDeviceConnected) { 779 expect(isDeviceConnected).assertFalse(); 780 return 781 } 782 783 if (testParam.interface == null || testParam.outEndpoint == null) { 784 expect(testParam.interface == null).assertFalse(); 785 expect(testParam.outEndpoint == null).assertFalse(); 786 return 787 } 788 789 toClaimInterface('testBulkTransferCompat016', testParam.pip, testParam.interface); 790 testParam.sendData = 'send time 13213213 wzy 03'; 791 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 792 testParam.outEndpoint.maxPacketSize = -1; 793 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 794 console.info(TAG, 'usb [', testParam.outEndpoint.maxPacketSize, '] bulkTransfer send ret: ' + data); 795 expect(data >= 0).assertTrue(); 796 }).catch (error => { 797 console.info(TAG, 'usb testBulkTransferCompat016 send error : ' + JSON.stringify(error)); 798 expect(error !== null).assertFalse(); 799 }); 800 toReleaseInterface('testBulkTransferCompat016'); 801 }) 802 803 /** 804 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2600 805 * @tc.name : testBulkTransferCompat017 806 * @tc.desc : Negative test: send data, endpoint direction +10 807 * @tc.size : MediumTest 808 * @tc.type : Function 809 * @tc.level : Level 3 810 */ 811 it('testBulkTransferCompat017', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 812 console.info(TAG, 'usb testBulkTransferCompat017 begin'); 813 if (!isDeviceConnected) { 814 expect(isDeviceConnected).assertFalse(); 815 return 816 } 817 818 if (testParam.interface == null || testParam.outEndpoint == null) { 819 expect(testParam.interface == null).assertFalse(); 820 expect(testParam.outEndpoint == null).assertFalse(); 821 return 822 } 823 824 toClaimInterface('testBulkTransferCompat017', testParam.pip, testParam.interface); 825 testParam.sendData = 'send time 13213213 wzy 03'; 826 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 827 testParam.outEndpoint.direction = testParam.outEndpoint.direction + 10; 828 try { 829 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 830 console.info(TAG, 'usb [', testParam.outEndpoint.direction, '] bulkTransfer send ret: ' + data); 831 expect(data !== null).assertFalse(); 832 }) 833 } catch (err) { 834 console.info(TAG, 'usb testBulkTransferCompat017 send error : ', err.code, ', message: ', err.message); 835 expect(err.code).assertEqual(401); 836 } 837 toReleaseInterface('testBulkTransferCompat017'); 838 }) 839 840 /** 841 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2700 842 * @tc.name : testBulkTransferCompat018 843 * @tc.desc : Negative test: send data, endpoint direction -1 844 * @tc.size : MediumTest 845 * @tc.type : Function 846 * @tc.level : Level 3 847 */ 848 it('testBulkTransferCompat018', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 849 console.info(TAG, 'usb testBulkTransferCompat018 begin'); 850 if (!isDeviceConnected) { 851 expect(isDeviceConnected).assertFalse(); 852 return 853 } 854 855 if (testParam.interface == null || testParam.outEndpoint == null) { 856 expect(testParam.interface == null).assertFalse(); 857 expect(testParam.outEndpoint == null).assertFalse(); 858 return 859 } 860 861 toClaimInterface('testBulkTransferCompat018', testParam.pip, testParam.interface); 862 testParam.sendData = 'send time 13213213 wzy 03'; 863 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 864 testParam.outEndpoint.direction = -1; 865 try { 866 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 867 console.info(TAG, 'usb [', testParam.outEndpoint.direction, '] bulkTransfer send ret: ' + data); 868 expect(data !== null).assertFalse(); 869 }) 870 } catch (err) { 871 console.info(TAG, 'usb testBulkTransferCompat018 send error : ', err.code, ', message: ', err.message); 872 expect(err.code).assertEqual(401); 873 } 874 toReleaseInterface('testBulkTransferCompat018'); 875 }) 876 877 /** 878 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2800 879 * @tc.name : testBulkTransferCompat019 880 * @tc.desc : Negative test: send data, endpoint interfaceId +10 881 * @tc.size : MediumTest 882 * @tc.type : Function 883 * @tc.level : Level 3 884 */ 885 it('testBulkTransferCompat019', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 886 console.info(TAG, 'usb testBulkTransferCompat019 begin'); 887 if (!isDeviceConnected) { 888 expect(isDeviceConnected).assertFalse(); 889 return 890 } 891 892 if (testParam.interface == null || testParam.outEndpoint == null) { 893 expect(testParam.interface == null).assertFalse(); 894 expect(testParam.outEndpoint == null).assertFalse(); 895 return 896 } 897 898 toClaimInterface('testBulkTransferCompat019', testParam.pip, testParam.interface); 899 testParam.sendData = 'send time 13213213 wzy 03'; 900 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 901 testParam.outEndpoint.interfaceId = testParam.outEndpoint.interfaceId + 10; 902 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 903 console.info(TAG, 'usb [', testParam.outEndpoint.interfaceId, '] bulkTransfer send ret: ' + data); 904 expect(data).assertEqual(-1); 905 }).catch (error => { 906 console.info(TAG, 'usb testBulkTransferCompat019 send error : ' + JSON.stringify(error)); 907 expect(error !== null).assertFalse(); 908 }); 909 toReleaseInterface('testBulkTransferCompat019'); 910 }) 911 912 /** 913 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_2900 914 * @tc.name : testBulkTransferCompat020 915 * @tc.desc : Negative test: send data, endpoint interfaceId -1 916 * @tc.size : MediumTest 917 * @tc.type : Function 918 * @tc.level : Level 3 919 */ 920 it('testBulkTransferCompat020', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 921 console.info(TAG, 'usb testBulkTransferCompat020 begin'); 922 if (!isDeviceConnected) { 923 expect(isDeviceConnected).assertFalse(); 924 return 925 } 926 927 if (testParam.interface == null || testParam.outEndpoint == null) { 928 expect(testParam.interface == null).assertFalse(); 929 expect(testParam.outEndpoint == null).assertFalse(); 930 return 931 } 932 933 toClaimInterface('testBulkTransferCompat020', testParam.pip, testParam.interface); 934 testParam.sendData = 'send time 13213213 wzy 03'; 935 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 936 testParam.outEndpoint.interfaceId = -1; 937 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, 5000).then(data => { 938 console.info(TAG, 'usb [', testParam.outEndpoint.interfaceId, '] bulkTransfer send ret: ' + data); 939 expect(data).assertEqual(-1); 940 }).catch (error => { 941 console.info(TAG, 'usb testBulkTransferCompat020 send error : ' + JSON.stringify(error)); 942 expect(error !== null).assertFalse(); 943 }); 944 toReleaseInterface('testBulkTransferCompat020'); 945 }) 946 947 /** 948 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_3000 949 * @tc.name : testBulkTransferCompat021 950 * @tc.desc : Negative test: send data, timeout is "" 951 * @tc.size : MediumTest 952 * @tc.type : Function 953 * @tc.level : Level 3 954 */ 955 it('testBulkTransferCompat021', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 956 console.info(TAG, 'usb testBulkTransferCompat021 begin'); 957 if (!isDeviceConnected) { 958 expect(isDeviceConnected).assertFalse(); 959 return 960 } 961 962 if (testParam.interface == null || testParam.outEndpoint == null) { 963 expect(testParam.interface == null).assertFalse(); 964 expect(testParam.outEndpoint == null).assertFalse(); 965 return 966 } 967 968 toClaimInterface('testBulkTransferCompat021', testParam.pip, testParam.interface); 969 testParam.sendData = 'send time 13213213 wzy 03'; 970 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 971 let timeout = PARAM_NULLSTRING; 972 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, timeout).then(data => { 973 console.info(TAG, 'usb [timeout:""] bulkTransfer send ret: ' + data); 974 expect(data >= 0).assertTrue(); 975 }).catch (error => { 976 console.info(TAG, 'usb testBulkTransferCompat021 send error : ' + JSON.stringify(error)); 977 expect(error !== null).assertFalse(); 978 }); 979 toReleaseInterface('testBulkTransferCompat021'); 980 }) 981 982 /** 983 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_3100 984 * @tc.name : testBulkTransferCompat022 985 * @tc.desc : Negative test: Enter five parameters 986 * @tc.size : MediumTest 987 * @tc.type : Function 988 * @tc.level : Level 3 989 */ 990 it('testBulkTransferCompat022', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 991 console.info(TAG, 'usb testBulkTransferCompat022 begin'); 992 if (!isDeviceConnected) { 993 expect(isDeviceConnected).assertFalse(); 994 return 995 } 996 997 if (testParam.interface == null || testParam.outEndpoint == null) { 998 expect(testParam.interface == null).assertFalse(); 999 expect(testParam.outEndpoint == null).assertFalse(); 1000 return 1001 } 1002 1003 toClaimInterface('testBulkTransferCompat022', testParam.pip, testParam.interface); 1004 testParam.sendData = 'send time 13213213 wzy 03'; 1005 let tmpUint8Array = CheckEmptyUtils.str2ab(testParam.sendData); 1006 let timeout = 5000; 1007 await usbManager.bulkTransfer(testParam.pip, testParam.outEndpoint, tmpUint8Array, timeout, 1008 testParam.pip).then(data => { 1009 console.info(TAG, 'usb [timeout:""] bulkTransfer send ret: ' + data); 1010 expect(data >= 0).assertTrue(); 1011 }).catch (error => { 1012 console.info(TAG, 'usb testBulkTransferCompat022 send error : ' + JSON.stringify(error)); 1013 expect(error !== null).assertFalse(); 1014 }); 1015 toReleaseInterface('testBulkTransferCompat022'); 1016 }) 1017 1018 /** 1019 * @tc.number : SUB_USB_HostManager_JS_TranCompatibility_3200 1020 * @tc.name : testUsbControlTransferCompat001 1021 * @tc.desc : Negative test: Enter four parameters 1022 * @tc.size : MediumTest 1023 * @tc.type : Function 1024 * @tc.level : Level 3 1025 */ 1026 it('testUsbControlTransferCompat001', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 1027 console.info(TAG, 'usb testUsbControlTransferCompat001 begin'); 1028 if (!isDeviceConnected) { 1029 expect(isDeviceConnected).assertFalse(); 1030 return 1031 } 1032 1033 if (testParam.inEndpoint == null || testParam.interface == null || testParam.outEndpoint == null) { 1034 expect(testParam.inEndpoint == null).assertFalse(); 1035 expect(testParam.interface == null).assertFalse(); 1036 expect(testParam.outEndpoint == null).assertFalse(); 1037 return 1038 } 1039 1040 let requestparam = getControlTransferParam(0x80, 0x60, (0x01 << 8 | 0), TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, 18); 1041 let timeout = 5000; 1042 1043 await usbManager.usbControlTransfer(testParam.pip, requestparam, timeout, testParam.pip).then(data => { 1044 console.info(TAG, 'usb [Enter four parameters] usbControlTransfer data: ' + data); 1045 console.info(TAG, 'usb [Enter four parameters] usbControlTransfer buffer data: ' + requestparam.data); 1046 expect(data >= 0).assertTrue(); 1047 }).catch (error => { 1048 console.info(TAG, 'usb testUsbControlTransferCompat001 send error : ' + JSON.stringify(error)); 1049 expect(error !== null).assertFalse(); 1050 }); 1051 }) 1052 1053 /** 1054 * @tc.number : SUB_USB_HostManager_JS_TranCompatibilityErr_3200 1055 * @tc.name : testUsbControlTransferCompat801Err001 1056 * @tc.desc : Negative test: Enter four parameters 1057 * @tc.size : MediumTest 1058 * @tc.type : Function 1059 * @tc.level : Level 3 1060 */ 1061 it('testUsbControlTransferCompat801Err001', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async function () { 1062 console.info(TAG, 'usb testUsbControlTransferCompat801Err001 begin'); 1063 if (!isDeviceConnected) { 1064 expect(isDeviceConnected).assertFalse(); 1065 return 1066 } 1067 1068 if (testParam.inEndpoint == null || testParam.interface == null || testParam.outEndpoint == null) { 1069 expect(testParam.inEndpoint == null).assertFalse(); 1070 expect(testParam.interface == null).assertFalse(); 1071 expect(testParam.outEndpoint == null).assertFalse(); 1072 return 1073 } 1074 1075 let requestparam = getControlTransferParam(0x80, 0x60, (0x01 << 8 | 0), TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, 18); 1076 let timeout = 5000; 1077 1078 await usbManager.usbControlTransfer(testParam.pip, requestparam, timeout, testParam.pip).then(data => { 1079 console.info(TAG, 'usb [Enter four parameters] usbControlTransfer data: ' + data); 1080 console.info(TAG, 'usb [Enter four parameters] usbControlTransfer buffer data: ' + requestparam.data); 1081 expect(data >= 0).assertTrue(); 1082 }).catch (error => { 1083 console.info(TAG, 'usb testUsbControlTransferCompat801Err001 send error : ' + JSON.stringify(error)); 1084 expect(err.code).assertEqual(801); 1085 }); 1086 }) 1087 1088 /** 1089 * @tc.number : SUB_USB_Host_JS_usbCancelTransfer_ErrCode_0200 1090 * @tc.name : testUsbCancelTransfer003 1091 * @tc.desc : interrupt transfer cancel failed. 1092 * @tc.size : MediumTest 1093 * @tc.type : Function 1094 * @tc.level : Level 3 1095 */ 1096 it('testUsbCancelTransfer003', TestType.FUNCTION | Size.MEDIUMTEST | Level.LEVEL3, async (done) => { 1097 console.info(TAG, 'interrupt testUsbCancelTransfer003 enter'); 1098 if (!isDeviceConnected) { 1099 console.info(TAG, 'usb testUsbCancelTransfer003 No device is connected'); 1100 expect(isDeviceConnected).assertFalse(); 1101 done() 1102 return 1103 } 1104 let type = usbManager.TRANSFER_TYPE_INTERRUPT; 1105 let transferParams = getTransfersParam(null, 2, 129, type, 2000); 1106 try { 1107 usbManager.usbCancelTransfer(transferParams); 1108 expect().assertFail(); 1109 done() 1110 } catch (error) { 1111 console.info(TAG, 'interrupt testUsbCancelTransfer003 end'); 1112 console.error('interrupt cancel failed:', error); 1113 expect(error.code).assertEqual(401); 1114 usbManager.closePipe(devices); 1115 done() 1116 } 1117 }); 1118}) 1119}