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