1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "usbd_device_status_test.h"
17
18 #include <iostream>
19 #include <vector>
20
21 #include "UsbSubTest.h"
22 #include "hdf_log.h"
23 #include "usbd_type.h"
24 #include "usbd_wrapper.h"
25 #include "v2_0/iusb_host_interface.h"
26 #include "v2_0/iusb_port_interface.h"
27
28 const int SLEEP_TIME = 3;
29 const uint8_t BUS_NUM_INVALID = 255;
30 const uint8_t DEV_ADDR_INVALID = 255;
31 const uint8_t INTERFACEID_OK = 1;
32 const uint8_t INTERFACEID_OK_NEW = 0;
33 const uint8_t INTERFACEID_INVALID = 255;
34 const uint8_t POINTID_DIR_IN = USB_ENDPOINT_DIR_IN | 2;
35
36 using namespace testing::ext;
37 using namespace OHOS;
38 using namespace OHOS::USB;
39 using namespace std;
40 using namespace OHOS::HDI::Usb::V2_0;
41 namespace OHOS {
42 namespace USB {
43 UsbDev UsbdDeviceStatusTest::dev_ = {0, 0};
44 sptr<UsbSubTest> UsbdDeviceStatusTest::subscriber_ = nullptr;
45 sptr<OHOS::HDI::Usb::V2_0::IUsbHostInterface> g_usbHostInterface = nullptr;
46 sptr<OHOS::HDI::Usb::V2_0::IUsbPortInterface> g_usbPortInterface = nullptr;
47
SwitchErrCode(int32_t ret)48 int32_t SwitchErrCode(int32_t ret)
49 {
50 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
51 }
52
SetUpTestCase(void)53 void UsbdDeviceStatusTest::SetUpTestCase(void)
54 {
55 g_usbPortInterface = OHOS::HDI::Usb::V2_0::IUsbPortInterface::Get();
56 g_usbHostInterface = OHOS::HDI::Usb::V2_0::IUsbHostInterface::Get(true);
57 if (g_usbPortInterface == nullptr) {
58 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
59 exit(0);
60 }
61 auto ret = g_usbPortInterface->SetPortRole(1, 1, 1);
62 sleep(SLEEP_TIME);
63 HDF_LOGI("UsbdDeviceStatusTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
64 ret = SwitchErrCode(ret);
65 ASSERT_EQ(0, ret);
66 if (ret != 0) {
67 exit(0);
68 }
69
70 subscriber_ = new UsbSubTest();
71 if (g_usbHostInterface->BindUsbdHostSubscriber(subscriber_) != HDF_SUCCESS) {
72 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
73 exit(0);
74 }
75
76 std::cout << "please connect device, press enter to continue" << std::endl;
77 int c;
78 while ((c = getchar()) != '\n' && c != EOF) {}
79 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
80
81 ret = g_usbHostInterface->OpenDevice(dev_);
82 HDF_LOGI("UsbdDeviceStatusTest::%{public}d OpenDevice=%{public}d", __LINE__, ret);
83 ASSERT_EQ(0, ret);
84 }
85
TearDownTestCase(void)86 void UsbdDeviceStatusTest::TearDownTestCase(void)
87 {
88 g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
89 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
90 auto ret = g_usbHostInterface->CloseDevice(dev_);
91 HDF_LOGI("UsbdDeviceStatusTest::%{public}d Close=%{public}d", __LINE__, ret);
92 ASSERT_EQ(0, ret);
93 }
94
SetUp(void)95 void UsbdDeviceStatusTest::SetUp(void) {}
96
TearDown(void)97 void UsbdDeviceStatusTest::TearDown(void) {}
98
99 /**
100 * @tc.name: UsbdGetDeviceSpeed001
101 * @tc.desc: Test functions to GetDeviceSpeed
102 * @tc.desc: int32_t GetDeviceSpeed(const UsbDev &dev, uint8_t interfaceId, uint8_t speed);
103 * @tc.desc: Positive test: parameters correctly
104 * @tc.type: FUNC
105 */
106 HWTEST_F(UsbdDeviceStatusTest, UsbdGetDeviceSpeed001, TestSize.Level1)
107 {
108 struct UsbDev dev = dev_;
109 int32_t ret = -1;
110 uint8_t speed = 0;
111 ret = g_usbHostInterface->GetDeviceSpeed(dev, speed);
112 HDF_LOGI("UsbdGetDeviceSpeed001 %{public}d GetDeviceSpeed=%{public}d, speed=%{public}d", __LINE__, ret, speed);
113 EXPECT_EQ(0, ret);
114 }
115
116 /**
117 * @tc.name: UsbdGetDeviceSpeed002
118 * @tc.desc: Test functions to GetDeviceSpeed
119 * @tc.desc: int32_t GetDeviceSpeed(const UsbDev &dev, uint8_t interfaceId, uint8_t speed);
120 * @tc.desc: Negative test: parameters exception, busNum error
121 * @tc.type: FUNC
122 */
123 HWTEST_F(UsbdDeviceStatusTest, UsbdGetDeviceSpeed002, TestSize.Level1)
124 {
125 struct UsbDev dev = dev_;
126 dev.busNum = BUS_NUM_INVALID;
127 uint8_t speed = 0;
128 auto ret = g_usbHostInterface->GetDeviceSpeed(dev, speed);
129 HDF_LOGI("UsbdGetDeviceSpeed002 %{public}d ret=%{public}d, speed=%{public}d", __LINE__, ret, speed);
130 EXPECT_NE(ret, 0);
131 }
132
133
134 /**
135 * @tc.name: UsbdGetDeviceSpeed003
136 * @tc.desc: Test functions to GetDeviceSpeed
137 * @tc.desc: int32_t GetDeviceSpeed(const UsbDev &dev, uint8_t interfaceId, uint8_t speed);
138 * @tc.desc: Negative test: parameters exception, devAddr error
139 * @tc.type: FUNC
140 */
141 HWTEST_F(UsbdDeviceStatusTest, UsbdGetDeviceSpeed003, TestSize.Level1)
142 {
143 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
144 uint8_t speed = 0;
145 auto ret = g_usbHostInterface->GetDeviceSpeed(dev, speed);
146 HDF_LOGI("UsbdGetDeviceSpeed003 %{public}d, ret=%{public}d, speed=%{public}d", __LINE__, ret, speed);
147 EXPECT_NE(ret, 0);
148 }
149
150 /**
151 * @tc.name: UsbdGetDeviceSpeed004
152 * @tc.desc: Test functions to GetDeviceSpeed
153 * @tc.desc: int32_t GetDeviceSpeed(const UsbDev &dev, uint8_t interfaceId, uint8_t speed);
154 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
155 * @tc.type: FUNC
156 */
157 HWTEST_F(UsbdDeviceStatusTest, UsbdGetDeviceSpeed004, TestSize.Level1)
158 {
159 uint8_t speed = 0;
160 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
161 auto ret = g_usbHostInterface->GetDeviceSpeed(dev, speed);
162 HDF_LOGI("UsbdGetDeviceSpeed004 %{public}d, ret=%{public}d, speed=%{public}d", __LINE__, ret, speed);
163 EXPECT_NE(ret, 0);
164 }
165
166 /**
167 * @tc.name: UsbdGetInterfaceActiveStatus001
168 * @tc.desc: Test functions to GetInterfaceActiveStatus
169 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
170 * @tc.desc: Positive test: parameters correctly
171 * @tc.type: FUNC
172 */
173 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus001, TestSize.Level1)
174 {
175 uint8_t interfaceId = INTERFACEID_OK_NEW;
176 struct UsbDev dev = dev_;
177 int32_t ret = -1;
178 bool unactived = 1;
179 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
180 HDF_LOGI("UsbdDeviceStatusTest::UsbdGetInterfaceActiveStatus %{public}d ClaimInterface=%{public}d", __LINE__, ret);
181 ASSERT_EQ(0, ret);
182 for (; interfaceId < INTERFACEID_INVALID; interfaceId++) {
183 ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
184 if (ret == 0) {
185 break;
186 }
187 }
188 HDF_LOGI("UsbdGetInterfaceActiveStatus001 %{public}d GetInterfaceActiveStatus=%{public}d, unactived=%{public}d",
189 __LINE__, ret, unactived);
190 EXPECT_EQ(0, ret);
191 }
192
193 /**
194 * @tc.name: UsbdGetInterfaceActiveStatus002
195 * @tc.desc: Test functions to GetInterfaceActiveStatus
196 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
197 * @tc.desc: Negative test: parameters exception, busNum error
198 * @tc.type: FUNC
199 */
200 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus002, TestSize.Level1)
201 {
202 uint8_t interfaceId = INTERFACEID_OK;
203 struct UsbDev dev = dev_;
204 dev.busNum = BUS_NUM_INVALID;
205 bool unactived = 1;
206 auto ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
207 HDF_LOGI("UsbdGetInterfaceActiveStatus002 %{public}d ret=%{public}d, unactived=%{public}d",
208 __LINE__, ret, unactived);
209 EXPECT_NE(ret, 0);
210 }
211
212 /**
213 * @tc.name: UsbdGetInterfaceActiveStatus003
214 * @tc.desc: Test functions to GetInterfaceActiveStatus
215 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
216 * @tc.desc: Negative test: parameters exception, devAddr error
217 * @tc.type: FUNC
218 */
219 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus003, TestSize.Level1)
220 {
221 uint8_t interfaceId = INTERFACEID_OK;
222 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
223 bool unactived = 1;
224 auto ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
225 HDF_LOGI("UsbdGetInterfaceActiveStatus003 %{public}d, ret=%{public}d, unactived=%{public}d",
226 __LINE__, ret, unactived);
227 EXPECT_NE(ret, 0);
228 }
229
230 /**
231 * @tc.name: UsbdGetInterfaceActiveStatus004
232 * @tc.desc: Test functions to GetInterfaceActiveStatus
233 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
234 * @tc.desc: Negative test: parameters exception, interfaceid error
235 * @tc.type: FUNC
236 */
237 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus004, TestSize.Level1)
238 {
239 uint8_t interfaceId = INTERFACEID_OK;
240 struct UsbDev dev = dev_;
241 interfaceId = INTERFACEID_INVALID;
242 bool unactived = 1;
243 auto ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
244 HDF_LOGI("UsbdGetInterfaceActiveStatus004 %{public}d, ret=%{public}d, unactived=%{public}d",
245 __LINE__, ret, unactived);
246 EXPECT_NE(ret, 0);
247 }
248
249 /**
250 * @tc.name: UsbdGetInterfaceActiveStatus005
251 * @tc.desc: Test functions to GetInterfaceActiveStatus
252 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
253 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
254 * @tc.type: FUNC
255 */
256 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus005, TestSize.Level1)
257 {
258 uint8_t interfaceId = INTERFACEID_OK;
259 bool unactived = 1;
260 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
261 auto ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
262 HDF_LOGI("UsbdGetInterfaceActiveStatus005 %{public}d, ret=%{public}d, unactived=%{public}d",
263 __LINE__, ret, unactived);
264 EXPECT_NE(ret, 0);
265 }
266
267 /**
268 * @tc.name: UsbdGetInterfaceActiveStatus006
269 * @tc.desc: Test functions to GetInterfaceActiveStatus
270 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
271 * @tc.desc: Negative test: parameters exception, busNum && interfaceid error
272 * @tc.type: FUNC
273 */
274 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus006, TestSize.Level1)
275 {
276 uint8_t interfaceId = INTERFACEID_INVALID;
277 bool unactived = 1;
278 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
279 auto ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
280 HDF_LOGI("UsbdGetInterfaceActiveStatus006 %{public}d, ret=%{public}d, unactived=%{public}d",
281 __LINE__, ret, unactived);
282 EXPECT_NE(ret, 0);
283 }
284
285 /**
286 * @tc.name: UsbdGetInterfaceActiveStatus007
287 * @tc.desc: Test functions to GetInterfaceActiveStatus
288 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
289 * @tc.desc: Negative test: parameters exception, devAddr && interfaceid error
290 * @tc.type: FUNC
291 */
292 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus007, TestSize.Level1)
293 {
294 uint8_t interfaceId = INTERFACEID_INVALID;
295 bool unactived = 1;
296 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
297 auto ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
298 HDF_LOGI("UsbdGetInterfaceActiveStatus007 %{public}d, ret=%{public}d, unactived=%{public}d",
299 __LINE__, ret, unactived);
300 EXPECT_NE(ret, 0);
301 }
302
303 /**
304 * @tc.name: UsbdGetInterfaceActiveStatus008
305 * @tc.desc: Test functions to GetInterfaceActiveStatus
306 * @tc.desc: int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived);
307 * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceid error
308 * @tc.type: FUNC
309 */
310 HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus008, TestSize.Level1)
311 {
312 uint8_t interfaceId = INTERFACEID_INVALID;
313 bool unactived = 1;
314 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
315 auto ret = g_usbHostInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
316 HDF_LOGI("UsbdGetInterfaceActiveStatus008 %{public}d, ret=%{public}d, unactived=%{public}d",
317 __LINE__, ret, unactived);
318 EXPECT_NE(ret, 0);
319 }
320
321 /**
322 * @tc.name: UsbdClearHalt001
323 * @tc.desc: Test functions to ClearHalt
324 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
325 * @tc.desc: Positive test: parameters correctly
326 * @tc.type: FUNC
327 */
328 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt001, TestSize.Level1)
329 {
330 struct UsbDev dev = dev_;
331 int32_t ret = -1;
332 uint8_t interfaceId = INTERFACEID_OK;
333 uint8_t pointId = POINTID_DIR_IN;
334 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
335 HDF_LOGI("UsbdRequestTest::UsbdClearHalt001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
336 ASSERT_EQ(0, ret);
337 struct UsbPipe pipe = {interfaceId, pointId};
338 ret = g_usbHostInterface->ClearHalt(dev, pipe);
339 HDF_LOGI("UsbdClearHalt001 %{public}d ClearHalt=%{public}d", __LINE__, ret);
340 EXPECT_TRUE(ret == 0);
341 }
342
343 /**
344 * @tc.name: UsbdClearHalt002
345 * @tc.desc: Test functions to ClearHalt
346 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
347 * @tc.desc: Negative test: parameters exception, busNum error
348 * @tc.type: FUNC
349 */
350 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt002, TestSize.Level1)
351 {
352 struct UsbDev dev = dev_;
353 int32_t ret = -1;
354 uint8_t interfaceId = INTERFACEID_OK;
355 uint8_t pointId = POINTID_DIR_IN;
356 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
357 HDF_LOGI("UsbdRequestTest::UsbdClearHalt002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
358 ASSERT_EQ(0, ret);
359 struct UsbPipe pipe = {interfaceId, pointId};
360 dev.busNum = BUS_NUM_INVALID;
361 ret = g_usbHostInterface->ClearHalt(dev, pipe);
362 HDF_LOGI("UsbdClearHalt002 %{public}d ClearHalt=%{public}d", __LINE__, ret);
363 EXPECT_NE(0, ret);
364 }
365
366 /**
367 * @tc.name: UsbdClearHalt003
368 * @tc.desc: Test functions to GetInterfaceActiveStatus
369 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
370 * @tc.desc: Negative test: parameters exception, devAddr error
371 * @tc.type: FUNC
372 */
373 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt003, TestSize.Level1)
374 {
375 struct UsbDev dev = dev_;
376 int32_t ret = -1;
377 uint8_t interfaceId = INTERFACEID_OK;
378 uint8_t pointId = POINTID_DIR_IN;
379 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
380 HDF_LOGI("UsbdRequestTest::UsbdClearHalt003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
381 ASSERT_EQ(0, ret);
382 struct UsbPipe pipe = {interfaceId, pointId};
383 dev.devAddr = DEV_ADDR_INVALID;
384 ret = g_usbHostInterface->ClearHalt(dev, pipe);
385 HDF_LOGI("UsbdClearHalt003 %{public}d ClearHalt=%{public}d", __LINE__, ret);
386 EXPECT_NE(0, ret);
387 }
388
389 /**
390 * @tc.name: UsbdClearHalt004
391 * @tc.desc: Test functions to ClearHalt
392 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
393 * @tc.desc: Negative test: parameters exception, interfaceid error
394 * @tc.type: FUNC
395 */
396 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt004, TestSize.Level1)
397 {
398 struct UsbDev dev = dev_;
399 int32_t ret = -1;
400 uint8_t interfaceId = INTERFACEID_INVALID;
401 uint8_t pointId = POINTID_DIR_IN;
402 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
403 HDF_LOGI("UsbdRequestTest::UsbdClearHalt004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
404 ASSERT_NE(0, ret);
405 struct UsbPipe pipe = {interfaceId, pointId};
406 ret = g_usbHostInterface->ClearHalt(dev, pipe);
407 HDF_LOGI("UsbdClearHalt004 %{public}d ClearHalt=%{public}d", __LINE__, ret);
408 EXPECT_NE(0, ret);
409 }
410
411 /**
412 * @tc.name: UsbdClearHalt005
413 * @tc.desc: Test functions to ClearHalt
414 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
415 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
416 * @tc.type: FUNC
417 */
418 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt005, TestSize.Level1)
419 {
420 struct UsbDev dev = dev_;
421 int32_t ret = -1;
422 uint8_t interfaceId = INTERFACEID_OK;
423 uint8_t pointId = POINTID_DIR_IN;
424 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
425 HDF_LOGI("UsbdRequestTest::UsbdClearHalt005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
426 ASSERT_EQ(0, ret);
427 struct UsbPipe pipe = {interfaceId, pointId};
428 dev.busNum = BUS_NUM_INVALID;
429 dev.devAddr = DEV_ADDR_INVALID;
430 ret = g_usbHostInterface->ClearHalt(dev, pipe);
431 HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d", __LINE__, ret);
432 EXPECT_NE(0, ret);
433 }
434
435 /**
436 * @tc.name: UsbdClearHalt006
437 * @tc.desc: Test functions to ClearHalt
438 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
439 * @tc.desc: Negative test: parameters exception, busNum && interfaceid error
440 * @tc.type: FUNC
441 */
442 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt006, TestSize.Level1)
443 {
444 struct UsbDev dev = dev_;
445 int32_t ret = -1;
446 uint8_t interfaceId = INTERFACEID_INVALID;
447 uint8_t pointId = POINTID_DIR_IN;
448 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
449 HDF_LOGI("UsbdRequestTest::UsbdClearHalt006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
450 ASSERT_NE(0, ret);
451 struct UsbPipe pipe = {interfaceId, pointId};
452 dev.busNum = BUS_NUM_INVALID;
453 ret = g_usbHostInterface->ClearHalt(dev, pipe);
454 HDF_LOGI("UsbdClearHalt006 %{public}d ClearHalt=%{public}d", __LINE__, ret);
455 EXPECT_NE(0, ret);
456 }
457
458 /**
459 * @tc.name: UsbdClearHalt007
460 * @tc.desc: Test functions to ClearHalt
461 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
462 * @tc.desc: Negative test: parameters exception, devAddr && interfaceid error
463 * @tc.type: FUNC
464 */
465 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt007, TestSize.Level1)
466 {
467 struct UsbDev dev = dev_;
468 int32_t ret = -1;
469 uint8_t interfaceId = INTERFACEID_INVALID;
470 uint8_t pointId = POINTID_DIR_IN;
471 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
472 HDF_LOGI("UsbdRequestTest::UsbdClearHalt007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
473 ASSERT_NE(0, ret);
474 struct UsbPipe pipe = {interfaceId, pointId};
475 dev.devAddr = DEV_ADDR_INVALID;
476 ret = g_usbHostInterface->ClearHalt(dev, pipe);
477 HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d", __LINE__, ret);
478 EXPECT_NE(0, ret);
479 }
480
481 /**
482 * @tc.name: UsbdClearHalt008
483 * @tc.desc: Test functions to ClearHalt
484 * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe);
485 * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceid error
486 * @tc.type: FUNC
487 */
488 HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt008, TestSize.Level1)
489 {
490 struct UsbDev dev = dev_;
491 int32_t ret = -1;
492 uint8_t interfaceId = INTERFACEID_INVALID;
493 uint8_t pointId = POINTID_DIR_IN;
494 ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
495 HDF_LOGI("UsbdRequestTest::UsbdClearHalt008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
496 ASSERT_NE(0, ret);
497 struct UsbPipe pipe = {interfaceId, pointId};
498 dev.busNum = BUS_NUM_INVALID;
499 dev.devAddr = DEV_ADDR_INVALID;
500 ret = g_usbHostInterface->ClearHalt(dev, pipe);
501 HDF_LOGI("UsbdClearHalt008 %{public}d ClearHalt=%{public}d", __LINE__, ret);
502 EXPECT_NE(0, ret);
503 }
504 } // USB
505 } // OHOS
506