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