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 <gtest/gtest.h>
17 #include <iostream>
18
19 #include "UsbSubscriberTest.h"
20 #include "hdf_log.h"
21 #include "usbd_request_test.h"
22 #include "v1_0/iusb_interface.h"
23 #include "v1_0/usb_types.h"
24
25 using OHOS::HDI::Usb::V1_0::UsbDev;
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 namespace {
33 const uint8_t INDEX_0 = 0;
34 const uint8_t INDEX_1 = 1;
35 const uint8_t INDEX_INVALID = 255;
36 const uint8_t BUS_NUM_INVALID = 255;
37 const uint8_t DEV_ADDR_INVALID = 255;
38 const uint8_t INTERFACEID_OK = 1;
39 const uint8_t INTERFACEID_INVALID = 255;
40 const int SLEEP_TIME = 3;
41
42 class UsbdInterfaceTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48
49 static UsbDev dev_;
50 static OHOS::sptr<OHOS::USB::UsbSubscriberTest> subscriber_;
51 };
52 UsbDev UsbdInterfaceTest::dev_ = {0, 0};
53 OHOS::sptr<OHOS::USB::UsbSubscriberTest> UsbdInterfaceTest::subscriber_ = nullptr;
54
55 sptr<IUsbInterface> g_usbInterface = nullptr;
56
SwitchErrCode(int32_t ret)57 int32_t SwitchErrCode(int32_t ret)
58 {
59 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
60 }
61
SetUpTestCase(void)62 void UsbdInterfaceTest::SetUpTestCase(void)
63 {
64 g_usbInterface = IUsbInterface::Get();
65 if (g_usbInterface == nullptr) {
66 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
67 exit(0);
68 }
69 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
70 sleep(SLEEP_TIME);
71 HDF_LOGI("UsbdInterfaceTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
72 ret = SwitchErrCode(ret);
73 ASSERT_EQ(0, ret);
74 if (ret != 0) {
75 exit(0);
76 }
77
78 subscriber_ = new UsbSubscriberTest();
79 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
80 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
81 exit(0);
82 }
83
84 std::cout << "please connect device, press enter to continue" << std::endl;
85 int c;
86 while ((c = getchar()) != '\n' && c != EOF) {}
87 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
88
89 ret = g_usbInterface->OpenDevice(dev_);
90 ASSERT_EQ(0, ret);
91 HDF_LOGI("UsbdInterfaceTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
92 ret = g_usbInterface->ClaimInterface(dev_, 1, 1);
93 ASSERT_EQ(0, ret);
94 }
95
TearDownTestCase(void)96 void UsbdInterfaceTest::TearDownTestCase(void)
97 {
98 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
99 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
100 auto ret = g_usbInterface->CloseDevice(dev_);
101 HDF_LOGI("UsbdInterfaceTest:: %{public}d Close=%{public}d", __LINE__, ret);
102 ASSERT_EQ(0, ret);
103 }
104
SetUp(void)105 void UsbdInterfaceTest::SetUp(void) {}
106
TearDown(void)107 void UsbdInterfaceTest::TearDown(void) {}
108
109 /**
110 * @tc.name: SUB_USB_HostManager_HDI_Func_0900
111 * @tc.desc: Test functions to SetInterface
112 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
113 * @tc.desc: Positive test: parameters correctly
114 * @tc.type: FUNC
115 */
116 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Func_0900, Function | MediumTest | Level1)
117 {
118 uint8_t interfaceId = INTERFACEID_OK;
119 uint8_t altIndex = INDEX_0;
120 struct UsbDev dev = dev_;
121 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
122 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Func_0900 %{public}d ret=%{public}d", __LINE__, ret);
123 ASSERT_EQ(0, ret);
124 }
125
126 /**
127 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_4700
128 * @tc.desc: Test functions to SetInterface
129 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
130 * @tc.desc: Negative test: parameters exception, busNum error
131 * @tc.type: FUNC
132 */
133 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_4700, Function | MediumTest | Level1)
134 {
135 uint8_t interfaceId = INTERFACEID_OK;
136 uint8_t altIndex = INDEX_0;
137 struct UsbDev dev = dev_;
138 ;
139 dev.busNum = BUS_NUM_INVALID;
140 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
141 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_4700 %{public}d ret=%{public}d", __LINE__, ret);
142 ASSERT_NE(ret, 0);
143 }
144
145 /**
146 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_4800
147 * @tc.desc: Test functions to SetInterface
148 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
149 * @tc.desc: Negative test: parameters exception, devAddr error
150 * @tc.type: FUNC
151 */
152 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_4800, Function | MediumTest | Level1)
153 {
154 uint8_t interfaceId = INTERFACEID_OK;
155 uint8_t altIndex = INDEX_INVALID;
156 struct UsbDev dev = dev_;
157 dev.devAddr = DEV_ADDR_INVALID;
158 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
159 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_4800 %{public}d ret=%{public}d", __LINE__, ret);
160 ASSERT_NE(ret, 0);
161 }
162
163 /**
164 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_4900
165 * @tc.desc: Test functions to SetInterface
166 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
167 * @tc.desc: Negative test: parameters exception, interfaceId error
168 * @tc.type: FUNC
169 */
170 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_4900, Function | MediumTest | Level1)
171 {
172 uint8_t interfaceId = INTERFACEID_INVALID;
173 uint8_t altIndex = INDEX_INVALID;
174 struct UsbDev dev = dev_;
175 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
176 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_4900 %{public}d ret=%{public}d", __LINE__, ret);
177 ASSERT_NE(ret, 0);
178 }
179
180 /**
181 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5000
182 * @tc.desc: Test functions to SetInterface
183 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
184 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
185 * @tc.type: FUNC
186 */
187 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_5000, Function | MediumTest | Level1)
188 {
189 uint8_t interfaceId = INTERFACEID_OK;
190 uint8_t altIndex = INDEX_0;
191 struct UsbDev dev = dev_;
192 dev.busNum = BUS_NUM_INVALID;
193 dev.devAddr = DEV_ADDR_INVALID;
194 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
195 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_5000 %{public}d ret=%{public}d", __LINE__, ret);
196 ASSERT_NE(ret, 0);
197 }
198
199 /**
200 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5100
201 * @tc.desc: Test functions to SetInterface
202 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
203 * @tc.desc: Negative test: parameters exception, busNum && interfaceId error
204 * @tc.type: FUNC
205 */
206 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_5100, Function | MediumTest | Level1)
207 {
208 int32_t interfaceId = INTERFACEID_INVALID;
209 uint8_t altIndex = INDEX_1;
210 struct UsbDev dev = dev_;
211 dev.busNum = BUS_NUM_INVALID;
212 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
213 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_5100 %{public}d ret=%{public}d", __LINE__, ret);
214 ASSERT_NE(ret, 0);
215 }
216
217 /**
218 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5200
219 * @tc.desc: Test functions to SetInterface
220 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
221 * @tc.desc: Negative test: parameters exception, devAddr && interfaceId error
222 * @tc.type: FUNC
223 */
224 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_5200, Function | MediumTest | Level1)
225 {
226 int32_t interfaceId = INTERFACEID_INVALID;
227 uint8_t altIndex = INDEX_INVALID;
228 struct UsbDev dev = dev_;
229 dev.devAddr = DEV_ADDR_INVALID;
230 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
231 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_5200 %{public}d ret=%{public}d", __LINE__, ret);
232 ASSERT_NE(ret, 0);
233 }
234
235 /**
236 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5300
237 * @tc.desc: Test functions to SetInterface
238 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
239 * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceId error
240 * @tc.type: FUNC
241 */
242 HWTEST_F(UsbdInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_5300, Function | MediumTest | Level1)
243 {
244 uint8_t altIndex = INDEX_INVALID;
245 int32_t interfaceId = INTERFACEID_INVALID;
246 struct UsbDev dev = dev_;
247 dev.busNum = BUS_NUM_INVALID;
248 dev.devAddr = DEV_ADDR_INVALID;
249 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
250 HDF_LOGI("UsbdInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_5300 %{public}d ret=%{public}d", __LINE__, ret);
251 ASSERT_NE(ret, 0);
252 }
253 } // namespace