1 /*
2 * Copyright (c) 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 "coauth_test.h"
17 #include <gtest/gtest.h>
18
19 using namespace testing::ext;
20 namespace OHOS {
21 namespace UserIAM {
22 namespace CoAuth {
23 class CoAuthTest : public testing::Test {
24 public:
25 static void SetUpTestCase(void);
26
27 static void TearDownTestCase(void);
28
29 void SetUp();
30
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void CoAuthTest::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void CoAuthTest::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void CoAuthTest::SetUp()
43 {
44 }
45
TearDown()46 void CoAuthTest::TearDown()
47 {
48 }
49
50 /**
51 * @tc.name: UseriamUtTest001
52 * @tc.desc: Test GetExecutorProp(FACE).
53 * @tc.type: FUNC
54 */
55 HWTEST_F(CoAuthTest, UseriamUtTest001, TestSize.Level0)
56 {
57 COAUTH_HILOGE(MODULE_SERVICE, "UseriamUtTest001 enter.");
58 AuthResPool::AuthAttributes conditions;
59 conditions.SetUint32Value(AUTH_TYPE, FACE);
60 conditions.SetBoolValue(AUTH_CONTROLLER, 0);
61 conditions.SetUint32Value(AUTH_SCHEDULE_MODE, 1);
62 conditions.SetUint64Value(AUTH_SCHEDULE_ID, 1);
63
64 std::vector<uint64_t> val1;
65 val1.push_back(1);
66 conditions.SetUint64ArrayValue(AUTH_TEMPLATE_ID_LIST, val1);
67
68 std::vector<uint8_t> val2;
69 val2.push_back('5');
70 conditions.SetUint8ArrayValue(AUTH_CALLER_NAME, val2);
71
72 std::shared_ptr<AuthResPool::AuthAttributes> values = std::make_shared<AuthResPool::AuthAttributes>();
73 int32_t ret = CoAuth::GetInstance().GetExecutorProp(conditions, values);
74 sleep(5);
75 EXPECT_NE(0, ret);
76 }
77
78 /**
79 * @tc.name: UseriamUtTest002
80 * @tc.desc: Test GetExecutorProp().
81 * @tc.type: FUNC
82 */
83 HWTEST_F(CoAuthTest, UseriamUtTest002, TestSize.Level0)
84 {
85 COAUTH_HILOGE(MODULE_SERVICE, "UseriamUtTest002 enter.");
86 AuthResPool::AuthAttributes conditions;
87 conditions.SetBoolValue(AUTH_CONTROLLER, 0);
88 conditions.SetUint32Value(AUTH_SCHEDULE_MODE, 1);
89 conditions.SetUint64Value(AUTH_SCHEDULE_ID, 1);
90
91 std::vector<uint64_t> val1;
92 val1.push_back(1);
93 conditions.SetUint64ArrayValue(AUTH_TEMPLATE_ID_LIST, val1);
94
95 std::vector<uint8_t> val2;
96 val2.push_back('5');
97 conditions.SetUint8ArrayValue(AUTH_CALLER_NAME, val2);
98
99 std::shared_ptr<AuthResPool::AuthAttributes> values = nullptr;
100 int32_t ret = CoAuth::GetInstance().GetExecutorProp(conditions, values);
101 sleep(5);
102 EXPECT_EQ(1, ret);
103 }
104
105 /**
106 * @tc.name: UseriamUtTest003
107 * @tc.desc: Test GetExecutorProp(PIN).
108 * @tc.type: FUNC
109 */
110 HWTEST_F(CoAuthTest, UseriamUtTest003, TestSize.Level0)
111 {
112 COAUTH_HILOGE(MODULE_SERVICE, "UseriamUtTest003 enter.");
113 AuthResPool::AuthAttributes conditions;
114 conditions.SetUint32Value(AUTH_TYPE, PIN);
115 conditions.SetBoolValue(AUTH_CONTROLLER, 0);
116 conditions.SetUint32Value(AUTH_SCHEDULE_MODE, 1);
117 conditions.SetUint64Value(AUTH_SCHEDULE_ID, 1);
118 conditions.SetUint32Value(AUTH_PROPERTY_MODE, 1);
119 conditions.SetUint64Value(AUTH_TEMPLATE_ID, 1);
120
121 std::vector<uint64_t> val1;
122 val1.push_back(1);
123 conditions.SetUint64ArrayValue(AUTH_TEMPLATE_ID_LIST, val1);
124
125 std::vector<uint8_t> val2;
126 val2.push_back('5');
127 conditions.SetUint8ArrayValue(AUTH_CALLER_NAME, val2);
128
129 std::shared_ptr<AuthResPool::AuthAttributes> values = std::make_shared<AuthResPool::AuthAttributes>();
130 int32_t ret = CoAuth::GetInstance().GetExecutorProp(conditions, values);
131 sleep(5);
132 EXPECT_EQ(0, ret);
133 }
134
135 /**
136 * @tc.name: UseriamUtTest004
137 * @tc.desc: Test AuthType(PIN).
138 * @tc.type: FUNC
139 */
140 HWTEST_F(CoAuthTest, UseriamUtTest004, TestSize.Level0)
141 {
142 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest004 start");
143 std::shared_ptr<AuthResPool::AuthExecutor> executorInfo = std::make_shared<AuthResPool::AuthExecutor>();
144 executorInfo->SetAuthType(PIN);
145 executorInfo->SetAuthAbility(1);
146 executorInfo->SetExecutorSecLevel(ESL0);
147 executorInfo->SetExecutorType(TYPE_CO_AUTH);
148
149 std::vector<uint8_t> publicKey(32, '1');
150 executorInfo->SetPublicKey(publicKey);
151
152 std::vector<uint8_t> deviceId;
153 deviceId.push_back('2');
154 executorInfo->SetDeviceId(deviceId);
155 class MyExecutorCallback : public AuthResPool::ExecutorCallback {
156 public:
~MyExecutorCallback()157 virtual ~MyExecutorCallback() {};
OnMessengerReady(const sptr<AuthResPool::IExecutorMessenger> & messenger)158 void OnMessengerReady(const sptr<AuthResPool::IExecutorMessenger> &messenger)override {
159 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnMessengerReady.");
160 return;
161 }
OnBeginExecute(uint64_t scheduleId,std::vector<uint8_t> & publicKey,std::shared_ptr<AuthResPool::AuthAttributes> commandAttrs)162 int32_t OnBeginExecute(uint64_t scheduleId, std::vector<uint8_t> &publicKey,
163 std::shared_ptr<AuthResPool::AuthAttributes> commandAttrs)override {
164 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnBeginExecute.");
165 return SUCCESS;
166 }
OnEndExecute(uint64_t scheduleId,std::shared_ptr<AuthResPool::AuthAttributes> consumerAttr)167 int32_t OnEndExecute(uint64_t scheduleId, std::shared_ptr<AuthResPool::AuthAttributes> consumerAttr)override {
168 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnEndExecute.");
169 return SUCCESS;
170 }
OnSetProperty(std::shared_ptr<AuthResPool::AuthAttributes> properties)171 int32_t OnSetProperty(std::shared_ptr<AuthResPool::AuthAttributes> properties)override {
172 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnSetProperty.");
173 return SUCCESS;
174 }
OnGetProperty(std::shared_ptr<AuthResPool::AuthAttributes> conditions,std::shared_ptr<AuthResPool::AuthAttributes> values)175 int32_t OnGetProperty(std::shared_ptr<AuthResPool::AuthAttributes> conditions,
176 std::shared_ptr<AuthResPool::AuthAttributes> values)override {
177 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnGetProperty.");
178 return SUCCESS;
179 }
180 };
181 std::shared_ptr<AuthResPool::ExecutorCallback> callback = std::make_shared<MyExecutorCallback>();
182 uint64_t ret = AuthResPool::AuthExecutorRegistry::GetInstance().Register(executorInfo, callback);
183 EXPECT_LE(10000, ret);
184 }
185
186
187 /**
188 * @tc.name: UseriamUtTest005
189 * @tc.desc: Test empty callback.
190 * @tc.type: FUNC
191 */
192 HWTEST_F(CoAuthTest, UseriamUtTest005, TestSize.Level0)
193 {
194 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest005 start");
195 std::shared_ptr<AuthResPool::AuthExecutor> executorInfo = std::make_shared<AuthResPool::AuthExecutor>();
196 executorInfo->SetAuthType(PIN);
197 executorInfo->SetAuthAbility(1);
198 executorInfo->SetExecutorSecLevel(ESL0);
199 executorInfo->SetExecutorType(TYPE_CO_AUTH);
200
201 std::vector<uint8_t> publicKey(32, '1');
202 executorInfo->SetPublicKey(publicKey);
203
204 std::vector<uint8_t> deviceId;
205 deviceId.push_back('2');
206 executorInfo->SetDeviceId(deviceId);
207 std::shared_ptr<AuthResPool::ExecutorCallback> callback = nullptr;
208 uint64_t ret = AuthResPool::AuthExecutorRegistry::GetInstance().Register(executorInfo, callback);
209 EXPECT_LE(FAIL, ret);
210 }
211 /**
212 * @tc.name: UseriamUtTest006
213 * @tc.desc: Test AuthType(FACE).
214 * @tc.type: FUNC
215 */
216 HWTEST_F(CoAuthTest, UseriamUtTest006, TestSize.Level0)
217 {
218 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest006 start");
219 std::shared_ptr<AuthResPool::AuthExecutor> executorInfo = std::make_shared<AuthResPool::AuthExecutor>();
220 executorInfo->SetAuthType(FACE);
221 executorInfo->SetAuthAbility(1);
222 executorInfo->SetExecutorSecLevel(ESL0);
223 executorInfo->SetExecutorType(TYPE_CO_AUTH);
224
225 std::vector<uint8_t> publicKey(32, '1');
226 executorInfo->SetPublicKey(publicKey);
227
228 std::vector<uint8_t> deviceId;
229 deviceId.push_back('2');
230 executorInfo->SetDeviceId(deviceId);
231 class MyExecutorCallback : public AuthResPool::ExecutorCallback {
232 public:
~MyExecutorCallback()233 virtual ~MyExecutorCallback() {};
OnMessengerReady(const sptr<AuthResPool::IExecutorMessenger> & messenger)234 void OnMessengerReady(const sptr<AuthResPool::IExecutorMessenger> &messenger)override {
235 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnMessengerReady.");
236 return;
237 }
OnBeginExecute(uint64_t scheduleId,std::vector<uint8_t> & publicKey,std::shared_ptr<AuthResPool::AuthAttributes> commandAttrs)238 int32_t OnBeginExecute(uint64_t scheduleId, std::vector<uint8_t> &publicKey,
239 std::shared_ptr<AuthResPool::AuthAttributes> commandAttrs)override {
240 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnBeginExecute.");
241 return SUCCESS;
242 }
OnEndExecute(uint64_t scheduleId,std::shared_ptr<AuthResPool::AuthAttributes> consumerAttr)243 int32_t OnEndExecute(uint64_t scheduleId, std::shared_ptr<AuthResPool::AuthAttributes> consumerAttr)override {
244 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnEndExecute.");
245 return SUCCESS;
246 }
OnSetProperty(std::shared_ptr<AuthResPool::AuthAttributes> properties)247 int32_t OnSetProperty(std::shared_ptr<AuthResPool::AuthAttributes> properties)override {
248 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnSetProperty.");
249 return SUCCESS;
250 }
OnGetProperty(std::shared_ptr<AuthResPool::AuthAttributes> conditions,std::shared_ptr<AuthResPool::AuthAttributes> values)251 int32_t OnGetProperty(std::shared_ptr<AuthResPool::AuthAttributes> conditions,
252 std::shared_ptr<AuthResPool::AuthAttributes> values)override {
253 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnGetProperty.");
254 return SUCCESS;
255 }
256 };
257 std::shared_ptr<AuthResPool::ExecutorCallback> callback = std::make_shared<MyExecutorCallback>();
258 uint64_t ret = AuthResPool::AuthExecutorRegistry::GetInstance().Register(executorInfo, callback);
259 EXPECT_LE(10000, ret);
260 }
261
262 /**
263 * @tc.name: UseriamUtTest007
264 * @tc.desc: Test publicKey error length.
265 * @tc.type: FUNC
266 */
267 HWTEST_F(CoAuthTest, UseriamUtTest007, TestSize.Level0)
268 {
269 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest007 start");
270 std::shared_ptr<AuthResPool::AuthExecutor> executorInfo = std::make_shared<AuthResPool::AuthExecutor>();
271 executorInfo->SetAuthType(FACE);
272 executorInfo->SetAuthAbility(1);
273 executorInfo->SetExecutorSecLevel(ESL0);
274 executorInfo->SetExecutorType(TYPE_CO_AUTH);
275
276 std::vector<uint8_t> publicKey(10, '1');
277 executorInfo->SetPublicKey(publicKey);
278
279 std::vector<uint8_t> deviceId;
280 deviceId.push_back('2');
281 executorInfo->SetDeviceId(deviceId);
282 class MyExecutorCallback : public AuthResPool::ExecutorCallback {
283 public:
~MyExecutorCallback()284 virtual ~MyExecutorCallback() {};
OnMessengerReady(const sptr<AuthResPool::IExecutorMessenger> & messenger)285 void OnMessengerReady(const sptr<AuthResPool::IExecutorMessenger> &messenger)override {
286 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnMessengerReady.");
287 return;
288 }
OnBeginExecute(uint64_t scheduleId,std::vector<uint8_t> & publicKey,std::shared_ptr<AuthResPool::AuthAttributes> commandAttrs)289 int32_t OnBeginExecute(uint64_t scheduleId, std::vector<uint8_t> &publicKey,
290 std::shared_ptr<AuthResPool::AuthAttributes> commandAttrs)override {
291 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnBeginExecute.");
292 return SUCCESS;
293 }
OnEndExecute(uint64_t scheduleId,std::shared_ptr<AuthResPool::AuthAttributes> consumerAttr)294 int32_t OnEndExecute(uint64_t scheduleId, std::shared_ptr<AuthResPool::AuthAttributes> consumerAttr)override {
295 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnEndExecute.");
296 return SUCCESS;
297 }
OnSetProperty(std::shared_ptr<AuthResPool::AuthAttributes> properties)298 int32_t OnSetProperty(std::shared_ptr<AuthResPool::AuthAttributes> properties)override {
299 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnSetProperty.");
300 return SUCCESS;
301 }
OnGetProperty(std::shared_ptr<AuthResPool::AuthAttributes> conditions,std::shared_ptr<AuthResPool::AuthAttributes> values)302 int32_t OnGetProperty(std::shared_ptr<AuthResPool::AuthAttributes> conditions,
303 std::shared_ptr<AuthResPool::AuthAttributes> values)override {
304 COAUTH_HILOGE(MODULE_SERVICE, "MyExecutorCallback OnGetProperty.");
305 return SUCCESS;
306 }
307 };
308 std::shared_ptr<AuthResPool::ExecutorCallback> callback = std::make_shared<MyExecutorCallback>();
309 uint64_t ret = AuthResPool::AuthExecutorRegistry::GetInstance().Register(executorInfo, callback);
310 EXPECT_LE(0, ret);
311 }
312
313 /**
314 * @tc.name: UseriamUtTest008
315 * @tc.desc: Test empty executorInfo and empty callback.
316 * @tc.type: FUNC
317 */
318 HWTEST_F(CoAuthTest, UseriamUtTest008, TestSize.Level0)
319 {
320 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest008 start");
321 std::shared_ptr<AuthResPool::AuthExecutor> executorInfo = nullptr;
322 std::shared_ptr<AuthResPool::ExecutorCallback> callback = nullptr;
323 uint64_t ret = AuthResPool::AuthExecutorRegistry::GetInstance().Register(executorInfo, callback);
324 EXPECT_EQ(FAIL, ret);
325 }
326
327 /**
328 * @tc.name: UseriamUtTest009
329 * @tc.desc: Test AuthType(PIN).
330 * @tc.type: FUNC
331 */
332 HWTEST_F(CoAuthTest, UseriamUtTest009, TestSize.Level0)
333 {
334 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest009 start");
335 AuthResPool::AuthExecutor executorInfo;
336 executorInfo.SetAuthType(PIN);
337 executorInfo.SetAuthAbility(1);
338 executorInfo.SetExecutorSecLevel(ESL0);
339 executorInfo.SetExecutorType(TYPE_CO_AUTH);
340
341 std::vector<uint8_t> publicKey(32, '1');
342 executorInfo.SetPublicKey(publicKey);
343
344 std::vector<uint8_t> deviceId;
345 deviceId.push_back('2');
346 executorInfo.SetDeviceId(deviceId);
347
348 class MyQueryCallback : public AuthResPool::QueryCallback {
349 public:
~MyQueryCallback()350 virtual ~MyQueryCallback() {};
OnResult(uint32_t resultCode)351 virtual void OnResult(uint32_t resultCode) override {
352 COAUTH_HILOGE(MODULE_SERVICE, "MyQueryCallback OnResult.");
353 return;
354 }
355 };
356 std::shared_ptr<AuthResPool::QueryCallback> callback = std::make_shared<MyQueryCallback>();
357 AuthResPool::AuthExecutorRegistry::GetInstance().QueryStatus(executorInfo, callback);
358 SUCCEED();
359 }
360
361 /**
362 * @tc.name: UseriamUtTest0010
363 * @tc.desc: Test empty executorInfo and empty callback.
364 * @tc.type: FUNC
365 */
366 HWTEST_F(CoAuthTest, UseriamUtTest010, TestSize.Level0)
367 {
368 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest010 start");
369 AuthResPool::AuthExecutor executorInfo;
370 std::shared_ptr<AuthResPool::QueryCallback> callback = nullptr;
371 AuthResPool::AuthExecutorRegistry::GetInstance().QueryStatus(executorInfo, callback);
372 SUCCEED();
373 }
374
375 /**
376 * @tc.name: UseriamUtTest011
377 * @tc.desc: Test AuthType(FACE).
378 * @tc.type: FUNC
379 */
380 HWTEST_F(CoAuthTest, UseriamUtTest011, TestSize.Level0)
381 {
382 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest011 start");
383 AuthResPool::AuthExecutor executorInfo;
384 executorInfo.SetAuthType(FACE);
385 executorInfo.SetAuthAbility(1);
386 executorInfo.SetExecutorSecLevel(ESL0);
387 executorInfo.SetExecutorType(TYPE_CO_AUTH);
388
389 std::vector<uint8_t> publicKey(32, '1');
390 executorInfo.SetPublicKey(publicKey);
391
392 std::vector<uint8_t> deviceId;
393 deviceId.push_back('2');
394 executorInfo.SetDeviceId(deviceId);
395
396 class MyQueryCallback : public AuthResPool::QueryCallback {
397 public:
~MyQueryCallback()398 virtual ~MyQueryCallback() {};
OnResult(uint32_t resultCode)399 virtual void OnResult(uint32_t resultCode) override {
400 COAUTH_HILOGE(MODULE_SERVICE, "MyQueryCallback OnResult.");
401 return;
402 }
403 };
404 std::shared_ptr<AuthResPool::QueryCallback> callback = std::make_shared<MyQueryCallback>();
405 AuthResPool::AuthExecutorRegistry::GetInstance().QueryStatus(executorInfo, callback);
406 SUCCEED();
407 }
408 /**
409 * @tc.name: UseriamUtTest012
410 * @tc.desc: Test empty callback.
411 * @tc.type: FUNC
412 */
413 HWTEST_F(CoAuthTest, UseriamUtTest012, TestSize.Level0)
414 {
415 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest012 start");
416 AuthResPool::AuthExecutor executorInfo;
417 executorInfo.SetAuthType(FACE);
418 executorInfo.SetAuthAbility(1);
419 executorInfo.SetExecutorSecLevel(ESL0);
420 executorInfo.SetExecutorType(TYPE_CO_AUTH);
421
422 std::vector<uint8_t> publicKey(32, '1');
423 executorInfo.SetPublicKey(publicKey);
424
425 std::vector<uint8_t> deviceId;
426 deviceId.push_back('2');
427 executorInfo.SetDeviceId(deviceId);
428
429 std::shared_ptr<AuthResPool::QueryCallback> callback = nullptr;
430 AuthResPool::AuthExecutorRegistry::GetInstance().QueryStatus(executorInfo, callback);
431 SUCCEED();
432 }
433 /**
434 * @tc.name: UseriamUtTest013
435 * @tc.desc: Test empty authInfo and empty callback.
436 * @tc.type: FUNC
437 */
438 HWTEST_F(CoAuthTest, UseriamUtTest013, TestSize.Level0)
439 {
440 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest013 start");
441 AuthInfo authInfo;
442 std::shared_ptr<CoAuthCallback> callback = nullptr;
443 CoAuth::GetInstance().BeginSchedule(1, authInfo, callback);
444 SUCCEED();
445 }
446
447 /**
448 * @tc.name: UseriamUtTest014
449 * @tc.desc: Test normal value.
450 * @tc.type: FUNC
451 */
452 HWTEST_F(CoAuthTest, UseriamUtTest014, TestSize.Level0)
453 {
454 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest014 start");
455 AuthInfo authInfo;
456 std::string value = "packagedemo";
457 authInfo.SetPkgName(value);
458 authInfo.SetCallerUid(10000);
459 class MyCoAuthCallback : public CoAuthCallback {
460 public:
~MyCoAuthCallback()461 virtual ~MyCoAuthCallback() {};
OnFinish(uint32_t resultCode,std::vector<uint8_t> & scheduleToken)462 virtual void OnFinish(uint32_t resultCode, std::vector<uint8_t> &scheduleToken) override {
463 COAUTH_HILOGE(MODULE_SERVICE, "MyCoAuthCallback OnFinish.");
464 return;
465 }
OnAcquireInfo(uint32_t acquire)466 virtual void OnAcquireInfo(uint32_t acquire) override {
467 COAUTH_HILOGE(MODULE_SERVICE, "MyCoAuthCallback OnAcquireInfo.");
468 return;
469 }
470 };
471 std::shared_ptr<CoAuthCallback> callback = std::make_shared<MyCoAuthCallback>();
472 CoAuth::GetInstance().BeginSchedule(1, authInfo, callback);
473 SUCCEED();
474 }
475
476 /**
477 * @tc.name: UseriamUtTest015
478 * @tc.desc: Test empty callback.
479 * @tc.type: FUNC
480 */
481 HWTEST_F(CoAuthTest, UseriamUtTest015, TestSize.Level0)
482 {
483 COAUTH_HILOGD(MODULE_INNERKIT, "UseriamUtTest015 start");
484 AuthInfo authInfo;
485 std::string value = "packagedemo";
486 authInfo.SetPkgName(value);
487 authInfo.SetCallerUid(10000);
488 std::shared_ptr<CoAuthCallback> callback = nullptr;
489 CoAuth::GetInstance().BeginSchedule(1, authInfo, callback);
490 SUCCEED();
491 }
492
493 /**
494 * @tc.name: UseriamUtTest016
495 * @tc.desc: Test Cancel().
496 * @tc.type: FUNC
497 */
498 HWTEST_F(CoAuthTest, UseriamUtTest016, TestSize.Level0)
499 {
500 COAUTH_HILOGE(MODULE_SERVICE, "UseriamUtTest016 enter.");
501 uint64_t scheduleId = 0;
502 EXPECT_NE(0, CoAuth::GetInstance().Cancel(scheduleId));
503
504 scheduleId = 1;
505 EXPECT_NE(0, CoAuth::GetInstance().Cancel(scheduleId));
506 }
507
508 /**
509 * @tc.name: UseriamUtTest017
510 * @tc.desc: Test SetExecutorProp().
511 * @tc.type: FUNC
512 */
513 HWTEST_F(CoAuthTest, UseriamUtTest017, TestSize.Level0)
514 {
515 COAUTH_HILOGE(MODULE_SERVICE, "UseriamUtTest017 enter.");
516 AuthResPool::AuthAttributes conditions;
517 conditions.SetUint32Value(AUTH_TYPE, FACE);
518 conditions.SetBoolValue(AUTH_CONTROLLER, 0);
519 conditions.SetUint32Value(AUTH_SCHEDULE_MODE, 1);
520 conditions.SetUint64Value(AUTH_SCHEDULE_ID, 1);
521
522 std::vector<uint64_t> val1;
523 val1.push_back(1);
524 conditions.SetUint64ArrayValue(AUTH_TEMPLATE_ID_LIST, val1);
525
526 std::vector<uint8_t> val2;
527 val2.push_back('5');
528 conditions.SetUint8ArrayValue(AUTH_CALLER_NAME, val2);
529
530 class MySetPropCallback : public SetPropCallback {
531 public:
532
~MySetPropCallback()533 virtual ~MySetPropCallback() {};
OnResult(uint32_t result,std::vector<uint8_t> & extraInfo)534 void OnResult(uint32_t result, std::vector<uint8_t> &extraInfo)override
535 {
536 COAUTH_HILOGE(MODULE_SERVICE, "MySetPropCallback OnResult.");
537 return;
538 }
539
540 };
541 std::shared_ptr<SetPropCallback> callback = std::make_shared<MySetPropCallback>();
542 CoAuth::GetInstance().SetExecutorProp(conditions, callback);
543 sleep(5);
544 SUCCEED();
545 }
546
547 /**
548 * @tc.name: UseriamUtTest018
549 * @tc.desc: Test SetExecutorProp().
550 * @tc.type: FUNC
551 */
552 HWTEST_F(CoAuthTest, UseriamUtTest018, TestSize.Level0)
553 {
554 COAUTH_HILOGE(MODULE_SERVICE, "UseriamUtTest018 enter.");
555 AuthResPool::AuthAttributes conditions;
556 conditions.SetUint32Value(AUTH_TYPE, FACE);
557 conditions.SetBoolValue(AUTH_CONTROLLER, 0);
558 conditions.SetUint32Value(AUTH_SCHEDULE_MODE, 1);
559 conditions.SetUint64Value(AUTH_SCHEDULE_ID, 1);
560
561 std::vector<uint64_t> val1;
562 val1.push_back(1);
563 conditions.SetUint64ArrayValue(AUTH_TEMPLATE_ID_LIST, val1);
564
565 std::vector<uint8_t> val2;
566 val2.push_back('5');
567 conditions.SetUint8ArrayValue(AUTH_CALLER_NAME, val2);
568 std::shared_ptr<SetPropCallback> callback = nullptr;
569 CoAuth::GetInstance().SetExecutorProp(conditions, callback);
570 sleep(5);
571 SUCCEED();
572 }
573 }
574 }
575 }