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