• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
23 extern "C" {
24     extern LinkedList *g_poolList;
25     extern LinkedList *g_scheduleList;
26     extern bool IsScheduleMatch(const void *data, const void *condition);
27     extern bool IsScheduleIdDuplicate(uint64_t scheduleId);
28     extern ResultCode GenerateValidScheduleId(uint64_t *scheduleId);
29     extern ResultCode MountExecutorOnce(const LinkedList *executors, CoAuthSchedule *coAuthSchedule,
30         uint32_t sensorHint, uint32_t executorRole);
31     extern void DestroyExecutorInfo(void *data);
32     extern ResultCode MountExecutor(const ScheduleParam *param, CoAuthSchedule *coAuthSchedule);
33 }
34 
35 namespace OHOS {
36 namespace UserIam {
37 namespace UserAuth {
38 using namespace testing;
39 using namespace testing::ext;
40 
41 class CoAuthTest : public testing::Test {
42 public:
SetUpTestCase()43     static void SetUpTestCase() {};
44 
TearDownTestCase()45     static void TearDownTestCase() {};
46 
SetUp()47     void SetUp() {};
48 
TearDown()49     void TearDown() {};
50 };
51 
52 HWTEST_F(CoAuthTest, TestDestroyScheduleNode, TestSize.Level0)
53 {
54     DestroyScheduleNode(nullptr);
55     CoAuthSchedule *schedule = (CoAuthSchedule *)Malloc(sizeof(CoAuthSchedule));
56     EXPECT_NE(schedule, nullptr);
57     ASSERT_NE(schedule, nullptr);
58     (void)memset_s(schedule, sizeof(CoAuthSchedule), 0, sizeof(CoAuthSchedule));
59     schedule->templateIds.data = (uint64_t *)Malloc(sizeof(uint64_t));
60     EXPECT_NE(schedule->templateIds.data, nullptr);
61     ASSERT_NE(schedule->templateIds.data, nullptr);
62     schedule->templateIds.len = 1;
63     DestroyScheduleNode(schedule);
64 }
65 
66 HWTEST_F(CoAuthTest, TestCopyCoAuthSchedule, TestSize.Level0)
67 {
68     EXPECT_EQ(CopyCoAuthSchedule(nullptr), nullptr);
69     CoAuthSchedule schedule = {};
70     schedule.templateIds.len = 1;
71     schedule.templateIds.data = nullptr;
72     EXPECT_EQ(CopyCoAuthSchedule(&schedule), nullptr);
73 }
74 
75 HWTEST_F(CoAuthTest, TestDestroyCoAuthSchedule, TestSize.Level0)
76 {
77     DestroyCoAuthSchedule(nullptr);
78     CoAuthSchedule *schedule = (CoAuthSchedule *)Malloc(sizeof(CoAuthSchedule));
79     EXPECT_NE(schedule, nullptr);
80     ASSERT_NE(schedule, nullptr);
81     (void)memset_s(schedule, sizeof(CoAuthSchedule), 0, sizeof(CoAuthSchedule));
82     schedule->templateIds.data = (uint64_t *)Malloc(sizeof(uint64_t));
83     EXPECT_NE(schedule->templateIds.data, nullptr);
84     ASSERT_NE(schedule->templateIds.data, nullptr);
85     schedule->templateIds.len = 1;
86     DestroyCoAuthSchedule(schedule);
87 }
88 
89 HWTEST_F(CoAuthTest, TestInitCoAuth, TestSize.Level0)
90 {
91     InitCoAuth();
92     EXPECT_EQ(InitCoAuth(), RESULT_SUCCESS);
93     DestoryCoAuth();
94 }
95 
96 HWTEST_F(CoAuthTest, TestAddCoAuthSchedule, TestSize.Level0)
97 {
98     g_scheduleList = nullptr;
99     EXPECT_EQ(AddCoAuthSchedule(nullptr), RESULT_NEED_INIT);
100     InitCoAuth();
101     EXPECT_EQ(AddCoAuthSchedule(nullptr), RESULT_BAD_PARAM);
102     CoAuthSchedule schedule = {};
103     schedule.templateIds.len = 1;
104     schedule.templateIds.data = nullptr;
105     EXPECT_EQ(AddCoAuthSchedule(&schedule), RESULT_NO_MEMORY);
106     DestoryCoAuth();
107 }
108 
109 HWTEST_F(CoAuthTest, TestIsScheduleMatch, TestSize.Level0)
110 {
111     EXPECT_FALSE(IsScheduleMatch(nullptr, nullptr));
112 }
113 
114 HWTEST_F(CoAuthTest, TestRemoveCoAuthSchedule, TestSize.Level0)
115 {
116     g_scheduleList = nullptr;
117     uint64_t scheduleId = 32565;
118     EXPECT_EQ(RemoveCoAuthSchedule(scheduleId), RESULT_NEED_INIT);
119 }
120 
121 HWTEST_F(CoAuthTest, TestGetCoAuthSchedule, TestSize.Level0)
122 {
123     g_scheduleList = nullptr;
124     uint64_t scheduleId = 32565;
125     EXPECT_EQ(GetCoAuthSchedule(scheduleId), nullptr);
126     InitCoAuth();
127     CoAuthSchedule schedule1 = {};
128     schedule1.scheduleId = 32565;
129     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule1));
130     CoAuthSchedule schedule2 = {};
131     schedule2.scheduleId = 3200;
132     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule2));
133     g_scheduleList->insert(g_scheduleList, nullptr);
134     EXPECT_NE(GetCoAuthSchedule(scheduleId), nullptr);
135 }
136 
137 HWTEST_F(CoAuthTest, TestIsScheduleIdDuplicate, TestSize.Level0)
138 {
139     g_scheduleList = nullptr;
140     uint64_t scheduleId = 36163;
141     InitCoAuth();
142     EXPECT_FALSE(IsScheduleIdDuplicate(scheduleId));
143     CoAuthSchedule schedule1 = {};
144     schedule1.scheduleId = 36163;
145     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule1));
146     CoAuthSchedule schedule2 = {};
147     schedule2.scheduleId = 3200;
148     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule2));
149     g_scheduleList->insert(g_scheduleList, nullptr);
150     EXPECT_TRUE(IsScheduleIdDuplicate(scheduleId));
151 }
152 
153 HWTEST_F(CoAuthTest, TestGenerateValidScheduleId, TestSize.Level0)
154 {
155     g_scheduleList = nullptr;
156     uint64_t scheduleId = 0;
157     EXPECT_EQ(GenerateValidScheduleId(&scheduleId), RESULT_BAD_PARAM);
158 }
159 
160 HWTEST_F(CoAuthTest, TestMountExecutorOnce_001, TestSize.Level0)
161 {
162     LinkedList *executor = CreateLinkedList(DestroyExecutorInfo);
163     CoAuthSchedule schedule = {};
164     uint32_t sensorHint = 3565;
165     uint32_t executorRole = 6636;
166     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, executorRole), RESULT_NOT_FOUND);
167     executor->insert(executor, nullptr);
168     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, executorRole), RESULT_UNKNOWN);
169 }
170 
171 HWTEST_F(CoAuthTest, TestMountExecutorOnce_002, TestSize.Level0)
172 {
173     LinkedList *executor = CreateLinkedList(DestroyExecutorInfo);
174     CoAuthSchedule schedule = {};
175     uint32_t sensorHint = 0;
176     uint32_t executorRole = 6636;
177     ExecutorInfoHal info1 = {};
178     info1.executorRole = 6636;
179     info1.executorSensorHint = 10;
180     executor->insert(executor, static_cast<void *>(&info1));
181     ExecutorInfoHal info2 = {};
182     info2.executorRole = 6636;
183     info2.executorSensorHint = 20;
184     executor->insert(executor, static_cast<void *>(&info2));
185     ExecutorInfoHal info3 = {};
186     info3.executorRole = 6110;
187     executor->insert(executor, static_cast<void *>(&info3));
188     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, executorRole), RESULT_SUCCESS);
189     sensorHint = 10;
190     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, executorRole), RESULT_SUCCESS);
191 }
192 
193 HWTEST_F(CoAuthTest, TestMountExecutor_001, TestSize.Level0)
194 {
195     g_poolList = nullptr;
196     ScheduleParam param = {};
197     param.collectorSensorHint = 1012;
198     CoAuthSchedule schedule = {};
199     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_UNKNOWN);
200     InitResourcePool();
201     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
202     DestroyResourcePool();
203 }
204 
205 HWTEST_F(CoAuthTest, TestMountExecutor_002, TestSize.Level0)
206 {
207     InitResourcePool();
208     ScheduleParam param = {};
209     param.collectorSensorHint = 0;
210     param.verifierSensorHint = 0;
211     CoAuthSchedule schedule = {};
212     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
213     param.verifierSensorHint = 1024;
214     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
215     DestroyResourcePool();
216 }
217 
218 HWTEST_F(CoAuthTest, TestMountExecutor_003, TestSize.Level0)
219 {
220     InitResourcePool();
221     ScheduleParam param = {};
222     param.collectorSensorHint = 1024;
223     param.collectorSensorHint = 0;
224     CoAuthSchedule schedule = {};
225     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
226     param.collectorSensorHint = 10;
227     param.verifierSensorHint = 0;
228     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
229     param.verifierSensorHint = 10;
230     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
231     param.verifierSensorHint = 20;
232     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
233     DestroyResourcePool();
234 }
235 
236 HWTEST_F(CoAuthTest, TestMountExecutor_004, TestSize.Level0)
237 {
238     g_poolList = nullptr;
239     InitResourcePool();
240     ExecutorInfoHal info = {};
241     info.authType = 1;
242     info.executorRole = 3;
243     info.executorSensorHint = 10;
244     g_poolList->insert(g_poolList, static_cast<void *>(&info));
245 
246     ScheduleParam param = {};
247     param.authType = 1;
248     param.collectorSensorHint = 0;
249     param.verifierSensorHint = 0;
250     CoAuthSchedule schedule = {};
251     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_SUCCESS);
252 }
253 
254 HWTEST_F(CoAuthTest, TestMountExecutor_005, TestSize.Level0)
255 {
256     g_poolList = nullptr;
257     InitResourcePool();
258     ExecutorInfoHal info = {};
259     info.authType = 1;
260     info.executorRole = 3;
261     info.executorSensorHint = 10;
262     g_poolList->insert(g_poolList, static_cast<void *>(&info));
263 
264     ScheduleParam param = {};
265     param.authType = 1;
266     param.collectorSensorHint = 101;
267     param.verifierSensorHint = 201;
268     param.scheduleMode = SCHEDULE_MODE_IDENTIFY;
269     CoAuthSchedule schedule = {};
270     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_GENERAL_ERROR);
271     param.scheduleMode = SCHEDULE_MODE_AUTH;
272     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
273     param.verifierSensorHint = 10;
274     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
275     param.collectorSensorHint = 10;
276     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_SUCCESS);
277 }
278 
279 HWTEST_F(CoAuthTest, TestGetScheduleVeriferSensorHint_001, TestSize.Level0)
280 {
281     EXPECT_EQ(GetScheduleVeriferSensorHint(nullptr), INVALID_SENSOR_HINT);
282     CoAuthSchedule schedule = {};
283     ExecutorInfoHal info = {};
284     info.executorSensorHint = 10;
285     info.executorRole = VERIFIER;
286     schedule.executorSize = 1;
287     schedule.executors[0] = info;
288     EXPECT_EQ(GetScheduleVeriferSensorHint(&schedule), info.executorSensorHint);
289 }
290 
291 HWTEST_F(CoAuthTest, TestGetScheduleVeriferSensorHint_002, TestSize.Level0)
292 {
293     CoAuthSchedule schedule = {};
294     ExecutorInfoHal info = {};
295     info.executorSensorHint = 10;
296     info.executorRole = COLLECTOR;
297     schedule.executorSize = 1;
298     schedule.executors[0] = info;
299     EXPECT_EQ(GetScheduleVeriferSensorHint(&schedule), INVALID_SENSOR_HINT);
300     schedule.executors[0].executorRole = ALL_IN_ONE;
301     EXPECT_EQ(GetScheduleVeriferSensorHint(&schedule), info.executorSensorHint);
302 }
303 
304 HWTEST_F(CoAuthTest, TestGenerateSchedule_001, TestSize.Level0)
305 {
306     EXPECT_EQ(GenerateSchedule(nullptr), nullptr);
307     g_scheduleList = nullptr;
308     ScheduleParam param = {};
309     EXPECT_EQ(GenerateSchedule(&param), nullptr);
310 }
311 
312 HWTEST_F(CoAuthTest, TestGenerateSchedule_002, TestSize.Level0)
313 {
314     g_scheduleList = nullptr;
315     InitCoAuth();
316     ScheduleParam param = {};
317     param.templateIds = nullptr;
318     EXPECT_EQ(GenerateSchedule(&param), nullptr);
319     Uint64Array array = {};
320     array.len = 1;
321     array.data = nullptr;
322     param.templateIds = &array;
323     EXPECT_EQ(GenerateSchedule(&param), nullptr);
324     uint64_t temp = 1024;
325     array.data = &temp;
326     EXPECT_EQ(GenerateSchedule(&param), nullptr);
327 }
328 
329 HWTEST_F(CoAuthTest, TestIsTemplateArraysValid, TestSize.Level0)
330 {
331     EXPECT_FALSE(IsTemplateArraysValid(nullptr));
332     Uint64Array array = {};
333     array.len = 200;
334     array.data = nullptr;
335     EXPECT_FALSE(IsTemplateArraysValid(&array));
336     array.len = 1;
337     EXPECT_FALSE(IsTemplateArraysValid(&array));
338     uint64_t temp = 1024;
339     array.data = &temp;
340     EXPECT_TRUE(IsTemplateArraysValid(&array));
341     array.len = 0;
342     EXPECT_TRUE(IsTemplateArraysValid(&array));
343 }
344 
345 HWTEST_F(CoAuthTest, TestCopyTemplateArrays, TestSize.Level0)
346 {
347     EXPECT_EQ(CopyTemplateArrays(nullptr, nullptr), RESULT_BAD_PARAM);
348     Uint64Array inArray = {};
349     inArray.len = 1;
350     uint64_t temp = 1024;
351     inArray.data = &temp;
352     EXPECT_EQ(CopyTemplateArrays(&inArray, nullptr), RESULT_BAD_PARAM);
353     Uint64Array outArray = {};
354     uint64_t num = 0;
355     outArray.data = &num;
356     EXPECT_EQ(CopyTemplateArrays(&inArray, &outArray), RESULT_BAD_PARAM);
357     outArray.data = nullptr;
358     EXPECT_EQ(CopyTemplateArrays(&inArray, &outArray), RESULT_SUCCESS);
359     inArray.len = 0;
360     outArray.data = nullptr;
361     EXPECT_EQ(CopyTemplateArrays(&inArray, &outArray), RESULT_SUCCESS);
362 }
363 } // namespace UserAuth
364 } // namespace UserIam
365 } // namespace OHOS
366