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