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 ASSERT_EQ(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 ASSERT_EQ(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 ASSERT_EQ(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 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType001, TestSize.Level1)
188 {
189 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType001 : ManageInterfaceType");
190 auto &client = UsbSrvClient::GetInstance();
191 vector<UsbDevice> devi;
192 auto ret = client.GetDevices(devi);
193 ASSERT_EQ(ret, 0);
194 vector<UsbDeviceType> disableType;
195 UsbDeviceType usbDeviceType;
196 usbDeviceType.baseClass = 3;
197 usbDeviceType.subClass = 1;
198 usbDeviceType.protocol = 2;
199 usbDeviceType.isDeviceType = 0;
200 disableType.emplace_back(usbDeviceType);
201 ret = client.ManageInterfaceType(disableType, true);
202 ASSERT_EQ(ret, 0);
203 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType001 : ManageInterfaceType");
204 }
205
206 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType002, TestSize.Level1)
207 {
208 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType002 : ManageInterfaceType");
209 auto &client = UsbSrvClient::GetInstance();
210 vector<UsbDevice> devi;
211 auto ret = client.GetDevices(devi);
212 ASSERT_EQ(ret, 0);
213 vector<UsbDeviceType> disableType;
214 UsbDeviceType usbDeviceType;
215 usbDeviceType.baseClass = 8;
216 usbDeviceType.subClass = 6;
217 usbDeviceType.protocol = 80;
218 usbDeviceType.isDeviceType = 0;
219 disableType.emplace_back(usbDeviceType);
220 ret = client.ManageInterfaceType(disableType, true);
221 ASSERT_EQ(ret, 0);
222 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType002 : ManageInterfaceType");
223 }
224
225 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType003, TestSize.Level1)
226 {
227 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType003 : ManageInterfaceType");
228 auto &client = UsbSrvClient::GetInstance();
229 vector<UsbDevice> devi;
230 auto ret = client.GetDevices(devi);
231 ASSERT_EQ(ret, 0);
232 vector<UsbDeviceType> disableType;
233 UsbDeviceType usbDeviceType;
234 usbDeviceType.baseClass = 3;
235 usbDeviceType.subClass = 1;
236 usbDeviceType.protocol = 2;
237 usbDeviceType.isDeviceType = 0;
238 disableType.emplace_back(usbDeviceType);
239 ret = client.ManageInterfaceType(disableType, false);
240 ASSERT_EQ(ret, 0);
241 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType003 : ManageInterfaceType");
242 }
243
244 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType004, TestSize.Level1)
245 {
246 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType004 : ManageInterfaceType");
247 auto &client = UsbSrvClient::GetInstance();
248 vector<UsbDevice> devi;
249 auto ret = client.GetDevices(devi);
250 ASSERT_EQ(ret, 0);
251 vector<UsbDeviceType> disableType;
252 UsbDeviceType usbDeviceType;
253 usbDeviceType.baseClass = 8;
254 usbDeviceType.subClass = 6;
255 usbDeviceType.protocol = 80;
256 usbDeviceType.isDeviceType = 0;
257 disableType.emplace_back(usbDeviceType);
258 ret = client.ManageInterfaceType(disableType, false);
259 ASSERT_EQ(ret, 0);
260 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType004 : ManageInterfaceType");
261 }
262
263
264 HWTEST_F(UsbManageInterfaceTest, ManageInterfaceType005, TestSize.Level1)
265 {
266 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ManageInterfaceType005 : ManageDevice");
267 UsbCommonTest::GrantPermissionNormalNative();
268 auto &client = UsbSrvClient::GetInstance();
269 vector<UsbDevice> devi;
270 auto ret = client.GetDevices(devi);
271 ASSERT_EQ(ret, 0);
272 vector<UsbDeviceType> disableType;
273 UsbDeviceType usbDeviceType;
274 usbDeviceType.baseClass = 8;
275 usbDeviceType.subClass = 6;
276 usbDeviceType.protocol = 80;
277 usbDeviceType.isDeviceType = 0;
278 disableType.emplace_back(usbDeviceType);
279 ret = client.ManageInterfaceType(disableType, false);
280 ASSERT_NE(ret, 0);
281 UsbCommonTest::GrantPermissionSysNative();
282 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ManageInterfaceType005 : ManageDevice");
283 }
284 } // ManagerInterface
285 } // USB
286 } // OHOS
287