/*
* 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");
})
})
}