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_core_test.h"
17 #include <csignal>
18 #include <iostream>
19 #include <string>
20 #include <vector>
21
22 #include "hilog_wrapper.h"
23 #include "if_system_ability_manager.h"
24 #include "ipc_skeleton.h"
25 #include "iservice_registry.h"
26 #include "string_ex.h"
27 #include "system_ability_definition.h"
28 #include "usb_errors.h"
29 #include "usb_srv_client.h"
30 #include "usb_srv_support.h"
31
32 using namespace testing::ext;
33 using namespace OHOS::USB;
34 using namespace OHOS;
35 using namespace std;
36
37 namespace OHOS {
38 namespace USB {
39 namespace Core {
40 constexpr int32_t SLEEP_TIME = 3;
41 constexpr int32_t TEST_PORT_ID = 1;
42 constexpr int32_t TEST_POWER_ROLE = 2;
43 constexpr int32_t TEST_DATAR_ROLE = 2;
SetUpTestCase(void)44 void UsbCoreTest::SetUpTestCase(void)
45 {
46 auto &srvClient = UsbSrvClient::GetInstance();
47 auto ret = srvClient.SetPortRole(TEST_PORT_ID, TEST_POWER_ROLE, TEST_DATAR_ROLE);
48 sleep(SLEEP_TIME);
49 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest:: [Device] SetPortRole=%{public}d", ret);
50 ASSERT_TRUE(ret == 0);
51 if (ret != 0) {
52 exit(0);
53 }
54 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbCoreTest");
55 }
56
TearDownTestCase(void)57 void UsbCoreTest::TearDownTestCase(void)
58 {
59 USB_HILOGI(MODULE_USB_SERVICE, "End UsbCoreTest");
60 }
61
SetUp(void)62 void UsbCoreTest::SetUp(void) {}
63
TearDown(void)64 void UsbCoreTest::TearDown(void) {}
65
66 /**
67 * @tc.name: GetCurrentFunctions001
68 * @tc.desc: Test functions to GetCurrentFunctions()
69 * @tc.type: FUNC
70 */
71 HWTEST_F(UsbCoreTest, GetCurrentFunctions001, TestSize.Level1)
72 {
73 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetCurrentFunctions001 : SetConfig");
74 auto &instance = UsbSrvClient::GetInstance();
75 int32_t funcs = 0;
76 funcs = instance.GetCurrentFunctions(funcs);
77 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::funcs=%{public}d", funcs);
78 ASSERT_TRUE(funcs == 0);
79 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetCurrentFunctions001 : SetConfig");
80 }
81
82 /**
83 * @tc.name: SetCurrentFunctions001
84 * @tc.desc: Test functions to SetCurrentFunctions(int32_t funcs)
85 * @tc.type: FUNC
86 */
87 HWTEST_F(UsbCoreTest, SetCurrentFunctions001, TestSize.Level1)
88 {
89 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetCurrentFunctions001 : SetConfig");
90 auto &instance = UsbSrvClient::GetInstance();
91 int32_t isok = instance.SetCurrentFunctions(1);
92 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::SetCurrentFunctions=%{public}d", isok);
93 ASSERT_TRUE(isok == 0);
94 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetCurrentFunctions001 : SetConfig");
95 }
96
97 /**
98 * @tc.name: SetCurrentFunctions002
99 * @tc.desc: Test functions to SetCurrentFunctions(int32_t funcs)
100 * @tc.type: FUNC
101 */
102 HWTEST_F(UsbCoreTest, SetCurrentFunctions002, TestSize.Level1)
103 {
104 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetCurrentFunctions002 : SetConfig");
105 auto &instance = UsbSrvClient::GetInstance();
106 int32_t isok = instance.SetCurrentFunctions(2);
107 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::SetCurrentFunctions=%{public}d", isok);
108 ASSERT_TRUE(isok == 0);
109 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetCurrentFunctions002 : SetConfig");
110 }
111
112 /**
113 * @tc.name: SetCurrentFunctions003
114 * @tc.desc: Test functions to SetCurrentFunctions(int32_t funcs)
115 * @tc.type: FUNC
116 */
117 HWTEST_F(UsbCoreTest, SetCurrentFunctions003, TestSize.Level1)
118 {
119 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetCurrentFunctions003 : SetConfig");
120 auto &instance = UsbSrvClient::GetInstance();
121 int32_t isok = instance.SetCurrentFunctions(3);
122 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::SetCurrentFunctions=%{public}d", isok);
123 ASSERT_TRUE(isok == 0);
124 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetCurrentFunctions003 : SetConfig");
125 }
126
127 /**
128 * @tc.name: SetCurrentFunctions004
129 * @tc.desc: Test functions to SetCurrentFunctions(int32_t funcs)
130 * @tc.type: FUNC
131 */
132 HWTEST_F(UsbCoreTest, SetCurrentFunctions004, TestSize.Level1)
133 {
134 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetCurrentFunctions004 : SetConfig");
135 auto &instance = UsbSrvClient::GetInstance();
136 int32_t isok = instance.SetCurrentFunctions(4);
137 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::SetCurrentFunctions=%{public}d", isok);
138 ASSERT_TRUE(isok == 0);
139 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetCurrentFunctions004 : SetConfig");
140 }
141
142 /**
143 * @tc.name: SetCurrentFunctions005
144 * @tc.desc: Test functions to SetCurrentFunctions(int32_t funcs)
145 * @tc.type: FUNC
146 */
147 HWTEST_F(UsbCoreTest, SetCurrentFunctions005, TestSize.Level1)
148 {
149 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetCurrentFunctions005 : SetConfig");
150 auto &instance = UsbSrvClient::GetInstance();
151 int32_t isok = instance.SetCurrentFunctions(5);
152 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::SetCurrentFunctions=%{public}d", isok);
153 ASSERT_TRUE(isok == 0);
154 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetCurrentFunctions005 : SetConfig");
155 }
156
157 /**
158 * @tc.name: SetCurrentFunctions006
159 * @tc.desc: Test functions to SetCurrentFunctions(int32_t funcs)
160 * @tc.type: FUNC
161 */
162 HWTEST_F(UsbCoreTest, SetCurrentFunctions006, TestSize.Level1)
163 {
164 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetCurrentFunctions006 : SetConfig");
165 auto &instance = UsbSrvClient::GetInstance();
166 int32_t isok = instance.SetCurrentFunctions(6);
167 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::SetCurrentFunctions=%{public}d", isok);
168 ASSERT_TRUE(isok == 0);
169 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetCurrentFunctions006 : SetConfig");
170 }
171
172 /**
173 * @tc.name: SetCurrentFunctions007
174 * @tc.desc: Test functions to SetCurrentFunctions(int32_t funcs)
175 * @tc.type: FUNC
176 */
177 HWTEST_F(UsbCoreTest, SetCurrentFunctions007, TestSize.Level1)
178 {
179 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetCurrentFunctions007 : SetConfig");
180 auto &instance = UsbSrvClient::GetInstance();
181 int32_t isok = instance.SetCurrentFunctions(8);
182 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::SetCurrentFunctions=%{public}d", isok);
183 ASSERT_TRUE(isok != 0);
184 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetCurrentFunctions007 : SetConfig");
185 }
186
187 /**
188 * @tc.name: UsbFunctionsFromString001
189 * @tc.desc: Test functions to UsbFunctionsFromString(string funcs)
190 * @tc.type: FUNC
191 */
192 HWTEST_F(UsbCoreTest, UsbFunctionsFromString001, TestSize.Level1)
193 {
194 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsFromString001 : SetConfig");
195 auto &instance = UsbSrvClient::GetInstance();
196 int32_t funcCode = instance.UsbFunctionsFromString(UsbSrvSupport::FUNCTION_NAME_NONE);
197 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::functionsFromString=%{public}d", funcCode);
198 ASSERT_TRUE(funcCode != UEC_SERVICE_INVALID_VALUE);
199 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsFromString001 : SetConfig");
200 }
201
202 /**
203 * @tc.name: UsbFunctionsFromString002
204 * @tc.desc: Test functions to UsbFunctionsFromString(string funcs)
205 * @tc.type: FUNC
206 */
207 HWTEST_F(UsbCoreTest, UsbFunctionsFromString002, TestSize.Level1)
208 {
209 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsFromString002 : SetConfig");
210 auto &instance = UsbSrvClient::GetInstance();
211 int32_t funcCode = instance.UsbFunctionsFromString(UsbSrvSupport::FUNCTION_NAME_HDC);
212 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::functionsFromString=%{public}d", funcCode);
213 ASSERT_TRUE(funcCode != UEC_SERVICE_INVALID_VALUE);
214 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsFromString002 : SetConfig");
215 }
216
217 /**
218 * @tc.name: UsbFunctionsFromString003
219 * @tc.desc: Test functions to UsbFunctionsFromString(string funcs)
220 * @tc.type: FUNC
221 */
222 HWTEST_F(UsbCoreTest, UsbFunctionsFromString003, TestSize.Level1)
223 {
224 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsFromString003 : SetConfig");
225 auto &instance = UsbSrvClient::GetInstance();
226 int32_t funcCode = instance.UsbFunctionsFromString(UsbSrvSupport::FUNCTION_NAME_ACM);
227 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::functionsFromString=%{public}d", funcCode);
228 ASSERT_TRUE(funcCode != UEC_SERVICE_INVALID_VALUE);
229 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsFromString003 : SetConfig");
230 }
231
232 /**
233 * @tc.name: UsbFunctionsFromString004
234 * @tc.desc: Test functions to UsbFunctionsFromString(string funcs)
235 * @tc.type: FUNC
236 */
237 HWTEST_F(UsbCoreTest, UsbFunctionsFromString004, TestSize.Level1)
238 {
239 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsFromString004 : SetConfig");
240 auto &instance = UsbSrvClient::GetInstance();
241 int32_t funcCode = instance.UsbFunctionsFromString(UsbSrvSupport::FUNCTION_NAME_ECM);
242 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::functionsFromString=%{public}d", funcCode);
243 ASSERT_TRUE(funcCode != UEC_SERVICE_INVALID_VALUE);
244 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsFromString004 : SetConfig");
245 }
246
247 /**
248 * @tc.name: UsbFunctionsFromString005
249 * @tc.desc: Test functions to UsbFunctionsFromString(string funcs)
250 * @tc.type: FUNC
251 */
252 HWTEST_F(UsbCoreTest, UsbFunctionsFromString005, TestSize.Level1)
253 {
254 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsFromString005 : SetConfig");
255 auto &instance = UsbSrvClient::GetInstance();
256 std::string funcs = "qwerts";
257 int32_t funcCode = instance.UsbFunctionsFromString(funcs);
258 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::functionsFromString=%{public}d", funcCode);
259 ASSERT_TRUE(funcCode == UEC_SERVICE_INVALID_VALUE);
260 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsFromString005 : SetConfig");
261 }
262
263 /**
264 * @tc.name: UsbFunctionsFromString006
265 * @tc.desc: Test functions to UsbFunctionsFromString(string funcs)
266 * @tc.type: FUNC
267 */
268 HWTEST_F(UsbCoreTest, UsbFunctionsFromString006, TestSize.Level1)
269 {
270 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsFromString006 : SetConfig");
271 auto &instance = UsbSrvClient::GetInstance();
272 std::string funcs = "zxcbvx";
273 int32_t funcCode = instance.UsbFunctionsFromString(funcs);
274 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::functionsFromString=%{public}d", funcCode);
275 ASSERT_TRUE(funcCode == UEC_SERVICE_INVALID_VALUE);
276 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsFromString006 : SetConfig");
277 }
278
279 /**
280 * @tc.name: UsbFunctionsToString001
281 * @tc.desc: Test functions to UsbFunctionsToString(int32_t funcs)
282 * @tc.type: FUNC
283 */
284 HWTEST_F(UsbCoreTest, UsbFunctionsToString001, TestSize.Level1)
285 {
286 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsToString001 : SetConfig");
287 auto &instance = UsbSrvClient::GetInstance();
288 std::string funcName = instance.UsbFunctionsToString(UsbSrvSupport::FUNCTION_NONE);
289 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbFunctionsToString=%{public}s", funcName.c_str());
290 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbFunctionsToString=%{public}zu", funcName.size());
291 ASSERT_TRUE(!(funcName.empty()));
292 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsToString001 : SetConfig");
293 }
294
295 /**
296 * @tc.name: UsbFunctionsToString002
297 * @tc.desc: Test functions to UsbFunctionsToString(int32_t funcs)
298 * @tc.type: FUNC
299 */
300 HWTEST_F(UsbCoreTest, UsbFunctionsToString002, TestSize.Level1)
301 {
302 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsToString002 : SetConfig");
303 auto &instance = UsbSrvClient::GetInstance();
304 std::string funcName = instance.UsbFunctionsToString(UsbSrvSupport::FUNCTION_HDC);
305 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbFunctionsToString=%{public}s", funcName.c_str());
306 ASSERT_TRUE(!(funcName.empty()));
307 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsToString002 : SetConfig");
308 }
309
310 /**
311 * @tc.name: UsbFunctionsToString003
312 * @tc.desc: Test functions to UsbFunctionsToString(int32_t funcs)
313 * @tc.type: FUNC
314 */
315 HWTEST_F(UsbCoreTest, UsbFunctionsToString003, TestSize.Level1)
316 {
317 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsToString003 : SetConfig");
318 auto &instance = UsbSrvClient::GetInstance();
319 std::string funcName = instance.UsbFunctionsToString(UsbSrvSupport::FUNCTION_ACM);
320 USB_HILOGI(MODULE_USB_SERVICE, "UsbFunctionServiceTest::UsbFunctionsToString=%{public}s", funcName.c_str());
321 ASSERT_TRUE(!(funcName.empty()));
322 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsToString003 : SetConfig");
323 }
324
325 /**
326 * @tc.name: UsbFunctionsToString004
327 * @tc.desc: Test functions to UsbFunctionsToString(int32_t funcs)
328 * @tc.type: FUNC
329 */
330 HWTEST_F(UsbCoreTest, UsbFunctionsToString004, TestSize.Level1)
331 {
332 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsToString004 : SetConfig");
333 auto &instance = UsbSrvClient::GetInstance();
334 std::string funcName = instance.UsbFunctionsToString(UsbSrvSupport::FUNCTION_ECM);
335 USB_HILOGI(MODULE_USB_SERVICE, "UsbFunctionServiceTest::UsbFunctionsToString=%{public}s", funcName.c_str());
336 ASSERT_TRUE(!(funcName.empty()));
337 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsToString004 : SetConfig");
338 }
339
340 /**
341 * @tc.name: UsbFunctionsToString005
342 * @tc.desc: Test functions to UsbFunctionsToString(int32_t funcs)
343 * @tc.type: FUNC
344 */
345 HWTEST_F(UsbCoreTest, UsbFunctionsToString005, TestSize.Level1)
346 {
347 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbFunctionsToString005 : SetConfig");
348 auto &instance = UsbSrvClient::GetInstance();
349 std::string funcName = instance.UsbFunctionsToString(-1);
350 USB_HILOGI(MODULE_USB_SERVICE, "UsbFunctionServiceTest::UsbFunctionsToString=%{public}s", funcName.c_str());
351 ASSERT_TRUE(!(funcName.empty()));
352 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbFunctionsToString005 : SetConfig");
353 }
354
355 /**
356 * @tc.name: UsbHasRight001
357 * @tc.desc: Test functions of HasRight
358 * @tc.desc: bool HasRight(std::string deviceName)
359 * @tc.desc: Before RequestRight, HasRight return false.
360 * @tc.type: FUNC
361 */
362 HWTEST_F(UsbCoreTest, UsbHasRight001, TestSize.Level1)
363 {
364 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbHasRight001: SetConfig");
365 auto &UsbSrvClient = UsbSrvClient::GetInstance();
366 std::string deviceName = "device_80";
367 bool result = UsbSrvClient.HasRight(deviceName);
368 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight001 HasRight=%{public}d", result);
369 ASSERT_FALSE(result);
370 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbHasRight001: SetConfig");
371 }
372
373 /**
374 * @tc.name: UsbHasRight002
375 * @tc.desc: Test functions of HasRight
376 * @tc.desc: bool HasRight(std::string deviceName)
377 * @tc.desc: After RequestRight, HasRight return true.
378 * @tc.type: FUNC
379 */
380 HWTEST_F(UsbCoreTest, UsbHasRight002, TestSize.Level1)
381 {
382 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbHasRight002: SetConfig");
383 auto &UsbSrvClient = UsbSrvClient::GetInstance();
384 std::string deviceName = "device_80";
385 bool result = UsbSrvClient.HasRight(deviceName);
386 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight002 HasRight=%{public}d", result);
387 ASSERT_FALSE(result);
388 int32_t ret = UsbSrvClient.RequestRight(deviceName);
389 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight002 RequestRight=%{public}d", result);
390 ASSERT_EQ(ret, 0);
391 result = UsbSrvClient.HasRight(deviceName);
392 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight002 HasRight=%{public}d", result);
393 ASSERT_TRUE(result);
394 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbHasRight002: SetConfig");
395 }
396
397 /**
398 * @tc.name: UsbHasRight003
399 * @tc.desc: Test functions of HasRight
400 * @tc.desc: bool HasRight(std::string deviceName)
401 * @tc.desc: After RemoveRight, HasRight return false.
402 * @tc.type: FUNC
403 */
404 HWTEST_F(UsbCoreTest, UsbHasRight003, TestSize.Level1)
405 {
406 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbHasRight003: SetConfig");
407 auto &UsbSrvClient = UsbSrvClient::GetInstance();
408 std::string deviceName = "device_80";
409 bool result = UsbSrvClient.HasRight(deviceName);
410 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight003 HasRight=%{public}d", result);
411 ASSERT_TRUE(result);
412 int32_t ret = UsbSrvClient.RemoveRight(deviceName);
413 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight003 RemoveRight=%{public}d", result);
414 ASSERT_EQ(ret, 0);
415 deviceName = "device_81";
416 result = UsbSrvClient.HasRight(deviceName);
417 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight003 HasRight=%{public}d", result);
418 ASSERT_FALSE(result);
419 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbHasRight003: SetConfig");
420 }
421
422 /**
423 * @tc.name: UsbHasRight004
424 * @tc.desc: Test functions of HasRight
425 * @tc.desc: bool HasRight(std::string deviceName)
426 * @tc.desc: RequestRight then RemoveRight
427 * @tc.type: FUNC
428 */
429 HWTEST_F(UsbCoreTest, UsbHasRight004, TestSize.Level1)
430 {
431 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbHasRight004: SetConfig");
432 auto &UsbSrvClient = UsbSrvClient::GetInstance();
433 std::string deviceName = "device_82";
434 bool result = UsbSrvClient.HasRight(deviceName);
435 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight004 HasRight=%{public}d", result);
436 ASSERT_FALSE(result);
437 int32_t ret = UsbSrvClient.RequestRight(deviceName);
438 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight004 RequestRight=%{public}d", result);
439 ASSERT_EQ(ret, 0);
440 result = UsbSrvClient.HasRight(deviceName);
441 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::UsbHasRight004 HasRight=%{public}d", result);
442 ASSERT_TRUE(result);
443 ret = UsbSrvClient.RemoveRight(deviceName);
444 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright003 RemoveRight=%{public}d", result);
445 ASSERT_EQ(ret, 0);
446 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbHasRight004: SetConfig");
447 }
448
449 /**
450 * @tc.name: Usbrequestright001
451 * @tc.desc: Test functions of requestright
452 * @tc.desc: int32_t requestright(std::string deviceName)
453 * @tc.desc: RequestRight then RemoveRight
454 * @tc.type: FUNC
455 */
456 HWTEST_F(UsbCoreTest, Usbrequestright001, TestSize.Level1)
457 {
458 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestright001: SetConfig");
459 auto &UsbSrvClient = UsbSrvClient::GetInstance();
460 std::string deviceName = "device_83";
461 int32_t ret = UsbSrvClient.RequestRight(deviceName);
462 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright001 RequestRight=%{public}d", ret);
463 ASSERT_EQ(ret, 0);
464 bool result = UsbSrvClient.HasRight(deviceName);
465 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright001 HasRight=%{public}d", result);
466 ASSERT_TRUE(result);
467 ret = UsbSrvClient.RemoveRight(deviceName);
468 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright003 RemoveRight=%{public}d", result);
469 ASSERT_EQ(ret, 0);
470 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestright001: SetConfig");
471 }
472
473 /**
474 * @tc.name: Usbrequestright003
475 * @tc.desc: Test functions of requestright
476 * @tc.desc: int32_t requestright(std::string deviceName)
477 * @tc.type: FUNC
478 */
479 HWTEST_F(UsbCoreTest, Usbrequestright003, TestSize.Level1)
480 {
481 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestright003: SetConfig");
482 auto &UsbSrvClient = UsbSrvClient::GetInstance();
483 std::string deviceName = "device_81";
484 bool result = UsbSrvClient.HasRight(deviceName);
485 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright003 HasRight=%{public}d", result);
486 ASSERT_FALSE(result);
487 int32_t ret = UsbSrvClient.RequestRight(deviceName);
488 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright003 RequestRight=%{public}d", result);
489 ASSERT_EQ(ret, 0);
490 result = UsbSrvClient.HasRight(deviceName);
491 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright003 HasRight=%{public}d", result);
492 ASSERT_TRUE(result);
493 ret = UsbSrvClient.RemoveRight(deviceName);
494 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Usbrequestright003 RemoveRight=%{public}d", result);
495 ASSERT_EQ(ret, 0);
496 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestright003: SetConfig");
497 }
498
499 /**
500 * @tc.name: GetPorts001
501 * @tc.desc: Test functions to GetPorts
502 * @tc.desc: int32_t GetPorts(std::vector<UsbPort *> &usbports);
503 * @tc.desc: 正向测试：参数正确
504 * @tc.type: FUNC
505 */
506
507 HWTEST_F(UsbCoreTest, GetPorts001, TestSize.Level1)
508 {
509 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetPorts001 : GetPorts");
510 auto &usbSrvClient = UsbSrvClient::GetInstance();
511 std::vector<UsbPort> portlist;
512 auto ports = usbSrvClient.GetPorts(portlist);
513 USB_HILOGD(MODULE_USB_SERVICE, "Get UsbPort size=%{public}zu", portlist.size());
514 ASSERT_TRUE(ports == 0);
515 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetPorts001 : GetPorts");
516 }
517
518 /**
519 * @tc.name: GetSupportedModes001
520 * @tc.desc: Test functions to GetSupportedModes
521 * @tc.desc: int32_t GetSupportedModes(int32_t portId, int32_t &result);
522 * @tc.desc: 正向测试：参数正确
523 * @tc.type: FUNC
524 */
525
526 HWTEST_F(UsbCoreTest, GetSupportedModes001, TestSize.Level1)
527 {
528 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetSupportedModes001 : GetSupportedModes");
529 auto &UsbSrvClient = UsbSrvClient::GetInstance();
530 int32_t result = 0;
531 auto modes = UsbSrvClient.GetSupportedModes(0, result);
532 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", modes);
533 ASSERT_TRUE(modes != 0);
534 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetSupportedModes001 : GetSupportedModes");
535 }
536
537 /**
538 * @tc.name: GetSupportedModes002
539 * @tc.desc: Test functions to GetSupportedModes
540 * @tc.desc: int32_t GetSupportedModes(int32_t portId, int32_t &result);
541 * @tc.desc: 反向测试：portid错误
542 * @tc.type: FUNC
543 */
544
545 HWTEST_F(UsbCoreTest, GetSupportedModes002, TestSize.Level1)
546 {
547 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetSupportedModes002 : GetSupportedModes");
548 auto &UsbSrvClient = UsbSrvClient::GetInstance();
549 int32_t result = 0;
550 auto modes = UsbSrvClient.GetSupportedModes(-1, result);
551 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", modes);
552 ASSERT_TRUE(modes != 0);
553 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetSupportedModes002 : GetSupportedModes");
554 }
555
556 /**
557 * @tc.name: GetSupportedModes003
558 * @tc.desc: Test functions to GetSupportedModes
559 * @tc.desc: int32_t GetSupportedModes(int32_t portId, int32_t &result);
560 * @tc.desc: 反向测试：portid错误
561 * @tc.type: FUNC
562 */
563
564 HWTEST_F(UsbCoreTest, GetSupportedModes003, TestSize.Level1)
565 {
566 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetSupportedModes003 : GetSupportedModes");
567 auto &UsbSrvClient = UsbSrvClient::GetInstance();
568 int32_t result = 0;
569 auto modes = UsbSrvClient.GetSupportedModes(0xFFFFFFFF, result);
570 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", modes);
571 ASSERT_TRUE(modes != 0);
572 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetSupportedModes003 : GetSupportedModes");
573 }
574
575 /**
576 * @tc.name: GetSupportedModes004
577 * @tc.desc: Test functions to GetSupportedModes
578 * @tc.desc: int32_t GetSupportedModes(int32_t portId, int32_t &result);
579 * @tc.desc: 正向测试：参数正确
580 * @tc.type: FUNC
581 */
582
583 HWTEST_F(UsbCoreTest, GetSupportedModes004, TestSize.Level1)
584 {
585 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetSupportedModes004 : GetSupportedModes");
586 auto &UsbSrvClient = UsbSrvClient::GetInstance();
587 int32_t result = 0;
588 auto modes = UsbSrvClient.GetSupportedModes(1, result);
589 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", modes);
590 ASSERT_TRUE(modes == 0);
591 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetSupportedModes004 : GetSupportedModes");
592 }
593
594 /**
595 * @tc.name: SetPortRole001
596 * @tc.desc: Test functions to SetPortRole
597 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
598 * @tc.desc: 正向测试：参数正确
599 * @tc.type: FUNC
600 */
601
602 HWTEST_F(UsbCoreTest, SetPortRole001, TestSize.Level1)
603 {
604 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole001 : SetPortRole");
605 auto &UsbSrvClient = UsbSrvClient::GetInstance();
606 auto ret = UsbSrvClient.SetPortRole(1, 1, 1);
607 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
608 ASSERT_TRUE(ret == 0);
609 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole001 : SetPortRole");
610 }
611
612 /**
613 * @tc.name: SetPortRole002
614 * @tc.desc: Test functions to SetPortRole
615 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
616 * @tc.desc: 反向测试：portid错误
617 * @tc.type: FUNC
618 */
619
620 HWTEST_F(UsbCoreTest, SetPortRole002, TestSize.Level1)
621 {
622 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole002 : SetPortRole");
623 auto &UsbSrvClient = UsbSrvClient::GetInstance();
624 auto ret = UsbSrvClient.SetPortRole(2, 1, 1);
625 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
626 ASSERT_TRUE(ret != 0);
627 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole002 : SetPortRole");
628 }
629
630 /**
631 * @tc.name: SetPortRole003
632 * @tc.desc: Test functions to SetPortRole
633 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
634 * @tc.desc: 反向测试：powerRole错误
635 * @tc.type: FUNC
636 */
637
638 HWTEST_F(UsbCoreTest, SetPortRole003, TestSize.Level1)
639 {
640 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole003 : SetPortRole");
641 auto &UsbSrvClient = UsbSrvClient::GetInstance();
642 auto ret = UsbSrvClient.SetPortRole(1, 4, 2);
643 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
644 ASSERT_TRUE(ret != 0);
645 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole003 : SetPortRole");
646 }
647
648 /**
649 * @tc.name: SetPortRole004
650 * @tc.desc: Test functions to SetPortRole
651 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
652 * @tc.desc: 反向测试：dataRole错误
653 * @tc.type: FUNC
654 */
655 HWTEST_F(UsbCoreTest, SetPortRole004, TestSize.Level1)
656 {
657 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole004 : SetPortRole");
658 auto &UsbSrvClient = UsbSrvClient::GetInstance();
659 auto ret = UsbSrvClient.SetPortRole(1, 1, 5);
660 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
661 ASSERT_TRUE(ret != 0);
662 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole004 : SetPortRole");
663 }
664
665 /**
666 * @tc.name: SetPortRole005
667 * @tc.desc: Test functions to SetPortRole
668 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
669 * @tc.desc: 反向测试：参数异常，portId、powerRole错误
670 * @tc.type: FUNC
671 */
672 HWTEST_F(UsbCoreTest, SetPortRole005, TestSize.Level1)
673 {
674 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole005 : SetPortRole");
675 auto &UsbSrvClient = UsbSrvClient::GetInstance();
676 auto ret = UsbSrvClient.SetPortRole(1, 5, 5);
677 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
678 ASSERT_TRUE(ret != 0);
679 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole005 : SetPortRole");
680 }
681
682 /**
683 * @tc.name: SetPortRole006
684 * @tc.desc: Test functions to SetPortRole
685 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
686 * @tc.desc: 反向测试：powerRole、dataRole错误
687 * @tc.type: FUNC
688 */
689 HWTEST_F(UsbCoreTest, SetPortRole006, TestSize.Level1)
690 {
691 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole006 : SetPortRole");
692 auto &UsbSrvClient = UsbSrvClient::GetInstance();
693 auto ret = UsbSrvClient.SetPortRole(5, 1, 5);
694 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
695 ASSERT_TRUE(ret != 0);
696 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole006 : SetPortRole");
697 }
698
699 /**
700 * @tc.name: SetPortRole007
701 * @tc.desc: Test functions to SetPortRole
702 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
703 * @tc.desc: 反向测试：powerRole、dataRole错误
704 * @tc.type: FUNC
705 */
706 HWTEST_F(UsbCoreTest, SetPortRole007, TestSize.Level1)
707 {
708 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole007 : SetPortRole");
709 auto &UsbSrvClient = UsbSrvClient::GetInstance();
710 auto ret = UsbSrvClient.SetPortRole(2, 5, 5);
711 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
712 ASSERT_TRUE(ret != 0);
713 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole007 : SetPortRole");
714 }
715
716 /**
717 * @tc.name: SetPortRole008
718 * @tc.desc: Test functions to SetPortRole
719 * @tc.desc: int32_t SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole);
720 * @tc.desc:
721 * @tc.type: FUNC
722 */
723 HWTEST_F(UsbCoreTest, SetPortRole008, TestSize.Level1)
724 {
725 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetPortRole008 : SetPortRole");
726 auto &UsbSrvClient = UsbSrvClient::GetInstance();
727 auto ret = UsbSrvClient.SetPortRole(1, 2, 2);
728 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::status=%{public}d", ret);
729 ASSERT_TRUE(ret == 0);
730 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetPortRole008 : SetPortRole");
731 }
732 } // Core
733 } // USB
734 } // OHOS
735