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(¶mSet);
89 EXPECT_EQ(ret, CF_SUCCESS);
90
91 ret = CfAddParams(paramSet, nullptr, 0);
92 EXPECT_NE(ret, CF_SUCCESS);
93
94 CfFreeParamSet(¶mSet);
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(¶mSet, 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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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(¶mSet);
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, ¶m);
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(¶mSet);
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(¶mSet);
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(¶mSet, CF_TAG_PARAM0_BUFFER, ¶m);
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(¶mSet, CF_TAG_PARAM0_BUFFER, ¶m);
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(¶mSet, CF_TAG_PARAM0_BUFFER, ¶m);
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(¶mSet);
348
349 CfParam *param = nullptr;
350 int32_t ret = CfGetParam(paramSet, CF_TAG_PARAM0_BOOL, ¶m);
351 EXPECT_EQ(ret, CF_SUCCESS);
352
353 CfFreeParamSet(¶mSet);
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 CfFreeParamSet(nullptr);
365 CfParamSet *paramSet = nullptr;
366 ConstrutParamSet(¶mSet);
367
368 CfParam *param = nullptr;
369 int32_t ret = CfGetParam(paramSet, CF_TAG_PARAM0_BUFFER, ¶m);
370 EXPECT_NE(ret, CF_SUCCESS);
371
372 CfFreeParamSet(¶mSet);
373 }
374
375 /**
376 * @tc.name: CfBuildParamSet001
377 * @tc.desc: test CfBuildParamSet paramSet is nullptr
378 * @tc.type: FUNC
379 * @tc.require: AR000HS2RB /SR000HS2Q1
380 */
381 HWTEST_F(CfParamTest, CfBuildParamSet001, TestSize.Level0)
382 {
383 int32_t ret = CfBuildParamSet(nullptr);
384 EXPECT_NE(ret, CF_SUCCESS);
385 }
386
387 /**
388 * @tc.name: CfBuildParamSet002
389 * @tc.desc: test CfBuildParamSet *paramSet is nullptr
390 * @tc.type: FUNC
391 * @tc.require: AR000HS2RB /SR000HS2Q1
392 */
393 HWTEST_F(CfParamTest, CfBuildParamSet002, TestSize.Level0)
394 {
395 CfParamSet *paramSet = nullptr;
396 int32_t ret = CfBuildParamSet(¶mSet);
397 EXPECT_NE(ret, CF_SUCCESS);
398 }
399
400 /**
401 * @tc.name: CfBuildParamSet003
402 * @tc.desc: test CfBuildParamSet paramSet size is invalid
403 * @tc.type: FUNC
404 * @tc.require: AR000HS2RB /SR000HS2Q1
405 */
406 HWTEST_F(CfParamTest, CfBuildParamSet003, TestSize.Level0)
407 {
408 CfParamSet *paramSet = nullptr;
409 int32_t ret = CfInitParamSet(¶mSet);
410 ASSERT_EQ(ret, CF_SUCCESS);
411 paramSet->paramSetSize = sizeof(CfParamSet) - 1;
412
413 ret = CfBuildParamSet(¶mSet);
414 EXPECT_NE(ret, CF_SUCCESS);
415
416 CfFreeParamSet(¶mSet);
417 }
418
419 /**
420 * @tc.name: CfBuildParamSet004
421 * @tc.desc: test CfBuildParamSet param tag blob size is invalid
422 * @tc.type: FUNC
423 * @tc.require: AR000HS2RB /SR000HS2Q1
424 */
425 HWTEST_F(CfParamTest, CfBuildParamSet004, TestSize.Level0)
426 {
427 CfParamSet *paramSet = nullptr;
428 int32_t ret = CfInitParamSet(¶mSet);
429 ASSERT_EQ(ret, CF_SUCCESS);
430
431 uint8_t tempBuf[] = "this is for test020";
432 paramSet->paramsCnt = 1;
433 paramSet->paramSetSize += sizeof(CfParam);
434 paramSet->params[0].tag = CF_TAG_PARAM1_BUFFER;
435 paramSet->params[0].blob.size = UINT32_MAX;
436 paramSet->params[0].blob.data = tempBuf;
437
438 ret = CfBuildParamSet(¶mSet);
439 EXPECT_NE(ret, CF_SUCCESS);
440
441 CfFreeParamSet(¶mSet);
442 }
443
444 /**
445 * @tc.name: CfBuildParamSet005
446 * @tc.desc: test CfBuildParamSet param tag blob data is invalid
447 * @tc.type: FUNC
448 * @tc.require: AR000HS2RB /SR000HS2Q1
449 */
450 HWTEST_F(CfParamTest, CfBuildParamSet005, TestSize.Level0)
451 {
452 CfParamSet *paramSet = nullptr;
453 int32_t ret = CfInitParamSet(¶mSet);
454 ASSERT_EQ(ret, CF_SUCCESS);
455
456 uint8_t tempBuf[] = "this is for test021";
457 paramSet->paramsCnt = 1;
458 paramSet->paramSetSize += sizeof(CfParam) + sizeof(tempBuf);
459 paramSet->params[0].tag = CF_TAG_PARAM0_BUFFER;
460 paramSet->params[0].blob.size = sizeof(tempBuf);
461 paramSet->params[0].blob.data = nullptr;
462
463 ret = CfBuildParamSet(¶mSet);
464 EXPECT_NE(ret, CF_SUCCESS);
465
466 CfFreeParamSet(¶mSet);
467 }
468
469 /**
470 * @tc.name: CfBuildParamSet006
471 * @tc.desc: test CfBuildParamSet paramSet size is invalid
472 * @tc.type: FUNC
473 * @tc.require: AR000HS2RB /SR000HS2Q1
474 */
475 HWTEST_F(CfParamTest, CfBuildParamSet006, TestSize.Level0)
476 {
477 CfParamSet *paramSet = nullptr;
478 int32_t ret = CfInitParamSet(¶mSet);
479 ASSERT_EQ(ret, CF_SUCCESS);
480
481 uint8_t tempBuf[] = "this is for test022";
482 paramSet->paramsCnt = 1;
483 paramSet->paramSetSize += sizeof(CfParam) + sizeof(tempBuf) + 1; /* invalid size */
484 paramSet->params[0].tag = CF_TAG_PARAM0_BUFFER;
485 paramSet->params[0].blob.size = sizeof(tempBuf);
486 paramSet->params[0].blob.data = tempBuf;
487
488 ret = CfBuildParamSet(¶mSet);
489 EXPECT_NE(ret, CF_SUCCESS);
490
491 CfFreeParamSet(¶mSet);
492 }
493 } // end of namespace
494