1 /*
2 * Copyright (c) 2021-2022 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 "usb_manage_interface_test.h"
17
18 #include <sys/time.h>
19
20 #include <iostream>
21 #include <vector>
22
23 #include "delayed_sp_singleton.h"
24 #include "hilog_wrapper.h"
25 #include "if_system_ability_manager.h"
26 #include "system_ability_definition.h"
27 #include "usb_common_test.h"
28 #include "usb_srv_client.h"
29 #include "usb_errors.h"
30 #include "usb_interface_type.h"
31
32 using namespace testing::ext;
33 using namespace OHOS;
34 using namespace OHOS::USB;
35 using namespace std;
36 using namespace OHOS::HDI::Usb::V1_0;
37 using namespace OHOS::USB::Common;
38
39 namespace OHOS {
40 namespace USB {
41 namespace ManageInterface {
42 constexpr int32_t SLEEP_TIME = 3;
43
SetUpTestCase(void)44 void UsbManageInterfaceTest::SetUpTestCase(void)
45 {
46 UsbCommonTest::GrantPermissionSysNative();
47 auto &srvClient = UsbSrvClient::GetInstance();
48 auto ret = srvClient.SetPortRole(1, 1, 1);
49 sleep(SLEEP_TIME);
50 USB_HILOGI(MODULE_USB_SERVICE, "UsbManageInterfaceTest:: [Device] SetPortRole=%{public}d", ret);
51 ret = UsbCommonTest::SwitchErrCode(ret);
52 ASSERT_TRUE(ret == 0);
53 if (ret != 0) {
54 exit(0);
55 }
56
57 std::cout << "please connect device, press enter to continue" << std::endl;
58 int32_t c;
59 while ((c = getchar()) != '\n' && c != EOF) {
60 ;
61 }
62 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbManageInterfaceTest");
63 }
64
TearDownTestCase(void)65 void UsbManageInterfaceTest::TearDownTestCase(void)
66 {
67 USB_HILOGI(MODULE_USB_SERVICE, "End UsbManageInterfaceTest");
68 }
69
SetUp(void)70 void UsbManageInterfaceTest::SetUp(void) {}
71
TearDown(void)72 void UsbManageInterfaceTest::TearDown(void) {}
73
74 /**
75 * @tc.name: ManageGlobalInterface001
76 * @tc.desc: Test functions to ManageGlobalInterface(bool disable);
77 * @tc.type: FUNC
78 */
79 HWTEST_F(UsbManageInterfaceTest, ManageGlobalInterface001, TestSize.Level1)
80 {
81 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageGlobalInterface001 : ManageGlobalInterface");
82 auto &client = UsbSrvClient::GetInstance();
83 auto ret = client.ManageGlobalInterface(true);
84 ASSERT_EQ(ret, 0);
85 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageGlobalInterface001 : ManageGlobalInterface");
86 }
87
88 /**
89 * @tc.name: ManageGlobalInterface002
90 * @tc.desc: Test functions to ManageGlobalInterface(bool disable);
91 * @tc.type: FUNC
92 */
93 HWTEST_F(UsbManageInterfaceTest, ManageGlobalInterface002, TestSize.Level1)
94 {
95 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageGlobalInterface002 : ManageGlobalInterface");
96 UsbCommonTest::GrantPermissionNormalNative();
97 auto &client = UsbSrvClient::GetInstance();
98 auto ret = client.ManageGlobalInterface(true);
99 ASSERT_NE(ret, 0);
100 UsbCommonTest::GrantPermissionSysNative();
101 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageGlobalInterface002 : ManageGlobalInterface");
102 }
103
104 /**
105 * @tc.name: ManageGlobalInterface003
106 * @tc.desc: Test functions to ManageGlobalInterface(bool disable);
107 * @tc.type: FUNC
108 */
109 HWTEST_F(UsbManageInterfaceTest, ManageGlobalInterface003, TestSize.Level1)
110 {
111 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageGlobalInterface003 : ManageGlobalInterface");
112 auto &client = UsbSrvClient::GetInstance();
113 auto ret = client.ManageGlobalInterface(false);
114 ASSERT_EQ(ret, 0);
115 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageGlobalInterface003 : ManageGlobalInterface");
116 }
117
118 /**
119 * @tc.name: ManageDevice001
120 * @tc.desc: Test functions to ManageDevice(int32_t vendorId, int32_t productId, bool disable);
121 * @tc.type: FUNC
122 */
123 HWTEST_F(UsbManageInterfaceTest, ManageDevice001, TestSize.Level1)
124 {
125 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageDevice001 : ManageDevice");
126 auto &client = UsbSrvClient::GetInstance();
127 vector<UsbDevice> devi;
128 auto ret = client.GetDevices(devi);
129 EXPECT_TRUE(ret == 0);
130 int32_t vendorId = 0;
131 int32_t productId = 0;
132 if (devi.size() > 0) {
133 vendorId = devi.at(0).GetVendorId();
134 productId = devi.at(0).GetProductId();
135 }
136 ret = client.ManageDevice(vendorId, productId, true);
137 ASSERT_EQ(ret, 0);
138 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageDevice001 : ManageDevice");
139 }
140
141 /**
142 * @tc.name: ManageDevice002
143 * @tc.desc: Test functions to ManageDevice(int32_t vendorId, int32_t productId, bool disable);
144 * @tc.type: FUNC
145 */
146 HWTEST_F(UsbManageInterfaceTest, ManageDevice002, TestSize.Level1)
147 {
148 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageDevice002 : ManageDevice");
149 UsbCommonTest::GrantPermissionNormalNative();
150 auto &client = UsbSrvClient::GetInstance();
151 vector<UsbDevice> devi;
152 auto ret = client.GetDevices(devi);
153 EXPECT_TRUE(ret == 0);
154 int32_t vendorId = 0;
155 int32_t productId = 0;
156 if (devi.size() > 0) {
157 vendorId = devi.at(0).GetVendorId();
158 productId = devi.at(0).GetProductId();
159 }
160 ret = client.ManageDevice(vendorId, productId, true);
161 ASSERT_NE(ret, 0);
162 UsbCommonTest::GrantPermissionSysNative();
163 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageDevice002 : ManageDevice");
164 }
165
166 /**
167 * @tc.name: ManageDevice003
168 * @tc.desc: Test functions to ManageDevice(int32_t vendorId, int32_t productId, bool disable);
169 * @tc.type: FUNC
170 */
171 HWTEST_F(UsbManageInterfaceTest, ManageDevice003, TestSize.Level1)
172 {
173 auto &client = UsbSrvClient::GetInstance();
174 vector<UsbDevice> devi;
175 auto ret = client.GetDevices(devi);
176 EXPECT_TRUE(ret == 0);
177 int32_t vendorId = 0;
178 int32_t productId = 0;
179 if (devi.size() > 0) {
180 vendorId = devi.at(0).GetVendorId();
181 productId = devi.at(0).GetProductId();
182 }
183 ret = client.ManageDevice(vendorId, productId, false);
184 ASSERT_EQ(ret, 0);
185 }
186
187 /**
188 * @tc.name: ManageInterfaceStorage001
189 * @tc.desc: Test functions toManageInterfaceStorage(InterfaceType interfaceType, bool disable);
190 * @tc.type: FUNC
191 */
192 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType001, TestSize.Level1)
193 {
194 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceStorage001 : ManageInterfaceStorage");
195 auto &client = UsbSrvClient::GetInstance();
196 vector<UsbDevice> devi;
197 auto ret = client.GetDevices(devi);
198 ASSERT_EQ(ret, 0);
199 vector<UsbDeviceType> disableType;
200 UsbDeviceType usbDeviceType;
201 usbDeviceType.baseClass = 3;
202 usbDeviceType.subClass = 1;
203 usbDeviceType.protocol = 2;
204 usbDeviceType.isDeviceType = 0;
205 disableType.emplace_back(usbDeviceType);
206 ret = client.ManageInterfaceType(disableType, true);
207 ASSERT_EQ(ret, 0);
208 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceStorage001 : ManageInterfaceStorage");
209 }
210
211 /**
212 * @tc.name: ManageInterfaceStorage002
213 * @tc.desc: Test functions to ManageInterfaceStorage(InterfaceType interfaceType, bool disable);
214 * @tc.type: FUNC
215 */
216 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType002, TestSize.Level1)
217 {
218 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceStorage002 : ManageInterfaceStorage");
219 UsbCommonTest::GrantPermissionNormalNative();
220 auto &client = UsbSrvClient::GetInstance();
221 vector<UsbDevice> devi;
222 auto ret = client.GetDevices(devi);
223 ASSERT_EQ(ret, 0);
224 vector<UsbDeviceType> disableType;
225 UsbDeviceType usbDeviceType;
226 usbDeviceType.baseClass = 8;
227 usbDeviceType.subClass = 6;
228 usbDeviceType.protocol = 80;
229 usbDeviceType.isDeviceType = 0;
230 disableType.emplace_back(usbDeviceType);
231 ret = client.ManageInterfaceType(disableType, true);
232 ASSERT_NE(ret, 0);
233 UsbCommonTest::GrantPermissionSysNative();
234 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceStorage002 : ManageInterfaceStorage");
235 }
236
237 /**
238 * @tc.name: ManageInterfaceStorage003
239 * @tc.desc: Test functions to ManageInterfaceStorage(InterfaceType interfaceType, bool disable);
240 * @tc.type: FUNC
241 */
242 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType003, TestSize.Level1)
243 {
244 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType003 : ManageInterfaceType");
245 auto &client = UsbSrvClient::GetInstance();
246 vector<UsbDevice> devi;
247 auto ret = client.GetDevices(devi);
248 ASSERT_EQ(ret, 0);
249 vector<UsbDeviceType> disableType;
250 UsbDeviceType usbDeviceType;
251 usbDeviceType.baseClass = 3;
252 usbDeviceType.subClass = 1;
253 usbDeviceType.protocol = 2;
254 usbDeviceType.isDeviceType = 0;
255 disableType.emplace_back(usbDeviceType);
256 ret = client.ManageInterfaceType(disableType, false);
257 ASSERT_EQ(ret, 0);
258 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType003 : ManageInterfaceType");
259 }
260
261 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType004, TestSize.Level1)
262 {
263 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType004 : ManageInterfaceType");
264 auto &client = UsbSrvClient::GetInstance();
265 vector<UsbDevice> devi;
266 auto ret = client.GetDevices(devi);
267 ASSERT_EQ(ret, 0);
268 vector<UsbDeviceType> disableType;
269 UsbDeviceType usbDeviceType;
270 usbDeviceType.baseClass = 8;
271 usbDeviceType.subClass = 6;
272 usbDeviceType.protocol = 80;
273 usbDeviceType.isDeviceType = 0;
274 disableType.emplace_back(usbDeviceType);
275 ret = client.ManageInterfaceType(disableType, false);
276 ASSERT_EQ(ret, 0);
277 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType004 : ManageInterfaceType");
278 }
279
280
281 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType005, TestSize.Level1)
282 {
283 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType005 : ManageDevice");
284 UsbCommonTest::GrantPermissionNormalNative();
285 auto &client = UsbSrvClient::GetInstance();
286 vector<UsbDevice> devi;
287 auto ret = client.GetDevices(devi);
288 ASSERT_EQ(ret, 0);
289 vector<UsbDeviceType> disableType;
290 UsbDeviceType usbDeviceType;
291 usbDeviceType.baseClass = 8;
292 usbDeviceType.subClass = 6;
293 usbDeviceType.protocol = 80;
294 usbDeviceType.isDeviceType = 0;
295 disableType.emplace_back(usbDeviceType);
296 ret = client.ManageInterfaceType(disableType, false);
297 ASSERT_NE(ret, 0);
298 UsbCommonTest::GrantPermissionSysNative();
299 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType005 : ManageDevice");
300 }
301 } // ManagerInterface
302 } // USB
303 } // OHOS
304