1 /*
2  * Copyright (c) 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 "cf_param.h"
19 #include "cf_result.h"
20 #include "cf_type.h"
21 
22 using namespace testing::ext;
23 namespace {
24 constexpr int32_t CF_TAG_PARAM0_BOOL = 0x1;
25 class CfParamTest : public testing::Test {
26 public:
27     static void SetUpTestCase(void);
28 
29     static void TearDownTestCase(void);
30 
31     void SetUp();
32 
33     void TearDown();
34 };
35 
SetUpTestCase(void)36 void CfParamTest::SetUpTestCase(void)
37 {
38 }
39 
TearDownTestCase(void)40 void CfParamTest::TearDownTestCase(void)
41 {
42 }
43 
SetUp()44 void CfParamTest::SetUp()
45 {
46 }
47 
TearDown()48 void CfParamTest::TearDown()
49 {
50 }
51 
52 /**
53 * @tc.name: CfInitParamSet001
54 * @tc.desc: test CfInitParamSet nullptr
55 * @tc.type: FUNC
56 * @tc.require: AR000HS2RB /SR000HS2Q1
57 */
58 HWTEST_F(CfParamTest, CfInitParamSet001, TestSize.Level0)
59 {
60     int32_t ret = CfInitParamSet(nullptr);
61     EXPECT_NE(ret, CF_SUCCESS);
62 }
63 
64 /**
65 * @tc.name: CfAddParams001
66 * @tc.desc: test CfAddParams paramSet is nullptr
67 * @tc.type: FUNC
68 * @tc.require: AR000HS2RB /SR000HS2Q1
69 */
70 HWTEST_F(CfParamTest, CfAddParams001, TestSize.Level0)
71 {
72     CfParam param[] = {
73         { .tag = CF_TAG_PARAM0_BOOL, .boolParam = false },
74     };
75     int32_t ret = CfAddParams(nullptr, param, sizeof(param) / sizeof(CfParam));
76     EXPECT_NE(ret, CF_SUCCESS);
77 }
78 
79 /**
80 * @tc.name: CfAddParams002
81 * @tc.desc: test CfAddParams param is nullptr
82 * @tc.type: FUNC
83 * @tc.require: AR000HS2RB /SR000HS2Q1
84 */
85 HWTEST_F(CfParamTest, CfAddParams002, TestSize.Level0)
86 {
87     CfParamSet *paramSet = nullptr;
88     int32_t ret = CfInitParamSet(&paramSet);
89     EXPECT_EQ(ret, CF_SUCCESS);
90 
91     ret = CfAddParams(paramSet, nullptr, 0);
92     EXPECT_NE(ret, CF_SUCCESS);
93 
94     CfFreeParamSet(&paramSet);
95 }
96 
97 /**
98 * @tc.name: CfAddParams003
99 * @tc.desc: test CfAddParams paramSet size is invalid
100 * @tc.type: FUNC
101 * @tc.require: AR000HS2RB /SR000HS2Q1
102 */
103 HWTEST_F(CfParamTest, CfAddParams003, TestSize.Level0)
104 {
105     CfParamSet paramSet = { CF_PARAM_SET_MAX_SIZE + 1, 0 };
106     CfParam param[] = {
107         { .tag = CF_TAG_PARAM0_BOOL, .boolParam = false },
108     };
109     int32_t ret = CfAddParams(&paramSet, param, sizeof(param) / sizeof(CfParam));
110     EXPECT_NE(ret, CF_SUCCESS);
111 }
112 
113 /**
114 * @tc.name: CfAddParams004
115 * @tc.desc: test CfAddParams param cnt is invalid
116 * @tc.type: FUNC
117 * @tc.require: AR000HS2RB /SR000HS2Q1
118 */
119 HWTEST_F(CfParamTest, CfAddParams004, TestSize.Level0)
120 {
121     CfParamSet *paramSet = nullptr;
122     int32_t ret = CfInitParamSet(&paramSet);
123     EXPECT_EQ(ret, CF_SUCCESS);
124 
125     CfParam param[] = {
126         { .tag = CF_TAG_PARAM0_BOOL, .boolParam = false },
127     };
128     ret = CfAddParams(paramSet, param, CF_DEFAULT_PARAM_CNT + 1);
129     EXPECT_NE(ret, CF_SUCCESS);
130 
131     CfFreeParamSet(&paramSet);
132 }
133 
134 /**
135 * @tc.name: CfAddParams005
136 * @tc.desc: test CfAddParams paramSet cnt is invalid
137 * @tc.type: FUNC
138 * @tc.require: AR000HS2RB /SR000HS2Q1
139 */
140 HWTEST_F(CfParamTest, CfAddParams005, TestSize.Level0)
141 {
142     CfParamSet *paramSet = nullptr;
143     int32_t ret = CfInitParamSet(&paramSet);
144     EXPECT_EQ(ret, CF_SUCCESS);
145     paramSet->paramsCnt = CF_DEFAULT_PARAM_CNT;
146 
147     CfParam param[] = {
148         { .tag = CF_TAG_PARAM0_BOOL, .boolParam = false },
149     };
150     ret = CfAddParams(paramSet, param, sizeof(param) / sizeof(CfParam));
151     EXPECT_NE(ret, CF_SUCCESS);
152 
153     CfFreeParamSet(&paramSet);
154 }
155 
156 /**
157 * @tc.name: CfAddParams006
158 * @tc.desc: test CfAddParams param tag blob.data is invalid
159 * @tc.type: FUNC
160 * @tc.require: AR000HS2RB /SR000HS2Q1
161 */
162 HWTEST_F(CfParamTest, CfAddParams006, TestSize.Level0)
163 {
164     CfParamSet *paramSet = nullptr;
165     int32_t ret = CfInitParamSet(&paramSet);
166     EXPECT_EQ(ret, CF_SUCCESS);
167 
168     CfBlob tempBlob = { 1, nullptr };
169     CfParam param[] = {
170         { .tag = CF_TAG_PARAM0_BUFFER, .blob = tempBlob },
171     };
172     ret = CfAddParams(paramSet, param, sizeof(param) / sizeof(CfParam));
173     EXPECT_NE(ret, CF_SUCCESS);
174 
175     CfFreeParamSet(&paramSet);
176 }
177 
178 /**
179 * @tc.name: CfAddParams007
180 * @tc.desc: test CfAddParams param tag blob.size is 0
181 * @tc.type: FUNC
182 * @tc.require: AR000HS2RB /SR000HS2Q1
183 */
184 HWTEST_F(CfParamTest, CfAddParams007, TestSize.Level0)
185 {
186     CfParamSet *paramSet = nullptr;
187     int32_t ret = CfInitParamSet(&paramSet);
188     EXPECT_EQ(ret, CF_SUCCESS);
189 
190     uint8_t tempBuf[] = "this is for test 007";
191     CfBlob tempBlob = { 0, tempBuf };
192     CfParam param[] = {
193         { .tag = CF_TAG_PARAM0_BUFFER, .blob = tempBlob },
194     };
195     ret = CfAddParams(paramSet, param, sizeof(param) / sizeof(CfParam));
196     EXPECT_NE(ret, CF_SUCCESS);
197 
198     CfFreeParamSet(&paramSet);
199 }
200 
201 /**
202 * @tc.name: CfAddParams008
203 * @tc.desc: test CfAddParams param size after add invalid
204 * @tc.type: FUNC
205 * @tc.require: AR000HS2RB /SR000HS2Q1
206 */
207 HWTEST_F(CfParamTest, CfAddParams008, TestSize.Level0)
208 {
209     CfParamSet *paramSet = nullptr;
210     int32_t ret = CfInitParamSet(&paramSet);
211     EXPECT_EQ(ret, CF_SUCCESS);
212 
213     paramSet->paramSetSize = CF_PARAM_SET_MAX_SIZE - 1; /* after add sizeof(tempBuf) invalid */
214 
215     uint8_t tempBuf[] = "this is for test 007";
216     CfBlob tempBlob = { sizeof(tempBuf), tempBuf };
217     CfParam param[] = {
218         { .tag = CF_TAG_PARAM0_BUFFER, .blob = tempBlob },
219         { .tag = CF_TAG_PARAM0_BOOL, .boolParam = false },
220     };
221     ret = CfAddParams(paramSet, param, sizeof(param) / sizeof(CfParam));
222     EXPECT_NE(ret, CF_SUCCESS);
223 
224     CfFreeParamSet(&paramSet);
225 }
226 
227 /**
228 * @tc.name: CfAddParams009
229 * @tc.desc: test CfAddParams param tag blob.size is invalid
230 * @tc.type: FUNC
231 * @tc.require: AR000HS2RB /SR000HS2Q1
232 */
233 HWTEST_F(CfParamTest, CfAddParams009, TestSize.Level0)
234 {
235     CfParamSet *paramSet = nullptr;
236     int32_t ret = CfInitParamSet(&paramSet);
237     EXPECT_EQ(ret, CF_SUCCESS);
238 
239     uint8_t tempBuf[] = "this is for test";
240     CfBlob tempBlob = { UINT32_MAX, tempBuf };
241     CfParam param[] = {
242         { .tag = CF_TAG_PARAM0_BUFFER, .blob = tempBlob },
243     };
244     ret = CfAddParams(paramSet, param, sizeof(param) / sizeof(CfParam));
245     EXPECT_NE(ret, CF_SUCCESS);
246 
247     CfFreeParamSet(&paramSet);
248 }
249 
250 /**
251 * @tc.name: CfGetParam001
252 * @tc.desc: test CfGetParam paramSet is nullptr
253 * @tc.type: FUNC
254 * @tc.require: AR000HS2RB /SR000HS2Q1
255 */
256 HWTEST_F(CfParamTest, CfGetParam001, TestSize.Level0)
257 {
258     CfParam *param = nullptr;
259     int32_t ret = CfGetParam(nullptr, CF_TAG_PARAM0_BUFFER, &param);
260     EXPECT_NE(ret, CF_SUCCESS);
261 }
262 
263 /**
264 * @tc.name: CfGetParam002
265 * @tc.desc: test CfGetParam out param is nullptr
266 * @tc.type: FUNC
267 * @tc.require: AR000HS2RB /SR000HS2Q1
268 */
269 HWTEST_F(CfParamTest, CfGetParam002, TestSize.Level0)
270 {
271     CfParamSet *paramSet = nullptr;
272     int32_t ret = CfInitParamSet(&paramSet);
273     EXPECT_EQ(ret, CF_SUCCESS);
274 
275     ret = CfGetParam(paramSet, CF_TAG_PARAM0_BUFFER, nullptr);
276     EXPECT_NE(ret, CF_SUCCESS);
277 
278     CfFreeParamSet(&paramSet);
279 }
280 
281 /**
282 * @tc.name: CfGetParam003
283 * @tc.desc: test CfGetParam paramSet size is invalid
284 * @tc.type: FUNC
285 * @tc.require: AR000HS2RB /SR000HS2Q1
286 */
287 HWTEST_F(CfParamTest, CfGetParam003, TestSize.Level0)
288 {
289     CfParamSet paramSet = {CF_PARAM_SET_MAX_SIZE + 1, 1 };
290     CfParam *param = nullptr;
291     int32_t ret = CfGetParam(&paramSet, CF_TAG_PARAM0_BUFFER, &param);
292     EXPECT_NE(ret, CF_SUCCESS);
293 }
294 
295 /**
296 * @tc.name: CfGetParam004
297 * @tc.desc: test CfGetParam paramSet size is invalid (smaller than struct size)
298 * @tc.type: FUNC
299 * @tc.require: AR000HS2RB /SR000HS2Q1
300 */
301 HWTEST_F(CfParamTest, CfGetParam004, TestSize.Level0)
302 {
303     CfParamSet paramSet = { sizeof(CfParamSet) - 1, 1 };
304     CfParam *param = nullptr;
305     int32_t ret = CfGetParam(&paramSet, CF_TAG_PARAM0_BUFFER, &param);
306     EXPECT_NE(ret, CF_SUCCESS);
307 }
308 
309 /**
310 * @tc.name: CfGetParam005
311 * @tc.desc: test CfGetParam paramSet cnt is invalid
312 * @tc.type: FUNC
313 * @tc.require: AR000HS2RB /SR000HS2Q1
314 */
315 HWTEST_F(CfParamTest, CfGetParam005, TestSize.Level0)
316 {
317     CfParamSet paramSet = { sizeof(CfParamSet), 1 };
318     CfParam *param = nullptr;
319     int32_t ret = CfGetParam(&paramSet, CF_TAG_PARAM0_BUFFER, &param);
320     EXPECT_NE(ret, CF_SUCCESS);
321 }
322 
ConstrutParamSet(CfParamSet ** paramSet)323 static void ConstrutParamSet(CfParamSet **paramSet)
324 {
325     int32_t ret = CfInitParamSet(paramSet);
326     EXPECT_EQ(ret, CF_SUCCESS);
327 
328     CfParam param[] = {
329         { .tag = CF_TAG_PARAM0_BOOL, .boolParam = false },
330     };
331     ret = CfAddParams(*paramSet, param, sizeof(param) / sizeof(CfParam));
332     EXPECT_EQ(ret, CF_SUCCESS);
333 
334     ret = CfBuildParamSet(paramSet);
335     EXPECT_EQ(ret, CF_SUCCESS);
336 }
337 
338 /**
339 * @tc.name: CfGetParam006
340 * @tc.desc: test CfGetParam normal testcase
341 * @tc.type: FUNC
342 * @tc.require: AR000HS2RB /SR000HS2Q1
343 */
344 HWTEST_F(CfParamTest, CfGetParam006, TestSize.Level0)
345 {
346     CfParamSet *paramSet = nullptr;
347     ConstrutParamSet(&paramSet);
348 
349     CfParam *param = nullptr;
350     int32_t ret = CfGetParam(paramSet, CF_TAG_PARAM0_BOOL, &param);
351     EXPECT_EQ(ret, CF_SUCCESS);
352 
353     CfFreeParamSet(&paramSet);
354 }
355 
356 /**
357 * @tc.name: CfGetParam007
358 * @tc.desc: test CfGetParam param not exist
359 * @tc.type: FUNC
360 * @tc.require: AR000HS2RB /SR000HS2Q1
361 */
362 HWTEST_F(CfParamTest, CfGetParam007, TestSize.Level0)
363 {
364     CfParamSet *paramSet = nullptr;
365     ConstrutParamSet(&paramSet);
366 
367     CfParam *param = nullptr;
368     int32_t ret = CfGetParam(paramSet, CF_TAG_PARAM0_BUFFER, &param);
369     EXPECT_NE(ret, CF_SUCCESS);
370 
371     CfFreeParamSet(&paramSet);
372 }
373 
374 /**
375 * @tc.name: CfFreeParamSet001
376 * @tc.desc: test CfFreeParamSet paramSet is nullptr
377 * @tc.type: FUNC
378 * @tc.require: AR000HS2RB /SR000HS2Q1
379 */
380 HWTEST_F(CfParamTest, CfFreeParamSet001, TestSize.Level0)
381 {
382     CfFreeParamSet(nullptr);
383 }
384 
385 /**
386 * @tc.name: CfBuildParamSet001
387 * @tc.desc: test CfBuildParamSet paramSet is nullptr
388 * @tc.type: FUNC
389 * @tc.require: AR000HS2RB /SR000HS2Q1
390 */
391 HWTEST_F(CfParamTest, CfBuildParamSet001, TestSize.Level0)
392 {
393     int32_t ret = CfBuildParamSet(nullptr);
394     EXPECT_NE(ret, CF_SUCCESS);
395 }
396 
397 /**
398 * @tc.name: CfBuildParamSet002
399 * @tc.desc: test CfBuildParamSet *paramSet is nullptr
400 * @tc.type: FUNC
401 * @tc.require: AR000HS2RB /SR000HS2Q1
402 */
403 HWTEST_F(CfParamTest, CfBuildParamSet002, TestSize.Level0)
404 {
405     CfParamSet *paramSet = nullptr;
406     int32_t ret = CfBuildParamSet(&paramSet);
407     EXPECT_NE(ret, CF_SUCCESS);
408 }
409 
410 /**
411 * @tc.name: CfBuildParamSet003
412 * @tc.desc: test CfBuildParamSet paramSet size is invalid
413 * @tc.type: FUNC
414 * @tc.require: AR000HS2RB /SR000HS2Q1
415 */
416 HWTEST_F(CfParamTest, CfBuildParamSet003, TestSize.Level0)
417 {
418     CfParamSet *paramSet = nullptr;
419     int32_t ret = CfInitParamSet(&paramSet);
420     EXPECT_EQ(ret, CF_SUCCESS);
421     if (ret != CF_SUCCESS) {
422         return;
423     }
424     paramSet->paramSetSize = sizeof(CfParamSet) - 1;
425 
426     ret = CfBuildParamSet(&paramSet);
427     EXPECT_NE(ret, CF_SUCCESS);
428 
429     CfFreeParamSet(&paramSet);
430 }
431 
432 /**
433 * @tc.name: CfBuildParamSet004
434 * @tc.desc: test CfBuildParamSet param tag blob size is invalid
435 * @tc.type: FUNC
436 * @tc.require: AR000HS2RB /SR000HS2Q1
437 */
438 HWTEST_F(CfParamTest, CfBuildParamSet004, TestSize.Level0)
439 {
440     CfParamSet *paramSet = nullptr;
441     int32_t ret = CfInitParamSet(&paramSet);
442     EXPECT_EQ(ret, CF_SUCCESS);
443     if (ret != CF_SUCCESS) {
444         return;
445     }
446 
447     uint8_t tempBuf[] = "this is for test020";
448     paramSet->paramsCnt = 1;
449     paramSet->paramSetSize += sizeof(CfParam);
450     paramSet->params[0].tag = CF_TAG_PARAM1_BUFFER;
451     paramSet->params[0].blob.size = UINT32_MAX;
452     paramSet->params[0].blob.data = tempBuf;
453 
454     ret = CfBuildParamSet(&paramSet);
455     EXPECT_NE(ret, CF_SUCCESS);
456 
457     CfFreeParamSet(&paramSet);
458 }
459 
460 /**
461 * @tc.name: CfBuildParamSet005
462 * @tc.desc: test CfBuildParamSet param tag blob data is invalid
463 * @tc.type: FUNC
464 * @tc.require: AR000HS2RB /SR000HS2Q1
465 */
466 HWTEST_F(CfParamTest, CfBuildParamSet005, TestSize.Level0)
467 {
468     CfParamSet *paramSet = nullptr;
469     int32_t ret = CfInitParamSet(&paramSet);
470     EXPECT_EQ(ret, CF_SUCCESS);
471     if (ret != CF_SUCCESS) {
472         return;
473     }
474 
475     uint8_t tempBuf[] = "this is for test021";
476     paramSet->paramsCnt = 1;
477     paramSet->paramSetSize += sizeof(CfParam) + sizeof(tempBuf);
478     paramSet->params[0].tag = CF_TAG_PARAM0_BUFFER;
479     paramSet->params[0].blob.size = sizeof(tempBuf);
480     paramSet->params[0].blob.data = nullptr;
481 
482     ret = CfBuildParamSet(&paramSet);
483     EXPECT_NE(ret, CF_SUCCESS);
484 
485     CfFreeParamSet(&paramSet);
486 }
487 
488 /**
489 * @tc.name: CfBuildParamSet006
490 * @tc.desc: test CfBuildParamSet paramSet size is invalid
491 * @tc.type: FUNC
492 * @tc.require: AR000HS2RB /SR000HS2Q1
493 */
494 HWTEST_F(CfParamTest, CfBuildParamSet006, TestSize.Level0)
495 {
496     CfParamSet *paramSet = nullptr;
497     int32_t ret = CfInitParamSet(&paramSet);
498     EXPECT_EQ(ret, CF_SUCCESS);
499     if (ret != CF_SUCCESS) {
500         return;
501     }
502 
503     uint8_t tempBuf[] = "this is for test022";
504     paramSet->paramsCnt = 1;
505     paramSet->paramSetSize += sizeof(CfParam) + sizeof(tempBuf) + 1; /* invalid size */
506     paramSet->params[0].tag = CF_TAG_PARAM0_BUFFER;
507     paramSet->params[0].blob.size = sizeof(tempBuf);
508     paramSet->params[0].blob.data = tempBuf;
509 
510     ret = CfBuildParamSet(&paramSet);
511     EXPECT_NE(ret, CF_SUCCESS);
512 
513     CfFreeParamSet(&paramSet);
514 }
515 } // end of namespace
516