1 /*
2 * Copyright (c) 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 <climits>
17 #include <iostream>
18 #include <vector>
19
20 #include "mock_linux_adapter.h"
21 #include "usb_impl.h"
22 #include "usbd_dispatcher.h"
23 #include "UsbSubscriberTest.h"
24 #include "v1_0/iusb_interface.h"
25 #include "v1_0/usb_types.h"
26
27 using ::testing::Exactly;
28 using ::testing::Return;
29
30 using namespace std;
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 constexpr uint8_t BUS_NUM_INVALID = 255;
38 constexpr uint8_t DEV_ADDR_INVALID = 255;
39 constexpr uint8_t BUS_NUM_OK = 6;
40 constexpr uint8_t DEV_ADDR_OK = 2;
41
42 namespace {
43 class UsbdDeviceTest : public testing::Test {
44 public:
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
47
48 static UsbDev dev_;
49 };
50 sptr<IUsbInterface> g_usbInterfaceProxy = nullptr;
51 sptr<IUsbInterface> g_usbInterface = nullptr;
52 UsbDev UsbdDeviceTest::dev_ = {0, 0};
53
SetUpTestCase(void)54 void UsbdDeviceTest::SetUpTestCase(void)
55 {
56 struct UsbOsAdapterOps *osAdapterOps = UsbAdapterGetOps();
57 g_usbInterface = IUsbInterface::Get(true);
58 ASSERT_NE(nullptr, g_usbInterface);
59 sptr<UsbImpl> sp = static_cast<UsbImpl *>(g_usbInterface.GetRefPtr());
60 osAdapterOps->openDevice = FuncAdapterOpenDevice;
61 osAdapterOps->init = FuncAdapterInit;
62 osAdapterOps->getConfiguration = FuncAdapterGetConfiguration;
63 osAdapterOps->getConfigDescriptor = FuncAdapterGetConfigDescriptor;
64 osAdapterOps->urbCompleteHandle = FuncAdapterUrbCompleteHandle;
65 osAdapterOps->allocRequest = FuncAdapterAllocRequest;
66 osAdapterOps->cancelRequest = FuncAdapterCancelRequest;
67 osAdapterOps->submitRequest = FuncAdapterSubmitRequest;
68 osAdapterOps->claimInterface = FuncAdapterClaimInterface;
69 osAdapterOps->detachKernelDriverAndClaim = FuncAdapterClaimInterface;
70 osAdapterOps->freeRequest = FuncAdapterFreeRequest;
71 osAdapterOps->closeDevice = FuncAdapterCloseDevice;
72 osAdapterOps->releaseInterface = FuncAdapterReleaseInterface;
73 auto ret = UsbdDispatcher::UsbdDeviceCreateAndAttach(sp, BUS_NUM_OK, DEV_ADDR_OK);
74 dev_ = {BUS_NUM_OK, DEV_ADDR_OK};
75 ASSERT_EQ(0, ret);
76 g_usbInterfaceProxy = IUsbInterface::Get();
77 ASSERT_NE(nullptr, g_usbInterfaceProxy);
78 }
79
TearDownTestCase(void)80 void UsbdDeviceTest::TearDownTestCase(void)
81 {
82 g_usbInterface->CloseDevice(dev_);
83 sptr<UsbImpl> sp = static_cast<UsbImpl *>(g_usbInterface.GetRefPtr());
84 UsbdDispatcher::UsbdDeviceDettach(sp, BUS_NUM_OK, DEV_ADDR_OK);
85 }
86
87 /**
88 * @tc.name: UnbindUsbdSubscriber001
89 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
90 * @tc.desc: Positive test: parameters correctly
91 * @tc.type: FUNC
92 */
93 HWTEST_F(UsbdDeviceTest, UnbindUsbdSubscriber001, TestSize.Level1)
94 {
95 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
96 ASSERT_NE(nullptr, subscriber);
97 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
98 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber001 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret);
99 ASSERT_EQ(0, ret);
100 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
101 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber001 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
102 ASSERT_EQ(0, ret);
103 }
104
105 /**
106 * @tc.name: UnbindUsbdSubscriber002
107 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
108 * @tc.desc: Negative test: no bind first
109 * @tc.type: FUNC
110 */
111 HWTEST_F(UsbdDeviceTest, UnbindUsbdSubscriber002, TestSize.Level1)
112 {
113 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
114 ASSERT_NE(nullptr, subscriber);
115 auto ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
116 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber002 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
117 ASSERT_NE(0, ret);
118 }
119
120 /**
121 * @tc.name: UnbindUsbdSubscriber003
122 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
123 * @tc.desc: Positive test: no bind first, unbind failed; then bind, unbind success
124 * @tc.type: FUNC
125 */
126 HWTEST_F(UsbdDeviceTest, UnbindUsbdSubscriber003, TestSize.Level1)
127 {
128 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
129 ASSERT_NE(nullptr, subscriber);
130 auto ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
131 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber003 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
132 ASSERT_NE(0, ret);
133 ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
134 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber003 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret);
135 ASSERT_EQ(0, ret);
136 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
137 HDF_LOGI(
138 "UsbdDeviceTest::UnbindUsbdSubscriber003 %{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
139 ASSERT_EQ(0, ret);
140 }
141
142 /**
143 * @tc.name: UnbindUsbdSubscriber004
144 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
145 * @tc.desc: Negative test: call twice
146 * @tc.type: FUNC
147 */
148 HWTEST_F(UsbdDeviceTest, UnbindUsbdSubscriber004, TestSize.Level1)
149 {
150 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
151 ASSERT_NE(nullptr, subscriber);
152 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
153 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber004 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret);
154 ASSERT_EQ(0, ret);
155 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
156 HDF_LOGI(
157 "UsbdDeviceTest::UnbindUsbdSubscriber004 %{public}d first UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
158 ASSERT_EQ(0, ret);
159 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
160 HDF_LOGI(
161 "UsbdDeviceTest::UnbindUsbdSubscriber004 %{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
162 ASSERT_NE(0, ret);
163 }
164
165 /**
166 * @tc.name: UnbindUsbdSubscriber005
167 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
168 * @tc.desc: Positive test: test repeatedly
169 * @tc.type: FUNC
170 */
171 HWTEST_F(UsbdDeviceTest, UnbindUsbdSubscriber005, TestSize.Level1)
172 {
173 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
174 ASSERT_NE(nullptr, subscriber);
175 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
176 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber005 %{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret);
177 ASSERT_EQ(0, ret);
178 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
179 HDF_LOGI(
180 "UsbdDeviceTest::UnbindUsbdSubscriber005 %{public}d first UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
181 ASSERT_EQ(0, ret);
182 ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
183 HDF_LOGI("UsbdDeviceTest::UnbindUsbdSubscriber005 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
184 ASSERT_EQ(0, ret);
185 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
186 HDF_LOGI(
187 "UsbdDeviceTest::UnbindUsbdSubscriber005 %{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
188 ASSERT_EQ(0, ret);
189 }
190
191 /**
192 * @tc.name: BindUsbdSubscriber001
193 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
194 * @tc.desc: Positive test: parameters correctly
195 * @tc.type: FUNC
196 */
197 HWTEST_F(UsbdDeviceTest, BindUsbdSubscriber001, TestSize.Level1)
198 {
199 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
200 ASSERT_NE(nullptr, subscriber);
201 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
202 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber001 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
203 ASSERT_EQ(0, ret);
204 }
205
206 /**
207 * @tc.name: BindUsbdSubscriber002
208 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
209 * @tc.desc: Positive test: bind different
210 * @tc.type: FUNC
211 */
212 HWTEST_F(UsbdDeviceTest, BindUsbdSubscriber002, TestSize.Level1)
213 {
214 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
215 ASSERT_NE(nullptr, subscriber);
216 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
217 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber002 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
218 ASSERT_EQ(0, ret);
219 sptr<UsbSubscriberTest> subscriber2 = new UsbSubscriberTest();
220 ASSERT_NE(nullptr, subscriber2);
221 ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber2);
222 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber002 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
223 ASSERT_EQ(0, ret);
224 }
225
226 /**
227 * @tc.name: BindUsbdSubscriber003
228 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
229 * @tc.desc: Positive test: bind same
230 * @tc.type: FUNC
231 */
232 HWTEST_F(UsbdDeviceTest, BindUsbdSubscriber003, TestSize.Level1)
233 {
234 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
235 ASSERT_NE(nullptr, subscriber);
236 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
237 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber003 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
238 ASSERT_EQ(0, ret);
239 ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
240 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber003 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
241 ASSERT_EQ(0, ret);
242 }
243
244 /**
245 * @tc.name: BindUsbdSubscriber004
246 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
247 * @tc.desc: Positive test: bind and unbind, then bind another
248 * @tc.type: FUNC
249 */
250 HWTEST_F(UsbdDeviceTest, BindUsbdSubscriber004, TestSize.Level1)
251 {
252 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
253 ASSERT_NE(nullptr, subscriber);
254 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
255 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber004 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
256 ASSERT_EQ(0, ret);
257 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
258 HDF_LOGI("UsbdDeviceTest::bindUsbdSubscriber005 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
259 ASSERT_EQ(0, ret);
260 sptr<UsbSubscriberTest> subscriber2 = new UsbSubscriberTest();
261 ASSERT_NE(subscriber2, subscriber);
262 ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber2);
263 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber004 again %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
264 ASSERT_EQ(0, ret);
265 }
266
267 /**
268 * @tc.name: BindUsbdSubscriber005
269 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
270 * @tc.desc: Positive test: bind again after unbind
271 * @tc.type: FUNC
272 */
273 HWTEST_F(UsbdDeviceTest, BindUsbdSubscriber005, TestSize.Level1)
274 {
275 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
276 ASSERT_NE(nullptr, subscriber);
277 auto ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
278 HDF_LOGI("UsbdDeviceTest::BindUsbdSubscriber005 %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
279 ASSERT_EQ(0, ret);
280 ret = g_usbInterfaceProxy->UnbindUsbdSubscriber(subscriber);
281 HDF_LOGI("UsbdDeviceTest::bindUsbdSubscriber005 %{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
282 ASSERT_EQ(0, ret);
283 ret = g_usbInterfaceProxy->BindUsbdSubscriber(subscriber);
284 HDF_LOGI("UsbdDeviceTest::bindUsbdSubscriber005 %{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
285 ASSERT_EQ(0, ret);
286 }
287
288 /**
289 * @tc.name: UsbdDevice001
290 * @tc.desc: Test functions to OpenDevice
291 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
292 * @tc.desc: Positive test: parameters correctly
293 * @tc.type: FUNC
294 */
295 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice001, TestSize.Level1)
296 {
297 int32_t ret = g_usbInterface->OpenDevice(dev_);
298 ASSERT_EQ(0, ret);
299 }
300
301 /**
302 * @tc.name: UsbdDevice002
303 * @tc.desc: Test functions to OpenDevice
304 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
305 * @tc.desc: Negative test
306 * @tc.type: FUNC
307 */
308 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice002, TestSize.Level1)
309 {
310 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
311 auto ret = g_usbInterface->OpenDevice(dev);
312 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
313 ASSERT_NE(ret, 0);
314 }
315
316 /**
317 * @tc.name: UsbdDevice003
318 * @tc.desc: Test functions to OpenDevice
319 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
320 * @tc.desc: Negative test
321 * @tc.type: FUNC
322 */
323 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice003, TestSize.Level1)
324 {
325 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
326 auto ret = g_usbInterface->OpenDevice(dev);
327 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
328 ASSERT_NE(ret, 0);
329 }
330
331 /**
332 * @tc.name: UsbdDevice004
333 * @tc.desc: Test functions to OpenDevice
334 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
335 * @tc.desc: Negative test
336 * @tc.type: FUNC
337 */
338 HWTEST_F(UsbdDeviceTest, UsbdOpenDevice004, TestSize.Level1)
339 {
340 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
341 auto ret = g_usbInterface->OpenDevice(dev);
342 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
343 ASSERT_NE(ret, 0);
344 }
345
346 /**********************************************************************************************************/
347
348 /**
349 * @tc.name: UsbdDevice011
350 * @tc.desc: Test functions to CloseDevice
351 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
352 * @tc.desc: Positive test: parameters correctly
353 * @tc.type: FUNC
354 */
355 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice001, TestSize.Level1)
356 {
357 struct UsbDev dev = dev_;
358 auto ret = g_usbInterface->OpenDevice(dev);
359 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
360 ASSERT_EQ(0, ret);
361 ret = g_usbInterface->CloseDevice(dev);
362 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
363 ASSERT_EQ(0, ret);
364 }
365
366 /**
367 * @tc.name: UsbdDevice012
368 * @tc.desc: Test functions to CloseDevice
369 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
370 * @tc.desc: Negative test
371 * @tc.type: FUNC
372 */
373 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice002, TestSize.Level1)
374 {
375 struct UsbDev dev = dev_;
376 auto ret = g_usbInterface->OpenDevice(dev);
377 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
378 ASSERT_EQ(0, ret);
379 dev.busNum = BUS_NUM_INVALID;
380 ret = g_usbInterface->CloseDevice(dev);
381 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
382 ASSERT_NE(ret, 0);
383 dev = dev_;
384 g_usbInterface->CloseDevice(dev);
385 }
386
387 /**
388 * @tc.name: UsbdDevice013
389 * @tc.desc: Test functions to CloseDevice
390 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
391 * @tc.desc: Negative test
392 * @tc.type: FUNC
393 */
394 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice003, TestSize.Level1)
395 {
396 struct UsbDev dev = dev_;
397 auto ret = g_usbInterface->OpenDevice(dev);
398 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
399 ASSERT_EQ(0, ret);
400 dev.devAddr = DEV_ADDR_INVALID;
401 ret = g_usbInterface->CloseDevice(dev);
402 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
403 ASSERT_NE(ret, 0);
404 dev = dev_;
405 g_usbInterface->CloseDevice(dev);
406 }
407
408 /**
409 * @tc.name: UsbdDevice014
410 * @tc.desc: Test functions to CloseDevice
411 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
412 * @tc.desc: Negative test
413 * @tc.type: FUNC
414 */
415 HWTEST_F(UsbdDeviceTest, UsbdCloseDevice004, TestSize.Level1)
416 {
417 struct UsbDev dev = dev_;
418 auto ret = g_usbInterface->OpenDevice(dev);
419 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
420 ASSERT_EQ(0, ret);
421 dev.busNum = BUS_NUM_INVALID;
422 dev.devAddr = DEV_ADDR_INVALID;
423 ret = g_usbInterface->CloseDevice(dev);
424 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
425 ASSERT_NE(ret, 0);
426 dev = dev_;
427 g_usbInterface->CloseDevice(dev);
428 }
429 } // namespace
430