openharmony/xts_hats
1
0
Fork 0
mirror of https://gitee.com/openharmony/xts_hats synced 2024-12-02 20:29:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

usb test

Browse Source 
Signed-off-by: liuhonggang123 <honggang.liu@huawei.com>
Change-Id: Ibcb7ded3675db1b15a96d5228ba6b1c760b680d3
This commit is contained in:
liuhonggang123 2022-02-26 16:43:25 +08:00
parent 62e0e82710
commit cc441e0dff
17 changed files with 2283 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
hdf/usb/BUILD.gn Normal file
View File

@ -0,0 +1,25 @@
# Copyright (c) 2021 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("//build/ohos_var.gni")
import("//test/xts/tools/build/suite.gni")
group("HatsHdfUsbTest") {
testonly = true
deps = [
"deviceTest:HatsHdfUsbDeviceTest",
"functionTest:HatsHdfUsbFunctionTest",
"requestTest:HatsHdfUsbRequestTest",
"transferTest:HatsHdfUsbTransferTest",
]
}

47
hdf/usb/deviceTest/BUILD.gn Normal file
View File

@ -0,0 +1,47 @@
# Copyright (c) 2021 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("//build/ohos_var.gni")
import("//test/xts/tools/build/suite.gni")
module_output_path = "hdf/usb"
ohos_moduletest_suite("HatsHdfUsbDeviceTest") {
module_out_path = module_output_path
sources = [ "./common/usbd_device_test.cpp" ]
include_dirs = [
"include",
"//utils/system/safwk/native/include",
"//drivers/peripheral/usb/hal/client/include",
]
deps = [
"//drivers/peripheral/usb/ddk:libusb_core",
"//drivers/peripheral/usb/hal/client:usbd_client",
"//third_party/googletest:gtest_main",
]
external_deps = [
"ability_base:want",
"bundle_framework:appexecfwk_base",
"ces_standard:cesfwk_innerkits",
"device_driver_framework:libhdf_utils",
"eventhandler:libeventhandler",
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_single",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
"utils_base:utils",
]
}

18
hdf/usb/deviceTest/Test.json Normal file
View File

@ -0,0 +1,18 @@
{
"kits": [
{
"push": [
"HatsHdfUsbDeviceTest->/data/local/tmp/HatsHdfUsbDeviceTest"
],
"type": "PushKit"
}
],
"driver": {
"native-test-timeout": "120000",
"type": "CppTest",
"module-name": "HatsHdfUsbDeviceTest",
"runtime-hint": "1s",
"native-test-device-path": "/data/local/tmp"
},
"description": "Configuration for HatsHdfUsbDeviceTest Tests"
}

125
hdf/usb/deviceTest/common/usbd_device_test.cpp Normal file
View File

@ -0,0 +1,125 @@
/*
* Copyright (c) 2021 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.
*/
#include "usbd_device_test.h"
#include <iostream>
#include <vector>
#include "hdf_log.h"
#include "usb_param.h"
#include "usbd_client.h"
using namespace testing::ext;
using namespace OHOS;
using namespace OHOS::USB;
using namespace std;
const int SLEEP_TIME = 3;
const uint8_t BUS_NUM_1 = 1;
const uint8_t DEV_ADDR_2 = 2;
const uint8_t BUS_NUM_255 = 255;
void UsbdDeviceTest::SetUpTestCase(void)
{
auto ret = UsbdClient::GetInstance().SetPortRole(1, 1, 1);
sleep(SLEEP_TIME);
HDF_LOGI("UsbdFunctionTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
if (ret != 0) {
exit(0);
}
std::cout << "please connect device, press enter to continue" << std::endl;
int c;
while ((c = getchar()) != '\n' && c != EOF) {
}
}
void UsbdDeviceTest::TearDownTestCase(void) {}
void UsbdDeviceTest::SetUp(void) {}
void UsbdDeviceTest::TearDown(void) {}
/**
* @tc.name: UsbdDevice001
* @tc.desc: Test functions to OpenDevice
* @tc.desc: int32_t OpenDevice(const UsbDev &dev);
* @tc.type: FUNC
*/
HWTEST_F(UsbdDeviceTest, UsbdOpenDevice001, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_1;
uint8_t devAddr = DEV_ADDR_2;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().OpenDevice(dev);
HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result =%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDevice002
* @tc.desc: Test functions to OpenDevice
* @tc.desc: int32_t OpenDevice(const UsbDev &dev);
* @tc.type: FUNC
*/
HWTEST_F(UsbdDeviceTest, UsbdOpenDevice002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_255;
uint8_t devAddr = DEV_ADDR_2;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().OpenDevice(dev);
HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdDevice011
* @tc.desc: Test functions to CloseDevice
* @tc.desc: int32_t CloseDevice(const UsbDev &dev);
* @tc.type: FUNC
*/
HWTEST_F(UsbdDeviceTest, UsbdCloseDevice001, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_1;
uint8_t devAddr = DEV_ADDR_2;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().OpenDevice(dev);
HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
ret = UsbdClient::GetInstance().CloseDevice(dev);
HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDevice012
* @tc.desc: Test functions to CloseDevice
* @tc.desc: int32_t CloseDevice(const UsbDev &dev);
* @tc.type: FUNC
*/
HWTEST_F(UsbdDeviceTest, UsbdCloseDevice002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_1;
uint8_t devAddr = DEV_ADDR_2;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().OpenDevice(dev);
HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
dev.busNum = BUS_NUM_255;
ret = UsbdClient::GetInstance().CloseDevice(dev);
HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
dev.busNum = BUS_NUM_1;
UsbdClient::GetInstance().CloseDevice(dev);
}

27
hdf/usb/deviceTest/include/usbd_device_test.h Normal file
View File

@ -0,0 +1,27 @@
/*
* Copyright (c) 2021 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.
*/
#ifndef USBD_DEVICE_TEST_H
#define USBD_DEVICE_TEST_H
#include <gtest/gtest.h>
class UsbdDeviceTest : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
#endif // USBD_DEVICE_TEST_H

46
hdf/usb/functionTest/BUILD.gn Normal file
View File

@ -0,0 +1,46 @@
# Copyright (c) 2021 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("//build/ohos_var.gni")
import("//test/xts/tools/build/suite.gni")
module_output_path = "hdf/usb"
ohos_moduletest_suite("HatsHdfUsbFunctionTest") {
module_out_path = module_output_path
sources = [ "./common/usbd_function_test.cpp" ]
include_dirs = [
"include",
"//utils/system/safwk/native/include",
"//drivers/peripheral/usb/hal/client/include",
]
deps = [
"//drivers/peripheral/usb/hal/client:usbd_client",
"//third_party/googletest:gtest_main",
]
external_deps = [
"ability_base:want",
"bundle_framework:appexecfwk_base",
"ces_standard:cesfwk_innerkits",
"device_driver_framework:libhdf_utils",
"eventhandler:libeventhandler",
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_single",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
"utils_base:utils",
]
}

18
hdf/usb/functionTest/Test.json Normal file
View File

@ -0,0 +1,18 @@
{
"kits": [
{
"push": [
"HatsHdfUsbFunctionTest->/data/local/tmp/HatsHdfUsbFunctionTest"
],
"type": "PushKit"
}
],
"driver": {
"native-test-timeout": "120000",
"type": "CppTest",
"module-name": "HatsHdfUsbFunctionTest",
"runtime-hint": "1s",
"native-test-device-path": "/data/local/tmp"
},
"description": "Configuration for HatsHdfUsbFunctionTest Tests"
}

234
hdf/usb/functionTest/common/usbd_function_test.cpp Normal file
View File

@ -0,0 +1,234 @@
/*
* Copyright (c) 2021 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.
*/
#include "usbd_function_test.h"
#include <iostream>
#include "hdf_log.h"
#include "if_system_ability_manager.h"
#include "system_ability_definition.h"
#include "usbd_client.h"
using namespace testing::ext;
using namespace OHOS;
using namespace OHOS::USB;
using namespace std;
const int SLEEP_TIME = 3;
const int TEST_PORT_ID = 1;
const int TEST_POWER_ROLE = 2;
const int TEST_DATAR_ROLE = 2;
const int USB_FUNCTION_ACM = 1;
const int USB_FUNCTION_ECM = 2;
const int USB_FUNCTION_HDC = 4;
void UsbdFunctionTest::SetUpTestCase(void)
{
auto ret = UsbdClient::GetInstance().SetPortRole(TEST_PORT_ID, TEST_POWER_ROLE, TEST_DATAR_ROLE);
sleep(SLEEP_TIME);
HDF_LOGI("UsbdFunctionTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
if (ret != 0) {
exit(0);
}
}
void UsbdFunctionTest::TearDownTestCase(void) {}
void UsbdFunctionTest::SetUp(void) {}
void UsbdFunctionTest::TearDown(void) {}
/**
* @tc.name: UsbdGetCurrentFunctions001
* @tc.desc: Test functions to GetCurrentFunctions
* @tc.desc: int32_t GetCurrentFunctions(int32_t &funcs);
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdGetCurrentFunctions001, Function | MediumTest | Level1)
{
int32_t funcs = 0;
auto ret = UsbdClient::GetInstance().GetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdGetCurrentFunctions001 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdGetCurrentFunctions002
* @tc.desc: Test functions to GetCurrentFunctions
* @tc.desc: int32_t GetCurrentFunctions(int32_t &funcs);
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdGetCurrentFunctions002, Function | MediumTest | Level1)
{
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(1);
HDF_LOGI("UsbdFunctionTest::UsbdFunction011 %{public}d SetCurrentFunctions=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
int32_t funcs = 1;
ret = UsbdClient::GetInstance().GetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdFunction001 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetCurrentFunctions001
* @tc.desc: Test functions to SetCurrentFunctions
* @tc.desc: int32_t SetCurrentFunctions(int32_t funcs)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetCurrentFunctions001, Function | MediumTest | Level1)
{
int32_t funcs = 1;
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdSetCurrentFunctions001 %{public}d SetCurrentFunctions=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetCurrentFunctions002
* @tc.desc: Test functions to SetCurrentFunctions
* @tc.desc: int32_t SetCurrentFunctions(int32_t funcs)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetCurrentFunctions002, Function | MediumTest | Level1)
{
int32_t funcs = -1;
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdFunction002 %{public}d, ret=%{public}d, funcs=%{public}d", __LINE__, ret, funcs);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdSetCurrentFunctions003
* @tc.desc: Test functions to SetCurrentFunctions
* @tc.desc: int32_t SetCurrentFunctions(int32_t funcs)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetCurrentFunctions003, Function | MediumTest | Level1)
{
int32_t funcs = USB_FUNCTION_ECM;
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdSetCurrentFunctions003 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetCurrentFunctions004
* @tc.desc: Test functions to SetCurrentFunctions
* @tc.desc: int32_t SetCurrentFunctions(int32_t funcs)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetCurrentFunctions004, Function | MediumTest | Level1)
{
int32_t funcs = USB_FUNCTION_ACM | USB_FUNCTION_ECM;
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdSetCurrentFunctions004 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetCurrentFunctions005
* @tc.desc: Test functions to SetCurrentFunctions
* @tc.desc: int32_t SetCurrentFunctions(int32_t funcs)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetCurrentFunctions005, Function | MediumTest | Level1)
{
int32_t funcs = USB_FUNCTION_HDC;
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdSetCurrentFunctions005 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetCurrentFunctions006
* @tc.desc: Test functions to SetCurrentFunctions
* @tc.desc: int32_t SetCurrentFunctions(int32_t funcs)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetCurrentFunctions006, Function | MediumTest | Level1)
{
int32_t funcs = USB_FUNCTION_ACM | USB_FUNCTION_HDC;
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdSetCurrentFunctions006 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetCurrentFunctions007
* @tc.desc: Test functions to SetCurrentFunctions
* @tc.desc: int32_t SetCurrentFunctions(int32_t funcs)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetCurrentFunctions007, Function | MediumTest | Level1)
{
int32_t funcs = USB_FUNCTION_ECM | USB_FUNCTION_HDC;
auto ret = UsbdClient::GetInstance().SetCurrentFunctions(funcs);
HDF_LOGI("UsbdFunctionTest::UsbdSetCurrentFunctions007 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetPortRole001
* @tc.desc: Test functions to SetPortRole
* @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetPortRole001, Function | MediumTest | Level1)
{
auto ret = UsbdClient::GetInstance().SetPortRole(1, 1, 1);
HDF_LOGI("UsbdFunctionTest::UsbdSetPortRole001 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetPortRole002
* @tc.desc: Test functions to SetPortRole
* @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, UsbdSetPortRole002, Function | MediumTest | Level1)
{
auto ret = UsbdClient::GetInstance().SetPortRole(2, 1, 1);
HDF_LOGI("UsbdFunctionTest::UsbdSetPortRole002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: SetPortRole009
* @tc.desc: Test functions to SetPortRole
* @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole)
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, SetPortRole09, Function | MediumTest | Level1)
{
auto ret = UsbdClient::GetInstance().SetPortRole(1, 2, 2);
HDF_LOGI("UsbdFunctionTest::SetPortRole09 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: QueryPort001
* @tc.desc: Test functions to QueryPort
* @tc.desc: int32_t QueryPort(int32_t &portId, int32_t &powerRole, int32_t &dataRole, int32_t &mode);
* @tc.type: FUNC
*/
HWTEST_F(UsbdFunctionTest, QueryPort001, Function | MediumTest | Level1)
{
int32_t portId = 0;
int32_t powerRole = 0;
int32_t dataRole = 0;
int32_t mode = 0;
auto ret = UsbdClient::GetInstance().QueryPort(portId, powerRole, dataRole, mode);
HDF_LOGI("UsbdFunctionTest::QueryPort001 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}

27
hdf/usb/functionTest/include/usbd_function_test.h Normal file
View File

@ -0,0 +1,27 @@
/*
* Copyright (c) 2021 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.
*/
#ifndef USBD_FUNCTION_TEST_H
#define USBD_FUNCTION_TEST_H
#include <gtest/gtest.h>
class UsbdFunctionTest : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
#endif // USBD_FUNCTION_TEST_H

47
hdf/usb/requestTest/BUILD.gn Normal file
View File

@ -0,0 +1,47 @@
# Copyright (c) 2021 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("//build/ohos_var.gni")
import("//test/xts/tools/build/suite.gni")
module_output_path = "hdf/usb"
ohos_moduletest_suite("HatsHdfUsbRequestTest") {
module_out_path = module_output_path
sources = [ "./common/usbd_request_test.cpp" ]
include_dirs = [
"include",
"//utils/system/safwk/native/include",
"//drivers/peripheral/usb/hal/client/include",
]
deps = [
"//drivers/peripheral/usb/ddk:libusb_core",
"//drivers/peripheral/usb/hal/client:usbd_client",
"//third_party/googletest:gtest_main",
]
external_deps = [
"ability_base:want",
"bundle_framework:appexecfwk_base",
"ces_standard:cesfwk_innerkits",
"device_driver_framework:libhdf_utils",
"eventhandler:libeventhandler",
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_single",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
"utils_base:utils",
]
}

18
hdf/usb/requestTest/Test.json Normal file
View File

@ -0,0 +1,18 @@
{
"kits": [
{
"push": [
"HatsHdfUsbRequestTest->/data/local/tmp/HatsHdfUsbRequestTest"
],
"type": "PushKit"
}
],
"driver": {
"native-test-timeout": "120000",
"type": "CppTest",
"module-name": "HatsHdfUsbRequestTest",
"runtime-hint": "1s",
"native-test-device-path": "/data/local/tmp"
},
"description": "Configuration for HatsHdfUsbRequestTest Tests"
}

944
hdf/usb/requestTest/common/usbd_request_test.cpp Normal file
View File

@ -0,0 +1,944 @@
/*
* Copyright (c) 2021 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.
*/
#include "usbd_request_test.h"
#include <iostream>
#include <vector>
#include "hdf_log.h"
#include "usb_param.h"
#include "usbd_client.h"
using namespace testing::ext;
using namespace OHOS;
using namespace OHOS::USB;
using namespace std;
const int SLEEP_TIME = 3;
const uint8_t BUS_NUM_1 = 1;
const uint8_t DEV_ADDR_2 = 2;
const uint8_t BUS_NUM_255 = 255;
const uint8_t DEV_ADDR_255 = 255;
const uint8_t BUS_NUM_222 = 222;
const uint8_t DEV_ADDR_222 = 222;
const uint32_t LENGTH_NUM_255 = 255;
const uint32_t TAG_LENGTH_NUM_1000 = 1000;
const int TAG_NUM_10 = 10;
const int TAG_NUM_11 = 11;
const uint8_t INTERFACEID_1 = 1;
const uint8_t POINTID_1 = 1;
const uint8_t POINTID_129 = 129;
void UsbdRequestTest::SetUpTestCase(void)
{
auto ret = UsbdClient::GetInstance().SetPortRole(1, 1, 1);
sleep(SLEEP_TIME);
HDF_LOGI("UsbdFunctionTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
if (ret != 0) {
exit(0);
}
std::cout << "please connect device, press enter to continue" << std::endl;
int c;
while ((c = getchar()) != '\n' && c != EOF) {
}
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
ret = UsbdClient::GetInstance().OpenDevice(dev);
HDF_LOGI("UsbdRequestTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
void UsbdRequestTest::TearDownTestCase(void)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
auto ret = UsbdClient::GetInstance().CloseDevice(dev);
HDF_LOGI("UsbdRequestTest:: %{public}d Close=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
void UsbdRequestTest::SetUp(void) {}
void UsbdRequestTest::TearDown(void) {}
/**
* @tc.name: UsbdConfig001
* @tc.desc: Test functions to SetConfig
* @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdSetConfig001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t configIndex = 1;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().SetConfig(dev, configIndex);
HDF_LOGI("UsbdRequestTest::UsbdSetConfigConfig001 %{public}d SetConfig=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdConfig002
* @tc.desc: Test functions to SetConfig
* @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdSetConfig002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_222;
uint8_t devAddr = 2;
uint8_t configIndex = 1;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().SetConfig(dev, configIndex);
HDF_LOGI("UsbdRequestTest::UsbdSetConfig002 %{public}d SetConfig=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdConfig001
* @tc.desc: Test functions to GetConfig
* @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
* @tc.desc: 正向测试：参数正确
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetConfig001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t configIndex = 1;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().GetConfig(dev, configIndex);
HDF_LOGI("UsbdRequestTest::UsbdGetConfig001 %{public}d GetConfig=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdConfig002
* @tc.desc: Test functions to GetConfig
* @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetConfig002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_222;
uint8_t devAddr = 2;
uint8_t configIndex = 1;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().GetConfig(dev, configIndex);
HDF_LOGI("UsbdRequestTest::UsbdGetConfig002 %{public}d GetConfig=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdClaimInterface001
* @tc.desc: Test functions to ClaimInterface
* @tc.desc: int32_t ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdClaimInterface001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdClaimInterface001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdClaimInterface002
* @tc.desc: Test functions to ClaimInterface
* @tc.desc: int32_t ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdClaimInterface002, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {busNum, devAddr};
dev.busNum = 20;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdClaimInterface002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdSetInterface001
* @tc.desc: Test functions to SetInterface
* @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdSetInterface001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t altIndex = 0;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdClaimInterface001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
ret = UsbdClient::GetInstance().SetInterface(dev, interfaceId, altIndex);
HDF_LOGI("UsbdRequestTest::UsbdSetInterface001 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdSetInterface002
* @tc.desc: Test functions to SetInterface
* @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdSetInterface002, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t altIndex = 0;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdSetInterface002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
dev.busNum = BUS_NUM_222;
ret = UsbdClient::GetInstance().SetInterface(dev, interfaceId, altIndex);
HDF_LOGI("UsbdRequestTest::UsbdSetInterface002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdDescriptor001
* @tc.desc: Test functions to GetDeviceDescriptor
* @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint32_t length = LENGTH_NUM_255;
uint8_t buffer[LENGTH_NUM_255] = {0};
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetDeviceDescriptor(dev, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDescriptor002
* @tc.desc: Test functions to GetDeviceDescriptor
* @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_222;
uint8_t devAddr = 2;
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetDeviceDescriptor(dev, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdDescriptor004
* @tc.desc: Test functions to GetDeviceDescriptor
* @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor004, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t buffer[LENGTH_NUM_255] = {};
uint32_t length = 0;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetDeviceDescriptor(dev, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor004 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor004 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDescriptor001
* @tc.desc: Test functions to GetStringDescriptor
* @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t stringId = 0;
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDescriptor002
* @tc.desc: Test functions to GetStringDescriptor
* @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor002, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t stringId = 1;
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDescriptor003
* @tc.desc: Test functions to GetStringDescriptor
* @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor003, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t stringId = 222;
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor003 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor003 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDescriptor004
* @tc.desc: Test functions to GetStringDescriptor
* @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor004, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 255;
uint8_t stringId = 0;
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = 8;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor004 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor004 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdDescriptor001
* @tc.desc: Test functions to GetConfigDescriptor
* @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t configId = 0;
uint8_t buffer[LENGTH_NUM_255] = {};
uint32_t length = LENGTH_NUM_255;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetConfigDescriptor(dev, configId, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdDescriptor002
* @tc.desc: Test functions to GetConfigDescriptor
* @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_222;
uint8_t devAddr = 2;
uint8_t configId = 1;
uint8_t buffer[LENGTH_NUM_255] = {};
uint32_t length = LENGTH_NUM_255;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetConfigDescriptor(dev, configId, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdDescriptor004
* @tc.desc: Test functions to GetConfigDescriptor
* @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor004, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t configId = 1;
uint8_t buffer[LENGTH_NUM_255] = {};
uint32_t length = LENGTH_NUM_255;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> devdata(buffer, buffer + length);
auto ret = UsbdClient::GetInstance().GetConfigDescriptor(dev, configId, devdata);
HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor004 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
devdata.size(), sizeof(devdata));
HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor004 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdGetRawDescriptor001
* @tc.desc: Test functions to GetRawDescriptor
* @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetRawDescriptor001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> rawData;
auto ret = UsbdClient::GetInstance().GetRawDescriptor(dev, rawData);
HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
rawData.size(), sizeof(rawData));
HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdGetRawDescriptor002
* @tc.desc: Test functions to GetRawDescriptor
* @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdGetRawDescriptor002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_222;
uint8_t devAddr = 2;
struct UsbDev dev = {busNum, devAddr};
std::vector<uint8_t> rawData;
auto ret = UsbdClient::GetInstance().GetRawDescriptor(dev, rawData);
HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
rawData.size(), sizeof(rawData));
HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: GetFileDescriptor001
* @tc.desc: Test functions to GetFileDescriptor
* @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, GetFileDescriptor001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
struct UsbDev dev = {busNum, devAddr};
int32_t fd = 0;
auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor001 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor001 %{public}d fd=%{public}d", __LINE__, fd);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: GetFileDescriptor002
* @tc.desc: Test functions to GetFileDescriptor
* @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, GetFileDescriptor002, Function | MediumTest | Level1)
{
uint8_t busNum = BUS_NUM_222;
uint8_t devAddr = 2;
struct UsbDev dev = {busNum, devAddr};
int32_t fd = 0;
auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor002 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor002 %{public}d fd=%{public}d", __LINE__, fd);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: GetFileDescriptor003
* @tc.desc: Test functions to GetFileDescriptor
* @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, GetFileDescriptor003, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = DEV_ADDR_222;
struct UsbDev dev = {busNum, devAddr};
int32_t fd = 0;
auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor003 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor003 %{public}d fd=%{public}d", __LINE__, fd);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: GetFileDescriptor004
* @tc.desc: Test functions to GetFileDescriptor
* @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, GetFileDescriptor004, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
struct UsbDev dev = {busNum, devAddr};
int32_t fd = LENGTH_NUM_255;
auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor004 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
HDF_LOGI("UsbdRequestTest::GetFileDescriptor004 %{public}d fd=%{public}d", __LINE__, fd);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdRequest001
* @tc.desc: Test functions to RequestQueue
* @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
std::vector<uint8_t> &buffer);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestQueue001, Function | MediumTest | Level1)
{
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 %{public}d interfaceId=%{public}d pointid=%{public}d", __LINE__,
interfaceId, pointid);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdRequest002
* @tc.desc: Test functions to RequestQueue
* @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
std::vector<uint8_t> &buffer);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestQueue002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.devAddr = DEV_ADDR_2;
dev.busNum = BUS_NUM_1;
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
dev = {222, 222};
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 %{public}d interfaceId=%{public}d pointid=%{public}d", __LINE__,
interfaceId, pointid);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdRequest007
* @tc.desc: Test functions to RequestQueue
* @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
std::vector<uint8_t> &buffer);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestQueue007, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t buffer[LENGTH_NUM_255] = "request 007";
uint32_t length = LENGTH_NUM_255;
uint8_t pointid = POINTID_1;
uint8_t interfaceId = INTERFACEID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue write";
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_11};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestQueue007 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdRequest001
* @tc.desc: Test functions to RequestWait
* @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
* int32_t timeout);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestWait001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t buffer[LENGTH_NUM_255] = {};
uint32_t length = LENGTH_NUM_255;
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t *clientObj = new uint8_t[10];
std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, 10000);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d RequestWait=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
delete[] clientObj;
clientObj = nullptr;
}
/**
* @tc.name: UsbdRequest002
* @tc.desc: Test functions to RequestWait
* @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
* int32_t timeout);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestWait002, Function | MediumTest | Level1)
{
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t buffer[LENGTH_NUM_255] = {};
uint32_t length = LENGTH_NUM_255;
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbPipe pipe = {interfaceId, pointid};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
dev.busNum = BUS_NUM_222;
uint8_t *clientObj = new uint8_t[10];
std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, 10000);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d RequestWait=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
delete[] clientObj;
clientObj = nullptr;
}
/**
* @tc.name: UsbdRequest004
* @tc.desc: Test functions to RequestWait
* @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
* int32_t timeout);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestWait004, Function | MediumTest | Level1)
{
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t buffer[LENGTH_NUM_255] = {};
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
uint32_t length = LENGTH_NUM_255;
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t *clientObj = new uint8_t[10];
std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, -10000);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d RequestWait=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
delete[] clientObj;
clientObj = nullptr;
}
/**
* @tc.name: UsbdRequest005
* @tc.desc: Test functions to RequestWait
* @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
* int32_t timeout);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestWait005, Function | MediumTest | Level1)
{
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint32_t length = LENGTH_NUM_255;
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
uint8_t buffer[LENGTH_NUM_255] = {};
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t *clientObj = new uint8_t[10];
std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
dev.devAddr = DEV_ADDR_255;
dev.busNum = BUS_NUM_255;
ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, 10000);
HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d RequestWait=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
delete[] clientObj;
clientObj = nullptr;
}
/**
* @tc.name: UsbdRequest001
* @tc.desc: Test functions to RequestCancel
* @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestCancel001, Function | MediumTest | Level1)
{
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t buffer[LENGTH_NUM_255] = "request001";
uint32_t length = LENGTH_NUM_255;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
EXPECT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d RequestCancel=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdRequest002
* @tc.desc: Test functions to RequestCancel
* @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestCancel002, Function | MediumTest | Level1)
{
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint32_t length = LENGTH_NUM_255;
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
uint8_t buffer[LENGTH_NUM_255] = "request002";
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
EXPECT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
;
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
dev.busNum = BUS_NUM_222;
ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d RequestCancel=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
dev.busNum = BUS_NUM_1;
ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdRequest004
* @tc.desc: Test functions to RequestCancel
* @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestCancel004, Function | MediumTest | Level1)
{
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint32_t length = LENGTH_NUM_255;
uint8_t buffer[LENGTH_NUM_255] = "request004";
uint8_t pointid = POINTID_129;
uint8_t interfaceId = INTERFACEID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
EXPECT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
pipe.interfaceId = 222;
pipe.endpointId = 222;
ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d RequestCancel=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdRequest005
* @tc.desc: Test functions to RequestCancel
* @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdRequestCancel005, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t buffer[LENGTH_NUM_255] = "request005";
uint32_t length = LENGTH_NUM_255;
uint8_t pointid = POINTID_1;
uint8_t interfaceId = INTERFACEID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
EXPECT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
uint8_t tag[TAG_LENGTH_NUM_1000] = "queue Write";
std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_11};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d RequestQueue=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d RequestCancel=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdReleaseInterface001
* @tc.desc: Test functions to ReleaseInterface
* @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdReleaseInterface001, Function | MediumTest | Level1)
{
uint8_t busNum = 1;
uint8_t devAddr = 2;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().ReleaseInterface(dev, interfaceId);
HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface001 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdReleaseInterface002
* @tc.desc: Test functions to ReleaseInterface
* @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
* @tc.type: FUNC
*/
HWTEST_F(UsbdRequestTest, UsbdReleaseInterface002, Function | MediumTest | Level1)
{
uint8_t busNum = 25;
uint8_t devAddr = 2;
uint8_t interfaceId = INTERFACEID_1;
struct UsbDev dev = {busNum, devAddr};
auto ret = UsbdClient::GetInstance().ReleaseInterface(dev, interfaceId);
HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface002 %{public}d ret=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}

27
hdf/usb/requestTest/include/usbd_request_test.h Normal file
View File

@ -0,0 +1,27 @@
/*
* Copyright (c) 2021 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.
*/
#ifndef USBD_Request_TEST_H
#define USBD_Request_TEST_H
#include <gtest/gtest.h>
class UsbdRequestTest : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
#endif // USBD_Request_TEST_H

47
hdf/usb/transferTest/BUILD.gn Normal file
View File

@ -0,0 +1,47 @@
# Copyright (c) 2021 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("//build/ohos_var.gni")
import("//test/xts/tools/build/suite.gni")
module_output_path = "hdf/usb"
ohos_moduletest_suite("HatsHdfUsbTransferTest") {
module_out_path = module_output_path
sources = [ "./common/usbd_transfer_test.cpp" ]
include_dirs = [
"include",
"//utils/system/safwk/native/include",
"//drivers/peripheral/usb/hal/client/include",
]
deps = [
"//drivers/peripheral/usb/ddk:libusb_core",
"//drivers/peripheral/usb/hal/client:usbd_client",
"//third_party/googletest:gtest_main",
]
external_deps = [
"ability_base:want",
"bundle_framework:appexecfwk_base",
"ces_standard:cesfwk_innerkits",
"device_driver_framework:libhdf_utils",
"eventhandler:libeventhandler",
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_single",
"safwk:system_ability_fwk",
"samgr_standard:samgr_proxy",
"utils_base:utils",
]
}

18
hdf/usb/transferTest/Test.json Normal file
View File

@ -0,0 +1,18 @@
{
"kits": [
{
"push": [
"HatsHdfUsbTransferTest->/data/local/tmp/HatsHdfUsbTransferTest"
],
"type": "PushKit"
}
],
"driver": {
"native-test-timeout": "120000",
"type": "CppTest",
"module-name": "HatsHdfUsbTransferTest",
"runtime-hint": "1s",
"native-test-device-path": "/data/local/tmp"
},
"description": "Configuration for HatsHdfUsbTransferTest Tests"
}

588
hdf/usb/transferTest/common/usbd_transfer_test.cpp Normal file
View File

@ -0,0 +1,588 @@
/*
* Copyright (c) 2021 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.
*/
#include "usbd_transfer_test.h"
#include <iostream>
#include <vector>
#include "hdf_log.h"
#include "usb_param.h"
#include "usbd_client.h"
using namespace testing::ext;
using namespace OHOS;
using namespace OHOS::USB;
using namespace std;
const int SLEEP_TIME = 3;
const uint8_t BUS_NUM_1 = 1;
const uint8_t DEV_ADDR_2 = 2;
const uint8_t BUS_NUM_255 = 255;
const uint8_t BUS_NUM_222 = 222;
const uint32_t LENGTH_NUM_255 = 255;
const uint8_t INTERFACEID_1 = 1;
const uint8_t POINTID_1 = 1;
const uint8_t POINTID_129 = 129;
void UsbdTransferTest::SetUpTestCase(void)
{
auto ret = UsbdClient::GetInstance().SetPortRole(1, 1, 1);
sleep(SLEEP_TIME);
HDF_LOGI("UsbdFunctionTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
if (ret != 0) {
exit(0);
}
std::cout << "please connect device, press enter to continue" << std::endl;
int c;
while ((c = getchar()) != '\n' && c != EOF) {
}
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
ret = UsbdClient::GetInstance().OpenDevice(dev);
HDF_LOGI("UsbdTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
void UsbdTransferTest::TearDownTestCase(void)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
auto ret = UsbdClient::GetInstance().CloseDevice(dev);
HDF_LOGI("UsbdTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
void UsbdTransferTest::SetUp(void) {}
void UsbdTransferTest::TearDown(void) {}
/**
* @tc.name: UsbdControlTransfer001
* @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdControlTransfer001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbCtrlTransfer ctrlparmas = {0b10000000, 8, 0, 0, 1000};
auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdControlTransfer001 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdControlTransfer002
* @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdControlTransfer002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_255;
dev.devAddr = DEV_ADDR_2;
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbCtrlTransfer ctrlparmas = {0b10000000, 8, 0, 0, 1000};
auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdControlTransfer002 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdControlTransfer004
* @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdControlTransfer004, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint32_t length = LENGTH_NUM_255;
uint8_t buffer[LENGTH_NUM_255] = {0};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbCtrlTransfer ctrlparmas = {0b10000000, 6, 0x100, 0, 1000};
auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdControlTransfer004 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdControlTransfer010
* @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdControlTransfer010, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint32_t length = LENGTH_NUM_255;
uint8_t buffer[LENGTH_NUM_255] = {0};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbCtrlTransfer ctrlparmas = {0b10000000, 0, 0, 0, 1000};
auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdControlTransfer010 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdControlTransfer013
* @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdControlTransfer013, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint32_t length = LENGTH_NUM_255;
uint8_t buffer[LENGTH_NUM_255] = {0};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0, 0, 0, 1000};
auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdControlTransfer013 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdControlTransfer016
* @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdControlTransfer016, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint32_t length = LENGTH_NUM_255;
uint8_t buffer[LENGTH_NUM_255] = {0};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0, 0, 0, 1000};
auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdControlTransfer016 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdControlTransfer019
* @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdControlTransfer019, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint32_t length = LENGTH_NUM_255;
uint8_t buffer[LENGTH_NUM_255] = {};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0X0C, 0, 0, 1000};
auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdControlTransfer019 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdBulkTransferRead001
* @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_129;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdBulkTransferRead002
* @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_129;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
dev.busNum = BUS_NUM_222;
uint32_t length = 100;
uint8_t buffer[100] = {0};
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdBulkTransferWrite001
* @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint32_t length = 100;
uint8_t buffer[100] = "hello world bulk writ01";
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdBulkTransferWrite002
* @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
dev.busNum = 99;
uint32_t length = 100;
uint8_t buffer[100] = "hello world bulk writ02";
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdBulkTransferWrite008
* @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite008, Function | MediumTest | Level1)
{
HDF_LOGI("Case Start : UsbdBulkTransferWrite008 : BulkTransferWrite");
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
uint32_t length = 100;
uint8_t buffer[100] = "hello world bulk writ08";
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, -1, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: InterruptTransferRead001
* @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_129;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdInterruptTransferRead002
* @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_129;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
dev.busNum = BUS_NUM_222;
uint32_t length = 100;
uint8_t buffer[100] = {0};
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdInterruptTransferWrite001
* @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint32_t length = 100;
uint8_t buffer[100] = "hello world Interrupt writ01";
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdInterruptTransferWrite002
* @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
dev.busNum = 99;
uint32_t length = 100;
uint8_t buffer[100] = "hello world Interrupt writ02";
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdInterruptTransferWrite008
* @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite008, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
uint32_t length = 100;
uint8_t buffer[100] = "hello world Interrupt writ08";
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, -1, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdIsoTransferRead001
* @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_129;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint8_t buffer[LENGTH_NUM_255] = {0};
uint32_t length = LENGTH_NUM_255;
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdIsoTransferRead002
* @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_129;
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d interfaceId=%{public}d", __LINE__, interfaceId);
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
dev.busNum = BUS_NUM_222;
uint32_t length = 100;
uint8_t buffer[100] = {0};
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdIsoTransferWrite001
* @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite001, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
uint32_t length = 100;
uint8_t buffer[100] = "hello world Iso writ01";
struct UsbPipe pipe = {interfaceId, pointid};
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}
/**
* @tc.name: UsbdIsoTransferWrite002
* @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite002, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
dev.busNum = 99;
uint32_t length = 100;
uint8_t buffer[100] = "hello world Iso writ02";
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret != 0);
}
/**
* @tc.name: UsbdIsoTransferWrite008
* @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
* std::vector<uint8_t> &data);
* @tc.type: FUNC
*/
HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite008, Function | MediumTest | Level1)
{
struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
dev.busNum = BUS_NUM_1;
dev.devAddr = DEV_ADDR_2;
uint8_t interfaceId = INTERFACEID_1;
uint8_t pointid = POINTID_1;
auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
struct UsbPipe pipe = {interfaceId, pointid};
uint32_t length = 100;
uint8_t buffer[100] = "hello world Iso writ08";
std::vector<uint8_t> bufferdata = {buffer, buffer + length};
ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, -1, bufferdata);
HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
ASSERT_TRUE(ret == 0);
}

27
hdf/usb/transferTest/include/usbd_transfer_test.h Normal file
View File

@ -0,0 +1,27 @@
/*
* Copyright (c) 2021 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.
*/
#ifndef USBD_TRANSFER_TEST_H
#define USBD_TRANSFER_TEST_H
#include <gtest/gtest.h>
class UsbdTransferTest : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
#endif // USBD_TRANSFER_TEST_H