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