1/* 2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "usbd_transfer_test.h" 17 18#include <iostream> 19#include <vector> 20 21#include "UsbSubscriberTest.h" 22#include "hdf_log.h" 23#include "usb_ddk.h" 24#include "usb_ddk_interface.h" 25#include "securec.h" 26#include "usbd_type.h" 27#include "v1_1/iusb_interface.h" 28#include "v1_1/usb_types.h" 29 30const int SLEEP_TIME = 3; 31const uint8_t BUS_NUM_INVALID = 255; 32const uint8_t DEV_ADDR_INVALID = 255; 33const uint32_t MAX_BUFFER_LENGTH = 255; 34const uint8_t INTERFACEID_OK = 1; 35const uint8_t PIPE_ENDPOINTID_INVALID = 244; 36const uint8_t PIPE_INTERFACEID_INVALID = 244; 37// data interface have 2 point : 1->bulk_out 2->bulk_in 38static const uint8_t POINTID_BULK_IN = USB_ENDPOINT_DIR_IN | 2; 39static const uint8_t POINTID_BULK_OUT = USB_ENDPOINT_DIR_OUT | 1; 40const int32_t ASHMEM_MAX_SIZE = 1024; 41const uint8_t SAMPLE_DATA_1 = 1; 42static const uint8_t SAMPLE_DATA_2 = 2; 43static const uint8_t SAMPLE_DATA_3 = 3; 44const int32_t TRANSFER_TIME_OUT = 1000; 45const int32_t CTL_VALUE = 0x100; 46 47using namespace testing::ext; 48using namespace OHOS; 49using namespace OHOS::USB; 50using namespace std; 51using namespace OHOS::HDI::Usb::V1_0; 52using namespace OHOS::HDI::Usb::V1_1; 53 54UsbDev UsbdTransferTest::dev_ = {0, 0}; 55sptr<UsbSubscriberTest> UsbdTransferTest::subscriber_ = nullptr; 56namespace { 57sptr<OHOS::HDI::Usb::V1_1::IUsbInterface> g_usbInterface = nullptr; 58 59int32_t InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t rflg) 60{ 61 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize); 62 if (asmptr == nullptr) { 63 HDF_LOGE("InitAshmemOne CreateAshmem failed"); 64 return HDF_FAILURE; 65 } 66 67 asmptr->MapReadAndWriteAshmem(); 68 69 if (rflg == 0) { 70 uint8_t tdata[ASHMEM_MAX_SIZE]; 71 int32_t offset = 0; 72 int32_t tlen = 0; 73 74 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE); 75 if (retSafe != EOK) { 76 HDF_LOGE("InitAshmemOne memset_s failed"); 77 return HDF_FAILURE; 78 } 79 while (offset < asmSize) { 80 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE; 81 asmptr->WriteToAshmem(tdata, tlen, offset); 82 offset += tlen; 83 } 84 } 85 return HDF_SUCCESS; 86} 87 88int32_t SwitchErrCode(int32_t ret) 89{ 90 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret; 91} 92 93void UsbdTransferTest::SetUpTestCase(void) 94{ 95 g_usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); 96 if (g_usbInterface == nullptr) { 97 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__); 98 exit(0); 99 } 100 const int32_t DEFAULT_PORT_ID = 1; 101 const int32_t DEFAULT_ROLE_HOST = 1; 102 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, DEFAULT_ROLE_HOST, DEFAULT_ROLE_HOST); 103 sleep(SLEEP_TIME); 104 HDF_LOGI("UsbdTransferTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret); 105 ret = SwitchErrCode(ret); 106 ASSERT_EQ(0, ret); 107 if (ret != 0) { 108 exit(0); 109 } 110 111 subscriber_ = new UsbSubscriberTest(); 112 if (subscriber_ == nullptr) { 113 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 114 exit(0); 115 } 116 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) { 117 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__); 118 exit(0); 119 } 120 121 std::cout << "please connect device, press enter to continue" << std::endl; 122 int c; 123 while ((c = getchar()) != '\n' && c != EOF) {} 124 125 dev_ = {subscriber_->busNum_, subscriber_->devAddr_}; 126 ret = g_usbInterface->OpenDevice(dev_); 127 HDF_LOGI("UsbdTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret); 128 ASSERT_EQ(0, ret); 129} 130 131void UsbdTransferTest::TearDownTestCase(void) 132{ 133 g_usbInterface->UnbindUsbdSubscriber(subscriber_); 134 dev_ = {subscriber_->busNum_, subscriber_->devAddr_}; 135 auto ret = g_usbInterface->CloseDevice(dev_); 136 HDF_LOGI("UsbdTransferTest:: %{public}d Close=%{public}d", __LINE__, ret); 137 ASSERT_EQ(0, ret); 138} 139 140void UsbdTransferTest::SetUp(void) {} 141 142void UsbdTransferTest::TearDown(void) {} 143 144/** 145 * @tc.name: UsbdControlTransferRead001 146 * @tc.desc: Test functions to ControlTransferRead 147 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 148 * @tc.desc: Positive test: parameters correctly, standard request: get configuration 149 * @tc.type: FUNC 150 */ 151HWTEST_F(UsbdTransferTest, UsbdControlTransferRead001, TestSize.Level1) 152{ 153 struct UsbDev dev = dev_; 154 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 155 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT}; 156 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 157 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead001 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 158 EXPECT_EQ(0, ret); 159} 160 161/** 162 * @tc.name: UsbdControlTransferRead002 163 * @tc.desc: Test functions to ControlTransferRead 164 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 165 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get configuration 166 * @tc.type: FUNC 167 */ 168HWTEST_F(UsbdTransferTest, UsbdControlTransferRead002, TestSize.Level1) 169{ 170 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 171 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 172 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT}; 173 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 174 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead002 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 175 EXPECT_NE(ret, 0); 176} 177 178/** 179 * @tc.name: UsbdControlTransferRead003 180 * @tc.desc: Test functions to ControlTransferRead 181 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 182 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get configuration 183 * @tc.type: FUNC 184 */ 185HWTEST_F(UsbdTransferTest, UsbdControlTransferRead003, TestSize.Level1) 186{ 187 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 188 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 189 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT}; 190 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 191 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead003 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 192 EXPECT_NE(ret, 0); 193} 194 195/** 196 * @tc.name: UsbdControlTransferRead004 197 * @tc.desc: Test functions to ControlTransferRead 198 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 199 * @tc.desc: Positive test: parameters correctly, standard request: get descriptor(device) 200 * @tc.type: FUNC 201 */ 202HWTEST_F(UsbdTransferTest, UsbdControlTransferRead004, TestSize.Level1) 203{ 204 struct UsbDev dev = dev_; 205 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 206 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 207 TRANSFER_TIME_OUT}; 208 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 209 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead004 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 210 EXPECT_EQ(0, ret); 211} 212 213/** 214 * @tc.name: UsbdControlTransferRead005 215 * @tc.desc: Test functions to ControlTransferRead 216 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 217 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get descriptor(device) 218 * @tc.type: FUNC 219 */ 220HWTEST_F(UsbdTransferTest, UsbdControlTransferRead005, TestSize.Level1) 221{ 222 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 223 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 224 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 225 TRANSFER_TIME_OUT}; 226 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 227 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead005 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 228 EXPECT_NE(ret, 0); 229} 230 231/** 232 * @tc.name: UsbdControlTransferRead006 233 * @tc.desc: Test functions to ControlTransferRead 234 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 235 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get descriptor(device) 236 * @tc.type: FUNC 237 */ 238HWTEST_F(UsbdTransferTest, UsbdControlTransferRead006, TestSize.Level1) 239{ 240 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 241 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 242 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 243 TRANSFER_TIME_OUT}; 244 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 245 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead006 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 246 EXPECT_NE(ret, 0); 247} 248 249/** 250 * @tc.name: UsbdControlTransferRead007 251 * @tc.desc: Test functions to ControlTransferRead 252 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 253 * @tc.desc: Positive test: parameters correctly, standard request: get interface 254 * @tc.type: FUNC 255 */ 256HWTEST_F(UsbdTransferTest, UsbdControlTransferRead007, TestSize.Level1) 257{ 258 struct UsbDev dev = dev_; 259 int32_t intercafeidex = 0; 260 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 261 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 262 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT}; 263 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 264 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead007 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 265 EXPECT_EQ(0, ret); 266} 267 268/** 269 * @tc.name: UsbdControlTransferRead008 270 * @tc.desc: Test functions to ControlTransferRead 271 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 272 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get interface 273 * @tc.type: FUNC 274 */ 275HWTEST_F(UsbdTransferTest, UsbdControlTransferRead008, TestSize.Level1) 276{ 277 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 278 int32_t intercafeidex = 0; 279 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 280 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 281 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT}; 282 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 283 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead008 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 284 EXPECT_NE(ret, 0); 285} 286 287/** 288 * @tc.name: UsbdControlTransferRead009 289 * @tc.desc: Test functions to ControlTransferRead 290 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 291 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get interface 292 * @tc.type: FUNC 293 */ 294HWTEST_F(UsbdTransferTest, UsbdControlTransferRead009, TestSize.Level1) 295{ 296 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 297 int32_t intercafeidex = 0; 298 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 299 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 300 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT}; 301 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 302 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead009 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 303 EXPECT_NE(ret, 0); 304} 305 306/** 307 * @tc.name: UsbdControlTransferRead010 308 * @tc.desc: Test functions to ControlTransferRead 309 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 310 * @tc.desc: Positive test: parameters correctly, standard request: get status(recipient device) 311 * @tc.type: FUNC 312 */ 313HWTEST_F(UsbdTransferTest, UsbdControlTransferRead010, TestSize.Level1) 314{ 315 struct UsbDev dev = dev_; 316 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 317 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, TRANSFER_TIME_OUT}; 318 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 319 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead010 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 320 EXPECT_EQ(0, ret); 321} 322 323/** 324 * @tc.name: UsbdControlTransferRead011 325 * @tc.desc: Test functions to ControlTransferRead 326 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 327 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(device) 328 * @tc.type: FUNC 329 */ 330HWTEST_F(UsbdTransferTest, UsbdControlTransferRead011, TestSize.Level1) 331{ 332 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 333 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 334 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, TRANSFER_TIME_OUT}; 335 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 336 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead011 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 337 EXPECT_NE(ret, 0); 338} 339 340/** 341 * @tc.name: UsbdControlTransferRead012 342 * @tc.desc: Test functions to ControlTransferRead 343 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 344 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(device) 345 * @tc.type: FUNC 346 */ 347HWTEST_F(UsbdTransferTest, UsbdControlTransferRead012, TestSize.Level1) 348{ 349 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 350 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 351 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, TRANSFER_TIME_OUT}; 352 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 353 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead012 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 354 EXPECT_NE(ret, 0); 355} 356 357/** 358 * @tc.name: UsbdControlTransferRead013 359 * @tc.desc: Test functions to ControlTransferRead 360 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 361 * @tc.desc: Positive test: parameters correctly, standard request: get status(interface) 362 * @tc.type: FUNC 363 */ 364HWTEST_F(UsbdTransferTest, UsbdControlTransferRead013, TestSize.Level1) 365{ 366 struct UsbDev dev = dev_; 367 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 368 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 369 TRANSFER_TIME_OUT}; 370 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 371 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead013 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 372 EXPECT_EQ(0, ret); 373} 374 375/** 376 * @tc.name: UsbdControlTransferRead014 377 * @tc.desc: Test functions to ControlTransferRead 378 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 379 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(interface) 380 * @tc.type: FUNC 381 */ 382HWTEST_F(UsbdTransferTest, UsbdControlTransferRead014, TestSize.Level1) 383{ 384 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 385 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 386 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 387 TRANSFER_TIME_OUT}; 388 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 389 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead014 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 390 EXPECT_NE(ret, 0); 391} 392 393/** 394 * @tc.name: UsbdControlTransferRead015 395 * @tc.desc: Test functions to ControlTransferRead 396 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 397 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(interface) 398 * @tc.type: FUNC 399 */ 400HWTEST_F(UsbdTransferTest, UsbdControlTransferRead015, TestSize.Level1) 401{ 402 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 403 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 404 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 405 TRANSFER_TIME_OUT}; 406 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 407 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead015 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 408 EXPECT_NE(ret, 0); 409} 410 411/** 412 * @tc.name: UsbdControlTransferRead016 413 * @tc.desc: Test functions to ControlTransferRead 414 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 415 * @tc.desc: Positive test: parameters correctly, standard request: get status(endpoint) 416 * @tc.type: FUNC 417 */ 418HWTEST_F(UsbdTransferTest, UsbdControlTransferRead016, TestSize.Level1) 419{ 420 struct UsbDev dev = dev_; 421 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 422 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 423 TRANSFER_TIME_OUT}; 424 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 425 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead016 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 426 EXPECT_EQ(0, ret); 427} 428 429/** 430 * @tc.name: UsbdControlTransferRead017 431 * @tc.desc: Test functions to ControlTransferRead 432 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 433 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(endpoint) 434 * @tc.type: FUNC 435 */ 436HWTEST_F(UsbdTransferTest, UsbdControlTransferRead017, TestSize.Level1) 437{ 438 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 439 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 440 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 441 TRANSFER_TIME_OUT}; 442 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 443 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead017 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 444 EXPECT_NE(ret, 0); 445} 446 447/** 448 * @tc.name: UsbdControlTransferRead018 449 * @tc.desc: Test functions to ControlTransferRead 450 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 451 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(endpoint) 452 * @tc.type: FUNC 453 */ 454HWTEST_F(UsbdTransferTest, UsbdControlTransferRead018, TestSize.Level1) 455{ 456 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 457 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 458 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 459 TRANSFER_TIME_OUT}; 460 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 461 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead018 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 462 EXPECT_NE(ret, 0); 463} 464 465/** 466 * @tc.name: UsbdControlTransferRead019 467 * @tc.desc: Test functions to ControlTransferRead 468 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 469 * @tc.desc: Positive test: parameters correctly, standard request: sync frame 470 * @tc.type: FUNC 471 */ 472HWTEST_F(UsbdTransferTest, UsbdControlTransferRead019, TestSize.Level1) 473{ 474 struct UsbDev dev = dev_; 475 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 476 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 477 0, 0, TRANSFER_TIME_OUT}; 478 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 479 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead019 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 480 EXPECT_EQ(0, ret); 481} 482 483/** 484 * @tc.name: UsbdControlTransferRead020 485 * @tc.desc: Test functions to ControlTransferRead 486 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 487 * @tc.desc: Negative test: parameters exception, busNum error, standard request: sync frame 488 * @tc.type: FUNC 489 */ 490HWTEST_F(UsbdTransferTest, UsbdControlTransferRead020, TestSize.Level1) 491{ 492 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 493 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 494 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 495 0, 0, TRANSFER_TIME_OUT}; 496 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 497 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead020 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 498 EXPECT_NE(ret, 0); 499} 500 501/** 502 * @tc.name: UsbdControlTransferRead021 503 * @tc.desc: Test functions to ControlTransferRead 504 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 505 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: sync frame 506 * @tc.type: FUNC 507 */ 508HWTEST_F(UsbdTransferTest, UsbdControlTransferRead021, TestSize.Level1) 509{ 510 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 511 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 512 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 513 0, 0, TRANSFER_TIME_OUT}; 514 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData); 515 HDF_LOGI("UsbdTransferTest::UsbdControlTransferRead021 %{public}d ControlTransfer=%{public}d", __LINE__, ret); 516 EXPECT_NE(ret, 0); 517} 518 519/** 520 * @tc.name: UsbdControlTransferWrite001 521 * @tc.desc: Test functions to ControlTransferWrite 522 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 523 * @tc.desc: Positive test: parameters correctly 524 * @tc.type: FUNC 525 */ 526HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite001, TestSize.Level1) 527{ 528 struct UsbDev dev = dev_; 529 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 530 bufferData.push_back(SAMPLE_DATA_1); 531 bufferData.push_back(SAMPLE_DATA_2); 532 bufferData.push_back(SAMPLE_DATA_3); 533 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, 534 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT}; 535 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 536 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite001 %{public}d ret=%{public}d", __LINE__, ret); 537 EXPECT_EQ(0, ret); 538} 539 540/** 541 * @tc.name: UsbdControlTransferWrite002 542 * @tc.desc: Test functions to ControlTransferWrite 543 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 544 * @tc.desc: Negative test: parameters exception, busNum error 545 * @tc.type: FUNC 546 */ 547HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite002, TestSize.Level1) 548{ 549 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 550 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 551 bufferData.push_back(SAMPLE_DATA_1); 552 bufferData.push_back(SAMPLE_DATA_2); 553 bufferData.push_back(SAMPLE_DATA_3); 554 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 555 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT}; 556 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 557 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite002 %{public}d ret=%{public}d", __LINE__, ret); 558 EXPECT_NE(ret, 0); 559} 560 561/** 562 * @tc.name: UsbdControlTransferWrite003 563 * @tc.desc: Test functions to ControlTransferWrite 564 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 565 * @tc.desc: Negative test: parameters exception, devAddr error 566 * @tc.type: FUNC 567 */ 568HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite003, TestSize.Level1) 569{ 570 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 571 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 572 bufferData.push_back(SAMPLE_DATA_1); 573 bufferData.push_back(SAMPLE_DATA_2); 574 bufferData.push_back(SAMPLE_DATA_3); 575 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 576 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT}; 577 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 578 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite003 %{public}d ret=%{public}d", __LINE__, ret); 579 EXPECT_NE(ret, 0); 580} 581 582/** 583 * @tc.name: UsbdControlTransferWrite004 584 * @tc.desc: Test functions to ControlTransferWrite 585 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 586 * @tc.desc: Positive test: parameters correctly 587 * @tc.type: FUNC 588 */ 589HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite004, TestSize.Level1) 590{ 591 struct UsbDev dev = dev_; 592 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 593 bufferData.push_back(SAMPLE_DATA_1); 594 bufferData.push_back(SAMPLE_DATA_2); 595 bufferData.push_back(SAMPLE_DATA_3); 596 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, 597 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT}; 598 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 599 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite004 %{public}d ret=%{public}d", __LINE__, ret); 600 EXPECT_EQ(0, ret); 601} 602 603/** 604 * @tc.name: UsbdControlTransferWrite005 605 * @tc.desc: Test functions to ControlTransferWrite 606 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 607 * @tc.desc: Negative test: parameters exception, busNum error 608 * @tc.type: FUNC 609 */ 610HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite005, TestSize.Level1) 611{ 612 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 613 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 614 bufferData.push_back(SAMPLE_DATA_1); 615 bufferData.push_back(SAMPLE_DATA_2); 616 bufferData.push_back(SAMPLE_DATA_3); 617 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 618 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT}; 619 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 620 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite005 %{public}d ret=%{public}d", __LINE__, ret); 621 EXPECT_NE(ret, 0); 622} 623 624/** 625 * @tc.name: UsbdControlTransferWrite006 626 * @tc.desc: Test functions to ControlTransferWrite 627 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 628 * @tc.desc: Negative test: parameters exception, devAddr error 629 * @tc.type: FUNC 630 */ 631HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite006, TestSize.Level1) 632{ 633 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 634 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 635 bufferData.push_back(SAMPLE_DATA_1); 636 bufferData.push_back(SAMPLE_DATA_2); 637 bufferData.push_back(SAMPLE_DATA_3); 638 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 639 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT}; 640 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 641 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite006 %{public}d ret=%{public}d", __LINE__, ret); 642 EXPECT_NE(ret, 0); 643} 644 645/** 646 * @tc.name: UsbdControlTransferWrite007 647 * @tc.desc: Test functions to ControlTransferWrite 648 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 649 * @tc.desc: Positive test: parameters correctly 650 * @tc.type: FUNC 651 */ 652HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite007, TestSize.Level1) 653{ 654 struct UsbDev dev = dev_; 655 int32_t intercafeidex = 0; 656 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 657 bufferData.push_back(SAMPLE_DATA_1); 658 bufferData.push_back(SAMPLE_DATA_2); 659 bufferData.push_back(SAMPLE_DATA_3); 660 struct UsbCtrlTransfer ctrlparmas = {0, USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT}; 661 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 662 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite007 %{public}d ret=%{public}d", __LINE__, ret); 663 EXPECT_EQ(0, ret); 664} 665 666/** 667 * @tc.name: UsbdControlTransferWrite008 668 * @tc.desc: Test functions to ControlTransferWrite 669 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 670 * @tc.desc: Negative test: parameters exception, busNum error 671 * @tc.type: FUNC 672 */ 673HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite008, TestSize.Level1) 674{ 675 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 676 int32_t intercafeidex = 0; 677 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 678 bufferData.push_back(SAMPLE_DATA_1); 679 bufferData.push_back(SAMPLE_DATA_2); 680 bufferData.push_back(SAMPLE_DATA_3); 681 struct UsbCtrlTransfer ctrlparmas = {0, USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT}; 682 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 683 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite008 %{public}d ret=%{public}d", __LINE__, ret); 684 EXPECT_NE(ret, 0); 685} 686 687/** 688 * @tc.name: UsbdControlTransferWrite009 689 * @tc.desc: Test functions to ControlTransferWrite 690 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 691 * @tc.desc: Negative test: parameters exception, devAddr error 692 * @tc.type: FUNC 693 */ 694HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite009, TestSize.Level1) 695{ 696 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 697 int32_t intercafeidex = 0; 698 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 699 bufferData.push_back(SAMPLE_DATA_1); 700 bufferData.push_back(SAMPLE_DATA_2); 701 bufferData.push_back(SAMPLE_DATA_3); 702 struct UsbCtrlTransfer ctrlparmas = {0, USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT}; 703 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 704 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite009 %{public}d ret=%{public}d", __LINE__, ret); 705 EXPECT_NE(ret, 0); 706} 707 708/** 709 * @tc.name: UsbdControlTransferWrite010 710 * @tc.desc: Test functions to ControlTransferWrite 711 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 712 * @tc.desc: Positive test: parameters correctly 713 * @tc.type: FUNC 714 */ 715HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite010, TestSize.Level1) 716{ 717 struct UsbDev dev = dev_; 718 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 719 bufferData.push_back(SAMPLE_DATA_1); 720 bufferData.push_back(SAMPLE_DATA_2); 721 bufferData.push_back(SAMPLE_DATA_3); 722 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0, 723 TRANSFER_TIME_OUT}; 724 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 725 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite010 %{public}d ret=%{public}d", __LINE__, ret); 726 EXPECT_EQ(0, ret); 727} 728 729/** 730 * @tc.name: UsbdControlTransferWrite011 731 * @tc.desc: Test functions to ControlTransferWrite 732 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 733 * @tc.desc: Negative test: parameters exception, busNum error 734 * @tc.type: FUNC 735 */ 736HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite011, TestSize.Level1) 737{ 738 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 739 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 740 bufferData.push_back(SAMPLE_DATA_1); 741 bufferData.push_back(SAMPLE_DATA_2); 742 bufferData.push_back(SAMPLE_DATA_3); 743 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 744 TRANSFER_TIME_OUT}; 745 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 746 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite011 %{public}d ret=%{public}d", __LINE__, ret); 747 EXPECT_NE(ret, 0); 748} 749 750/** 751 * @tc.name: UsbdControlTransferWrite012 752 * @tc.desc: Test functions to ControlTransferWrite 753 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 754 * @tc.desc: Negative test: parameters exception, devAddr error 755 * @tc.type: FUNC 756 */ 757HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite012, TestSize.Level1) 758{ 759 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 760 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 761 bufferData.push_back(SAMPLE_DATA_1); 762 bufferData.push_back(SAMPLE_DATA_2); 763 bufferData.push_back(SAMPLE_DATA_3); 764 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 765 TRANSFER_TIME_OUT}; 766 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 767 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite012 %{public}d ret=%{public}d", __LINE__, ret); 768 EXPECT_NE(ret, 0); 769} 770 771/** 772 * @tc.name: UsbdControlTransferWrite013 773 * @tc.desc: Test functions to ControlTransferWrite 774 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 775 * @tc.desc: Positive test: parameters correctly 776 * @tc.type: FUNC 777 */ 778HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite013, TestSize.Level1) 779{ 780 struct UsbDev dev = dev_; 781 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 782 bufferData.push_back(SAMPLE_DATA_1); 783 bufferData.push_back(SAMPLE_DATA_2); 784 bufferData.push_back(SAMPLE_DATA_3); 785 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, USB_DDK_REQ_GET_INTERFACE, 0, 0, TRANSFER_TIME_OUT}; 786 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 787 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite013 %{public}d ret=%{public}d", __LINE__, ret); 788 EXPECT_EQ(0, ret); 789} 790 791/** 792 * @tc.name: UsbdControlTransferWrite014 793 * @tc.desc: Test functions to ControlTransferWrite 794 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 795 * @tc.desc: Negative test: parameters exception, busNum error 796 * @tc.type: FUNC 797 */ 798HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite014, TestSize.Level1) 799{ 800 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 801 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 802 bufferData.push_back(SAMPLE_DATA_1); 803 bufferData.push_back(SAMPLE_DATA_2); 804 bufferData.push_back(SAMPLE_DATA_3); 805 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, 0, 0, 0, TRANSFER_TIME_OUT}; 806 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 807 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite014 %{public}d ret=%{public}d", __LINE__, ret); 808 EXPECT_NE(ret, 0); 809} 810 811/** 812 * @tc.name: UsbdControlTransferWrite015 813 * @tc.desc: Test functions to ControlTransferWrite 814 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 815 * @tc.desc: Negative test: parameters exception, devAddr error 816 * @tc.type: FUNC 817 */ 818HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite015, TestSize.Level1) 819{ 820 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 821 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 822 bufferData.push_back(SAMPLE_DATA_1); 823 bufferData.push_back(SAMPLE_DATA_2); 824 bufferData.push_back(SAMPLE_DATA_3); 825 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, 0, 0, 0, TRANSFER_TIME_OUT}; 826 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 827 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite015 %{public}d ret=%{public}d", __LINE__, ret); 828 EXPECT_NE(ret, 0); 829} 830 831/** 832 * @tc.name: UsbdControlTransferWrite016 833 * @tc.desc: Test functions to ControlTransferWrite 834 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 835 * @tc.desc: Positive test: parameters correctly 836 * @tc.type: FUNC 837 */ 838HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite016, TestSize.Level1) 839{ 840 struct UsbDev dev = dev_; 841 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 842 bufferData.push_back(SAMPLE_DATA_1); 843 bufferData.push_back(SAMPLE_DATA_2); 844 bufferData.push_back(SAMPLE_DATA_3); 845 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 846 TRANSFER_TIME_OUT}; 847 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 848 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite016 %{public}d ret=%{public}d", __LINE__, ret); 849 EXPECT_EQ(0, ret); 850} 851 852/** 853 * @tc.name: UsbdControlTransferWrite017 854 * @tc.desc: Test functions to ControlTransferWrite 855 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 856 * @tc.desc: Negative test: parameters exception, busNum error 857 * @tc.type: FUNC 858 */ 859HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite017, TestSize.Level1) 860{ 861 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 862 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 863 bufferData.push_back(SAMPLE_DATA_1); 864 bufferData.push_back(SAMPLE_DATA_2); 865 bufferData.push_back(SAMPLE_DATA_3); 866 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 867 TRANSFER_TIME_OUT}; 868 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 869 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite017 %{public}d ret=%{public}d", __LINE__, ret); 870 EXPECT_NE(ret, 0); 871} 872 873/** 874 * @tc.name: UsbdControlTransferWrite018 875 * @tc.desc: Test functions to ControlTransferWrite 876 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 877 * @tc.desc: Negative test: parameters exception, devAddr error 878 * @tc.type: FUNC 879 */ 880HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite018, TestSize.Level1) 881{ 882 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 883 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 884 bufferData.push_back(SAMPLE_DATA_1); 885 bufferData.push_back(SAMPLE_DATA_2); 886 bufferData.push_back(SAMPLE_DATA_3); 887 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 888 TRANSFER_TIME_OUT}; 889 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 890 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite018 %{public}d ret=%{public}d", __LINE__, ret); 891 EXPECT_NE(ret, 0); 892} 893 894/** 895 * @tc.name: UsbdControlTransferWrite019 896 * @tc.desc: Test functions to ControlTransferWrite 897 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 898 * @tc.desc: Positive test: parameters correctly 899 * @tc.type: FUNC 900 */ 901HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite019, TestSize.Level1) 902{ 903 struct UsbDev dev = dev_; 904 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 905 bufferData.push_back(SAMPLE_DATA_1); 906 bufferData.push_back(SAMPLE_DATA_2); 907 bufferData.push_back(SAMPLE_DATA_3); 908 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 909 0, 0, TRANSFER_TIME_OUT}; 910 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 911 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite019 %{public}d ret=%{public}d", __LINE__, ret); 912 EXPECT_EQ(0, ret); 913} 914 915/** 916 * @tc.name: UsbdControlTransferWrite020 917 * @tc.desc: Test functions to ControlTransferWrite 918 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 919 * @tc.desc: Negative test: parameters exception, busNum error 920 * @tc.type: FUNC 921 */ 922HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite020, TestSize.Level1) 923{ 924 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 925 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 926 bufferData.push_back(SAMPLE_DATA_1); 927 bufferData.push_back(SAMPLE_DATA_2); 928 bufferData.push_back(SAMPLE_DATA_3); 929 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 930 0, 0, TRANSFER_TIME_OUT}; 931 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 932 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite020 %{public}d ret=%{public}d", __LINE__, ret); 933 EXPECT_NE(ret, 0); 934} 935 936/** 937 * @tc.name: UsbdControlTransferWrite021 938 * @tc.desc: Test functions to ControlTransferWrite 939 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data); 940 * @tc.desc: Negative test: parameters exception, devAddr error 941 * @tc.type: FUNC 942 */ 943HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite021, TestSize.Level1) 944{ 945 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 946 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 947 bufferData.push_back(SAMPLE_DATA_1); 948 bufferData.push_back(SAMPLE_DATA_2); 949 bufferData.push_back(SAMPLE_DATA_3); 950 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 951 0, 0, TRANSFER_TIME_OUT}; 952 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData); 953 HDF_LOGI("UsbdTransferTest::UsbdControlTransferWrite021 %{public}d ret=%{public}d", __LINE__, ret); 954 EXPECT_NE(ret, 0); 955} 956 957/** 958 * @tc.name: UsbdControlTransferReadwithLength001 959 * @tc.desc: Test functions to ControlTransferReadwithLength 960 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 961 * @tc.desc: std::vector<uint8_t> &data); 962 * @tc.desc: Positive test: parameters correctly, standard request: get configuration 963 * @tc.type: FUNC 964 */ 965HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength001, TestSize.Level1) 966{ 967 struct UsbDev dev = dev_; 968 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 969 struct UsbCtrlTransferParams ctrlparmas = { 970 USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 0, TRANSFER_TIME_OUT}; 971 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 972 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength001 ret=%{public}d", ret); 973 EXPECT_EQ(0, ret); 974} 975 976/** 977 * @tc.name: UsbdControlTransferReadwithLength002 978 * @tc.desc: Test functions to ControlTransferReadwithLength 979 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 980 * @tc.desc: std::vector<uint8_t> &data); 981 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get configuration 982 * @tc.type: FUNC 983 */ 984HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength002, TestSize.Level1) 985{ 986 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 987 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 988 struct UsbCtrlTransferParams ctrlparmas = { 989 USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 0, TRANSFER_TIME_OUT}; 990 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 991 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength002 ret=%{public}d", ret); 992 EXPECT_NE(ret, 0); 993} 994 995/** 996 * @tc.name: UsbdControlTransferReadwithLength003 997 * @tc.desc: Test functions to ControlTransferReadwithLength 998 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 999 * @tc.desc: std::vector<uint8_t> &data); 1000 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get configuration 1001 * @tc.type: FUNC 1002 */ 1003HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength003, TestSize.Level1) 1004{ 1005 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 1006 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1007 struct UsbCtrlTransferParams ctrlparmas = { 1008 USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 0, TRANSFER_TIME_OUT}; 1009 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1010 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength003 ret=%{public}d", ret); 1011 EXPECT_NE(ret, 0); 1012} 1013 1014/** 1015 * @tc.name: UsbdControlTransferReadwithLength004 1016 * @tc.desc: Test functions to ControlTransferReadwithLength 1017 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1018 * @tc.desc: std::vector<uint8_t> &data); 1019 * @tc.desc: Positive test: parameters correctly, standard request: get descriptor(device) 1020 * @tc.type: FUNC 1021 */ 1022HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength004, TestSize.Level1) 1023{ 1024 struct UsbDev dev = dev_; 1025 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1026 struct UsbCtrlTransferParams ctrlparmas = { 1027 USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 0, TRANSFER_TIME_OUT}; 1028 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1029 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength004 ret=%{public}d", ret); 1030 EXPECT_EQ(0, ret); 1031} 1032 1033/** 1034 * @tc.name: UsbdControlTransferReadwithLength005 1035 * @tc.desc: Test functions to ControlTransferReadwithLength 1036 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1037 * @tc.desc: std::vector<uint8_t> &data); 1038 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get descriptor(device) 1039 * @tc.type: FUNC 1040 */ 1041HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength005, TestSize.Level1) 1042{ 1043 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 1044 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1045 struct UsbCtrlTransferParams ctrlparmas = { 1046 USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 0, TRANSFER_TIME_OUT}; 1047 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1048 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength005 ret=%{public}d", ret); 1049 EXPECT_NE(ret, 0); 1050} 1051 1052/** 1053 * @tc.name: UsbdControlTransferReadwithLength006 1054 * @tc.desc: Test functions to ControlTransferReadwithLength 1055 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1056 * @tc.desc: std::vector<uint8_t> &data); 1057 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get descriptor(device) 1058 * @tc.type: FUNC 1059 */ 1060HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength006, TestSize.Level1) 1061{ 1062 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 1063 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1064 struct UsbCtrlTransferParams ctrlparmas = { 1065 USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 0, TRANSFER_TIME_OUT}; 1066 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1067 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength006 ret=%{public}d", ret); 1068 EXPECT_NE(ret, 0); 1069} 1070 1071/** 1072 * @tc.name: UsbdControlTransferReadwithLength007 1073 * @tc.desc: Test functions to ControlTransferReadwithLength 1074 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1075 * @tc.desc: std::vector<uint8_t> &data); 1076 * @tc.desc: Positive test: parameters correctly, standard request: get interface 1077 * @tc.type: FUNC 1078 */ 1079HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength007, TestSize.Level1) 1080{ 1081 struct UsbDev dev = dev_; 1082 int32_t intercafeidex = 0; 1083 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1084 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 1085 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, 0, TRANSFER_TIME_OUT}; 1086 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1087 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength007 ret=%{public}d", ret); 1088 EXPECT_EQ(0, ret); 1089} 1090 1091/** 1092 * @tc.name: UsbdControlTransferReadwithLength008 1093 * @tc.desc: Test functions to ControlTransferReadwithLength 1094 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1095 * @tc.desc: std::vector<uint8_t> &data); 1096 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get interface 1097 * @tc.type: FUNC 1098 */ 1099HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength008, TestSize.Level1) 1100{ 1101 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 1102 int32_t intercafeidex = 0; 1103 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1104 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 1105 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, 0, TRANSFER_TIME_OUT}; 1106 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1107 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength008 ret=%{public}d", ret); 1108 EXPECT_NE(ret, 0); 1109} 1110 1111/** 1112 * @tc.name: UsbdControlTransferReadwithLength009 1113 * @tc.desc: Test functions to ControlTransferReadwithLength 1114 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1115 * @tc.desc: std::vector<uint8_t> &data); 1116 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get interface 1117 * @tc.type: FUNC 1118 */ 1119HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength009, TestSize.Level1) 1120{ 1121 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 1122 int32_t intercafeidex = 0; 1123 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1124 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 1125 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, 0, TRANSFER_TIME_OUT}; 1126 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1127 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength009 ret=%{public}d", ret); 1128 EXPECT_NE(ret, 0); 1129} 1130 1131/** 1132 * @tc.name: UsbdControlTransferReadwithLength010 1133 * @tc.desc: Test functions to ControlTransferReadwithLength 1134 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1135 * @tc.desc: std::vector<uint8_t> &data); 1136 * @tc.desc: Positive test: parameters correctly, standard request: get status(recipient device) 1137 * @tc.type: FUNC 1138 */ 1139HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength010, TestSize.Level1) 1140{ 1141 struct UsbDev dev = dev_; 1142 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1143 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, 0, TRANSFER_TIME_OUT}; 1144 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1145 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength010 ret=%{public}d", ret); 1146 EXPECT_EQ(0, ret); 1147} 1148 1149/** 1150 * @tc.name: UsbdControlTransferReadwithLength011 1151 * @tc.desc: Test functions to ControlTransferReadwithLength 1152 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1153 * @tc.desc: std::vector<uint8_t> &data); 1154 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(device) 1155 * @tc.type: FUNC 1156 */ 1157HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength011, TestSize.Level1) 1158{ 1159 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 1160 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1161 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, 0, TRANSFER_TIME_OUT}; 1162 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1163 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength011 ret=%{public}d", ret); 1164 EXPECT_NE(ret, 0); 1165} 1166 1167/** 1168 * @tc.name: UsbdControlTransferReadwithLength012 1169 * @tc.desc: Test functions to ControlTransferReadwithLength 1170 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1171 * @tc.desc: std::vector<uint8_t> &data); 1172 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(device) 1173 * @tc.type: FUNC 1174 */ 1175HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength012, TestSize.Level1) 1176{ 1177 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 1178 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1179 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, 0, TRANSFER_TIME_OUT}; 1180 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1181 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength012 ret=%{public}d", ret); 1182 EXPECT_NE(ret, 0); 1183} 1184 1185/** 1186 * @tc.name: UsbdControlTransferReadwithLength013 1187 * @tc.desc: Test functions to ControlTransferReadwithLength 1188 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1189 * @tc.desc: std::vector<uint8_t> &data); 1190 * @tc.desc: Positive test: parameters correctly, standard request: get status(interface) 1191 * @tc.type: FUNC 1192 */ 1193HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength013, TestSize.Level1) 1194{ 1195 struct UsbDev dev = dev_; 1196 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1197 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 1198 0, TRANSFER_TIME_OUT}; 1199 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1200 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength013 ret=%{public}d", ret); 1201 EXPECT_EQ(0, ret); 1202} 1203 1204/** 1205 * @tc.name: UsbdControlTransferReadwithLength014 1206 * @tc.desc: Test functions to ControlTransferReadwithLength 1207 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1208 * @tc.desc: std::vector<uint8_t> &data); 1209 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(interface) 1210 * @tc.type: FUNC 1211 */ 1212HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength014, TestSize.Level1) 1213{ 1214 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 1215 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1216 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 1217 0, TRANSFER_TIME_OUT}; 1218 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1219 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength014 ret%{public}d", ret); 1220 EXPECT_NE(ret, 0); 1221} 1222 1223/** 1224 * @tc.name: UsbdControlTransferReadwithLength015 1225 * @tc.desc: Test functions to ControlTransferReadwithLength 1226 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1227 * @tc.desc: std::vector<uint8_t> &data); 1228 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(interface) 1229 * @tc.type: FUNC 1230 */ 1231HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength015, TestSize.Level1) 1232{ 1233 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 1234 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1235 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, 1236 0, TRANSFER_TIME_OUT}; 1237 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1238 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength015 ret=%{public}d", ret); 1239 EXPECT_NE(ret, 0); 1240} 1241 1242/** 1243 * @tc.name: UsbdControlTransferReadwithLength016 1244 * @tc.desc: Test functions to ControlTransferReadwithLength 1245 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1246 * @tc.desc: std::vector<uint8_t> &data); 1247 * @tc.desc: Positive test: parameters correctly, standard request: get status(endpoint) 1248 * @tc.type: FUNC 1249 */ 1250HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength016, TestSize.Level1) 1251{ 1252 struct UsbDev dev = dev_; 1253 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1254 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 1255 0, TRANSFER_TIME_OUT}; 1256 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1257 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength016 ret=%{public}d", ret); 1258 EXPECT_EQ(0, ret); 1259} 1260 1261/** 1262 * @tc.name: UsbdControlTransferReadwithLength017 1263 * @tc.desc: Test functions to ControlTransferReadwithLength 1264 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1265 * @tc.desc: std::vector<uint8_t> &data); 1266 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(endpoint) 1267 * @tc.type: FUNC 1268 */ 1269HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength017, TestSize.Level1) 1270{ 1271 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 1272 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1273 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 1274 0, TRANSFER_TIME_OUT}; 1275 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1276 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength017 ret=%{public}d", ret); 1277 EXPECT_NE(ret, 0); 1278} 1279 1280/** 1281 * @tc.name: UsbdControlTransferReadwithLength018 1282 * @tc.desc: Test functions to ControlTransferReadwithLength 1283 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1284 * @tc.desc: std::vector<uint8_t> &data); 1285 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(endpoint) 1286 * @tc.type: FUNC 1287 */ 1288HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength018, TestSize.Level1) 1289{ 1290 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 1291 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1292 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, 1293 0, TRANSFER_TIME_OUT}; 1294 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1295 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength018 ret=%{public}d", ret); 1296 EXPECT_NE(ret, 0); 1297} 1298 1299/** 1300 * @tc.name: UsbdControlTransferReadwithLength019 1301 * @tc.desc: Test functions to ControlTransferReadwithLength 1302 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1303 * @tc.desc: std::vector<uint8_t> &data); 1304 * @tc.desc: Positive test: parameters correctly, standard request: sync frame 1305 * @tc.type: FUNC 1306 */ 1307HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength019, TestSize.Level1) 1308{ 1309 struct UsbDev dev = dev_; 1310 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1311 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 1312 USB_DDK_REQ_SYNCH_FRAME, 0, 0, 0, TRANSFER_TIME_OUT}; 1313 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1314 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength019 ret=%{public}d", ret); 1315 EXPECT_EQ(0, ret); 1316} 1317 1318/** 1319 * @tc.name: UsbdControlTransferReadwithLength020 1320 * @tc.desc: Test functions to ControlTransferReadwithLength 1321 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1322 * @tc.desc: std::vector<uint8_t> &data); 1323 * @tc.desc: Negative test: parameters exception, busNum error, standard request: sync frame 1324 * @tc.type: FUNC 1325 */ 1326HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength020, TestSize.Level1) 1327{ 1328 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; 1329 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1330 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 1331 USB_DDK_REQ_SYNCH_FRAME, 0, 0, 0, TRANSFER_TIME_OUT}; 1332 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1333 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength020 ret=%{public}d", ret); 1334 EXPECT_NE(ret, 0); 1335} 1336 1337/** 1338 * @tc.name: UsbdControlTransferReadwithLength021 1339 * @tc.desc: Test functions to ControlTransferReadwithLength 1340 * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, 1341 * @tc.desc: std::vector<uint8_t> &data); 1342 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: sync frame 1343 * @tc.type: FUNC 1344 */ 1345HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength021, TestSize.Level1) 1346{ 1347 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; 1348 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1349 struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 1350 USB_DDK_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT}; 1351 auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); 1352 HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength021 ret=%{public}d", ret); 1353 EXPECT_NE(ret, 0); 1354} 1355 1356/** 1357 * @tc.name: UsbdBulkTransferRead001 1358 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1359 * std::vector<uint8_t> &data); 1360 * @tc.desc: Positive test: parameters correctly 1361 * @tc.type: FUNC 1362 */ 1363HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead001, TestSize.Level1) 1364{ 1365 struct UsbDev dev = dev_; 1366 uint8_t interfaceId = INTERFACEID_OK; 1367 uint8_t pointid = POINTID_BULK_IN; 1368 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1369 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1370 ASSERT_EQ(0, ret); 1371 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1372 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1373 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1374 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret); 1375 EXPECT_EQ(0, ret); 1376} 1377 1378/** 1379 * @tc.name: UsbdBulkTransferRead002 1380 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1381 * std::vector<uint8_t> &data); 1382 * @tc.desc: Negative test: parameters exception, busNum error 1383 * @tc.type: FUNC 1384 */ 1385HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead002, TestSize.Level1) 1386{ 1387 struct UsbDev dev = dev_; 1388 uint8_t interfaceId = INTERFACEID_OK; 1389 uint8_t pointid = POINTID_BULK_IN; 1390 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1391 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1392 ASSERT_EQ(0, ret); 1393 dev.busNum = BUS_NUM_INVALID; 1394 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1395 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1396 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1397 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret); 1398 EXPECT_NE(ret, 0); 1399} 1400 1401/** 1402 * @tc.name: UsbdBulkTransferRead003 1403 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1404 * std::vector<uint8_t> &data); 1405 * @tc.desc: Negative test: parameters exception, devAddr error 1406 * @tc.type: FUNC 1407 */ 1408HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead003, TestSize.Level1) 1409{ 1410 struct UsbDev dev = dev_; 1411 uint8_t interfaceId = INTERFACEID_OK; 1412 uint8_t pointid = POINTID_BULK_IN; 1413 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1414 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1415 ASSERT_EQ(0, ret); 1416 dev.devAddr = DEV_ADDR_INVALID; 1417 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1418 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1419 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1420 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead003 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret); 1421 EXPECT_NE(ret, 0); 1422} 1423 1424/** 1425 * @tc.name: UsbdBulkTransferRead004 1426 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1427 * std::vector<uint8_t> &data); 1428 * @tc.desc: Negative test: parameters exception, intfId error 1429 * @tc.type: FUNC 1430 */ 1431HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead004, TestSize.Level1) 1432{ 1433 struct UsbDev dev = dev_; 1434 uint8_t interfaceId = INTERFACEID_OK; 1435 uint8_t pointid = POINTID_BULK_IN; 1436 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1437 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1438 ASSERT_EQ(0, ret); 1439 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1440 pipe.intfId = PIPE_INTERFACEID_INVALID; 1441 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1442 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1443 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead004 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret); 1444 EXPECT_NE(ret, 0); 1445} 1446 1447/** 1448 * @tc.name: UsbdBulkTransferRead005 1449 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1450 * std::vector<uint8_t> &data); 1451 * @tc.desc: Negative test: parameters exception, endpointId error 1452 * @tc.type: FUNC 1453 */ 1454HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead005, TestSize.Level1) 1455{ 1456 struct UsbDev dev = dev_; 1457 uint8_t interfaceId = INTERFACEID_OK; 1458 uint8_t pointid = POINTID_BULK_IN; 1459 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1460 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1461 ASSERT_EQ(0, ret); 1462 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1463 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 1464 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1465 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1466 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead005 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret); 1467 EXPECT_NE(ret, 0); 1468} 1469 1470/** 1471 * @tc.name: UsbdBulkTransferReadwithLength001 1472 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1473 * std::vector<uint8_t> &data); 1474 * @tc.desc: Positive test: parameters correctly 1475 * @tc.type: FUNC 1476 */ 1477HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength001, TestSize.Level1) 1478{ 1479 struct UsbDev dev = dev_; 1480 uint8_t interfaceId = INTERFACEID_OK; 1481 uint8_t pointid = POINTID_BULK_IN; 1482 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1483 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1484 ASSERT_EQ(0, ret); 1485 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1486 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1487 ret = g_usbInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData); 1488 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength001 %{public}d ret=%{public}d", __LINE__, ret); 1489 EXPECT_EQ(0, ret); 1490} 1491 1492/** 1493 * @tc.name: UsbdBulkTransferReadwithLength002 1494 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1495 * std::vector<uint8_t> &data); 1496 * @tc.desc: Negative test: parameters exception, busNum error 1497 * @tc.type: FUNC 1498 */ 1499HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength002, TestSize.Level1) 1500{ 1501 struct UsbDev dev = dev_; 1502 uint8_t interfaceId = INTERFACEID_OK; 1503 uint8_t pointid = POINTID_BULK_IN; 1504 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1505 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1506 ASSERT_EQ(0, ret); 1507 dev.busNum = BUS_NUM_INVALID; 1508 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1509 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1510 ret = g_usbInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData); 1511 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength002 %{public}d ret=%{public}d", __LINE__, ret); 1512 EXPECT_NE(ret, 0); 1513} 1514 1515/** 1516 * @tc.name: UsbdBulkTransferReadwithLength003 1517 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1518 * std::vector<uint8_t> &data); 1519 * @tc.desc: Negative test: parameters exception, devAddr error 1520 * @tc.type: FUNC 1521 */ 1522HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength003, TestSize.Level1) 1523{ 1524 struct UsbDev dev = dev_; 1525 uint8_t interfaceId = INTERFACEID_OK; 1526 uint8_t pointid = POINTID_BULK_IN; 1527 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1528 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1529 ASSERT_EQ(0, ret); 1530 dev.devAddr = DEV_ADDR_INVALID; 1531 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1532 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1533 ret = g_usbInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData); 1534 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength003 %{public}d ret=%{public}d", __LINE__, ret); 1535 EXPECT_NE(ret, 0); 1536} 1537 1538/** 1539 * @tc.name: UsbdBulkTransferReadwithLength004 1540 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1541 * std::vector<uint8_t> &data); 1542 * @tc.desc: Negative test: parameters exception, intfId error 1543 * @tc.type: FUNC 1544 */ 1545HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength004, TestSize.Level1) 1546{ 1547 struct UsbDev dev = dev_; 1548 uint8_t interfaceId = INTERFACEID_OK; 1549 uint8_t pointid = POINTID_BULK_IN; 1550 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1551 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1552 ASSERT_EQ(0, ret); 1553 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1554 pipe.intfId = PIPE_INTERFACEID_INVALID; 1555 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1556 ret = g_usbInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData); 1557 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength004 %{public}d ret=%{public}d", __LINE__, ret); 1558 EXPECT_NE(ret, 0); 1559} 1560 1561/** 1562 * @tc.name: UsbdBulkTransferReadwithLength005 1563 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1564 * std::vector<uint8_t> &data); 1565 * @tc.desc: Negative test: parameters exception, endpointId error 1566 * @tc.type: FUNC 1567 */ 1568HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength005, TestSize.Level1) 1569{ 1570 struct UsbDev dev = dev_; 1571 uint8_t interfaceId = INTERFACEID_OK; 1572 uint8_t pointid = POINTID_BULK_IN; 1573 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1574 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1575 ASSERT_EQ(0, ret); 1576 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1577 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 1578 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1579 ret = g_usbInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData); 1580 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength005 %{public}d ret=%{public}d", __LINE__, ret); 1581 EXPECT_NE(ret, 0); 1582} 1583 1584/** 1585 * @tc.name: UsbdBulkTransferWrite001 1586 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1587 * std::vector<uint8_t> &data); 1588 * @tc.desc: Positive test: parameters correctly 1589 * @tc.type: FUNC 1590 */ 1591HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite001, TestSize.Level1) 1592{ 1593 struct UsbDev dev = dev_; 1594 uint8_t interfaceId = INTERFACEID_OK; 1595 uint8_t pointid = POINTID_BULK_OUT; 1596 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1597 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1598 ASSERT_EQ(0, ret); 1599 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1600 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '1'}; 1601 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1602 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1603 EXPECT_EQ(0, ret); 1604} 1605 1606/** 1607 * @tc.name: UsbdBulkTransferWrite002 1608 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1609 * std::vector<uint8_t> &data); 1610 * @tc.desc: Negative test: parameters exception, busNum error 1611 * @tc.type: FUNC 1612 */ 1613HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite002, TestSize.Level1) 1614{ 1615 struct UsbDev dev = dev_; 1616 uint8_t interfaceId = INTERFACEID_OK; 1617 uint8_t pointid = POINTID_BULK_OUT; 1618 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1619 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1620 ASSERT_EQ(0, ret); 1621 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1622 dev.busNum = BUS_NUM_INVALID; 1623 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '2'}; 1624 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1625 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1626 EXPECT_NE(ret, 0); 1627} 1628 1629/** 1630 * @tc.name: UsbdBulkTransferWrite003 1631 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1632 * std::vector<uint8_t> &data); 1633 * @tc.desc: Negative test: parameters exception, devAddr error 1634 * @tc.type: FUNC 1635 */ 1636HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite003, TestSize.Level1) 1637{ 1638 struct UsbDev dev = dev_; 1639 uint8_t interfaceId = INTERFACEID_OK; 1640 uint8_t pointid = POINTID_BULK_OUT; 1641 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1642 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1643 ASSERT_EQ(0, ret); 1644 dev.devAddr = DEV_ADDR_INVALID; 1645 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1646 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '3'}; 1647 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1648 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite003 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1649 EXPECT_NE(ret, 0); 1650} 1651 1652/** 1653 * @tc.name: UsbdBulkTransferWrite004 1654 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1655 * std::vector<uint8_t> &data); 1656 * @tc.desc: Negative test: parameters exception, intfId error 1657 * @tc.type: FUNC 1658 */ 1659HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite004, TestSize.Level1) 1660{ 1661 struct UsbDev dev = dev_; 1662 uint8_t interfaceId = INTERFACEID_OK; 1663 uint8_t pointid = POINTID_BULK_OUT; 1664 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1665 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1666 ASSERT_EQ(0, ret); 1667 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1668 pipe.intfId = PIPE_INTERFACEID_INVALID; 1669 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '4'}; 1670 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1671 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite004 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1672 EXPECT_NE(ret, 0); 1673} 1674 1675/** 1676 * @tc.name: UsbdBulkTransferWrite005 1677 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1678 * std::vector<uint8_t> &data); 1679 * @tc.desc: Negative test: parameters exception, endpointId error 1680 * @tc.type: FUNC 1681 */ 1682HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite005, TestSize.Level1) 1683{ 1684 struct UsbDev dev = dev_; 1685 uint8_t interfaceId = INTERFACEID_OK; 1686 uint8_t pointid = POINTID_BULK_OUT; 1687 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1688 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1689 ASSERT_EQ(0, ret); 1690 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1691 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 1692 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '5'}; 1693 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1694 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite005 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1695 EXPECT_NE(ret, 0); 1696} 1697 1698/** 1699 * @tc.name: UsbdBulkTransferWrite006 1700 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1701 * std::vector<uint8_t> &data); 1702 * @tc.desc: Negative test: parameters exception, busNum && devAddr error 1703 * @tc.type: FUNC 1704 */ 1705HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite006, TestSize.Level1) 1706{ 1707 struct UsbDev dev = dev_; 1708 uint8_t interfaceId = INTERFACEID_OK; 1709 uint8_t pointid = POINTID_BULK_OUT; 1710 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1711 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1712 ASSERT_EQ(0, ret); 1713 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1714 dev.busNum = BUS_NUM_INVALID; 1715 dev.devAddr = DEV_ADDR_INVALID; 1716 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '6'}; 1717 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1718 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite006 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1719 EXPECT_NE(ret, 0); 1720} 1721 1722/** 1723 * @tc.name: UsbdBulkTransferWrite007 1724 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1725 * std::vector<uint8_t> &data); 1726 * @tc.desc: Negative test: parameters exception, ClaimInterface failed first 1727 * @tc.type: FUNC 1728 */ 1729HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite007, TestSize.Level1) 1730{ 1731 struct UsbDev dev = dev_; 1732 uint8_t interfaceId = INTERFACEID_OK; 1733 uint8_t pointid = PIPE_ENDPOINTID_INVALID; 1734 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1735 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1736 ASSERT_EQ(0, ret); 1737 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1738 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '7'}; 1739 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1740 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite007 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1741 EXPECT_NE(ret, 0); 1742} 1743 1744/** 1745 * @tc.name: UsbdBulkTransferWrite008 1746 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1747 * std::vector<uint8_t> &data); 1748 * @tc.desc: Positive test: parameters correctly, different in timeout 1749 * @tc.type: FUNC 1750 */ 1751HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite008, TestSize.Level1) 1752{ 1753 struct UsbDev dev = dev_; 1754 uint8_t interfaceId = INTERFACEID_OK; 1755 uint8_t pointid = POINTID_BULK_OUT; 1756 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1757 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1758 ASSERT_EQ(0, ret); 1759 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1760 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '8'}; 1761 ret = g_usbInterface->BulkTransferWrite(dev, pipe, -1, bufferData); 1762 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret); 1763 EXPECT_EQ(0, ret); 1764} 1765 1766/** 1767 * @tc.name: InterruptTransferRead001 1768 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1769 * std::vector<uint8_t> &data); 1770 * @tc.desc: Positive test: parameters correctly 1771 * @tc.type: FUNC 1772 */ 1773HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead001, TestSize.Level1) 1774{ 1775 struct UsbDev dev = dev_; 1776 uint8_t interfaceId = INTERFACEID_OK; 1777 uint8_t pointid = POINTID_BULK_IN; 1778 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1779 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1780 ASSERT_EQ(0, ret); 1781 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1782 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1783 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1784 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d UsbdInterruptTransferRead=%{public}d", 1785 __LINE__, ret); 1786 EXPECT_EQ(0, ret); 1787} 1788 1789/** 1790 * @tc.name: UsbdInterruptTransferRead002 1791 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1792 * std::vector<uint8_t> &data); 1793 * @tc.desc: Negative test: parameters exception, busNum error 1794 * @tc.type: FUNC 1795 */ 1796HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead002, TestSize.Level1) 1797{ 1798 struct UsbDev dev = dev_; 1799 uint8_t interfaceId = INTERFACEID_OK; 1800 uint8_t pointid = POINTID_BULK_IN; 1801 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1802 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1803 ASSERT_EQ(0, ret); 1804 dev.busNum = BUS_NUM_INVALID; 1805 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1806 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1807 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1808 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d UsbdInterruptTransferRead=%{public}d", 1809 __LINE__, ret); 1810 EXPECT_NE(ret, 0); 1811} 1812 1813/** 1814 * @tc.name: UsbdInterruptTransferRead003 1815 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1816 * std::vector<uint8_t> &data); 1817 * @tc.desc: Negative test: parameters exception, devAddr error 1818 * @tc.type: FUNC 1819 */ 1820HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead003, TestSize.Level1) 1821{ 1822 struct UsbDev dev = dev_; 1823 uint8_t interfaceId = INTERFACEID_OK; 1824 uint8_t pointid = POINTID_BULK_IN; 1825 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1826 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1827 ASSERT_EQ(0, ret); 1828 dev.devAddr = DEV_ADDR_INVALID; 1829 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1830 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1831 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1832 EXPECT_NE(ret, 0); 1833} 1834 1835/** 1836 * @tc.name: UsbdInterruptTransferRead004 1837 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1838 * std::vector<uint8_t> &data); 1839 * @tc.desc: Negative test: parameters exception, intfId error 1840 * @tc.type: FUNC 1841 */ 1842HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead004, TestSize.Level1) 1843{ 1844 struct UsbDev dev = dev_; 1845 uint8_t interfaceId = INTERFACEID_OK; 1846 uint8_t pointid = POINTID_BULK_IN; 1847 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1848 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1849 ASSERT_EQ(0, ret); 1850 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1851 pipe.intfId = PIPE_INTERFACEID_INVALID; 1852 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1853 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1854 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead004 %{public}d UsbdInterruptTransferRead=%{public}d", 1855 __LINE__, ret); 1856 EXPECT_NE(ret, 0); 1857} 1858 1859/** 1860 * @tc.name: UsbdInterruptTransferRead005 1861 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1862 * std::vector<uint8_t> &data); 1863 * @tc.desc: Negative test: parameters exception, endpointId error 1864 * @tc.type: FUNC 1865 */ 1866HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead005, TestSize.Level1) 1867{ 1868 struct UsbDev dev = dev_; 1869 uint8_t interfaceId = INTERFACEID_OK; 1870 uint8_t pointid = POINTID_BULK_IN; 1871 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1872 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1873 ASSERT_EQ(0, ret); 1874 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1875 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 1876 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 1877 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1878 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead005 %{public}d UsbdInterruptTransferRead=%{public}d", 1879 __LINE__, ret); 1880 EXPECT_NE(ret, 0); 1881} 1882 1883/** 1884 * @tc.name: UsbdInterruptTransferWrite001 1885 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1886 * std::vector<uint8_t> &data); 1887 * @tc.desc: Positive test: parameters correctly 1888 * @tc.type: FUNC 1889 */ 1890HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite001, TestSize.Level1) 1891{ 1892 struct UsbDev dev = dev_; 1893 uint8_t interfaceId = INTERFACEID_OK; 1894 uint8_t pointid = POINTID_BULK_OUT; 1895 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1896 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1897 ASSERT_EQ(0, ret); 1898 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1899 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '1'}; 1900 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1901 HDF_LOGI( 1902 "UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 1903 EXPECT_EQ(0, ret); 1904} 1905 1906/** 1907 * @tc.name: UsbdInterruptTransferWrite002 1908 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1909 * std::vector<uint8_t> &data); 1910 * @tc.desc: Negative test: parameters exception, busNum error 1911 * @tc.type: FUNC 1912 */ 1913HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite002, TestSize.Level1) 1914{ 1915 struct UsbDev dev = dev_; 1916 uint8_t interfaceId = INTERFACEID_OK; 1917 uint8_t pointid = POINTID_BULK_OUT; 1918 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1919 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1920 ASSERT_EQ(0, ret); 1921 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1922 dev.busNum = BUS_NUM_INVALID; 1923 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '2'}; 1924 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1925 HDF_LOGI( 1926 "UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 1927 EXPECT_NE(ret, 0); 1928} 1929 1930/** 1931 * @tc.name: UsbdInterruptTransferWrite003 1932 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1933 * std::vector<uint8_t> &data); 1934 * @tc.desc: Negative test: parameters exception, devAddr error 1935 * @tc.type: FUNC 1936 */ 1937HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite003, TestSize.Level1) 1938{ 1939 struct UsbDev dev = dev_; 1940 uint8_t interfaceId = INTERFACEID_OK; 1941 uint8_t pointid = POINTID_BULK_OUT; 1942 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1943 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1944 ASSERT_EQ(0, ret); 1945 dev.devAddr = DEV_ADDR_INVALID; 1946 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1947 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '3'}; 1948 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1949 HDF_LOGI( 1950 "UsbdTransferTest::UsbdInterruptTransferWrite003 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 1951 EXPECT_NE(ret, 0); 1952} 1953 1954/** 1955 * @tc.name: UsbdInterruptTransferWrite004 1956 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1957 * std::vector<uint8_t> &data); 1958 * @tc.desc: Negative test: parameters exception, intfId error 1959 * @tc.type: FUNC 1960 */ 1961HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite004, TestSize.Level1) 1962{ 1963 struct UsbDev dev = dev_; 1964 uint8_t interfaceId = INTERFACEID_OK; 1965 uint8_t pointid = POINTID_BULK_OUT; 1966 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1967 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1968 ASSERT_EQ(0, ret); 1969 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1970 pipe.intfId = PIPE_INTERFACEID_INVALID; 1971 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '4'}; 1972 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1973 HDF_LOGI( 1974 "UsbdTransferTest::UsbdInterruptTransferWrite004 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 1975 EXPECT_NE(ret, 0); 1976} 1977 1978/** 1979 * @tc.name: UsbdInterruptTransferWrite005 1980 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 1981 * std::vector<uint8_t> &data); 1982 * @tc.desc: Negative test: parameters exception, endpointId error 1983 * @tc.type: FUNC 1984 */ 1985HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite005, TestSize.Level1) 1986{ 1987 struct UsbDev dev = dev_; 1988 uint8_t interfaceId = INTERFACEID_OK; 1989 uint8_t pointid = POINTID_BULK_OUT; 1990 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 1991 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 1992 ASSERT_EQ(0, ret); 1993 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 1994 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 1995 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '5'}; 1996 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 1997 HDF_LOGI( 1998 "UsbdTransferTest::UsbdInterruptTransferWrite005 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 1999 EXPECT_NE(ret, 0); 2000} 2001 2002/** 2003 * @tc.name: UsbdInterruptTransferWrite006 2004 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2005 * std::vector<uint8_t> &data); 2006 * @tc.desc: Negative test: parameters exception, busNum && devAddr error 2007 * @tc.type: FUNC 2008 */ 2009HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite006, TestSize.Level1) 2010{ 2011 struct UsbDev dev = dev_; 2012 uint8_t interfaceId = INTERFACEID_OK; 2013 uint8_t pointid = POINTID_BULK_OUT; 2014 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2015 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2016 ASSERT_EQ(0, ret); 2017 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2018 dev.busNum = BUS_NUM_INVALID; 2019 dev.devAddr = DEV_ADDR_INVALID; 2020 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '6'}; 2021 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2022 HDF_LOGI( 2023 "UsbdTransferTest::UsbdInterruptTransferWrite006 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 2024 EXPECT_NE(ret, 0); 2025} 2026 2027/** 2028 * @tc.name: UsbdInterruptTransferWrite007 2029 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2030 * std::vector<uint8_t> &data); 2031 * @tc.desc: Negative test: parameters exception, ClaimInterface failed first 2032 * @tc.type: FUNC 2033 */ 2034HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite007, TestSize.Level1) 2035{ 2036 struct UsbDev dev = dev_; 2037 uint8_t interfaceId = INTERFACEID_OK; 2038 uint8_t pointid = PIPE_ENDPOINTID_INVALID; 2039 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2040 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2041 ASSERT_EQ(0, ret); 2042 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2043 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '7'}; 2044 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2045 HDF_LOGI( 2046 "UsbdTransferTest::UsbdInterruptTransferWrite007 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 2047 EXPECT_NE(ret, 0); 2048} 2049 2050/** 2051 * @tc.name: UsbdInterruptTransferWrite008 2052 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2053 * std::vector<uint8_t> &data); 2054 * Positive test: parameters correctly, different in timeout 2055 * @tc.type: FUNC 2056 */ 2057HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite008, TestSize.Level1) 2058{ 2059 struct UsbDev dev = dev_; 2060 uint8_t interfaceId = INTERFACEID_OK; 2061 uint8_t pointid = POINTID_BULK_OUT; 2062 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2063 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2064 ASSERT_EQ(0, ret); 2065 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2066 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '8'}; 2067 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, -1, bufferData); 2068 HDF_LOGI( 2069 "UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret); 2070 EXPECT_EQ(0, ret); 2071} 2072 2073/** 2074 * @tc.name: UsbdIsoTransferRead001 2075 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2076 * std::vector<uint8_t> &data); 2077 * @tc.desc: Positive test: parameters correctly 2078 * @tc.type: FUNC 2079 */ 2080HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead001, TestSize.Level1) 2081{ 2082 struct UsbDev dev = dev_; 2083 uint8_t interfaceId = INTERFACEID_OK; 2084 uint8_t pointid = POINTID_BULK_IN; 2085 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2086 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2087 ASSERT_EQ(0, ret); 2088 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2089 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 2090 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2091 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret); 2092 EXPECT_EQ(0, ret); 2093} 2094 2095/** 2096 * @tc.name: UsbdIsoTransferRead002 2097 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2098 * std::vector<uint8_t> &data); 2099 * @tc.desc: Negative test: parameters exception, busNum error 2100 * @tc.type: FUNC 2101 */ 2102HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead002, TestSize.Level1) 2103{ 2104 struct UsbDev dev = dev_; 2105 uint8_t interfaceId = INTERFACEID_OK; 2106 uint8_t pointid = POINTID_BULK_IN; 2107 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d interfaceId=%{public}d", __LINE__, interfaceId); 2108 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2109 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2110 ASSERT_EQ(0, ret); 2111 dev.busNum = BUS_NUM_INVALID; 2112 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2113 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 2114 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2115 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret); 2116 EXPECT_NE(ret, 0); 2117} 2118 2119/** 2120 * @tc.name: UsbdIsoTransferRead003 2121 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2122 * std::vector<uint8_t> &data); 2123 * @tc.desc: Negative test: parameters exception, devAddr error 2124 * @tc.type: FUNC 2125 */ 2126HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead003, TestSize.Level1) 2127{ 2128 struct UsbDev dev = dev_; 2129 uint8_t interfaceId = INTERFACEID_OK; 2130 uint8_t pointid = POINTID_BULK_IN; 2131 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2132 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2133 ASSERT_EQ(0, ret); 2134 dev.devAddr = DEV_ADDR_INVALID; 2135 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2136 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 2137 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2138 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead003 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret); 2139 EXPECT_NE(ret, 0); 2140} 2141 2142/** 2143 * @tc.name: UsbdIsoTransferRead004 2144 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2145 * std::vector<uint8_t> &data); 2146 * @tc.desc: Negative test: parameters exception, intfId error 2147 * @tc.type: FUNC 2148 */ 2149HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead004, TestSize.Level1) 2150{ 2151 struct UsbDev dev = dev_; 2152 uint8_t interfaceId = INTERFACEID_OK; 2153 uint8_t pointid = POINTID_BULK_IN; 2154 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2155 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2156 ASSERT_EQ(0, ret); 2157 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2158 pipe.intfId = PIPE_INTERFACEID_INVALID; 2159 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 2160 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2161 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead004 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret); 2162 EXPECT_NE(ret, 0); 2163} 2164 2165/** 2166 * @tc.name: UsbdIsoTransferRead005 2167 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2168 * std::vector<uint8_t> &data); 2169 * @tc.desc: Negative test: parameters exception, endpointId error 2170 * @tc.type: FUNC 2171 */ 2172HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead005, TestSize.Level1) 2173{ 2174 struct UsbDev dev = dev_; 2175 uint8_t interfaceId = INTERFACEID_OK; 2176 uint8_t pointid = POINTID_BULK_IN; 2177 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2178 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2179 ASSERT_EQ(0, ret); 2180 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2181 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 2182 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH); 2183 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2184 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead005 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret); 2185 EXPECT_NE(ret, 0); 2186} 2187 2188/** 2189 * @tc.name: UsbdIsoTransferWrite001 2190 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2191 * std::vector<uint8_t> &data); 2192 * @tc.desc: Positive test: parameters correctly 2193 * @tc.type: FUNC 2194 */ 2195HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite001, TestSize.Level1) 2196{ 2197 struct UsbDev dev = dev_; 2198 uint8_t interfaceId = INTERFACEID_OK; 2199 uint8_t pointid = POINTID_BULK_OUT; 2200 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2201 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2202 ASSERT_EQ(0, ret); 2203 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2204 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '1'}; 2205 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2206 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2207 EXPECT_EQ(0, ret); 2208} 2209 2210/** 2211 * @tc.name: UsbdIsoTransferWrite002 2212 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2213 * std::vector<uint8_t> &data); 2214 * @tc.desc: Negative test: parameters exception, busNum error 2215 * @tc.type: FUNC 2216 */ 2217HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite002, TestSize.Level1) 2218{ 2219 struct UsbDev dev = dev_; 2220 uint8_t interfaceId = INTERFACEID_OK; 2221 uint8_t pointid = POINTID_BULK_OUT; 2222 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2223 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2224 ASSERT_EQ(0, ret); 2225 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2226 dev.busNum = BUS_NUM_INVALID; 2227 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '2'}; 2228 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2229 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2230 EXPECT_NE(ret, 0); 2231} 2232 2233/** 2234 * @tc.name: UsbdIsoTransferWrite003 2235 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2236 * std::vector<uint8_t> &data); 2237 * @tc.desc: Negative test: parameters exception, devAddr error 2238 * @tc.type: FUNC 2239 */ 2240HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite003, TestSize.Level1) 2241{ 2242 struct UsbDev dev = dev_; 2243 uint8_t interfaceId = INTERFACEID_OK; 2244 uint8_t pointid = POINTID_BULK_OUT; 2245 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2246 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2247 ASSERT_EQ(0, ret); 2248 dev.devAddr = DEV_ADDR_INVALID; 2249 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2250 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '3'}; 2251 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2252 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite003 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2253 EXPECT_NE(ret, 0); 2254} 2255 2256/** 2257 * @tc.name: UsbdIsoTransferWrite004 2258 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2259 * std::vector<uint8_t> &data); 2260 * @tc.desc: Negative test: parameters exception, intfId error 2261 * @tc.type: FUNC 2262 */ 2263HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite004, TestSize.Level1) 2264{ 2265 struct UsbDev dev = dev_; 2266 uint8_t interfaceId = INTERFACEID_OK; 2267 uint8_t pointid = POINTID_BULK_OUT; 2268 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2269 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2270 ASSERT_EQ(0, ret); 2271 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2272 pipe.intfId = PIPE_INTERFACEID_INVALID; 2273 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '4'}; 2274 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2275 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite004 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2276 EXPECT_NE(ret, 0); 2277} 2278 2279/** 2280 * @tc.name: UsbdIsoTransferWrite005 2281 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2282 * std::vector<uint8_t> &data); 2283 * @tc.desc: Negative test: parameters exception, endpointId error 2284 * @tc.type: FUNC 2285 */ 2286HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite005, TestSize.Level1) 2287{ 2288 struct UsbDev dev = dev_; 2289 uint8_t interfaceId = INTERFACEID_OK; 2290 uint8_t pointid = POINTID_BULK_OUT; 2291 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2292 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2293 ASSERT_EQ(0, ret); 2294 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2295 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 2296 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '5'}; 2297 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2298 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite005 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2299 EXPECT_NE(ret, 0); 2300} 2301 2302/** 2303 * @tc.name: UsbdIsoTransferWrite006 2304 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2305 * std::vector<uint8_t> &data); 2306 * @tc.desc: Negative test: parameters exception, busNum && devAddr error 2307 * @tc.type: FUNC 2308 */ 2309HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite006, TestSize.Level1) 2310{ 2311 struct UsbDev dev = dev_; 2312 uint8_t interfaceId = INTERFACEID_OK; 2313 uint8_t pointid = POINTID_BULK_OUT; 2314 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2315 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2316 ASSERT_EQ(0, ret); 2317 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2318 dev.busNum = BUS_NUM_INVALID; 2319 dev.devAddr = DEV_ADDR_INVALID; 2320 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '6'}; 2321 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2322 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite006 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2323 EXPECT_NE(ret, 0); 2324} 2325 2326/** 2327 * @tc.name: UsbdIsoTransferWrite007 2328 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2329 * std::vector<uint8_t> &data); 2330 * @tc.desc: Negative test: parameters exception, endpointId error, ClaimInterface failed first 2331 * @tc.type: FUNC 2332 */ 2333HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite007, TestSize.Level1) 2334{ 2335 struct UsbDev dev = dev_; 2336 uint8_t interfaceId = INTERFACEID_OK; 2337 uint8_t pointid = PIPE_ENDPOINTID_INVALID; 2338 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2339 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2340 ASSERT_EQ(0, ret); 2341 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2342 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '7'}; 2343 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData); 2344 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite007 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2345 EXPECT_NE(ret, 0); 2346} 2347 2348/** 2349 * @tc.name: UsbdIsoTransferWrite008 2350 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, 2351 * std::vector<uint8_t> &data); 2352 * @tc.desc: Positive test: parameters correctly, different in timeout 2353 * @tc.type: FUNC 2354 */ 2355HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite008, TestSize.Level1) 2356{ 2357 struct UsbDev dev = dev_; 2358 uint8_t interfaceId = INTERFACEID_OK; 2359 uint8_t pointid = POINTID_BULK_OUT; 2360 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2361 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2362 ASSERT_EQ(0, ret); 2363 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2364 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '8'}; 2365 ret = g_usbInterface->IsoTransferWrite(dev, pipe, -1, bufferData); 2366 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret); 2367 EXPECT_EQ(0, ret); 2368} 2369 2370/** 2371 * @tc.name: BulkWrite001 2372 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2373 * @tc.desc: Positive test: parameters correctly 2374 * @tc.type: FUNC 2375 */ 2376HWTEST_F(UsbdTransferTest, BulkWrite001, TestSize.Level1) 2377{ 2378 sptr<Ashmem> ashmem; 2379 uint8_t rflg = 0; 2380 int32_t asmSize = MAX_BUFFER_LENGTH; 2381 struct UsbDev dev = dev_; 2382 uint8_t interfaceId = INTERFACEID_OK; 2383 uint8_t pointid = POINTID_BULK_IN; 2384 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2385 HDF_LOGI("UsbdTransferTest::BulkWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2386 ASSERT_EQ(0, ret); 2387 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2388 (void)InitAshmemOne(ashmem, asmSize, rflg); 2389 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem); 2390 HDF_LOGI("UsbdTransferTest::BulkWrite001 %{public}d BulkWrite=%{public}d", __LINE__, ret); 2391 EXPECT_EQ(ret, 0); 2392} 2393 2394/** 2395 * @tc.name: BulkWrite002 2396 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2397 * @tc.desc: Negative test: parameters exception, busNum error 2398 * @tc.type: FUNC 2399 */ 2400HWTEST_F(UsbdTransferTest, BulkWrite002, TestSize.Level1) 2401{ 2402 sptr<Ashmem> ashmem; 2403 uint8_t rflg = 0; 2404 int32_t asmSize = MAX_BUFFER_LENGTH; 2405 struct UsbDev dev = dev_; 2406 uint8_t interfaceId = INTERFACEID_OK; 2407 uint8_t pointid = POINTID_BULK_OUT; 2408 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2409 HDF_LOGI("UsbdTransferTest::BulkWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2410 ASSERT_EQ(0, ret); 2411 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2412 dev.busNum = BUS_NUM_INVALID; 2413 (void)InitAshmemOne(ashmem, asmSize, rflg); 2414 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem); 2415 HDF_LOGI("UsbdTransferTest::BulkWrite002 %{public}d BulkWrite=%{public}d", __LINE__, ret); 2416 EXPECT_NE(ret, 0); 2417} 2418 2419/** 2420 * @tc.name: BulkWrite003 2421 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2422 * @tc.desc: Negative test: parameters exception, devAddr error 2423 * @tc.type: FUNC 2424 */ 2425HWTEST_F(UsbdTransferTest, BulkWrite003, TestSize.Level1) 2426{ 2427 sptr<Ashmem> ashmem; 2428 uint8_t rflg = 0; 2429 int32_t asmSize = MAX_BUFFER_LENGTH; 2430 struct UsbDev dev = dev_; 2431 uint8_t interfaceId = INTERFACEID_OK; 2432 uint8_t pointid = POINTID_BULK_OUT; 2433 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2434 HDF_LOGI("UsbdTransferTest::BulkWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2435 ASSERT_EQ(0, ret); 2436 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2437 dev.devAddr = DEV_ADDR_INVALID; 2438 (void)InitAshmemOne(ashmem, asmSize, rflg); 2439 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem); 2440 HDF_LOGI("UsbdTransferTest::BulkWrite003 %{public}d BulkWrite=%{public}d", __LINE__, ret); 2441 EXPECT_NE(ret, 0); 2442} 2443 2444/** 2445 * @tc.name: BulkWrite004 2446 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2447 * @tc.desc: Negative test: parameters exception, intfId error 2448 * @tc.type: FUNC 2449 */ 2450HWTEST_F(UsbdTransferTest, BulkWrite004, TestSize.Level1) 2451{ 2452 sptr<Ashmem> ashmem; 2453 uint8_t rflg = 0; 2454 int32_t asmSize = MAX_BUFFER_LENGTH; 2455 struct UsbDev dev = dev_; 2456 uint8_t interfaceId = INTERFACEID_OK; 2457 uint8_t pointid = POINTID_BULK_OUT; 2458 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2459 HDF_LOGI("UsbdTransferTest::BulkWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2460 ASSERT_EQ(0, ret); 2461 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2462 pipe.intfId = PIPE_INTERFACEID_INVALID; 2463 (void)InitAshmemOne(ashmem, asmSize, rflg); 2464 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem); 2465 HDF_LOGI("UsbdTransferTest::BulkWrite004 %{public}d BulkWrite=%{public}d", __LINE__, ret); 2466 EXPECT_NE(ret, 0); 2467} 2468 2469/** 2470 * @tc.name: BulkWrite005 2471 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2472 * @tc.desc: Negative test: parameters exception, endpointId error 2473 * @tc.type: FUNC 2474 */ 2475HWTEST_F(UsbdTransferTest, BulkWrite005, TestSize.Level1) 2476{ 2477 sptr<Ashmem> ashmem; 2478 uint8_t rflg = 0; 2479 int32_t asmSize = MAX_BUFFER_LENGTH; 2480 struct UsbDev dev = dev_; 2481 uint8_t interfaceId = INTERFACEID_OK; 2482 uint8_t pointid = POINTID_BULK_OUT; 2483 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2484 HDF_LOGI("UsbdTransferTest::BulkWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2485 ASSERT_EQ(0, ret); 2486 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2487 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 2488 (void)InitAshmemOne(ashmem, asmSize, rflg); 2489 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem); 2490 HDF_LOGI("UsbdTransferTest::BulkWrite005 %{public}d BulkWrite=%{public}d", __LINE__, ret); 2491 EXPECT_NE(ret, 0); 2492} 2493 2494/** 2495 * @tc.name: BulkRead001 2496 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2497 * @tc.desc: Positive test: parameters correctly 2498 * @tc.type: FUNC 2499 */ 2500HWTEST_F(UsbdTransferTest, BulkRead001, TestSize.Level1) 2501{ 2502 sptr<Ashmem> ashmem; 2503 uint8_t rflg = 0; 2504 int32_t asmSize = MAX_BUFFER_LENGTH; 2505 struct UsbDev dev = dev_; 2506 uint8_t interfaceId = INTERFACEID_OK; 2507 uint8_t pointid = POINTID_BULK_IN; 2508 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2509 HDF_LOGI("UsbdTransferTest::BulkRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2510 ASSERT_EQ(0, ret); 2511 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2512 (void)InitAshmemOne(ashmem, asmSize, rflg); 2513 ret = g_usbInterface->BulkRead(dev, pipe, ashmem); 2514 HDF_LOGI("UsbdTransferTest::BulkRead001 %{public}d BulkRead=%{public}d", __LINE__, ret); 2515 EXPECT_EQ(ret, 0); 2516} 2517 2518/** 2519 * @tc.name: BulkRead002 2520 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2521 * @tc.desc: Negative test: parameters exception, busNum error 2522 * @tc.type: FUNC 2523 */ 2524HWTEST_F(UsbdTransferTest, BulkRead002, TestSize.Level1) 2525{ 2526 sptr<Ashmem> ashmem; 2527 uint8_t rflg = 0; 2528 int32_t asmSize = MAX_BUFFER_LENGTH; 2529 struct UsbDev dev = dev_; 2530 uint8_t interfaceId = INTERFACEID_OK; 2531 uint8_t pointid = POINTID_BULK_OUT; 2532 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2533 HDF_LOGI("UsbdTransferTest::BulkRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2534 ASSERT_EQ(0, ret); 2535 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2536 dev.busNum = BUS_NUM_INVALID; 2537 (void)InitAshmemOne(ashmem, asmSize, rflg); 2538 ret = g_usbInterface->BulkRead(dev, pipe, ashmem); 2539 HDF_LOGI("UsbdTransferTest::BulkRead002 %{public}d BulkRead=%{public}d", __LINE__, ret); 2540 EXPECT_NE(ret, 0); 2541} 2542 2543/** 2544 * @tc.name: BulkRead003 2545 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2546 * @tc.desc: Negative test: parameters exception, devAddr error 2547 * @tc.type: FUNC 2548 */ 2549HWTEST_F(UsbdTransferTest, BulkRead003, TestSize.Level1) 2550{ 2551 sptr<Ashmem> ashmem; 2552 uint8_t rflg = 0; 2553 int32_t asmSize = MAX_BUFFER_LENGTH; 2554 struct UsbDev dev = dev_; 2555 uint8_t interfaceId = INTERFACEID_OK; 2556 uint8_t pointid = POINTID_BULK_OUT; 2557 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2558 HDF_LOGI("UsbdTransferTest::BulkRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2559 ASSERT_EQ(0, ret); 2560 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2561 dev.devAddr = DEV_ADDR_INVALID; 2562 (void)InitAshmemOne(ashmem, asmSize, rflg); 2563 ret = g_usbInterface->BulkRead(dev, pipe, ashmem); 2564 HDF_LOGI("UsbdTransferTest::BulkRead003 %{public}d BulkRead=%{public}d", __LINE__, ret); 2565 EXPECT_NE(ret, 0); 2566} 2567 2568/** 2569 * @tc.name: BulkRead004 2570 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2571 * @tc.desc: Negative test: parameters exception, intfId error 2572 * @tc.type: FUNC 2573 */ 2574HWTEST_F(UsbdTransferTest, BulkRead004, TestSize.Level1) 2575{ 2576 sptr<Ashmem> ashmem; 2577 uint8_t rflg = 0; 2578 int32_t asmSize = MAX_BUFFER_LENGTH; 2579 struct UsbDev dev = dev_; 2580 uint8_t interfaceId = INTERFACEID_OK; 2581 uint8_t pointid = POINTID_BULK_OUT; 2582 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2583 HDF_LOGI("UsbdTransferTest::BulkRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2584 ASSERT_EQ(0, ret); 2585 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2586 pipe.intfId = PIPE_INTERFACEID_INVALID; 2587 (void)InitAshmemOne(ashmem, asmSize, rflg); 2588 ret = g_usbInterface->BulkRead(dev, pipe, ashmem); 2589 HDF_LOGI("UsbdTransferTest::BulkRead004 %{public}d BulkRead=%{public}d", __LINE__, ret); 2590 EXPECT_NE(ret, 0); 2591} 2592 2593/** 2594 * @tc.name: BulkRead005 2595 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2596 * @tc.desc: Negative test: parameters exception, endpointId error 2597 * @tc.type: FUNC 2598 */ 2599HWTEST_F(UsbdTransferTest, BulkRead005, TestSize.Level1) 2600{ 2601 sptr<Ashmem> ashmem; 2602 uint8_t rflg = 0; 2603 int32_t asmSize = MAX_BUFFER_LENGTH; 2604 struct UsbDev dev = dev_; 2605 uint8_t interfaceId = INTERFACEID_OK; 2606 uint8_t pointid = POINTID_BULK_OUT; 2607 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); 2608 HDF_LOGI("UsbdTransferTest::BulkRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); 2609 ASSERT_EQ(0, ret); 2610 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2611 pipe.endpointId = PIPE_ENDPOINTID_INVALID; 2612 (void)InitAshmemOne(ashmem, asmSize, rflg); 2613 ret = g_usbInterface->BulkRead(dev, pipe, ashmem); 2614 HDF_LOGI("UsbdTransferTest::BulkRead005 %{public}d BulkRead=%{public}d", __LINE__, ret); 2615 EXPECT_NE(ret, 0); 2616} 2617 2618/** 2619 * @tc.name: RegBulkCallback001 2620 * @tc.desc: Test functions to RegBulkCallback 2621 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb) 2622 * @tc.desc: Positive test: parameters correctly 2623 * @tc.type: FUNC 2624 */ 2625HWTEST_F(UsbdTransferTest, RegBulkCallback001, TestSize.Level1) 2626{ 2627 struct UsbDev dev = dev_; 2628 uint8_t interfaceId = INTERFACEID_OK; 2629 uint8_t pointid = POINTID_BULK_OUT; 2630 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2631 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2632 if (usbdBulkCallback == nullptr) { 2633 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2634 exit(0); 2635 } 2636 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2637 HDF_LOGI("UsbdTransferTest::RegBulkCallback001 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2638 EXPECT_EQ(ret, 0); 2639} 2640 2641/** 2642 * @tc.name: RegBulkCallback002 2643 * @tc.desc: Test functions to RegBulkCallback 2644 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb) 2645 * @tc.desc: Negative test: parameters exception, busNum error 2646 * @tc.type: FUNC 2647 */ 2648HWTEST_F(UsbdTransferTest, RegBulkCallback002, TestSize.Level1) 2649{ 2650 struct UsbDev dev = dev_; 2651 uint8_t interfaceId = INTERFACEID_OK; 2652 uint8_t pointid = POINTID_BULK_OUT; 2653 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2654 dev.busNum = BUS_NUM_INVALID; 2655 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2656 if (usbdBulkCallback == nullptr) { 2657 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2658 exit(0); 2659 } 2660 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2661 HDF_LOGI("UsbdTransferTest::RegBulkCallback002 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2662 EXPECT_NE(ret, 0); 2663} 2664 2665/** 2666 * @tc.name: RegBulkCallback003 2667 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, 2668 * const sptr<IUsbdBulkCallback> &cb) 2669 * @tc.desc: Negative test: parameters exception, devAddr error 2670 * @tc.type: FUNC 2671 */ 2672HWTEST_F(UsbdTransferTest, RegBulkCallback003, TestSize.Level1) 2673{ 2674 struct UsbDev dev = dev_; 2675 uint8_t interfaceId = INTERFACEID_OK; 2676 uint8_t pointid = POINTID_BULK_OUT; 2677 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2678 dev.devAddr = DEV_ADDR_INVALID; 2679 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2680 if (usbdBulkCallback == nullptr) { 2681 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2682 exit(0); 2683 } 2684 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2685 HDF_LOGI("UsbdTransferTest::RegBulkCallback003 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2686 EXPECT_NE(ret, 0); 2687} 2688 2689/** 2690 * @tc.name: RegBulkCallback004 2691 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, 2692 * const sptr<IUsbdBulkCallback> &cb) 2693 * @tc.desc: Negative test: parameters exception, intfId error 2694 * @tc.type: FUNC 2695 */ 2696HWTEST_F(UsbdTransferTest, RegBulkCallback004, TestSize.Level1) 2697{ 2698 struct UsbDev dev = dev_; 2699 uint8_t interfaceId = INTERFACEID_OK; 2700 uint8_t pointid = POINTID_BULK_OUT; 2701 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2702 pipe.intfId = PIPE_INTERFACEID_INVALID; 2703 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2704 if (usbdBulkCallback == nullptr) { 2705 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2706 exit(0); 2707 } 2708 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2709 HDF_LOGI("UsbdTransferTest::RegBulkCallback004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2710 EXPECT_NE(ret, 0); 2711} 2712 2713/** 2714 * @tc.name: RegBulkCallback005 2715 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, 2716 * const sptr<IUsbdBulkCallback> &cb) 2717 * @tc.desc: Negative test: parameters exception, cb error 2718 * @tc.type: FUNC 2719 */ 2720HWTEST_F(UsbdTransferTest, RegBulkCallback005, TestSize.Level1) 2721{ 2722 struct UsbDev dev = dev_; 2723 uint8_t interfaceId = INTERFACEID_OK; 2724 uint8_t pointid = POINTID_BULK_OUT; 2725 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2726 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, nullptr); 2727 HDF_LOGI("UsbdTransferTest::RegBulkCallback005 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2728 EXPECT_NE(ret, 0); 2729} 2730 2731/** 2732 * @tc.name: UnRegBulkCallback001 2733 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe) 2734 * @tc.desc: Positive test: parameters correctly 2735 * @tc.type: FUNC 2736 */ 2737HWTEST_F(UsbdTransferTest, UnRegBulkCallback001, TestSize.Level1) 2738{ 2739 struct UsbDev dev = dev_; 2740 uint8_t interfaceId = INTERFACEID_OK; 2741 uint8_t pointid = POINTID_BULK_OUT; 2742 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2743 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2744 if (usbdBulkCallback == nullptr) { 2745 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2746 exit(0); 2747 } 2748 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2749 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback001 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2750 ASSERT_EQ(ret, 0); 2751 ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2752 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback001 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret); 2753 EXPECT_EQ(ret, 0); 2754} 2755 2756/** 2757 * @tc.name: UnRegBulkCallback002 2758 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe) 2759 * @tc.desc: Negative test: parameters exception, devAddr error 2760 * @tc.type: FUNC 2761 */ 2762HWTEST_F(UsbdTransferTest, UnRegBulkCallback002, TestSize.Level1) 2763{ 2764 struct UsbDev dev = dev_; 2765 uint8_t interfaceId = INTERFACEID_OK; 2766 uint8_t pointid = POINTID_BULK_OUT; 2767 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2768 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2769 if (usbdBulkCallback == nullptr) { 2770 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2771 exit(0); 2772 } 2773 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2774 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback002 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2775 ASSERT_EQ(ret, 0); 2776 dev.devAddr = DEV_ADDR_INVALID; 2777 ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2778 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback002 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret); 2779 EXPECT_NE(ret, 0); 2780 dev = dev_; 2781 ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2782 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback002 %{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret); 2783 EXPECT_EQ(ret, 0); 2784} 2785 2786/** 2787 * @tc.name: UnRegBulkCallback003 2788 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe) 2789 * @tc.desc: Negative test: parameters exception, intfId error 2790 * @tc.type: FUNC 2791 */ 2792HWTEST_F(UsbdTransferTest, UnRegBulkCallback003, TestSize.Level1) 2793{ 2794 struct UsbDev dev = dev_; 2795 uint8_t interfaceId = INTERFACEID_OK; 2796 uint8_t pointid = POINTID_BULK_OUT; 2797 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2798 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2799 if (usbdBulkCallback == nullptr) { 2800 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2801 exit(0); 2802 } 2803 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2804 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback003 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2805 ASSERT_EQ(ret, 0); 2806 pipe.intfId = PIPE_INTERFACEID_INVALID; 2807 ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2808 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback003 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret); 2809 EXPECT_NE(ret, 0); 2810 pipe = {interfaceId, pointid}; 2811 ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2812 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback003 %{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret); 2813 EXPECT_EQ(ret, 0); 2814} 2815 2816/** 2817 * @tc.name: UnRegBulkCallback004 2818 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe) 2819 * @tc.desc: Positive test: call again 2820 * @tc.type: FUNC 2821 */ 2822HWTEST_F(UsbdTransferTest, UnRegBulkCallback004, TestSize.Level1) 2823{ 2824 struct UsbDev dev = dev_; 2825 uint8_t interfaceId = INTERFACEID_OK; 2826 uint8_t pointid = POINTID_BULK_OUT; 2827 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2828 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest(); 2829 if (usbdBulkCallback == nullptr) { 2830 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__); 2831 exit(0); 2832 } 2833 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); 2834 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); 2835 ASSERT_EQ(ret, 0); 2836 ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2837 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback004 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret); 2838 EXPECT_EQ(ret, 0); 2839 ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2840 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback004 %{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret); 2841 EXPECT_EQ(ret, 0); 2842} 2843 2844/** 2845 * @tc.name: UnRegBulkCallback005 2846 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe) 2847 * @tc.desc: Positive test: no register 2848 * @tc.type: FUNC 2849 */ 2850HWTEST_F(UsbdTransferTest, UnRegBulkCallback005, TestSize.Level1) 2851{ 2852 struct UsbDev dev = dev_; 2853 uint8_t interfaceId = INTERFACEID_OK; 2854 uint8_t pointid = POINTID_BULK_OUT; 2855 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointid}; 2856 auto ret = g_usbInterface->UnRegBulkCallback(dev, pipe); 2857 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback005 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret); 2858 EXPECT_EQ(ret, 0); 2859} 2860 2861/** 2862 * @tc.name: UnbindUsbdSubscriber001 2863 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 2864 * @tc.desc: Positive test: parameters correctly 2865 * @tc.type: FUNC 2866 */ 2867HWTEST_F(UsbdTransferTest, UnbindUsbdSubscriber001, TestSize.Level1) 2868{ 2869 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 2870 if (subscriber_ == nullptr) { 2871 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 2872 exit(0); 2873 } 2874 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 2875 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber001 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret); 2876 ASSERT_EQ(0, ret); 2877 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2878 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber001 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2879 EXPECT_EQ(0, ret); 2880} 2881 2882/** 2883 * @tc.name: UnbindUsbdSubscriber002 2884 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 2885 * @tc.desc: Negative test: no bind first 2886 * @tc.type: FUNC 2887 */ 2888HWTEST_F(UsbdTransferTest, UnbindUsbdSubscriber002, TestSize.Level1) 2889{ 2890 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 2891 if (subscriber_ == nullptr) { 2892 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 2893 exit(0); 2894 } 2895 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2896 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber002 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2897 EXPECT_NE(0, ret); 2898} 2899 2900/** 2901 * @tc.name: UnbindUsbdSubscriber003 2902 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 2903 * @tc.desc: Positive test: no bind first, unbind failed; then bind, unbind success 2904 * @tc.type: FUNC 2905 */ 2906HWTEST_F(UsbdTransferTest, UnbindUsbdSubscriber003, TestSize.Level1) 2907{ 2908 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 2909 if (subscriber_ == nullptr) { 2910 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 2911 exit(0); 2912 } 2913 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2914 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber003 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2915 EXPECT_NE(0, ret); 2916 ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 2917 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber003 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret); 2918 ASSERT_EQ(0, ret); 2919 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2920 HDF_LOGI( 2921 "UsbdTransferTest::UnbindUsbdSubscriber003 %{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2922 EXPECT_EQ(0, ret); 2923} 2924 2925/** 2926 * @tc.name: UnbindUsbdSubscriber004 2927 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 2928 * @tc.desc: Negative test: call twice 2929 * @tc.type: FUNC 2930 */ 2931HWTEST_F(UsbdTransferTest, UnbindUsbdSubscriber004, TestSize.Level1) 2932{ 2933 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 2934 if (subscriber_ == nullptr) { 2935 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 2936 exit(0); 2937 } 2938 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 2939 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber004 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret); 2940 ASSERT_EQ(0, ret); 2941 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2942 HDF_LOGI( 2943 "UsbdTransferTest::UnbindUsbdSubscriber004 %{public}d first UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2944 EXPECT_EQ(0, ret); 2945 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2946 HDF_LOGI( 2947 "UsbdTransferTest::UnbindUsbdSubscriber004 %{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2948 EXPECT_NE(0, ret); 2949} 2950 2951/** 2952 * @tc.name: UnbindUsbdSubscriber005 2953 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 2954 * @tc.desc: Positive test: test repeatedly 2955 * @tc.type: FUNC 2956 */ 2957HWTEST_F(UsbdTransferTest, UnbindUsbdSubscriber005, TestSize.Level1) 2958{ 2959 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 2960 if (subscriber_ == nullptr) { 2961 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 2962 exit(0); 2963 } 2964 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 2965 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber005 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret); 2966 ASSERT_EQ(0, ret); 2967 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2968 HDF_LOGI( 2969 "UsbdTransferTest::UnbindUsbdSubscriber005 %{public}d first UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2970 EXPECT_EQ(0, ret); 2971 ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 2972 HDF_LOGI("UsbdTransferTest::UnbindUsbdSubscriber005 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret); 2973 ASSERT_EQ(0, ret); 2974 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 2975 HDF_LOGI( 2976 "UsbdTransferTest::UnbindUsbdSubscriber005 %{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 2977 EXPECT_EQ(0, ret); 2978} 2979 2980/** 2981 * @tc.name: BindUsbdSubscriber001 2982 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 2983 * @tc.desc: Positive test: parameters correctly 2984 * @tc.type: FUNC 2985 */ 2986HWTEST_F(UsbdTransferTest, BindUsbdSubscriber001, TestSize.Level1) 2987{ 2988 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 2989 if (subscriber_ == nullptr) { 2990 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 2991 exit(0); 2992 } 2993 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 2994 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber001 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret); 2995 EXPECT_EQ(0, ret); 2996} 2997 2998/** 2999 * @tc.name: BindUsbdSubscriber002 3000 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 3001 * @tc.desc: Positive test: bind different 3002 * @tc.type: FUNC 3003 */ 3004HWTEST_F(UsbdTransferTest, BindUsbdSubscriber002, TestSize.Level1) 3005{ 3006 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 3007 if (subscriber_ == nullptr) { 3008 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 3009 exit(0); 3010 } 3011 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 3012 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber002 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret); 3013 EXPECT_EQ(0, ret); 3014 sptr<UsbSubscriberTest> subscriber2 = new UsbSubscriberTest(); 3015 if (subscriber_ == nullptr) { 3016 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 3017 exit(0); 3018 } 3019 ret = g_usbInterface->BindUsbdSubscriber(subscriber2); 3020 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber002 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret); 3021 EXPECT_EQ(0, ret); 3022} 3023 3024/** 3025 * @tc.name: BindUsbdSubscriber003 3026 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 3027 * @tc.desc: Positive test: bind same 3028 * @tc.type: FUNC 3029 */ 3030HWTEST_F(UsbdTransferTest, BindUsbdSubscriber003, TestSize.Level1) 3031{ 3032 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 3033 if (subscriber_ == nullptr) { 3034 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 3035 exit(0); 3036 } 3037 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 3038 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber003 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret); 3039 EXPECT_EQ(0, ret); 3040 ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 3041 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber003 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret); 3042 EXPECT_EQ(0, ret); 3043} 3044 3045/** 3046 * @tc.name: BindUsbdSubscriber004 3047 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 3048 * @tc.desc: Positive test: bind and unbind, then bind another 3049 * @tc.type: FUNC 3050 */ 3051HWTEST_F(UsbdTransferTest, BindUsbdSubscriber004, TestSize.Level1) 3052{ 3053 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 3054 if (subscriber_ == nullptr) { 3055 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 3056 exit(0); 3057 } 3058 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 3059 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber004 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret); 3060 ASSERT_EQ(0, ret); 3061 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 3062 HDF_LOGI("UsbdTransferTest::bindUsbdSubscriber005 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 3063 EXPECT_EQ(0, ret); 3064 sptr<UsbSubscriberTest> subscriber2 = new UsbSubscriberTest(); 3065 if (subscriber_ == nullptr) { 3066 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 3067 exit(0); 3068 } 3069 ret = g_usbInterface->BindUsbdSubscriber(subscriber2); 3070 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber004 again %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret); 3071 EXPECT_EQ(0, ret); 3072} 3073 3074/** 3075 * @tc.name: BindUsbdSubscriber005 3076 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber_) 3077 * @tc.desc: Positive test: bind again after unbind 3078 * @tc.type: FUNC 3079 */ 3080HWTEST_F(UsbdTransferTest, BindUsbdSubscriber005, TestSize.Level1) 3081{ 3082 sptr<UsbSubscriberTest> subscriber_ = new UsbSubscriberTest(); 3083 if (subscriber_ == nullptr) { 3084 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__); 3085 exit(0); 3086 } 3087 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 3088 HDF_LOGI("UsbdTransferTest::BindUsbdSubscriber005 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret); 3089 ASSERT_EQ(0, ret); 3090 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_); 3091 HDF_LOGI("UsbdTransferTest::bindUsbdSubscriber005 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret); 3092 EXPECT_EQ(0, ret); 3093 ret = g_usbInterface->BindUsbdSubscriber(subscriber_); 3094 HDF_LOGI("UsbdTransferTest::bindUsbdSubscriber005 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret); 3095 EXPECT_EQ(0, ret); 3096} 3097} // namespace 3098