1 /*
2  * Copyright (c) 2022-2023 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 <gtest/gtest.h>
17 
18 #include "securec.h"
19 
20 #include "adaptor_memory.h"
21 #include "coauth.h"
22 #include "executor_message.h"
23 #include "idm_common.h"
24 
25 extern "C" {
26     extern LinkedList *g_poolList;
27     extern LinkedList *g_scheduleList;
28     extern LinkedList *g_userInfoList;
29     extern void DestroyUserInfoList(void);
30     extern ResultCode SignData(const Uint8Array *dataTlv, Uint8Array *signDataTlv, SignParam signParam);
31     extern ResultCode GetAttributeDataAndSignTlv(const Attribute *attribute, Uint8Array *retDataAndSignTlv,
32         SignParam signParam);
33     extern ResultCode Ed25519VerifyData(uint64_t scheduleId, Uint8Array dataTlv, Uint8Array signTlv);
34     extern ResultCode VerifyDataTlvSignature(const Attribute *dataAndSignAttribute, const Uint8Array dataTlv,
35         SignParam signParam);
36     extern Attribute *CreateAttributeFromDataAndSignTlv(const Uint8Array dataAndSignTlv, SignParam signParam);
37     extern Attribute *CreateAttributeFromExecutorMsg(const Uint8Array msg, SignParam signParam);
38     extern void GetRootSecretFromAttribute(const Attribute *attribute, ExecutorResultInfo *resultInfo);
39     extern ResultCode GetExecutorResultInfoFromAttribute(const Attribute *attribute, ExecutorResultInfo *resultInfo);
40     extern Buffer *CreateExecutorMsg(uint32_t authType, uint32_t authPropertyMode,
41         const Uint64Array *templateIds);
42     extern void DestoryExecutorMsg(void *data);
43     extern ResultCode GetExecutorTemplateList(
44         int32_t userId, const ExecutorInfoHal *executorNode, Uint64Array *templateIds);
45     extern ResultCode AssemblyMessage(
46         int32_t userId, const ExecutorInfoHal *executorNode, uint32_t authPropertyMode, LinkedList *executorMsg);
47     extern ResultCode TraverseExecutor(
48         int32_t userId, uint32_t executorRole, uint32_t authPropertyMode, LinkedList *executorMsg);
49 }
50 
51 namespace OHOS {
52 namespace UserIam {
53 namespace UserAuth {
54 using namespace testing;
55 using namespace testing::ext;
56 
57 class ExecutorMessageTest : public testing::Test {
58 public:
SetUpTestCase()59     static void SetUpTestCase() {};
60 
TearDownTestCase()61     static void TearDownTestCase() {};
62 
SetUp()63     void SetUp() {};
64 
TearDown()65     void TearDown() {};
66 };
67 
HWTEST_F(ExecutorMessageTest, TestSignData, TestSize.Level0)68 HWTEST_F(ExecutorMessageTest, TestSignData, TestSize.Level0)
69 {
70     constexpr uint32_t len = 32;
71     uint8_t dataTlvBuffer[len] = { 0 };
72     Uint8Array dataTlv = { dataTlvBuffer, len };
73     uint8_t signDataBuffer[len] = { 0 };
74     Uint8Array signData = { signDataBuffer, len };
75     dataTlv.len = 0;
76     SignParam signParam = { .needSignature = true, .keyType = KEY_TYPE_EXECUTOR };
77     ResultCode result = SignData(&dataTlv, &signData, signParam);
78     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
79     (void)memset_s(dataTlv.data, dataTlv.len, 1, dataTlv.len);
80     dataTlv.len = len;
81     result = SignData(&dataTlv, &signData, signParam);
82     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
83 }
84 
HWTEST_F(ExecutorMessageTest, TestGetAttributeDataAndSignTlv, TestSize.Level0)85 HWTEST_F(ExecutorMessageTest, TestGetAttributeDataAndSignTlv, TestSize.Level0)
86 {
87     Uint8Array retData = { (uint8_t *)Malloc(MAX_EXECUTOR_MSG_LEN), MAX_EXECUTOR_MSG_LEN };
88     Attribute *attribute = CreateEmptyAttribute();
89     EXPECT_NE(attribute, nullptr);
90     SignParam signParam = { .needSignature = false };
91     ResultCode result = GetAttributeDataAndSignTlv(nullptr, &retData, signParam);
92     EXPECT_EQ(result, RESULT_BAD_PARAM);
93 
94     constexpr uint32_t testUint32 = 123;
95     constexpr int32_t testInt32 = 123;
96     constexpr uint64_t testUint64 = 456;
97     uint8_t testUint8Buffer[] = { 'a', 'b', 'c' };
98     uint64_t testUint64Buffer[] = { 123, 456, 789 };
99     Uint8Array testUint8Array = { testUint8Buffer, sizeof(testUint8Buffer) };
100     Uint64Array testUint64Array = { testUint64Buffer, sizeof(testUint64Buffer) };
101     result = SetAttributeUint32(attribute, ATTR_IDENTIFY_MODE, testUint32);
102     EXPECT_EQ(result, RESULT_SUCCESS);
103     result = SetAttributeInt32(attribute, ATTR_RESULT_CODE, testInt32);
104     EXPECT_EQ(result, RESULT_SUCCESS);
105     result = SetAttributeUint64(attribute, ATTR_SCHEDULE_ID, testUint64);
106     EXPECT_EQ(result, RESULT_SUCCESS);
107     result = SetAttributeUint8Array(attribute, ATTR_SIGNATURE, testUint8Array);
108     EXPECT_EQ(result, RESULT_SUCCESS);
109     result = SetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, testUint64Array);
110     EXPECT_EQ(result, RESULT_SUCCESS);
111 
112     result = GetAttributeDataAndSignTlv(attribute, &retData, signParam);
113     EXPECT_EQ(result, RESULT_SUCCESS);
114     signParam = { .needSignature = true, .keyType = KEY_TYPE_EXECUTOR };
115     result = GetAttributeDataAndSignTlv(attribute, &retData, signParam);
116     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
117     Free(retData.data);
118     FreeAttribute(&attribute);
119 }
120 
HWTEST_F(ExecutorMessageTest, TestGetAttributeExecutorMsg, TestSize.Level0)121 HWTEST_F(ExecutorMessageTest, TestGetAttributeExecutorMsg, TestSize.Level0)
122 {
123     Uint8Array retData = { (uint8_t *)Malloc(MAX_EXECUTOR_MSG_LEN), MAX_EXECUTOR_MSG_LEN };
124     Attribute *attribute = CreateEmptyAttribute();
125     EXPECT_NE(attribute, nullptr);
126     SignParam signParam = { .needSignature = false };
127     ResultCode result = GetAttributeExecutorMsg(nullptr, &retData, signParam);
128     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
129     result = GetAttributeExecutorMsg(attribute, nullptr, signParam);
130     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
131     retData.len = 0;
132     result = GetAttributeExecutorMsg(attribute, &retData, signParam);
133     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
134 
135     constexpr uint32_t testUint32 = 123;
136     constexpr int32_t testInt32 = 123;
137     constexpr uint64_t testUint64 = 456;
138     uint8_t testUint8Buffer[] = { 'a', 'b', 'c' };
139     uint64_t testUint64Buffer[] = { 123, 456, 789 };
140     Uint8Array testUint8Array = { testUint8Buffer, sizeof(testUint8Buffer) };
141     Uint64Array testUint64Array = { testUint64Buffer, sizeof(testUint64Buffer) };
142     result = SetAttributeUint32(attribute, ATTR_IDENTIFY_MODE, testUint32);
143     EXPECT_EQ(result, RESULT_SUCCESS);
144     result = SetAttributeInt32(attribute, ATTR_RESULT_CODE, testInt32);
145     EXPECT_EQ(result, RESULT_SUCCESS);
146     result = SetAttributeUint64(attribute, ATTR_SCHEDULE_ID, testUint64);
147     EXPECT_EQ(result, RESULT_SUCCESS);
148     result = SetAttributeUint8Array(attribute, ATTR_SIGNATURE, testUint8Array);
149     EXPECT_EQ(result, RESULT_SUCCESS);
150     result = SetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, testUint64Array);
151     EXPECT_EQ(result, RESULT_SUCCESS);
152 
153     result = GetAttributeExecutorMsg(attribute, &retData, signParam);
154     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
155     signParam = { .needSignature = true, .keyType = KEY_TYPE_EXECUTOR };
156     result = GetAttributeExecutorMsg(attribute, &retData, signParam);
157     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
158     Free(retData.data);
159     FreeAttribute(&attribute);
160 }
161 
HWTEST_F(ExecutorMessageTest, TestEd25519VerifyData, TestSize.Level0)162 HWTEST_F(ExecutorMessageTest, TestEd25519VerifyData, TestSize.Level0)
163 {
164     uint64_t scheduleId = 0;
165     uint8_t testUint8Buffer[] = { 'a', 'b', 'c' };
166     Uint8Array dataTlv = { testUint8Buffer, sizeof(testUint8Buffer) };
167     Uint8Array signData = { testUint8Buffer, sizeof(testUint8Buffer) };
168     ResultCode result = Ed25519VerifyData(scheduleId, dataTlv, signData);
169     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
170 }
171 
HWTEST_F(ExecutorMessageTest, TestVerifyDataTlvSignature, TestSize.Level0)172 HWTEST_F(ExecutorMessageTest, TestVerifyDataTlvSignature, TestSize.Level0)
173 {
174     Attribute *attribute = CreateEmptyAttribute();
175     EXPECT_NE(attribute, nullptr);
176     constexpr uint32_t dataLen = 12;
177     uint8_t array[dataLen] = { 1, 2, 3, 4, 5, 6 };
178     Uint8Array dataTlv = { &array[0], dataLen };
179     ResultCode result = SetAttributeUint8Array(attribute, ATTR_SIGNATURE, dataTlv);
180     EXPECT_EQ(result, RESULT_SUCCESS);
181     result = SetAttributeUint8Array(attribute, ATTR_DATA, dataTlv);
182     EXPECT_EQ(result, RESULT_SUCCESS);
183     uint64_t scheduleId = 10;
184     result = SetAttributeUint64(attribute, ATTR_SCHEDULE_ID, scheduleId);
185     EXPECT_EQ(result, RESULT_SUCCESS);
186 
187     SignParam signParam = { .needSignature = false };
188     result = VerifyDataTlvSignature(nullptr, dataTlv, signParam);
189     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
190     FreeAttribute(&attribute);
191 }
192 
HWTEST_F(ExecutorMessageTest, TestCreateAttributeFromDataAndSignTlv, TestSize.Level0)193 HWTEST_F(ExecutorMessageTest, TestCreateAttributeFromDataAndSignTlv, TestSize.Level0)
194 {
195     uint8_t retInfoBuffer[MAX_EXECUTOR_SIZE] = { 0 };
196     Uint8Array retInfo = { retInfoBuffer, MAX_EXECUTOR_SIZE };
197     SignParam signParam = { .needSignature = true, .keyType = KEY_TYPE_EXECUTOR };
198     Attribute *retAttribute = CreateAttributeFromDataAndSignTlv(retInfo, signParam);
199     EXPECT_EQ(retAttribute, nullptr);
200     retInfo.len = 0;
201     retAttribute = CreateAttributeFromDataAndSignTlv(retInfo, signParam);
202     EXPECT_EQ(retAttribute, nullptr);
203     constexpr int32_t resultCode = 123;
204     constexpr uint32_t authType1 = 1;
205     constexpr uint64_t templateId = 456;
206     Attribute *attribute = CreateEmptyAttribute();
207     EXPECT_NE(attribute, nullptr);
208     ResultCode result = SetAttributeInt32(attribute, ATTR_RESULT_CODE, resultCode);
209     EXPECT_EQ(result, RESULT_SUCCESS);
210     result = SetAttributeUint32(attribute, ATTR_TYPE, authType1);
211     EXPECT_EQ(result, RESULT_SUCCESS);
212     result = SetAttributeUint64(attribute, ATTR_TEMPLATE_ID, templateId);
213     EXPECT_EQ(result, RESULT_SUCCESS);
214     result = GetAttributeExecutorMsg(attribute, &retInfo, signParam);
215     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
216 
217     Uint8Array dataAndSignTlv = { (uint8_t *)Malloc(MAX_EXECUTOR_MSG_LEN), MAX_EXECUTOR_MSG_LEN };
218     EXPECT_NE(dataAndSignTlv.data, nullptr);
219     Attribute *msgAttribute = CreateAttributeFromSerializedMsg(retInfo);
220     EXPECT_EQ(msgAttribute, nullptr);
221     result = GetAttributeUint8Array(msgAttribute, ATTR_ROOT, &dataAndSignTlv);
222     EXPECT_EQ(result, RESULT_BAD_PARAM);
223     retAttribute = CreateAttributeFromDataAndSignTlv(dataAndSignTlv, signParam);
224     EXPECT_EQ(retAttribute, nullptr);
225     signParam = { .needSignature = false };
226     retAttribute = CreateAttributeFromDataAndSignTlv(dataAndSignTlv, signParam);
227     EXPECT_EQ(retAttribute, nullptr);
228 
229     FreeAttribute(&retAttribute);
230     FreeAttribute(&msgAttribute);
231     Free(dataAndSignTlv.data);
232     FreeAttribute(&attribute);
233 }
234 
HWTEST_F(ExecutorMessageTest, TestCreateAttributeFromExecutorMsg, TestSize.Level0)235 HWTEST_F(ExecutorMessageTest, TestCreateAttributeFromExecutorMsg, TestSize.Level0)
236 {
237     Uint8Array msg = { (uint8_t *)Malloc(MAX_EXECUTOR_MSG_LEN), MAX_EXECUTOR_MSG_LEN };
238     SignParam signParam = { .needSignature = true, .keyType = KEY_TYPE_EXECUTOR };
239     Attribute *retAttribute = CreateAttributeFromExecutorMsg(msg, signParam);
240     EXPECT_EQ(retAttribute, nullptr);
241     constexpr int32_t resultCode = 1;
242     Attribute *attribute = CreateEmptyAttribute();
243     EXPECT_NE(attribute, nullptr);
244     ResultCode result = SetAttributeInt32(attribute, ATTR_RESULT_CODE, resultCode);
245     EXPECT_EQ(result, RESULT_SUCCESS);
246     result = GetAttributeExecutorMsg(attribute, &msg, signParam);
247     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
248 
249     SignParam signParam1 = { .needSignature = false };
250     retAttribute = CreateAttributeFromExecutorMsg(msg, signParam1);
251     EXPECT_EQ(retAttribute, nullptr);
252     retAttribute = CreateAttributeFromExecutorMsg(msg, signParam);
253     EXPECT_EQ(retAttribute, nullptr);
254     int32_t retCode;
255     result = GetAttributeInt32(attribute, ATTR_RESULT_CODE, &retCode);
256     EXPECT_EQ(result, RESULT_SUCCESS);
257     EXPECT_EQ(retCode, resultCode);
258     FreeAttribute(&retAttribute);
259     FreeAttribute(&attribute);
260     Free(msg.data);
261 }
262 
HWTEST_F(ExecutorMessageTest, TestGetRootSecretFromAttribute, TestSize.Level0)263 HWTEST_F(ExecutorMessageTest, TestGetRootSecretFromAttribute, TestSize.Level0)
264 {
265     Attribute *attribute = CreateEmptyAttribute();
266     EXPECT_NE(attribute, nullptr);
267     ExecutorResultInfo resultInfo= {};
268     GetRootSecretFromAttribute(attribute, &resultInfo);
269     uint8_t testUint8Buffer[] = { 'a', 'b', 'c' };
270     Uint8Array rootSecret = { testUint8Buffer, sizeof(testUint8Buffer) };
271     ResultCode result = SetAttributeUint8Array(attribute, ATTR_ROOT_SECRET, rootSecret);
272     EXPECT_EQ(result, RESULT_SUCCESS);
273     GetRootSecretFromAttribute(attribute, &resultInfo);
274     FreeAttribute(&attribute);
275 }
276 
HWTEST_F(ExecutorMessageTest, TestGetExecutorResultInfoFromAttribute, TestSize.Level0)277 HWTEST_F(ExecutorMessageTest, TestGetExecutorResultInfoFromAttribute, TestSize.Level0)
278 {
279     Attribute *attribute = CreateEmptyAttribute();
280     EXPECT_NE(attribute, nullptr);
281     ExecutorResultInfo resultInfo= {};
282     ResultCode result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
283     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
284     constexpr int32_t resultCode = 0;
285     result = SetAttributeInt32(attribute, ATTR_RESULT_CODE, resultCode);
286     EXPECT_EQ(result, RESULT_SUCCESS);
287     result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
288     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
289     constexpr uint64_t templateId = 123;
290     result = SetAttributeUint64(attribute, ATTR_TEMPLATE_ID, templateId);
291     EXPECT_EQ(result, RESULT_SUCCESS);
292     result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
293     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
294     constexpr uint64_t scheduleId = 234;
295     result = SetAttributeUint64(attribute, ATTR_SCHEDULE_ID, scheduleId);
296     EXPECT_EQ(result, RESULT_SUCCESS);
297     result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
298     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
299     constexpr uint64_t subType = 0;
300     result = SetAttributeUint64(attribute, ATTR_PIN_SUB_TYPE, subType);
301     EXPECT_EQ(result, RESULT_SUCCESS);
302     result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
303     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
304     constexpr int32_t remainTimes = 10;
305     result = SetAttributeInt32(attribute, ATTR_REMAIN_ATTEMPTS, remainTimes);
306     EXPECT_EQ(result, RESULT_SUCCESS);
307     result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
308     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
309     constexpr int32_t freezingTime = 0;
310     result = SetAttributeInt32(attribute, ATTR_LOCKOUT_DURATION, freezingTime);
311     EXPECT_EQ(result, RESULT_SUCCESS);
312     result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
313     EXPECT_EQ(result, RESULT_GENERAL_ERROR);
314     constexpr uint32_t capabilityLevel = 2;
315     result = SetAttributeUint32(attribute, ATTR_CAPABILITY_LEVEL, capabilityLevel);
316     EXPECT_EQ(result, RESULT_SUCCESS);
317     uint8_t testUint8Buffer[] = { 'a', 'b', 'c' };
318     Uint8Array rootSecret = { testUint8Buffer, sizeof(testUint8Buffer) };
319     result = SetAttributeUint8Array(attribute, ATTR_ROOT_SECRET, rootSecret);
320     EXPECT_EQ(result, RESULT_SUCCESS);
321     result = GetExecutorResultInfoFromAttribute(attribute, &resultInfo);
322     EXPECT_EQ(resultInfo.result, resultCode);
323     EXPECT_EQ(resultInfo.templateId, templateId);
324     EXPECT_EQ(resultInfo.remainTimes, remainTimes);
325     EXPECT_EQ(resultInfo.capabilityLevel, capabilityLevel);
326     FreeAttribute(&attribute);
327 }
328 
HWTEST_F(ExecutorMessageTest, TestCreateExecutorResultInfo, TestSize.Level0)329 HWTEST_F(ExecutorMessageTest, TestCreateExecutorResultInfo, TestSize.Level0)
330 {
331     Buffer *tlv = NULL;
332     ExecutorResultInfo *resultInfo = CreateExecutorResultInfo(tlv);
333     EXPECT_EQ(resultInfo, nullptr);
334     Attribute *attribute = CreateEmptyAttribute();
335     EXPECT_NE(attribute, nullptr);
336     constexpr int32_t resultCode = 0;
337     ResultCode result = SetAttributeInt32(attribute, ATTR_RESULT_CODE, resultCode);
338     EXPECT_EQ(result, RESULT_SUCCESS);
339     constexpr uint64_t templateId = 123;
340     result = SetAttributeUint64(attribute, ATTR_TEMPLATE_ID, templateId);
341     EXPECT_EQ(result, RESULT_SUCCESS);
342     constexpr uint64_t scheduleId = 234;
343     result = SetAttributeUint64(attribute, ATTR_SCHEDULE_ID, scheduleId);
344     EXPECT_EQ(result, RESULT_SUCCESS);
345     constexpr uint64_t subType = 0;
346     result = SetAttributeUint64(attribute, ATTR_PIN_SUB_TYPE, subType);
347     EXPECT_EQ(result, RESULT_SUCCESS);
348     constexpr int32_t remainTimes = 10;
349     result = SetAttributeInt32(attribute, ATTR_REMAIN_ATTEMPTS, remainTimes);
350     EXPECT_EQ(result, RESULT_SUCCESS);
351     constexpr int32_t freezingTime = 0;
352     result = SetAttributeInt32(attribute, ATTR_LOCKOUT_DURATION, freezingTime);
353     EXPECT_EQ(result, RESULT_SUCCESS);
354     constexpr uint32_t capabilityLevel = 2;
355     result = SetAttributeUint32(attribute, ATTR_CAPABILITY_LEVEL, capabilityLevel);
356     EXPECT_EQ(result, RESULT_SUCCESS);
357     constexpr uint32_t dataLen = 120;
358     std::vector<uint8_t> data;
359     data.resize(dataLen);
360     Uint8Array retExtraInfo = { data.data(), data.size() };
361     SignParam signParam = { .needSignature = false };
362     result = GetAttributeExecutorMsg(attribute, &retExtraInfo, signParam);
363     EXPECT_EQ(result, RESULT_SUCCESS);
364     Buffer *buf = CreateBufferByData(retExtraInfo.data, retExtraInfo.len);
365     EXPECT_NE(buf, nullptr);
366     resultInfo = CreateExecutorResultInfo(buf);
367     EXPECT_EQ(resultInfo, nullptr);
368     DestoryBuffer(buf);
369     FreeAttribute(&attribute);
370 }
371 
HWTEST_F(ExecutorMessageTest, TestDestroyExecutorResultInfo, TestSize.Level0)372 HWTEST_F(ExecutorMessageTest, TestDestroyExecutorResultInfo, TestSize.Level0)
373 {
374     DestroyExecutorResultInfo(nullptr);
375     ExecutorResultInfo *info1 = new ExecutorResultInfo();
376     EXPECT_NE(info1, nullptr);
377     info1->rootSecret = CreateBufferBySize(10);
378     DestroyExecutorResultInfo(info1);
379     ExecutorResultInfo *info2 = new ExecutorResultInfo();
380     EXPECT_NE(info2, nullptr);
381     info2->rootSecret = nullptr;
382     DestroyExecutorResultInfo(info2);
383 }
384 
HWTEST_F(ExecutorMessageTest, TestCreateExecutorMsg, TestSize.Level0)385 HWTEST_F(ExecutorMessageTest, TestCreateExecutorMsg, TestSize.Level0)
386 {
387     EXPECT_EQ(CreateExecutorMsg(1, 0, nullptr), nullptr);
388     constexpr uint32_t dataLen = 1;
389     Uint64Array array = {};
390     array.len = dataLen;
391     array.data = nullptr;
392     EXPECT_EQ(CreateExecutorMsg(1, 0, &array), nullptr);
393 }
394 
HWTEST_F(ExecutorMessageTest, TestDestoryExecutorMsg, TestSize.Level0)395 HWTEST_F(ExecutorMessageTest, TestDestoryExecutorMsg, TestSize.Level0)
396 {
397     DestoryExecutorMsg(nullptr);
398     ExecutorMsg *msg = (ExecutorMsg *)Malloc(sizeof(ExecutorMsg));
399     EXPECT_NE(msg, nullptr);
400     ASSERT_NE(msg, nullptr);
401     (void)memset_s(msg, sizeof(ExecutorMsg), 0, sizeof(ExecutorMsg));
402     DestoryExecutorMsg(msg);
403 }
404 
HWTEST_F(ExecutorMessageTest, TestGetExecutorTemplateList, TestSize.Level0)405 HWTEST_F(ExecutorMessageTest, TestGetExecutorTemplateList, TestSize.Level0)
406 {
407     constexpr uint32_t authType1 = 1;
408     constexpr uint32_t authType2 = 2;
409     constexpr uint32_t executorSensorHint = 10;
410     g_userInfoList = nullptr;
411     ExecutorInfoHal info = {};
412     info.authType = authType1;
413     info.executorSensorHint = executorSensorHint;
414     Uint64Array array = {};
415     EXPECT_EQ(GetExecutorTemplateList(0, &info, &array), RESULT_UNKNOWN);
416     g_userInfoList = CreateLinkedList(DestroyUserInfoNode);
417     EXPECT_NE(g_userInfoList, nullptr);
418     UserInfo userInfo = {};
419     userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode);
420     EXPECT_NE(userInfo.credentialInfoList, nullptr);
421     CredentialInfoHal credInfo = {};
422     credInfo.authType = authType1;
423     credInfo.executorSensorHint = executorSensorHint;
424     constexpr uint32_t credNum = 102;
425     for (uint32_t i = 0; i < credNum; ++i) {
426         userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credInfo));
427     }
428     g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo));
429     EXPECT_EQ(GetExecutorTemplateList(0, &info, &array), RESULT_REACH_LIMIT);
430     info.authType = authType2;
431     EXPECT_EQ(GetExecutorTemplateList(0, &info, &array), RESULT_SUCCESS);
432 }
433 
HWTEST_F(ExecutorMessageTest, TestAssemblyMessage_001, TestSize.Level0)434 HWTEST_F(ExecutorMessageTest, TestAssemblyMessage_001, TestSize.Level0)
435 {
436     constexpr uint32_t authType = 2;
437     constexpr uint32_t executorSensorHint = 10;
438     g_userInfoList = nullptr;
439     ExecutorInfoHal info = {};
440     info.authType = authType;
441     info.executorSensorHint = executorSensorHint;
442     EXPECT_EQ(AssemblyMessage(0, &info, 2, nullptr), RESULT_UNKNOWN);
443 }
444 
HWTEST_F(ExecutorMessageTest, TestAssemblyMessage_002, TestSize.Level0)445 HWTEST_F(ExecutorMessageTest, TestAssemblyMessage_002, TestSize.Level0)
446 {
447     constexpr uint32_t authType = 1;
448     constexpr uint32_t executorSensorHint_1 = 10;
449     constexpr uint32_t executorSensorHint_2 = 20;
450     g_userInfoList = CreateLinkedList(DestroyUserInfoNode);
451     EXPECT_NE(g_userInfoList, nullptr);
452     UserInfo *userInfo = static_cast<UserInfo *>(malloc(sizeof(UserInfo)));
453     EXPECT_NE(userInfo, nullptr);
454     static_cast<void>(memset_s(userInfo, sizeof(UserInfo), 0, sizeof(UserInfo)));
455     userInfo->credentialInfoList = CreateLinkedList(DestroyCredentialNode);
456     EXPECT_NE(userInfo->credentialInfoList, nullptr);
457     CredentialInfoHal *credInfo = static_cast<CredentialInfoHal *>(malloc(sizeof(CredentialInfoHal)));
458     EXPECT_NE(credInfo, nullptr);
459     static_cast<void>(memset_s(credInfo, sizeof(CredentialInfoHal), 0, sizeof(CredentialInfoHal)));
460     credInfo->authType = authType;
461     credInfo->executorSensorHint = executorSensorHint_1;
462     userInfo->credentialInfoList->insert(userInfo->credentialInfoList, static_cast<void *>(credInfo));
463     g_userInfoList->insert(g_userInfoList, static_cast<void *>(userInfo));
464 
465     ExecutorInfoHal info = {};
466     info.authType = authType;
467     info.executorSensorHint = executorSensorHint_2;
468     LinkedList *executorMsg = CreateLinkedList(DestoryExecutorMsg);
469     EXPECT_EQ(AssemblyMessage(0, &info, 2, executorMsg), RESULT_SUCCESS);
470     DestroyLinkedList(executorMsg);
471 
472     executorMsg = CreateLinkedList(DestoryExecutorMsg);
473     info.executorSensorHint = executorSensorHint_1;
474     EXPECT_EQ(AssemblyMessage(0, &info, 2, executorMsg), RESULT_SUCCESS);
475     DestroyLinkedList(executorMsg);
476     DestroyUserInfoList();
477 }
478 
HWTEST_F(ExecutorMessageTest, TestTraverseExecutor, TestSize.Level0)479 HWTEST_F(ExecutorMessageTest, TestTraverseExecutor, TestSize.Level0)
480 {
481     constexpr uint32_t authType = 2;
482     g_poolList = nullptr;
483     g_userInfoList = nullptr;
484     EXPECT_EQ(TraverseExecutor(0, 1, 0, nullptr), RESULT_UNKNOWN);
485     InitResourcePool();
486     ExecutorInfoHal info = {};
487     info.executorRole = VERIFIER;
488     info.authType = authType;
489     g_poolList->insert(g_poolList, static_cast<void *>(&info));
490     LinkedList *executorMsg = new LinkedList();
491     EXPECT_EQ(TraverseExecutor(0, 2, 0, executorMsg), RESULT_UNKNOWN);
492     delete executorMsg;
493 }
494 
HWTEST_F(ExecutorMessageTest, TestGetExecutorMsgList, TestSize.Level0)495 HWTEST_F(ExecutorMessageTest, TestGetExecutorMsgList, TestSize.Level0)
496 {
497     constexpr uint32_t authType = 1;
498     g_poolList = nullptr;
499     g_userInfoList = nullptr;
500     EXPECT_EQ(GetExecutorMsgList(1, 2, nullptr), RESULT_BAD_PARAM);
501     LinkedList *executorMsg = nullptr;
502     EXPECT_EQ(GetExecutorMsgList(1, 0, &executorMsg), RESULT_UNKNOWN);
503     InitResourcePool();
504     ExecutorInfoHal info = {};
505     info.executorRole = VERIFIER;
506     info.authType = authType;
507     g_poolList->insert(g_poolList, static_cast<void *>(&info));
508     EXPECT_EQ(GetExecutorMsgList(1, 4, &executorMsg), RESULT_SUCCESS);
509 }
510 } // namespace UserAuth
511 } // namespace UserIam
512 } // namespace OHOS
513