mirror of
https://gitee.com/openharmony/usb_usb_manager
synced 2024-11-27 00:41:39 +00:00
1686 lines
68 KiB
Plaintext
1686 lines
68 KiB
Plaintext
/*
|
|
* Copyright (c) 2024 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import usbManager from '@ohos.usbManager';
|
|
//import CheckEmptyUtils from './CheckEmptyUtils.js';
|
|
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'
|
|
|
|
|
|
describe('UsbApiParamExceJsunitTest', function () {
|
|
|
|
const TAG = "[UsbApiParamExceJsunitTest]";
|
|
const PARAM_NULL = null;
|
|
const PARAM_UNDEFINED = undefined;
|
|
const PARAM_NULLSTRING = "";
|
|
const PARAM_NUMBEREX = 123;
|
|
let gDeviceList;
|
|
let devices;
|
|
let gPipe;
|
|
let isDeviceConnected;
|
|
let tmpPipe = {
|
|
busNum: null,
|
|
devAddress: null
|
|
};
|
|
function deviceConnected() {
|
|
if (gDeviceList.length > 0) {
|
|
console.info(TAG, "Test USB device is connected");
|
|
return true;
|
|
}
|
|
console.info(TAG, "Test USB device is not connected");
|
|
return false;
|
|
}
|
|
|
|
beforeAll(async function () {
|
|
console.log(TAG, '*************Usb Unit UsbApiParamExceJsunitTest Begin*************');
|
|
const Version = usbManager.getVersion();
|
|
console.info(TAG, 'usb unit begin test getversion :' + Version);
|
|
|
|
// version > 17 host currentMode = 2 device currentMode = 1
|
|
gDeviceList = usbManager.getDevices();
|
|
isDeviceConnected = deviceConnected();
|
|
if (isDeviceConnected) {
|
|
let hasRight = usbManager.hasRight(gDeviceList[0].name);
|
|
if (!hasRight) {
|
|
console.info(TAG, `beforeAll: usb requestRight start`);
|
|
await getPermission();
|
|
CheckEmptyUtils.sleep(1000);
|
|
await driveFn();
|
|
CheckEmptyUtils.sleep(1000);
|
|
}
|
|
|
|
tmpPipe.busNum = gDeviceList[0].busNum;
|
|
tmpPipe.devAddress = gDeviceList[0].devAddress;
|
|
}
|
|
})
|
|
|
|
beforeEach(function () {
|
|
console.info(TAG, 'beforeEach: *************Usb Unit Test CaseEx*************');
|
|
gDeviceList = usbManager.getDevices();
|
|
if (isDeviceConnected) {
|
|
devices = gDeviceList[0];
|
|
console.info(TAG, 'beforeEach return devices : ' + JSON.stringify(devices));
|
|
}
|
|
})
|
|
|
|
afterEach(function () {
|
|
console.info(TAG, 'afterEach: *************Usb Unit Test CaseEx*************');
|
|
devices = null;
|
|
gPipe = null;
|
|
console.info(TAG, 'afterEach return devices : ' + JSON.stringify(devices));
|
|
})
|
|
|
|
afterAll(function () {
|
|
console.log(TAG, '*************Usb Unit UsbApiParamExceJsunitTest End*************');
|
|
})
|
|
|
|
async function driveFn() {
|
|
console.info('**************driveFn**************');
|
|
try {
|
|
let driver = await UiDriver.create();
|
|
console.info(TAG, ` come in driveFn`);
|
|
console.info(TAG, `driver is ${JSON.stringify(driver)}`);
|
|
CheckEmptyUtils.sleep(1000);
|
|
let button = await driver.findComponent(BY.text('允许'));
|
|
console.info(TAG, `button is ${JSON.stringify(button)}`);
|
|
CheckEmptyUtils.sleep(1000);
|
|
await button.click();
|
|
} catch (err) {
|
|
console.info(TAG, 'err is ' + err);
|
|
return;
|
|
}
|
|
}
|
|
|
|
async function getPermission() {
|
|
console.info('**************getPermission**************');
|
|
try {
|
|
usbManager.requestRight(gDeviceList[0].name).then(hasRight => {
|
|
console.info(TAG, `usb requestRight success, hasRight: ${hasRight}`);
|
|
})
|
|
} catch (err) {
|
|
console.info(TAG, `usb getPermission to requestRight hasRight fail: `, err);
|
|
return
|
|
}
|
|
}
|
|
|
|
function getPipe(testCaseName) {
|
|
gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, `usb ${testCaseName} connectDevice getPipe ret: ${JSON.stringify(gPipe)}`);
|
|
expect(gPipe !== null).assertTrue();
|
|
}
|
|
|
|
function toReleaseInterface(testCaseName, tInterface) {
|
|
let ret = usbManager.releaseInterface(tmpPipe, tInterface);
|
|
console.info(TAG, `usb ${testCaseName} releaseInterface ret: ${ret}`);
|
|
expect(ret).assertEqual(0);
|
|
}
|
|
|
|
function toClosePipe(testCaseName) {
|
|
let isPipClose = usbManager.closePipe(tmpPipe);
|
|
console.info(TAG, `usb ${testCaseName} closePipe ret: ${isPipClose}`);
|
|
expect(isPipClose).assertEqual(0);
|
|
}
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0100
|
|
* @tc.name : testHasRightParamEx001
|
|
* @tc.desc : Negative test: Param is null string
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testHasRightParamEx001', 0, function () {
|
|
console.info(TAG, 'usb testHasRightParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let isHasRight = usbManager.hasRight(PARAM_NULLSTRING);
|
|
console.info(TAG, 'usb case hasRight ret : ' + isHasRight);
|
|
expect(isHasRight).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testHasRightParamEx001 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0200
|
|
* @tc.name : testHasRightParamEx002
|
|
* @tc.desc : Negative test: Param add number '123'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testHasRightParamEx002', 0, function () {
|
|
console.info(TAG, 'usb testHasRightParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
for (var i = 0; i < gDeviceList.length; i++) {
|
|
let deviceName = gDeviceList[i].name;
|
|
deviceName = deviceName + "123";
|
|
let isHasRight = usbManager.hasRight(deviceName);
|
|
console.info(TAG, 'usb [', deviceName, '] hasRight ret : ' + isHasRight);
|
|
expect(isHasRight).assertFalse();
|
|
}
|
|
} catch (err) {
|
|
console.info(TAG, 'testHasRightParamEx002 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0300
|
|
* @tc.name : testRequestRightParamEx001
|
|
* @tc.desc : Negative test: Param is null string
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testRequestRightParamEx001', 0, async function () {
|
|
console.info(TAG, 'usb testRequestRightParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let isHasRight = await usbManager.requestRight(PARAM_NULLSTRING);
|
|
console.info(TAG, 'usb case requestRight ret : ' + isHasRight);
|
|
expect(isHasRight).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testRequestRightParamEx001 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0400
|
|
* @tc.name : testRequestRightParamEx002
|
|
* @tc.desc : Negative test: Param add number 'abc'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testRequestRightParamEx002', 0, async function () {
|
|
console.info(TAG, 'usb testRequestRightParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
for (var i = 0; i < gDeviceList.length; i++) {
|
|
let deviceName = gDeviceList[i].name;
|
|
deviceName = deviceName + "abc";
|
|
let isHasRight = await usbManager.requestRight(deviceName);
|
|
console.info(TAG, 'usb [', deviceName, '] requestRight ret : ' + isHasRight);
|
|
expect(isHasRight).assertFalse();
|
|
}
|
|
} catch (err) {
|
|
console.info(TAG, 'testRequestRightParamEx002 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0500
|
|
* @tc.name : testRemoveRightParamEx001
|
|
* @tc.desc : Negative test: Param is null string
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testRemoveRightParamEx001', 0, function () {
|
|
console.info(TAG, 'usb testRemoveRightParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let remRight = usbManager.removeRight(PARAM_NULLSTRING);
|
|
console.info(TAG, 'usb case removeRight ret : ' + remRight);
|
|
expect(remRight).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testRemoveRightParamEx001 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0600
|
|
* @tc.name : testRemoveRightParamEx002
|
|
* @tc.desc : Negative test: Param add letter 'abc'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testRemoveRightParamEx002', 0, function () {
|
|
console.info(TAG, 'usb testRemoveRightParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
for (var i = 0; i < gDeviceList.length; i++) {
|
|
let deviceName = gDeviceList[i].name;
|
|
deviceName = deviceName + "abc";
|
|
let remRight = usbManager.removeRight(deviceName);
|
|
console.info(TAG, 'usb [', deviceName, '] removeRight ret : ', remRight);
|
|
expect(remRight).assertFalse();
|
|
}
|
|
} catch (err) {
|
|
console.info(TAG, 'testRemoveRightParamEx002 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0700
|
|
* @tc.name : testRemoveRightParamEx003
|
|
* @tc.desc : Negative test: Param add special characters '@#'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testRemoveRightParamEx003', 0, function () {
|
|
console.info(TAG, 'usb testRemoveRightParamEx003 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
for (var i = 0; i < gDeviceList.length; i++) {
|
|
let deviceName = gDeviceList[i].name;
|
|
deviceName = deviceName + "@#";
|
|
let remRight = usbManager.removeRight(deviceName);
|
|
console.info(TAG, 'usb [', deviceName, '] removeRight ret : ', remRight);
|
|
expect(remRight).assertFalse();
|
|
}
|
|
} catch (err) {
|
|
console.info(TAG, 'testRemoveRightParamEx003 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0800
|
|
* @tc.name : testRemoveRightParamEx004
|
|
* @tc.desc : Negative test: Param add number '123'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testRemoveRightParamEx004', 0, function () {
|
|
console.info(TAG, 'usb testRemoveRightParamEx004 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
for (var i = 0; i < gDeviceList.length; i++) {
|
|
let deviceName = gDeviceList[i].name;
|
|
deviceName = deviceName + "123";
|
|
let remRight = usbManager.removeRight(deviceName);
|
|
console.info(TAG, 'usb [', deviceName, '] removeRight ret : ', remRight);
|
|
expect(remRight).assertFalse();
|
|
}
|
|
} catch (err) {
|
|
console.info(TAG, 'testRemoveRightParamEx004 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_0900
|
|
* @tc.name : testConnectDeviceParamEx001
|
|
* @tc.desc : Negative test: Param add number '123'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx001', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let deviceName = devices.name + "123";
|
|
devices.name = deviceName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
|
|
console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx001 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1000
|
|
* @tc.name : testConnectDeviceParamEx002
|
|
* @tc.desc : Negative test: Param add letter 'abc'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx002', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let deviceName = devices.name + "abc";
|
|
devices.name = deviceName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx002 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1100
|
|
* @tc.name : testConnectDeviceParamEx003
|
|
* @tc.desc : Negative test: Param add special characters '@#'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx003', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx003 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let deviceName = devices.name + "@#";
|
|
devices.name = deviceName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx003 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1200
|
|
* @tc.name : testConnectDeviceParamEx004
|
|
* @tc.desc : Negative test: devices name is null string ""
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx004', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx004 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
devices.name = PARAM_NULLSTRING;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx004 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1300
|
|
* @tc.name : testConnectDeviceParamEx005
|
|
* @tc.desc : Negative test: devices serial is null string ""
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx005', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx005 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
devices.serial = PARAM_NULLSTRING;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx005 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1400
|
|
* @tc.name : testConnectDeviceParamEx006
|
|
* @tc.desc : Negative test: devices serial add letter abc
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx006', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx006 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devSerial = devices.serial + "abc";
|
|
devices.serial = devSerial;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx006 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1500
|
|
* @tc.name : testConnectDeviceParamEx007
|
|
* @tc.desc : Negative test: devices serial add number 123
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx007', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx007 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devSerial = devices.serial + "123";
|
|
devices.serial = devSerial;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx007 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1600
|
|
* @tc.name : testConnectDeviceParamEx008
|
|
* @tc.desc : Negative test: devices serial add special characters '@#'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx008', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx008 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devSerial = devices.serial + "@#";
|
|
devices.serial = devSerial;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx008 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1700
|
|
* @tc.name : testConnectDeviceParamEx009
|
|
* @tc.desc : Negative test: devices manufacturerName add special characters '@#'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx009', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx009 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devManufacturerName = devices.manufacturerName + "@#";
|
|
devices.manufacturerName = devManufacturerName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx009 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1800
|
|
* @tc.name : testConnectDeviceParamEx010
|
|
* @tc.desc : Negative test: devices manufacturerName add special characters 'abc'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx010', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx010 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devManufacturerName = devices.manufacturerName + "abc";
|
|
devices.manufacturerName = devManufacturerName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx010 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_1900
|
|
* @tc.name : testConnectDeviceParamEx011
|
|
* @tc.desc : Negative test: devices manufacturerName add special characters '123'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx011', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx011 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devManufacturerName = devices.manufacturerName + "123";
|
|
devices.manufacturerName = devManufacturerName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx011 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2000
|
|
* @tc.name : testConnectDeviceParamEx012
|
|
* @tc.desc : Negative test: devices manufacturerName add special characters ""
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx012', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx012 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
devices.manufacturerName = PARAM_NULLSTRING;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx012 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2100
|
|
* @tc.name : testConnectDeviceParamEx013
|
|
* @tc.desc : Negative test: devices productName add special characters '@#'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx013', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx013 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devProductName = devices.productName + "@#";
|
|
devices.productName = devProductName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx013 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2200
|
|
* @tc.name : testConnectDeviceParamEx014
|
|
* @tc.desc : Negative test: devices productName add special characters 'abc'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx014', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx014 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devProductName = devices.productName + "abc";
|
|
devices.productName = devProductName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx014 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2300
|
|
* @tc.name : testConnectDeviceParamEx015
|
|
* @tc.desc : Negative test: devices productName add special characters '123'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx015', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx015 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devProductName = devices.productName + "123";
|
|
devices.productName = devProductName;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx015 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2400
|
|
* @tc.name : testConnectDeviceParamEx016
|
|
* @tc.desc : Negative test: devices productName is null string ""
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx016', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx016 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
devices.productName = PARAM_NULLSTRING;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx016 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2500
|
|
* @tc.name : testConnectDeviceParamEx017
|
|
* @tc.desc : Negative test: devices version add special characters '@#'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx017', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx017 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devVersion = devices.version + "@#";
|
|
devices.version = devVersion;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx017 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2600
|
|
* @tc.name : testConnectDeviceParamEx018
|
|
* @tc.desc : Negative test: devices version add special characters 'abc'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx018', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx018 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devVersion = devices.version + "abc";
|
|
devices.version = devVersion;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx018 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2700
|
|
* @tc.name : testConnectDeviceParamEx019
|
|
* @tc.desc : Negative test: devices version add special characters '123'
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx019', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx019 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devVersion = devices.version + "123";
|
|
devices.version = devVersion;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx019 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2800
|
|
* @tc.name : testConnectDeviceParamEx020
|
|
* @tc.desc : Negative test: devices version is null string ""
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx020', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx020 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
devices.version = PARAM_NULLSTRING;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx020 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_2900
|
|
* @tc.name : testConnectDeviceParamEx021
|
|
* @tc.desc : Negative test: devices vendorId is add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx021', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx021 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devVendorId = devices.vendorId + 1000;
|
|
devices.vendorId = devVendorId;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.vendorId, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx021 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3000
|
|
* @tc.name : testConnectDeviceParamEx022
|
|
* @tc.desc : Negative test: devices productId is add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx022', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx022 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devProductId = devices.productId + 1000;
|
|
devices.productId = devProductId;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.productId, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx022 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3100
|
|
* @tc.name : testConnectDeviceParamEx023
|
|
* @tc.desc : Negative test: devices clazz is add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx023', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx023 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devClazz = devices.clazz + 1000;
|
|
devices.clazz = devClazz;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.clazz, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx023 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3200
|
|
* @tc.name : testConnectDeviceParamEx024
|
|
* @tc.desc : Negative test: devices subClass is add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx024', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx024 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devSubClass = devices.subClass + 1000;
|
|
devices.subClass = devSubClass;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.subClass, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx024 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3300
|
|
* @tc.name : testConnectDeviceParamEx025
|
|
* @tc.desc : Negative test: devices protocol is add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx025', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx025 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devProtocol = devices.protocol + 1000;
|
|
devices.protocol = devProtocol;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.protocol, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx025 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3400
|
|
* @tc.name : testConnectDeviceParamEx026
|
|
* @tc.desc : Negative test: devices busNum is add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx026', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx026 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devBusNum = devices.busNum + 1000;
|
|
devices.busNum = devBusNum;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.busNum, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(gPipe !== null).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx026 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err.code).assertEqual(14400001);
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3500
|
|
* @tc.name : testConnectDeviceParamEx027
|
|
* @tc.desc : Negative test: devices devAddress is add number 10000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testConnectDeviceParamEx027', 0, function () {
|
|
console.info(TAG, 'usb testConnectDeviceParamEx027 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
try {
|
|
let devDevAddress = devices.devAddress + 1000;
|
|
devices.devAddress = devDevAddress;
|
|
let gPipe = usbManager.connectDevice(devices);
|
|
console.info(TAG, 'usb [', devices.devAddress, '] connectDevice ret : ', JSON.stringify(gPipe));
|
|
expect(gPipe !== null).assertFalse();
|
|
} catch (err) {
|
|
console.info(TAG, 'testConnectDeviceParamEx027 catch err code: ', err.code, ', message: ', err.message);
|
|
expect(err.code).assertEqual(14400001);
|
|
}
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3600
|
|
* @tc.name : testClosePipeParamEx001
|
|
* @tc.desc : Negative test: pipe busNum add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClosePipeParamEx001', 0, function () {
|
|
console.info(TAG, 'usb testClosePipeParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClosePipeParamEx001");
|
|
try {
|
|
gPipe.busNum = gPipe.busNum + 1000;
|
|
let ret = usbManager.closePipe(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.busNum, '] closePipe ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClosePipeParamEx001 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClosePipeParamEx001");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3700
|
|
* @tc.name : testClosePipeParamEx002
|
|
* @tc.desc : Negative test: pipe devAddress add number 10000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClosePipeParamEx002', 0, function () {
|
|
console.info(TAG, 'usb testClosePipeParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClosePipeParamEx002");
|
|
try {
|
|
let pipDevAdd = gPipe.devAddress + 10000;
|
|
gPipe.devAddress = pipDevAdd;
|
|
let ret = usbManager.closePipe(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] closePipe ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClosePipeParamEx002 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClosePipeParamEx002");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3800
|
|
* @tc.name : testGetRawDescriptorParamEx001
|
|
* @tc.desc : Negative test: pipe busNum add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetRawDescriptorParamEx001', 0, function () {
|
|
console.info(TAG, 'usb testGetRawDescriptorParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetRawDescriptorParamEx001");
|
|
try {
|
|
let pipBusNum = gPipe.busNum + 1000;
|
|
gPipe.busNum = pipBusNum;
|
|
let ret = usbManager.getRawDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.busNum, '] getRawDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(undefined);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetRawDescriptorParamEx001 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetRawDescriptorParamEx001");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_3900
|
|
* @tc.name : testGetRawDescriptorParamEx002
|
|
* @tc.desc : Negative test: pipe devAddress add number 10000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetRawDescriptorParamEx002', 0, function () {
|
|
console.info(TAG, 'usb testGetRawDescriptorParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetRawDescriptorParamEx002");
|
|
try {
|
|
let pipDevAdd = gPipe.devAddress + 10000;
|
|
gPipe.devAddress = pipDevAdd;
|
|
let ret = usbManager.getRawDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] getRawDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(undefined);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetRawDescriptorParamEx002 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetRawDescriptorParamEx002");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4000
|
|
* @tc.name : testGetRawDescriptorParamEx003
|
|
* @tc.desc : Negative test: pipe busNum -23
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetRawDescriptorParamEx003', 0, function () {
|
|
console.info(TAG, 'usb testGetRawDescriptorParamEx003 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetRawDescriptorParamEx003");
|
|
try {
|
|
gPipe.busNum = -23;
|
|
let ret = usbManager.getRawDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.busNum, '] getRawDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(undefined);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetRawDescriptorParamEx003 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetRawDescriptorParamEx003");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4100
|
|
* @tc.name : testGetRawDescriptorParamEx004
|
|
* @tc.desc : Negative test: pipe devAddress -23
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetRawDescriptorParamEx004', 0, function () {
|
|
console.info(TAG, 'usb testGetRawDescriptorParamEx004 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetRawDescriptorParamEx004");
|
|
try {
|
|
gPipe.devAddress = -23;
|
|
let ret = usbManager.getRawDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] getRawDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(undefined);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetRawDescriptorParamEx004 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetRawDescriptorParamEx004");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4200
|
|
* @tc.name : testGetRawDescriptorParamEx005
|
|
* @tc.desc : Negative test: pipe busNum -23, devAddress -23
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetRawDescriptorParamEx005', 0, function () {
|
|
console.info(TAG, 'usb testGetRawDescriptorParamEx005 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetRawDescriptorParamEx005");
|
|
try {
|
|
gPipe.busNum = -23;
|
|
gPipe.devAddress = -23;
|
|
let ret = usbManager.getRawDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] getRawDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(undefined);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetRawDescriptorParamEx005 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetRawDescriptorParamEx005");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4300
|
|
* @tc.name : testGetFileDescriptorParamEx001
|
|
* @tc.desc : Negative test: pipe busNum add number 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetFileDescriptorParamEx001', 0, function () {
|
|
console.info(TAG, 'usb testGetFileDescriptorParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetFileDescriptorParamEx001");
|
|
try {
|
|
let pipBusNum = gPipe.busNum + 1000;
|
|
gPipe.busNum = pipBusNum;
|
|
let ret = usbManager.getFileDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.busNum, '] getFileDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(-1);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetFileDescriptorParamEx001 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetFileDescriptorParamEx001");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4400
|
|
* @tc.name : testGetFileDescriptorParamEx002
|
|
* @tc.desc : Negative test: pipe devAddress add number 10000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetFileDescriptorParamEx002', 0, function () {
|
|
console.info(TAG, 'usb testGetFileDescriptorParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetFileDescriptorParamEx002");
|
|
try {
|
|
let pipDevAdd = gPipe.devAddress + 10000;
|
|
gPipe.devAddress = pipDevAdd;
|
|
let ret = usbManager.getFileDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] getFileDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(-1);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetFileDescriptorParamEx002 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetFileDescriptorParamEx002");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4500
|
|
* @tc.name : testGetFileDescriptorParamEx003
|
|
* @tc.desc : Negative test: pipe busNum -23
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetFileDescriptorParamEx003', 0, function () {
|
|
console.info(TAG, 'usb testGetFileDescriptorParamEx003 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetFileDescriptorParamEx003");
|
|
try {
|
|
gPipe.busNum = -23;
|
|
let ret = usbManager.getFileDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.busNum, '] getFileDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(-1);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetFileDescriptorParamEx003 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetFileDescriptorParamEx003");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4600
|
|
* @tc.name : testGetFileDescriptorParamEx004
|
|
* @tc.desc : Negative test: pipe devAddress -23
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetFileDescriptorParamEx004', 0, function () {
|
|
console.info(TAG, 'usb testGetFileDescriptorParamEx004 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetFileDescriptorParamEx004");
|
|
try {
|
|
gPipe.devAddress = -23;
|
|
let ret = usbManager.getFileDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] getFileDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(-1);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetFileDescriptorParamEx004 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetFileDescriptorParamEx004");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4700
|
|
* @tc.name : testGetFileDescriptorParamEx005
|
|
* @tc.desc : Negative test: pipe busNum -23, devAddress -23
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testGetFileDescriptorParamEx005', 0, function () {
|
|
console.info(TAG, 'usb testGetFileDescriptorParamEx005 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testGetFileDescriptorParamEx005");
|
|
try {
|
|
gPipe.busNum = -23;
|
|
gPipe.devAddress = -23;
|
|
let ret = usbManager.getFileDescriptor(gPipe);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] getFileDescriptor ret : ', ret);
|
|
expect(ret).assertEqual(-1);
|
|
} catch (err) {
|
|
console.info(TAG, 'testGetFileDescriptorParamEx005 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testGetFileDescriptorParamEx005");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4800
|
|
* @tc.name : testClaimInterfaceParamEx001
|
|
* @tc.desc : Negative test: interfaces id add 123
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx001', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx001 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx001");
|
|
try {
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
tmpInterface.id = tmpInterface.id + 123;
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', tmpInterface.id, '] claimInterface ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx001 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx001");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_4900
|
|
* @tc.name : testClaimInterfaceParamEx002
|
|
* @tc.desc : Negative test: interfaces id -1
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx002', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx002 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx002");
|
|
try {
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
tmpInterface.id = -1;
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', tmpInterface.id, '] claimInterface ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx002 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx002");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5000
|
|
* @tc.name : testClaimInterfaceParamEx003
|
|
* @tc.desc : Negative test: pipe busNum add 1000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx003', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx003 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx003");
|
|
try {
|
|
gPipe.busNum = gPipe.busNum + 1000;
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', gPipe.busNum, '] claimInterface ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx003 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx003");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5100
|
|
* @tc.name : testClaimInterfaceParamEx004
|
|
* @tc.desc : Negative test: pipe busNum -1
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx004', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx004 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx004");
|
|
try {
|
|
gPipe.busNum = -1;
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', gPipe.busNum, '] claimInterface ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx004 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx004");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5200
|
|
* @tc.name : testClaimInterfaceParamEx005
|
|
* @tc.desc : Negative test: pipe devAddress add 10000
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx005', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx005 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx005");
|
|
try {
|
|
gPipe.devAddress = gPipe.devAddress + 10000;
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] claimInterface ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx005 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx005");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5300
|
|
* @tc.name : testClaimInterfaceParamEx006
|
|
* @tc.desc : Negative test: pipe devAddress -1
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx006', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx006 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx006");
|
|
try {
|
|
gPipe.devAddress = -1;
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', gPipe.devAddress, '] claimInterface ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx006 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx006");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5400
|
|
* @tc.name : testClaimInterfaceParamEx007
|
|
* @tc.desc : Negative test: pipe devAddress -1, busNum -1
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx007', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx007 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx007");
|
|
try {
|
|
gPipe.busNum = -1;
|
|
gPipe.devAddress = -1;
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', gPipe.busNum , ", ",gPipe.devAddress, '] claimInterface ret : ', ret);
|
|
expect(ret !== 0).assertTrue();
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx007 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx007");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5500
|
|
* @tc.name : testClaimInterfaceParamEx008
|
|
* @tc.desc : Negative test: interfaces protocol add 100
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx008', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx008 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx008");
|
|
try {
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
tmpInterface.protocol = tmpInterface.protocol + 100;
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', tmpInterface.protocol, '] claimInterface ret : ', ret);
|
|
expect(ret).assertEqual(0);
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx008 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx008");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5600
|
|
* @tc.name : testClaimInterfaceParamEx009
|
|
* @tc.desc : Negative test: interfaces clazz add 100
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx009', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx009 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx009");
|
|
try {
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
tmpInterface.clazz = tmpInterface.clazz + 100;
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', tmpInterface.clazz, '] claimInterface ret : ', ret);
|
|
expect(ret).assertEqual(0);
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx009 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx009");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5700
|
|
* @tc.name : testClaimInterfaceParamEx010
|
|
* @tc.desc : Negative test: interfaces name add 123
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx010', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx010 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx010");
|
|
try {
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
tmpInterface.name = tmpInterface.name + '123';
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', tmpInterface.name, '] claimInterface ret : ', ret);
|
|
expect(ret).assertEqual(0);
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx010 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx010");
|
|
})
|
|
|
|
/**
|
|
* @tc.number : SUB_USB_HostManager_JS_ParamEx_5800
|
|
* @tc.name : testClaimInterfaceParamEx011
|
|
* @tc.desc : Negative test: interfaces name add @#
|
|
* @tc.size : MediumTest
|
|
* @tc.type : Function
|
|
* @tc.level : Level 3
|
|
*/
|
|
it('testClaimInterfaceParamEx011', 0, function () {
|
|
console.info(TAG, 'usb testClaimInterfaceParamEx011 begin');
|
|
if (!isDeviceConnected) {
|
|
expect(isDeviceConnected).assertFalse();
|
|
return
|
|
}
|
|
getPipe("testClaimInterfaceParamEx011");
|
|
try {
|
|
let tmpInterface = devices.configs[0].interfaces[0];
|
|
tmpInterface.name = tmpInterface.name + '@#';
|
|
let ret = usbManager.claimInterface(gPipe, tmpInterface);
|
|
console.info(TAG, 'usb [', tmpInterface.name, '] claimInterface ret : ', ret);
|
|
expect(ret).assertEqual(0);
|
|
} catch (err) {
|
|
console.info(TAG, 'testClaimInterfaceParamEx011 catch err code: ', err);
|
|
expect(err !== null).assertFalse();
|
|
}
|
|
toClosePipe("testClaimInterfaceParamEx011");
|
|
})
|
|
})
|
|
}
|