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
26using namespace testing::ext;
27using namespace OHOS;
28using namespace OHOS::USB;
29using namespace std;
30using namespace OHOS::HDI::Usb::V1_0;
31using namespace OHOS::HDI::Usb::V1_1;
32
33const int SLEEP_TIME = 3;
34const uint8_t BUS_NUM_INVALID = 255;
35const uint8_t DEV_ADDR_INVALID = 255;
36UsbDev UsbdDeviceTest::dev_ = {0, 0};
37sptr<UsbSubscriberTest> UsbdDeviceTest::subscriber_ = nullptr;
38
39namespace {
40sptr<OHOS::HDI::Usb::V1_1::IUsbInterface> g_usbInterface = nullptr;
41
42int32_t SwitchErrCode(int32_t ret)
43{
44    return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
45}
46
47void 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
75void UsbdDeviceTest::TearDownTestCase(void)
76{
77    g_usbInterface->UnbindUsbdSubscriber(subscriber_);
78}
79
80void UsbdDeviceTest::SetUp(void) {}
81
82void 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 */
91HWTEST_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 */
106HWTEST_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 */
121HWTEST_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 */
136HWTEST_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 */
153HWTEST_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 */
171HWTEST_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 */
192HWTEST_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 */
213HWTEST_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 */
235HWTEST_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 */
256HWTEST_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 */
280HWTEST_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 */
304HWTEST_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 */
327HWTEST_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 */
339HWTEST_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 */
351HWTEST_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 */
363HWTEST_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 */
375HWTEST_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 */
393HWTEST_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 */
411HWTEST_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 */
429HWTEST_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