1 /*
2 * Copyright (c) 2023-2024 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 "face_auth_hdi.h"
17
18 #include <hdf_base.h>
19
20 #include "iconsumer_surface.h"
21
22 #include "iam_hat_test.h"
23
24 #define LOG_LABEL OHOS::UserIam::Common::LABEL_FACE_AUTH_IMPL
25
26 using namespace std;
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::UserIam::Common;
30 using namespace OHOS::HDI::FaceAuth;
31
32 static AllInOneExecutorImpl g_executorImpl;
33 static Parcel parcel;
34 bool g_onResultFlag = false;
35 bool g_onTipFlag = false;
36 bool g_onSaCommandsFlag = false;
37
SetUpTestCase()38 void UserIamFaceAuthTestAdditional::SetUpTestCase()
39 {
40 }
41
TearDownTestCase()42 void UserIamFaceAuthTestAdditional::TearDownTestCase()
43 {
44 }
45
SetUp()46 void UserIamFaceAuthTestAdditional::SetUp()
47 {
48 }
49
TearDown()50 void UserIamFaceAuthTestAdditional::TearDown()
51 {
52 }
53
54 class DummyIExecutorCallback : public IExecutorCallback {
55 public:
DummyIExecutorCallback(int32_t result,int32_t tip,int32_t message)56 DummyIExecutorCallback(int32_t result, int32_t tip, int32_t message) : result_(result), tip_(tip), message_(message)
57 {
58 }
59
OnResult(int32_t result,const std::vector<uint8_t> & extraInfo)60 int32_t OnResult(int32_t result, const std::vector<uint8_t> &extraInfo) override
61 {
62 cout << "result is " << result << " extraInfo len is " << extraInfo.size() << endl;
63 g_onResultFlag = true;
64 return result_;
65 }
66
OnTip(int32_t tip,const std::vector<uint8_t> & extraInfo)67 int32_t OnTip(int32_t tip, const std::vector<uint8_t> &extraInfo) override
68 {
69 cout << "tip is " << tip << " extraInfo len is " << extraInfo.size() << endl;
70 g_onTipFlag = true;
71 return tip_;
72 }
73
OnMessage(int32_t destRole,const std::vector<uint8_t> & msg)74 int32_t OnMessage(int32_t destRole, const std::vector<uint8_t> &msg) override
75 {
76 cout << "destRole is " << destRole << " msg len is " << msg.size() << endl;
77 return message_;
78 }
79
80 private:
81 int32_t result_;
82 int32_t tip_;
83 int32_t message_;
84 };
85
86 class DummyISaCommandCallback : public ISaCommandCallback {
87 public:
DummyISaCommandCallback(int32_t result)88 explicit DummyISaCommandCallback(int32_t result) : result_(result)
89 {
90 }
91
OnSaCommands(const std::vector<SaCommand> & commands)92 int32_t OnSaCommands(const std::vector<SaCommand> &commands) override
93 {
94 g_onSaCommandsFlag = true;
95 return result_;
96 }
97
98 private:
99 int32_t result_;
100 };
101
FillTestIExecutorCallback(Parcel & parcel,sptr<IExecutorCallback> & callbackObj)102 static void FillTestIExecutorCallback(Parcel &parcel, sptr<IExecutorCallback> &callbackObj)
103 {
104 bool isNull = parcel.ReadBool();
105 if (isNull) {
106 callbackObj = nullptr;
107 } else {
108 callbackObj =
109 new (std::nothrow) DummyIExecutorCallback(parcel.ReadInt32(), parcel.ReadInt32(), parcel.ReadInt32());
110 if (callbackObj == nullptr) {
111 cout << "callbackObj construct fail" << endl;
112 }
113 }
114 cout << "success" << endl;
115 }
116
FillTestGetPropertyTypeVector(Parcel & parcel,std::vector<GetPropertyType> & types)117 void FillTestGetPropertyTypeVector(Parcel &parcel, std::vector<GetPropertyType> &types)
118 {
119 std::vector<uint32_t> propertyTypeUint32;
120 FillTestUint32Vector(parcel, propertyTypeUint32);
121 for (const auto &val : propertyTypeUint32) {
122 types.push_back(static_cast<GetPropertyType>(val));
123 }
124
125 cout << "success" << endl;
126 }
127
FillTestProperty(Parcel & parcel,Property & property)128 void FillTestProperty(Parcel &parcel, Property &property)
129 {
130 property.authSubType = parcel.ReadUint64();
131 property.lockoutDuration = parcel.ReadInt32();
132 property.remainAttempts = parcel.ReadInt32();
133 FillTestString(parcel, property.enrollmentProgress);
134 FillTestString(parcel, property.sensorInfo);
135
136 cout << "success" << endl;
137 }
138
FillTestISaCommandCallback(Parcel & parcel,sptr<ISaCommandCallback> & callbackObj)139 void FillTestISaCommandCallback(Parcel &parcel, sptr<ISaCommandCallback> &callbackObj)
140 {
141 bool isNull = parcel.ReadBool();
142 if (isNull) {
143 callbackObj = nullptr;
144 } else {
145 callbackObj = new (std::nothrow) DummyISaCommandCallback(parcel.ReadInt32());
146 if (callbackObj == nullptr) {
147 cout << "callbackObj construct fail" << endl;
148 }
149 }
150 cout << "success" << endl;
151 }
152 /**
153 * @tc.number SUB_Security_Iam_FaceAuth_HDI_GetExecutorInfo_0200
154 * @tc.name testFaceAuthTestGetExecutorInfo001
155 * @tc.desc test GetExecutorInfo not empty
156 */
157 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestGetExecutorInfo001, Function | MediumTest | Level1)
158 {
159 cout << "start test testFaceAuthTestGetExecutorInfo001" << endl;
160 ExecutorInfo executorInfo;
161 int32_t ret = g_executorImpl.GetExecutorInfo(executorInfo);
162 cout << "ret is " << ret << endl;
163 EXPECT_EQ(ret, 0);
164 }
165 /**
166 * @tc.number SUB_Security_Iam_FaceAuth_HDI_GetExecutorInfo_0300
167 * @tc.name testFaceAuthTestGetExecutorInfo002
168 * @tc.desc test GetExecutorInfo 1000 times
169 */
170 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestGetExecutorInfo002, Function | MediumTest | Level1)
171 {
172 cout << "start test testFaceAuthTestGetExecutorInfo002" << endl;
173 ExecutorInfo executorInfo;
174 int32_t ret = 0;
175 for (int32_t i = 0; i < 1000; i++) {
176 ret = g_executorImpl.GetExecutorInfo(executorInfo);
177 cout << "ret " << i << " is " << ret << endl;
178 EXPECT_EQ(ret, 0);
179 }
180 }
181
182 /**
183 * @tc.number SUB_Security_Iam_FaceAuth_HDI_OnRegisterFinish_0200
184 * @tc.name testFaceAuthTestOnRegisterFinish001
185 * @tc.desc test OnRegisterFinish empty
186 */
187 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestOnRegisterFinish001, Function | MediumTest | Level1)
188 {
189 cout << "start test testFaceAuthTestOnRegisterFinish001" << endl;
190 std::vector<uint64_t> templateIdList;
191 std::vector<uint8_t> frameworkPublicKey;
192 std::vector<uint8_t> extraInfo;
193 int32_t ret = g_executorImpl.OnRegisterFinish(templateIdList, frameworkPublicKey, extraInfo);
194 cout << "ret is " << ret << endl;
195 EXPECT_EQ(ret, 0);
196 FillTestUint64Vector(parcel, templateIdList);
197 ret = g_executorImpl.OnRegisterFinish(templateIdList, frameworkPublicKey, extraInfo);
198 cout << "ret is " << ret << endl;
199 EXPECT_EQ(ret, 0);
200 FillTestUint8Vector(parcel, frameworkPublicKey);
201 ret = g_executorImpl.OnRegisterFinish(templateIdList, frameworkPublicKey, extraInfo);
202 cout << "ret is " << ret << endl;
203 EXPECT_EQ(ret, 0);
204 FillTestUint8Vector(parcel, extraInfo);
205 ret = g_executorImpl.OnRegisterFinish(templateIdList, frameworkPublicKey, extraInfo);
206 cout << "ret is " << ret << endl;
207 EXPECT_EQ(ret, 0);
208 }
209 /**
210 * @tc.number SUB_Security_Iam_FaceAuth_HDI_OnRegisterFinish_0900
211 * @tc.name testFaceAuthTestOnRegisterFinish008
212 * @tc.desc test OnRegisterFinish 1000 times
213 */
214 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestOnRegisterFinish008, Function | MediumTest | Level1)
215 {
216 cout << "start test testFaceAuthTestOnRegisterFinish008" << endl;
217 std::vector<uint64_t> templateIdList;
218 FillTestUint64Vector(parcel, templateIdList);
219 std::vector<uint8_t> frameworkPublicKey;
220 FillTestUint8Vector(parcel, frameworkPublicKey);
221 std::vector<uint8_t> extraInfo;
222 FillTestUint8Vector(parcel, extraInfo);
223 int32_t ret = 0;
224 for (int32_t i = 0; i < 1000; i++) {
225 ret = g_executorImpl.OnRegisterFinish(templateIdList, frameworkPublicKey, extraInfo);
226 cout << "ret " << i << " is " << ret << endl;
227 EXPECT_EQ(ret, 0);
228 }
229 }
230 /**
231 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Enroll_0200
232 * @tc.name testFaceAuthTestEnroll001
233 * @tc.desc test Enroll scheduleId
234 */
235 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestEnroll001, Function | MediumTest | Level1)
236 {
237 cout << "start test testFaceAuthTestEnroll001" << endl;
238 uint64_t scheduleId = 0;
239 std::vector<uint8_t> extraInfo;
240 FillTestUint8Vector(parcel, extraInfo);
241 sptr<IExecutorCallback> callbackObj;
242 FillTestIExecutorCallback(parcel, callbackObj);
243 int32_t ret = g_executorImpl.Enroll(scheduleId, extraInfo, callbackObj);
244 cout << "ret is " << ret << endl;
245 EXPECT_EQ(ret, 0);
246 scheduleId = 0x7FFFFFFFFFFFFFFF;
247 ret = g_executorImpl.Enroll(scheduleId, extraInfo, callbackObj);
248 cout << "ret is " << ret << endl;
249 EXPECT_EQ(ret, 0);
250 scheduleId = 0xFFFFFFFFFFFFFFFF;
251 ret = g_executorImpl.Enroll(scheduleId, extraInfo, callbackObj);
252 cout << "ret is " << ret << endl;
253 EXPECT_EQ(ret, 0);
254 }
255 /**
256 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Enroll_0500
257 * @tc.name testFaceAuthTestEnroll004
258 * @tc.desc test Enroll extraInfo empty
259 */
260 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestEnroll004, Function | MediumTest | Level1)
261 {
262 cout << "start test testFaceAuthTestEnroll004" << endl;
263 uint64_t scheduleId = 0x7FFFFFFFFFFFFFFF;
264 std::vector<uint8_t> extraInfo;
265 sptr<IExecutorCallback> callbackObj;
266 FillTestIExecutorCallback(parcel, callbackObj);
267 int32_t ret = g_executorImpl.Enroll(scheduleId, extraInfo, callbackObj);
268 cout << "ret is " << ret << endl;
269 EXPECT_EQ(ret, 0);
270 ret = g_executorImpl.Enroll(scheduleId, extraInfo, nullptr);
271 cout << "ret is " << ret << endl;
272 EXPECT_NE(ret, 0);
273 FillTestUint8Vector(parcel, extraInfo);
274 ret = g_executorImpl.Enroll(scheduleId, extraInfo, nullptr);
275 cout << "ret is " << ret << endl;
276 EXPECT_NE(ret, 0);
277 }
278 /**
279 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Enroll_0800
280 * @tc.name testFaceAuthTestEnroll007
281 * @tc.desc test Enroll 1000 times
282 */
283 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestEnroll007, Function | MediumTest | Level1)
284 {
285 cout << "start test testFaceAuthTestEnroll007" << endl;
286 uint64_t scheduleId = 0x7FFFFFFFFFFFFFFF;
287 std::vector<uint8_t> extraInfo;
288 FillTestUint8Vector(parcel, extraInfo);
289 sptr<IExecutorCallback> callbackObj;
290 FillTestIExecutorCallback(parcel, callbackObj);
291 int32_t ret = 0;
292 for (int32_t i = 0; i < 1000; i++) {
293 ret = g_executorImpl.Enroll(scheduleId, extraInfo, callbackObj);
294 cout << "ret " << i << " is " << ret << endl;
295 EXPECT_EQ(ret, 0);
296 }
297 }
298 /**
299 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Authenticate_0200
300 * @tc.name testFaceAuthTestAuthenticate001
301 * @tc.desc test Authenticate scheduleId
302 */
303 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestAuthenticate001, Function | MediumTest | Level1)
304 {
305 cout << "start test testFaceAuthTestAuthenticate001" << endl;
306 uint64_t scheduleId = 0;
307 std::vector<uint64_t> templateIdList;
308 FillTestUint64Vector(parcel, templateIdList);
309 std::vector<uint8_t> extraInfo;
310 FillTestUint8Vector(parcel, extraInfo);
311 sptr<IExecutorCallback> callbackObj;
312 FillTestIExecutorCallback(parcel, callbackObj);
313 int32_t ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, callbackObj);
314 cout << "ret is " << ret << endl;
315 EXPECT_EQ(ret, 0);
316 scheduleId = 0xFFFFFFFFFFFFFFFF;
317 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, callbackObj);
318 cout << "ret is " << ret << endl;
319 EXPECT_EQ(ret, 0);
320 scheduleId = 0x7FFFFFFFFFFFFFFF;
321 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, callbackObj);
322 cout << "ret is " << ret << endl;
323 EXPECT_EQ(ret, 0);
324 }
325 /**
326 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Authenticate_0500
327 * @tc.name testFaceAuthTestAuthenticate004
328 * @tc.descc test Authenticate empty
329 */
330 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestAuthenticate004, Function | MediumTest | Level1)
331 {
332 cout << "start test testFaceAuthTestAuthenticate004" << endl;
333 uint64_t scheduleId = 0x7FFFFFFFFFFFFFFF;
334 std::vector<uint64_t> templateIdList;
335 std::vector<uint8_t> extraInfo;
336 sptr<IExecutorCallback> callbackObj;
337 FillTestIExecutorCallback(parcel, callbackObj);
338 int32_t ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, callbackObj);
339 cout << "ret is " << ret << endl;
340 EXPECT_EQ(ret, 0);
341 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, nullptr);
342 cout << "ret is " << ret << endl;
343 EXPECT_NE(ret, 0);
344 FillTestUint64Vector(parcel, templateIdList);
345 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, callbackObj);
346 cout << "ret is " << ret << endl;
347 EXPECT_EQ(ret, 0);
348 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, nullptr);
349 cout << "ret is " << ret << endl;
350 EXPECT_NE(ret, 0);
351 FillTestUint8Vector(parcel, extraInfo);
352 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, callbackObj);
353 cout << "ret is " << ret << endl;
354 EXPECT_EQ(ret, 0);
355 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, nullptr);
356 cout << "ret is " << ret << endl;
357 EXPECT_NE(ret, 0);
358 }
359 /**
360 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Authenticate_1200
361 * @tc.name testFaceAuthTestAuthenticate011
362 * @tc.desc test Authenticate 1000 times
363 */
364 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestAuthenticate011, Function | MediumTest | Level1)
365 {
366 cout << "start test testFaceAuthTestAuthenticate011" << endl;
367 uint64_t scheduleId = 0x7FFFFFFFFFFFFFFF;
368 std::vector<uint64_t> templateIdList;
369 FillTestUint64Vector(parcel, templateIdList);
370 std::vector<uint8_t> extraInfo;
371 FillTestUint8Vector(parcel, extraInfo);
372 sptr<IExecutorCallback> callbackObj;
373 FillTestIExecutorCallback(parcel, callbackObj);
374 int32_t ret = 0;
375 for (int32_t i = 0; i < 1000; i++) {
376 ret = g_executorImpl.Authenticate(scheduleId, templateIdList, extraInfo, callbackObj);
377 cout << "ret is " << ret << endl;
378 EXPECT_EQ(ret, 0);
379 }
380 }
381 /**
382 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Identify_0200
383 * @tc.name testFaceAuthTestIdentify001
384 * @tc.desc test Identify scheduleId
385 */
386 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestIdentify001, Function | MediumTest | Level1)
387 {
388 cout << "start test testFaceAuthTestIdentify001" << endl;
389 uint64_t scheduleId = 0;
390 std::vector<uint8_t> extraInfo;
391 FillTestUint8Vector(parcel, extraInfo);
392 sptr<IExecutorCallback> callbackObj;
393 FillTestIExecutorCallback(parcel, callbackObj);
394 int32_t ret = g_executorImpl.Identify(scheduleId, extraInfo, callbackObj);
395 cout << "ret is " << ret << endl;
396 EXPECT_EQ(ret, 0);
397 scheduleId = 0x7FFFFFFFFFFFFFFF;
398 ret = g_executorImpl.Identify(scheduleId, extraInfo, callbackObj);
399 cout << "ret is " << ret << endl;
400 EXPECT_EQ(ret, 0);
401 scheduleId = 0xFFFFFFFFFFFFFFFF;
402 ret = g_executorImpl.Identify(scheduleId, extraInfo, callbackObj);
403 cout << "ret is " << ret << endl;
404 EXPECT_EQ(ret, 0);
405 }
406 /**
407 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Identify_0500
408 * @tc.name testFaceAuthTestIdentify004
409 * @tc.desc test Identify empty
410 */
411 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestIdentify004, Function | MediumTest | Level1)
412 {
413 cout << "start test testFaceAuthTestIdentify004" << endl;
414 uint64_t scheduleId = 0x7FFFFFFFFFFFFFFF;
415 std::vector<uint8_t> extraInfo;
416 sptr<IExecutorCallback> callbackObj;
417 FillTestIExecutorCallback(parcel, callbackObj);
418 int32_t ret = g_executorImpl.Identify(scheduleId, extraInfo, callbackObj);
419 cout << "ret is " << ret << endl;
420 EXPECT_EQ(ret, 0);
421 ret = g_executorImpl.Identify(scheduleId, extraInfo, nullptr);
422 cout << "ret is " << ret << endl;
423 EXPECT_NE(ret, 0);
424 FillTestUint8Vector(parcel, extraInfo);
425 ret = g_executorImpl.Identify(scheduleId, extraInfo, nullptr);
426 cout << "ret is " << ret << endl;
427 EXPECT_NE(ret, 0);
428 }
429 /**
430 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Identify_0800
431 * @tc.name testFaceAuthTestIdentify007
432 * @tc.desc test Identify 1000 times
433 */
434 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestIdentify007, Function | MediumTest | Level1)
435 {
436 cout << "start test testFaceAuthTestIdentify007" << endl;
437 uint64_t scheduleId = 0x7FFFFFFFFFFFFFFF;
438 std::vector<uint8_t> extraInfo;
439 FillTestUint8Vector(parcel, extraInfo);
440 sptr<IExecutorCallback> callbackObj;
441 FillTestIExecutorCallback(parcel, callbackObj);
442 int32_t ret = 0;
443 for (int32_t i = 0; i < 1000; i++) {
444 ret = g_executorImpl.Identify(scheduleId, extraInfo, callbackObj);
445 cout << "ret is " << ret << endl;
446 EXPECT_EQ(ret, 0);
447 }
448 }
449 /**
450 * @tc.number: SUB_Security_Iam_FaceAuth_HDI_Delete_0200
451 * @tc.name: testFaceAuthTestDelete001
452 * @tc.desc test Delete templateIdList empty
453 */
454 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestDelete001, Function | MediumTest | Level1)
455 {
456 cout << "start test testFaceAuthTestDelete001" << endl;
457 std::vector<uint64_t> templateIdList;
458 int32_t ret = g_executorImpl.Delete(templateIdList);
459 cout << "ret is " << ret << endl;
460 EXPECT_EQ(ret, 0);
461 }
462 /**
463 * @tc.number: SUB_Security_Iam_FaceAuth_HDI_Delete_0300
464 * @tc.name: testFaceAuthTestDelete002
465 * @tc.desc test Delete 1000 times
466 */
467 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestDelete002, Function | MediumTest | Level1)
468 {
469 cout << "start test testFaceAuthTestDelete002" << endl;
470 std::vector<uint64_t> templateIdList;
471 FillTestUint64Vector(parcel, templateIdList);
472 int32_t ret = 0;
473 for (int32_t i = 0; i < 1000; i++) {
474 ret = g_executorImpl.Delete(templateIdList);
475 cout << "ret is " << ret << endl;
476 EXPECT_EQ(ret, 0);
477 }
478 }
479 /**
480 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Cancel_0200
481 * @tc.name testFaceAuthTestCancel001
482 * @tc.desc test Cancel scheduleId
483 */
484 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestCancel001, Function | MediumTest | Level1)
485 {
486 cout << "start test testFaceAuthTestCancel001" << endl;
487 uint64_t scheduleId = 0;
488 int32_t ret = g_executorImpl.Cancel(scheduleId);
489 cout << "ret is " << ret << endl;
490 EXPECT_EQ(ret, 0);
491 scheduleId = 0x7FFFFFFFFFFFFFFF;
492 ret = g_executorImpl.Cancel(scheduleId);
493 cout << "ret is " << ret << endl;
494 EXPECT_EQ(ret, 0);
495 scheduleId = 0xFFFFFFFFFFFFFFFF;
496 ret = g_executorImpl.Cancel(scheduleId);
497 cout << "ret is " << ret << endl;
498 EXPECT_EQ(ret, 0);
499 }
500 /**
501 * @tc.number SUB_Security_Iam_FaceAuth_HDI_Cancel_0500
502 * @tc.name testFaceAuthTestCancel004
503 * @tc.desc test Cancel 1000 times
504 */
505 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestCancel004, Function | MediumTest | Level1)
506 {
507 cout << "start test testFaceAuthTestCancel004" << endl;
508 uint64_t scheduleId = 0;
509 int32_t ret = 0;
510 for (int32_t i = 0; i < 1000; i++) {
511 ret = g_executorImpl.Cancel(scheduleId);
512 cout << "ret is " << ret << endl;
513 EXPECT_EQ(ret, 0);
514 }
515 }
516 /**
517 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SendCommand_0200
518 * @tc.name testFaceAuthTestSendCommand001
519 * @tc.desc test SendCommand commandId
520 */
521 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSendCommand001, Function | MediumTest | Level1)
522 {
523 cout << "start test testFaceAuthTestSendCommand001" << endl;
524 int32_t commandId = DriverCommandId::LOCK_TEMPLATE;
525 std::vector<uint8_t> extraInfo;
526 FillTestUint8Vector(parcel, extraInfo);
527 sptr<IExecutorCallback> callbackObj;
528 FillTestIExecutorCallback(parcel, callbackObj);
529 int32_t ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
530 cout << "ret is " << ret << endl;
531 EXPECT_EQ(ret, 0);
532 commandId = DriverCommandId::UNLOCK_TEMPLATE;
533 ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
534 cout << "ret is " << ret << endl;
535 EXPECT_EQ(ret, 0);
536 commandId = DriverCommandId::VENDOR_COMMAND_BEGIN;
537 ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
538 cout << "ret is " << ret << endl;
539 EXPECT_EQ(ret, 0);
540 commandId = 0;
541 ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
542 cout << "ret is " << ret << endl;
543 EXPECT_EQ(ret, 0);
544 commandId = 0x7FFFFFFF;
545 ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
546 cout << "ret is " << ret << endl;
547 EXPECT_EQ(ret, 0);
548 commandId = -0x01;
549 ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
550 cout << "ret is " << ret << endl;
551 EXPECT_EQ(ret, 0);
552 commandId = -0x7FFFFFFF;
553 ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
554 cout << "ret is " << ret << endl;
555 EXPECT_EQ(ret, 0);
556 }
557 /**
558 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SendCommand_0900
559 * @tc.name testFaceAuthTestSendCommand008
560 * @tc.desc test SendCommand extraInfo empty
561 */
562 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSendCommand008, Function | MediumTest | Level1)
563 {
564 cout << "start test testFaceAuthTestSendCommand008" << endl;
565 int32_t commandId = DriverCommandId::LOCK_TEMPLATE;
566 std::vector<uint8_t> extraInfo;
567 sptr<IExecutorCallback> callbackObj;
568 FillTestIExecutorCallback(parcel, callbackObj);
569 int32_t ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
570 cout << "ret is " << ret << endl;
571 EXPECT_EQ(ret, 0);
572 ret = g_executorImpl.SendCommand(commandId, extraInfo, nullptr);
573 cout << "ret is " << ret << endl;
574 EXPECT_NE(ret, 0);
575 FillTestUint8Vector(parcel, extraInfo);
576 ret = g_executorImpl.SendCommand(commandId, extraInfo, nullptr);
577 cout << "ret is " << ret << endl;
578 EXPECT_NE(ret, 0);
579 }
580 /**
581 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SendCommand_1200
582 * @tc.name testFaceAuthTestSendCommand011
583 * @tc.desc test SendCommand 1000 times
584 */
585 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSendCommand011, Function | MediumTest | Level1)
586 {
587 cout << "start test testFaceAuthTestSendCommand011" << endl;
588 int32_t commandId = DriverCommandId::LOCK_TEMPLATE;
589 std::vector<uint8_t> extraInfo;
590 FillTestUint8Vector(parcel, extraInfo);
591 sptr<IExecutorCallback> callbackObj;
592 FillTestIExecutorCallback(parcel, callbackObj);
593 int32_t ret = 0;
594 for (int32_t i = 0; i < 1000; i++) {
595 ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
596 cout << "ret is " << ret << endl;
597 EXPECT_EQ(ret, 0);
598 }
599 }
600 /**
601 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SetBufferProducer_0200
602 * @tc.name testFaceAuthTestSetBufferProducer001
603 * @tc.desc test SetBufferProducer producerSequenceable null
604 */
605 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSetBufferProducer001, Function | MediumTest | Level2)
606 {
607 cout << "start test testFaceAuthTestSetBufferProducer001" << endl;
608 FaceAuthInterfaceService faceauth_Interface;
609 int32_t ret = faceauth_Interface.SetBufferProducer(nullptr);
610 cout << "ret is " << ret << endl;
611 EXPECT_EQ(ret, 0);
612 }
613 /**
614 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SetBufferProducer_0300
615 * @tc.name testFaceAuthTestSetBufferProducer002
616 * @tc.desc test SetBufferProducer 1000 times
617 */
618 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSetBufferProducer002, Function | MediumTest | Level1)
619 {
620 cout << "start test testFaceAuthTestSetBufferProducer002" << endl;
621 sptr<IBufferProducer> bufferProducer = nullptr;
622 if (parcel.ReadBool()) {
623 auto surface = IConsumerSurface::Create();
624 if (surface == nullptr) {
625 cout << "CreateSurfaceAsConsumer fail" << endl;
626 } else {
627 bufferProducer = surface->GetProducer();
628 }
629 }
630 sptr<BufferProducerSequenceable> producerSequenceable =
631 new (std::nothrow) BufferProducerSequenceable(bufferProducer);
632 int32_t ret = 0;
633 FaceAuthInterfaceService faceauth_Interface;
634 for (int32_t i = 0; i < 1000; i++) {
635 ret = faceauth_Interface.SetBufferProducer(producerSequenceable);
636 cout << "ret is " << ret << endl;
637 EXPECT_EQ(ret, 0);
638 }
639 }
640 /**
641 * @tc.number SUB_Security_Iam_FaceAuth_HDI_GetProperty_0200
642 * @tc.name testFaceAuthTestGetProperty001
643 * @tc.desc test GetProperty
644 */
645 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestGetProperty001, Function | MediumTest | Level1)
646 {
647 cout << "start test testFaceAuthTestGetProperty001" << endl;
648 std::vector<uint64_t> templateIdList;
649 std::vector<int32_t> propertyTypes;
650 Property property;
651 int32_t ret = g_executorImpl.GetProperty(templateIdList, propertyTypes, property);
652 cout << "ret is " << ret << endl;
653 EXPECT_EQ(ret, 0);
654 FillTestUint64Vector(parcel, templateIdList);
655 ret = g_executorImpl.GetProperty(templateIdList, propertyTypes, property);
656 cout << "ret is " << ret << endl;
657 EXPECT_EQ(ret, 0);
658 propertyTypes.push_back(GetPropertyType::AUTH_SUB_TYPE);
659 propertyTypes.push_back(GetPropertyType::LOCKOUT_DURATION);
660 propertyTypes.push_back(GetPropertyType::REMAIN_ATTEMPTS);
661 propertyTypes.push_back(GetPropertyType::ENROLL_PROGRESS);
662 propertyTypes.push_back(GetPropertyType::SENSOR_INFO);
663 ret = g_executorImpl.GetProperty(templateIdList, propertyTypes, property);
664 cout << "ret is " << ret << endl;
665 EXPECT_EQ(ret, 0);
666 FillTestProperty(parcel, property);
667 ret = g_executorImpl.GetProperty(templateIdList, propertyTypes, property);
668 cout << "ret is " << ret << endl;
669 EXPECT_EQ(ret, 0);
670 }
671 /**
672 * @tc.number SUB_Security_Iam_FaceAuth_HDI_GetProperty_1000
673 * @tc.name testFaceAuthTestGetProperty009
674 * @tc.desc test GetProperty 1000 times
675 */
676 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestGetProperty009, Function | MediumTest | Level1)
677 {
678 cout << "start test testFaceAuthTestGetProperty009" << endl;
679 std::vector<uint64_t> templateIdList;
680 FillTestUint64Vector(parcel, templateIdList);
681 std::vector<int32_t> propertyTypes;
682 FillTestInt32Vector(parcel, propertyTypes);
683 Property property;
684 FillTestProperty(parcel, property);
685 int32_t ret = 0;
686 for (int32_t i = 0; i < 1000; i++) {
687 ret = g_executorImpl.GetProperty(templateIdList, propertyTypes, property);
688 cout << "ret is " << ret << endl;
689 EXPECT_EQ(ret, 0);
690 }
691 }
692 /**
693 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SetCachedTemplates_0200
694 * @tc.name testFaceAuthTestSetCachedTemplates001
695 * @tc.desc test SetCachedTemplates templateIdList empty
696 */
697 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSetCachedTemplates001, Function | MediumTest | Level1)
698 {
699 cout << "start test testFaceAuthTestSetCachedTemplates001" << endl;
700 std::vector<uint64_t> templateIdList;
701
702 int32_t ret = g_executorImpl.SetCachedTemplates(templateIdList);
703 cout << "ret is " << ret << endl;
704 EXPECT_EQ(ret, 0);
705 }
706 /**
707 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SetCachedTemplates_0300
708 * @tc.name testFaceAuthTestSetCachedTemplates002
709 * @tc.desc test SetCachedTemplates 1000 times
710 */
711 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSetCachedTemplates002, Function | MediumTest | Level1)
712 {
713 cout << "start test testFaceAuthTestSetCachedTemplates002" << endl;
714 std::vector<uint64_t> templateIdList;
715 FillTestUint64Vector(parcel, templateIdList);
716
717 int32_t ret = 0;
718 for (int32_t i = 0; i < 1000; i++) {
719 ret = g_executorImpl.SetCachedTemplates(templateIdList);
720 cout << "ret is " << ret << endl;
721 EXPECT_EQ(ret, 0);
722 }
723 }
724 /**
725 * @tc.number SUB_Security_Iam_FaceAuth_HDI_RegisterSaCommandCallback_0200
726 * @tc.name testFaceAuthTestRegisterSaCommandCallback001
727 * @tc.desc test RegisterSaCommandCallback callbackObj null
728 */
729 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestRegisterSaCommandCallback001, Function | MediumTest | Level1)
730 {
731 cout << "start test testFaceAuthTestRegisterSaCommandCallback001" << endl;
732
733 int32_t ret = g_executorImpl.RegisterSaCommandCallback(nullptr);
734
735 cout << "ret is " << ret << endl;
736 EXPECT_EQ(ret, 0);
737 }
738 /**
739 * @tc.number SUB_Security_Iam_FaceAuth_HDI_RegisterSaCommandCallback_0300
740 * @tc.name testFaceAuthTestRegisterSaCommandCallback002
741 * @tc.desc test RegisterSaCommandCallback 1000
742 */
743 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestRegisterSaCommandCallback002, Function | MediumTest | Level1)
744 {
745 cout << "start test testFaceAuthTestRegisterSaCommandCallback002" << endl;
746 sptr<ISaCommandCallback> callbackObj = nullptr;
747 FillTestISaCommandCallback(parcel, callbackObj);
748
749 int32_t ret = 0;
750 for (int32_t i = 0; i < 1000; i++) {
751 ret = g_executorImpl.RegisterSaCommandCallback(callbackObj);
752
753 cout << "ret is " << ret << endl;
754 EXPECT_EQ(ret, 0);
755 }
756 }
757 /**
758 * @tc.number SUB_Security_Iam_FaceAuth_HDI_SendMessage_0100
759 * @tc.name testFaceAuthTestSendMessage001
760 * @tc.desc test SetCachedTemplates 1000 times
761 */
762 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestSendMessage001, Function | MediumTest | Level1)
763 {
764 cout << "start test testFaceAuthTestSendMessage001" << endl;
765
766 uint64_t scheduleId = 0;
767 int32_t srcRole = 0;
768 std::vector<uint8_t> msg;
769 msg.resize(5);
770 int32_t ret = 0;
771 for (int32_t i = 0; i < 1000; i++) {
772 ret = g_executorImpl.SendMessage(scheduleId, srcRole, msg);
773 cout << "ret is " << ret << endl;
774 EXPECT_EQ(ret, 0);
775 }
776 }
777 /**
778 * @tc.number SUB_Security_Iam_FaceAuth_HDI_GetExecutorList_0200
779 * @tc.name testFaceAuthTestGetExecutorList001
780 * @tc.desc test GetExecutorList 1000 times
781 */
782 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestGetExecutorList001, Function | MediumTest | Level1)
783 {
784 cout << "start test GetExecutorList" << endl;
785 FaceAuthInterfaceService faceauth_Interface;
786 std::vector<sptr<IAllInOneExecutor>> executorList;
787 int32_t ret = 0;
788 for (int32_t i = 0; i < 1000; i++) {
789 ret = faceauth_Interface.GetExecutorList(executorList);
790 cout << "ret is " << ret << endl;
791 EXPECT_EQ(ret, 0);
792 }
793 }
794
795 /**
796 * @tc.number SUB_Security_Iam_FaceAuth_HDI_OnResult_0100
797 * @tc.name testFaceAuthTestOnResult001
798 * @tc.desc test OnResult Callback
799 */
800 HWTEST_F(UserIamFaceAuthTestAdditional, testFaceAuthTestOnResult001, Function | MediumTest | Level1)
801 {
802 cout << "start test testFaceAuthTestOnResult001" << endl;
803 uint8_t commandId = parcel.ReadUint8();
804 std::vector<uint8_t> extraInfo;
805 FillTestUint8Vector(parcel, extraInfo);
806 sptr<IExecutorCallback> callbackObj;
807 FillTestIExecutorCallback(parcel, callbackObj);
808 int32_t ret = g_executorImpl.SendCommand(commandId, extraInfo, callbackObj);
809 cout << "ret is " << ret << endl;
810 EXPECT_EQ(g_onResultFlag, true);
811 }