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_test.h"
17
18 #include <iostream>
19 #include <vector>
20
21 #include "UsbSubTest.h"
22 #include "hdf_log.h"
23 #include "usbd_wrapper.h"
24 #include "v2_0/iusb_host_interface.h"
25 #include "v2_0/iusb_port_interface.h"
26
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::USB;
30 using namespace std;
31 using namespace OHOS::HDI::Usb::V2_0;
32
33 const int SLEEP_TIME = 3;
34 const uint8_t BUS_NUM_INVALID = 255;
35 const uint8_t DEV_ADDR_INVALID = 255;
36 UsbDev UsbdDeviceTest::dev_ = {0, 0};
37 sptr<UsbSubTest> UsbdDeviceTest::subscriber_ = nullptr;
38
39 namespace {
40 sptr<OHOS::HDI::Usb::V2_0::IUsbHostInterface> g_usbHostInterface = nullptr;
41 sptr<OHOS::HDI::Usb::V2_0::IUsbPortInterface> g_usbPortInterface = nullptr;
42
SwitchErrCode(int32_t ret)43 int32_t SwitchErrCode(int32_t ret)
44 {
45 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
46 }
47
SetUpTestCase(void)48 void UsbdDeviceTest::SetUpTestCase(void)
49 {
50 g_usbHostInterface = OHOS::HDI::Usb::V2_0::IUsbHostInterface::Get(true);
51 g_usbPortInterface = OHOS::HDI::Usb::V2_0::IUsbPortInterface::Get();
52 if (g_usbPortInterface == nullptr || g_usbHostInterface == nullptr) {
53 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
54 exit(0);
55 }
56 auto ret = g_usbPortInterface->SetPortRole(1, 1, 1);
57 sleep(SLEEP_TIME);
58 HDF_LOGI("UsbdDeviceTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
59 ret = SwitchErrCode(ret);
60 ASSERT_EQ(0, ret);
61 if (ret != 0) {
62 exit(0);
63 }
64
65 subscriber_ = new UsbSubTest();
66 if (g_usbHostInterface->BindUsbdHostSubscriber(subscriber_) != HDF_SUCCESS) {
67 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
68 exit(0);
69 }
70 std::cout << "please connect device, press enter to continue" << std::endl;
71 int c;
72 while ((c = getchar()) != '\n' && c != EOF) {}
73 printf("busNum = %d, devAddr = %d \n", subscriber_->busNum_, subscriber_->devAddr_);
74 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
75 }
76
TearDownTestCase(void)77 void UsbdDeviceTest::TearDownTestCase(void)
78 {
79 g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
80 }
81
SetUp(void)82 void UsbdDeviceTest::SetUp(void) {}
83
TearDown(void)84 void UsbdDeviceTest::TearDown(void) {}
85
86 /**
87 * @tc.name: UsbdDevice001
88 * @tc.desc: Test functions to OpenDevice
89 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
90 * @tc.desc: 正向测试：参数正确
91 * @tc.type: FUNC
92 */
93 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice001, TestSize.Level1)
94 {
95 struct UsbDev dev = dev_;
96 auto ret = g_usbHostInterface->OpenDevice(dev);
97 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result =%{public}d", __LINE__, ret);
98 EXPECT_EQ(0, ret);
99 }
100
101 /**
102 * @tc.name: UsbdDevice002
103 * @tc.desc: Test functions to OpenDevice
104 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
105 * @tc.desc:
106 * @tc.type: FUNC
107 */
108 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice002, TestSize.Level1)
109 {
110 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
111 auto ret = g_usbHostInterface->OpenDevice(dev);
112 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
113 EXPECT_NE(ret, 0);
114 }
115
116 /**
117 * @tc.name: UsbdDevice003
118 * @tc.desc: Test functions to OpenDevice
119 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
120 * @tc.desc:
121 * @tc.type: FUNC
122 */
123 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice003, TestSize.Level1)
124 {
125 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
126 auto ret = g_usbHostInterface->OpenDevice(dev);
127 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
128 EXPECT_NE(ret, 0);
129 }
130
131 /**
132 * @tc.name: UsbdDevice004
133 * @tc.desc: Test functions to OpenDevice
134 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
135 * @tc.desc:
136 * @tc.type: FUNC
137 */
138 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice004, TestSize.Level1)
139 {
140 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
141 auto ret = g_usbHostInterface->OpenDevice(dev);
142 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
143 EXPECT_NE(ret, 0);
144 }
145
146 /**********************************************************************************************************/
147
148 /**
149 * @tc.name: UsbdDevice011
150 * @tc.desc: Test functions to CloseDevice
151 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
152 * @tc.desc: 正向测试：参数正确
153 * @tc.type: FUNC
154 */
155 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice001, TestSize.Level1)
156 {
157 struct UsbDev dev = dev_;
158 auto ret = g_usbHostInterface->OpenDevice(dev);
159 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
160 ASSERT_EQ(0, ret);
161 ret = g_usbHostInterface->CloseDevice(dev);
162 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
163 EXPECT_EQ(0, ret);
164 }
165
166 /**
167 * @tc.name: UsbdDevice012
168 * @tc.desc: Test functions to CloseDevice
169 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
170 * @tc.desc:
171 * @tc.type: FUNC
172 */
173 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice002, TestSize.Level1)
174 {
175 struct UsbDev dev = dev_;
176 auto ret = g_usbHostInterface->OpenDevice(dev);
177 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
178 ASSERT_EQ(0, ret);
179 dev.busNum = BUS_NUM_INVALID;
180 ret = g_usbHostInterface->CloseDevice(dev);
181 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
182 EXPECT_NE(ret, 0);
183 dev = dev_;
184 g_usbHostInterface->CloseDevice(dev);
185 }
186
187 /**
188 * @tc.name: UsbdDevice013
189 * @tc.desc: Test functions to CloseDevice
190 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
191 * @tc.desc:
192 * @tc.type: FUNC
193 */
194 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice003, TestSize.Level1)
195 {
196 struct UsbDev dev = dev_;
197 auto ret = g_usbHostInterface->OpenDevice(dev);
198 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
199 ASSERT_EQ(0, ret);
200 dev.devAddr = DEV_ADDR_INVALID;
201 ret = g_usbHostInterface->CloseDevice(dev);
202 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
203 EXPECT_NE(ret, 0);
204 dev = dev_;
205 g_usbHostInterface->CloseDevice(dev);
206 }
207
208 /**
209 * @tc.name: UsbdDevice014
210 * @tc.desc: Test functions to CloseDevice
211 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
212 * @tc.desc:
213 * @tc.type: FUNC
214 */
215 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice004, TestSize.Level1)
216 {
217 struct UsbDev dev = dev_;
218 auto ret = g_usbHostInterface->OpenDevice(dev);
219 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
220 ASSERT_EQ(0, ret);
221 dev.busNum = BUS_NUM_INVALID;
222 dev.devAddr = DEV_ADDR_INVALID;
223 ret = g_usbHostInterface->CloseDevice(dev);
224 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
225 EXPECT_NE(ret, 0);
226 dev = dev_;
227 g_usbHostInterface->CloseDevice(dev);
228 }
229
230 /**
231 * @tc.name: UsbdResetDevice001
232 * @tc.desc: Test functions to ResetDevice
233 * @tc.desc: int32_t ResetDevice(const UsbDev &dev);
234 * @tc.desc: 正向测试：参数正确
235 * @tc.type: FUNC
236 */
237 HWTEST_F(UsbdDeviceTest, UsbdResetDevice001, TestSize.Level1)
238 {
239 struct UsbDev dev = dev_;
240 auto ret = g_usbHostInterface->OpenDevice(dev);
241 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
242 ASSERT_EQ(0, ret);
243 ret = g_usbHostInterface->ResetDevice(dev);
244 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret);
245 EXPECT_EQ(0, ret);
246 ret = g_usbHostInterface->CloseDevice(dev);
247 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
248 EXPECT_EQ(0, ret);
249 }
250
251 /**
252 * @tc.name: UsbdResetDevice002
253 * @tc.desc: Test functions to ResetDevice
254 * @tc.desc: int32_t ResetDevice(const UsbDev &dev);
255 * @tc.desc:
256 * @tc.type: FUNC
257 */
258 HWTEST_F(UsbdDeviceTest, UsbdResetDevice002, TestSize.Level1)
259 {
260 struct UsbDev dev = dev_;
261 auto ret = g_usbHostInterface->OpenDevice(dev);
262 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
263 ASSERT_EQ(0, ret);
264 dev.busNum = BUS_NUM_INVALID;
265 ret = g_usbHostInterface->ResetDevice(dev);
266 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret);
267 EXPECT_NE(0, ret);
268 ret = g_usbHostInterface->CloseDevice(dev);
269 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
270 EXPECT_NE(ret, 0);
271 dev = dev_;
272 g_usbHostInterface->CloseDevice(dev);
273 }
274
275 /**
276 * @tc.name: UsbdResetDevice003
277 * @tc.desc: Test functions to ResetDevice
278 * @tc.desc: int32_t ResetDevice(const UsbDev &dev);
279 * @tc.desc:
280 * @tc.type: FUNC
281 */
282 HWTEST_F(UsbdDeviceTest, UsbdResetDevice003, TestSize.Level1)
283 {
284 struct UsbDev dev = dev_;
285 auto ret = g_usbHostInterface->OpenDevice(dev);
286 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
287 ASSERT_EQ(0, ret);
288 dev.devAddr = DEV_ADDR_INVALID;
289 ret = g_usbHostInterface->ResetDevice(dev);
290 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret);
291 EXPECT_NE(0, ret);
292 ret = g_usbHostInterface->CloseDevice(dev);
293 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
294 EXPECT_NE(ret, 0);
295 dev = dev_;
296 g_usbHostInterface->CloseDevice(dev);
297 }
298
299 /**
300 * @tc.name: UsbdResetDevice004
301 * @tc.desc: Test functions to ResetDevice
302 * @tc.desc: int32_t ResetDevice(const UsbDev &dev);
303 * @tc.desc:
304 * @tc.type: FUNC
305 */
306 HWTEST_F(UsbdDeviceTest, UsbdResetDevice004, TestSize.Level1)
307 {
308 struct UsbDev dev = dev_;
309 auto ret = g_usbHostInterface->OpenDevice(dev);
310 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
311 ASSERT_EQ(0, ret);
312 dev.busNum = BUS_NUM_INVALID;
313 dev.devAddr = DEV_ADDR_INVALID;
314 ret = g_usbHostInterface->ResetDevice(dev);
315 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret);
316 EXPECT_NE(0, ret);
317 ret = g_usbHostInterface->CloseDevice(dev);
318 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
319 EXPECT_NE(ret, 0);
320 dev = dev_;
321 g_usbHostInterface->CloseDevice(dev);
322 }
323
324 /**
325 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0100
326 * @tc.name: testHdiUsbDeviceTestOpenDevice001
327 * @tc.desc: Opens a USB device to set up a connection. dev ={1, 255}.
328 */
329 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestOpenDevice001, Function | MediumTest | Level2)
330 {
331 struct UsbDev dev = {1, 255};
332 auto ret = g_usbHostInterface->OpenDevice(dev);
333 EXPECT_NE(ret, 0);
334 }
335
336 /**
337 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0200
338 * @tc.name: testHdiUsbDeviceTestOpenDevice002
339 * @tc.desc: Opens a USB device to set up a connection. dev ={255, 1}.
340 */
341 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestOpenDevice002, Function | MediumTest | Level2)
342 {
343 struct UsbDev dev = {255, 1};
344 auto ret = g_usbHostInterface->OpenDevice(dev);
345 EXPECT_NE(ret, 0);
346 }
347
348 /**
349 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0300
350 * @tc.name: testHdiUsbDeviceTestOpenDevice003
351 * @tc.desc: Opens a USB device to set up a connection. dev ={255, 100}.
352 */
353 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestOpenDevice003, Function | MediumTest | Level2)
354 {
355 struct UsbDev dev = {255, 100};
356 auto ret = g_usbHostInterface->OpenDevice(dev);
357 EXPECT_NE(ret, 0);
358 }
359
360 /**
361 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0400
362 * @tc.name: testHdiUsbDeviceTestOpenDevice004
363 * @tc.desc: Opens a USB device to set up a connection. dev ={100, 255}.
364 */
365 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestOpenDevice004, Function | MediumTest | Level2)
366 {
367 struct UsbDev dev = {100, 255};
368 auto ret = g_usbHostInterface->OpenDevice(dev);
369 EXPECT_NE(ret, 0);
370 }
371
372 /**
373 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0500
374 * @tc.name: testHdiUsbDeviceTestCloseDevice001
375 * @tc.desc: Closes a USB device to release all system resources related to the device. dev ={1, 255}.
376 */
377 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestCloseDevice001, Function | MediumTest | Level2)
378 {
379 struct UsbDev dev = dev_;
380 auto ret = g_usbHostInterface->OpenDevice(dev);
381 ASSERT_EQ(0, ret);
382 dev = {1, 255};
383 ret = g_usbHostInterface->CloseDevice(dev);
384 EXPECT_NE(ret, 0);
385 dev = dev_;
386 ret = g_usbHostInterface->CloseDevice(dev);
387 EXPECT_EQ(ret, 0);
388 }
389
390 /**
391 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0600
392 * @tc.name: testHdiUsbDeviceTestCloseDevice002
393 * @tc.desc: Closes a USB device to release all system resources related to the device. dev ={255, 1}.
394 */
395 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestCloseDevice002, Function | MediumTest | Level2)
396 {
397 struct UsbDev dev = dev_;
398 auto ret = g_usbHostInterface->OpenDevice(dev);
399 ASSERT_EQ(0, ret);
400 dev = {255, 1};
401 ret = g_usbHostInterface->CloseDevice(dev);
402 EXPECT_NE(ret, 0);
403 dev = dev_;
404 ret = g_usbHostInterface->CloseDevice(dev);
405 EXPECT_EQ(ret, 0);
406 }
407
408 /**
409 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0700
410 * @tc.name: testHdiUsbDeviceTestCloseDevice003
411 * @tc.desc: Closes a USB device to release all system resources related to the device. dev ={255, 100}.
412 */
413 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestCloseDevice003, Function | MediumTest | Level2)
414 {
415 struct UsbDev dev = dev_;
416 auto ret = g_usbHostInterface->OpenDevice(dev);
417 ASSERT_EQ(0, ret);
418 dev = {255, 100};
419 ret = g_usbHostInterface->CloseDevice(dev);
420 EXPECT_NE(ret, 0);
421 dev = dev_;
422 ret = g_usbHostInterface->CloseDevice(dev);
423 EXPECT_EQ(ret, 0);
424 }
425
426 /**
427 * @tc.number: SUB_USB_DeviceManager_HDI_CompatDeviceTest_0800
428 * @tc.name: testHdiUsbDeviceTestCloseDevice004
429 * @tc.desc: Closes a USB device to release all system resources related to the device. dev ={100, 255}.
430 */
431 HWTEST_F(UsbdDeviceTest, testHdiUsbDeviceTestCloseDevice004, Function | MediumTest | Level2)
432 {
433 struct UsbDev dev = dev_;
434 auto ret = g_usbHostInterface->OpenDevice(dev);
435 ASSERT_EQ(0, ret);
436 dev = {100, 255};
437 ret = g_usbHostInterface->CloseDevice(dev);
438 EXPECT_NE(ret, 0);
439 dev = dev_;
440 ret = g_usbHostInterface->CloseDevice(dev);
441 EXPECT_EQ(ret, 0);
442 }
443 } // namespace
444