1 /*
2 * Copyright (c) 2021-2022 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_0/iusb_interface.h"
24 #include "v1_0/usb_types.h"
25
26 const int SLEEP_TIME = 3;
27 const uint8_t BUS_NUM_255 = 255;
28 const uint8_t DEV_ADDR_255 = 255;
29 UsbDev UsbdDeviceTest::dev_ = {0, 0};
30
31 using namespace testing::ext;
32 using namespace OHOS;
33 using namespace OHOS::USB;
34 using namespace std;
35 using namespace OHOS::HDI::Usb::V1_0;
36
37 namespace {
38 sptr<IUsbInterface> g_usbInterface = nullptr;
39
SetUpTestCase(void)40 void UsbdDeviceTest::SetUpTestCase(void)
41 {
42 g_usbInterface = IUsbInterface::Get();
43 if (g_usbInterface == nullptr) {
44 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
45 exit(0);
46 }
47 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
48 sleep(SLEEP_TIME);
49 HDF_LOGI("UsbdDeviceTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
50 ASSERT_EQ(0, ret);
51 if (ret != 0) {
52 exit(0);
53 }
54
55 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
56 if (g_usbInterface->BindUsbdSubscriber(subscriber) != HDF_SUCCESS) {
57 HDF_LOGE("%{public}s: bind usbd subscriber failed\n", __func__);
58 exit(0);
59 }
60 dev_ = {subscriber->busNum_, subscriber->devAddr_};
61
62 std::cout << "please connect device, press enter to continue" << std::endl;
63 int c;
64 while ((c = getchar()) != '\n' && c != EOF) {}
65 }
66
TearDownTestCase(void)67 void UsbdDeviceTest::TearDownTestCase(void) {}
68
SetUp(void)69 void UsbdDeviceTest::SetUp(void) {}
70
TearDown(void)71 void UsbdDeviceTest::TearDown(void) {}
72
73 /**
74 * @tc.name: UsbdDevice001
75 * @tc.desc: Test functions to OpenDevice
76 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
77 * @tc.desc: 正向测试：参数正确
78 * @tc.type: FUNC
79 */
80 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice001, TestSize.Level1)
81 {
82 struct UsbDev dev = dev_;
83 auto ret = g_usbInterface->OpenDevice(dev);
84 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result =%{public}d", __LINE__, ret);
85 ASSERT_EQ(0, ret);
86 }
87
88 /**
89 * @tc.name: UsbdDevice002
90 * @tc.desc: Test functions to OpenDevice
91 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
92 * @tc.desc:
93 * @tc.type: FUNC
94 */
95 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice002, TestSize.Level1)
96 {
97 struct UsbDev dev = {BUS_NUM_255, dev_.devAddr};
98 auto ret = g_usbInterface->OpenDevice(dev);
99 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
100 ASSERT_NE(ret, 0);
101 }
102
103 /**
104 * @tc.name: UsbdDevice003
105 * @tc.desc: Test functions to OpenDevice
106 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
107 * @tc.desc:
108 * @tc.type: FUNC
109 */
110 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice003, TestSize.Level1)
111 {
112 struct UsbDev dev = {dev_.busNum, DEV_ADDR_255};
113 auto ret = g_usbInterface->OpenDevice(dev);
114 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
115 ASSERT_NE(ret, 0);
116 }
117
118 /**
119 * @tc.name: UsbdDevice004
120 * @tc.desc: Test functions to OpenDevice
121 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
122 * @tc.desc:
123 * @tc.type: FUNC
124 */
125 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice004, TestSize.Level1)
126 {
127 struct UsbDev dev = {BUS_NUM_255, DEV_ADDR_255};
128 auto ret = g_usbInterface->OpenDevice(dev);
129 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
130 ASSERT_NE(ret, 0);
131 }
132
133 /**********************************************************************************************************/
134
135 /**
136 * @tc.name: UsbdDevice011
137 * @tc.desc: Test functions to CloseDevice
138 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
139 * @tc.desc: 正向测试：参数正确
140 * @tc.type: FUNC
141 */
142 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice001, TestSize.Level1)
143 {
144 struct UsbDev dev = dev_;
145 auto ret = g_usbInterface->OpenDevice(dev);
146 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
147 ASSERT_EQ(0, ret);
148 ret = g_usbInterface->CloseDevice(dev);
149 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
150 ASSERT_EQ(0, ret);
151 }
152
153 /**
154 * @tc.name: UsbdDevice012
155 * @tc.desc: Test functions to CloseDevice
156 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
157 * @tc.desc:
158 * @tc.type: FUNC
159 */
160 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice002, TestSize.Level1)
161 {
162 struct UsbDev dev = dev_;
163 auto ret = g_usbInterface->OpenDevice(dev);
164 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
165 ASSERT_EQ(0, ret);
166 dev.busNum = BUS_NUM_255;
167 ret = g_usbInterface->CloseDevice(dev);
168 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
169 ASSERT_NE(ret, 0);
170 dev = dev_;
171 g_usbInterface->CloseDevice(dev);
172 }
173
174 /**
175 * @tc.name: UsbdDevice013
176 * @tc.desc: Test functions to CloseDevice
177 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
178 * @tc.desc:
179 * @tc.type: FUNC
180 */
181 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice003, TestSize.Level1)
182 {
183 struct UsbDev dev = dev_;
184 auto ret = g_usbInterface->OpenDevice(dev);
185 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
186 ASSERT_EQ(0, ret);
187 dev.devAddr = DEV_ADDR_255;
188 ret = g_usbInterface->CloseDevice(dev);
189 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
190 ASSERT_NE(ret, 0);
191 dev = dev_;
192 g_usbInterface->CloseDevice(dev);
193 }
194
195 /**
196 * @tc.name: UsbdDevice014
197 * @tc.desc: Test functions to CloseDevice
198 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
199 * @tc.desc:
200 * @tc.type: FUNC
201 */
202 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice004, TestSize.Level1)
203 {
204 struct UsbDev dev = dev_;
205 auto ret = g_usbInterface->OpenDevice(dev);
206 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
207 ASSERT_EQ(0, ret);
208 dev.busNum = BUS_NUM_255;
209 dev.devAddr = DEV_ADDR_255;
210 ret = g_usbInterface->CloseDevice(dev);
211 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
212 ASSERT_NE(ret, 0);
213 dev = dev_;
214 g_usbInterface->CloseDevice(dev);
215 }
216 } // namespace
217