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