1 /*
2 * Copyright (c) 2022-2025 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 "cm_param.h"
19 #include "cm_type.h"
20
21 using namespace testing::ext;
22 namespace {
23 class CmParamTest : public testing::Test {
24 public:
25 static void SetUpTestCase(void);
26
27 static void TearDownTestCase(void);
28
29 void SetUp();
30
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void CmParamTest::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void CmParamTest::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void CmParamTest::SetUp()
43 {
44 }
45
TearDown()46 void CmParamTest::TearDown()
47 {
48 }
49
50 /**
51 * @tc.name: CmParamTest001
52 * @tc.desc: test CmInitParamSet nullptr
53 * @tc.type: FUNC
54 * @tc.require: AR000H0MIA /SR000H09NA
55 */
56 HWTEST_F(CmParamTest, CmParamTest001, TestSize.Level0)
57 {
58 int32_t ret = CmInitParamSet(nullptr);
59 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
60 }
61
62 /**
63 * @tc.name: CmParamTest002
64 * @tc.desc: test CmAddParams paramSet is nullptr
65 * @tc.type: FUNC
66 * @tc.require: AR000H0MIA /SR000H09NA
67 */
68 HWTEST_F(CmParamTest, CmParamTest002, TestSize.Level0)
69 {
70 struct CmParam param[] = {
71 { .tag = CM_TAG_PARAM0_BOOL, .boolParam = false },
72 };
73 int32_t ret = CmAddParams(nullptr, param, sizeof(param) / sizeof(struct CmParam));
74 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
75 }
76
77 /**
78 * @tc.name: CmParamTest003
79 * @tc.desc: test CmAddParams param is nullptr
80 * @tc.type: FUNC
81 * @tc.require: AR000H0MIA /SR000H09NA
82 */
83 HWTEST_F(CmParamTest, CmParamTest003, TestSize.Level0)
84 {
85 struct CmParamSet *paramSet = nullptr;
86 int32_t ret = CmInitParamSet(¶mSet);
87 EXPECT_EQ(ret, CM_SUCCESS);
88
89 ret = CmAddParams(paramSet, nullptr, 0);
90 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
91
92 CmFreeParamSet(¶mSet);
93 }
94
95 /**
96 * @tc.name: CmParamTest004
97 * @tc.desc: test CmAddParams paramSet size is invalid
98 * @tc.type: FUNC
99 * @tc.require: AR000H0MIA /SR000H09NA
100 */
101 HWTEST_F(CmParamTest, CmParamTest004, TestSize.Level0)
102 {
103 struct CmParamSet paramSet = { CM_PARAM_SET_MAX_SIZE + 1, 0 };
104 struct CmParam param[] = {
105 { .tag = CM_TAG_PARAM0_BOOL, .boolParam = false },
106 };
107 int32_t ret = CmAddParams(¶mSet, param, sizeof(param) / sizeof(struct CmParam));
108 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
109 }
110
111 /**
112 * @tc.name: CmParamTest005
113 * @tc.desc: test CmAddParams param cnt is invalid
114 * @tc.type: FUNC
115 * @tc.require: AR000H0MIA /SR000H09NA
116 */
117 HWTEST_F(CmParamTest, CmParamTest005, TestSize.Level0)
118 {
119 struct CmParamSet *paramSet = nullptr;
120 int32_t ret = CmInitParamSet(¶mSet);
121 EXPECT_EQ(ret, CM_SUCCESS);
122
123 struct CmParam param[] = {
124 { .tag = CM_TAG_PARAM0_BOOL, .boolParam = false },
125 };
126 ret = CmAddParams(paramSet, param, CM_DEFAULT_PARAM_CNT + 1);
127 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
128
129 CmFreeParamSet(¶mSet);
130 }
131
132 /**
133 * @tc.name: CmParamTest006
134 * @tc.desc: test CmAddParams paramSet cnt is invalid
135 * @tc.type: FUNC
136 * @tc.require: AR000H0MIA /SR000H09NA
137 */
138 HWTEST_F(CmParamTest, CmParamTest006, TestSize.Level0)
139 {
140 struct CmParamSet *paramSet = nullptr;
141 int32_t ret = CmInitParamSet(¶mSet);
142 EXPECT_EQ(ret, CM_SUCCESS);
143 paramSet->paramsCnt = CM_DEFAULT_PARAM_CNT;
144
145 struct CmParam param[] = {
146 { .tag = CM_TAG_PARAM0_BOOL, .boolParam = false },
147 };
148 ret = CmAddParams(paramSet, param, sizeof(param) / sizeof(struct CmParam));
149 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
150
151 CmFreeParamSet(¶mSet);
152 }
153
154 /**
155 * @tc.name: CmParamTest007
156 * @tc.desc: test CmAddParams param tag blob.data is invalid
157 * @tc.type: FUNC
158 * @tc.require: AR000H0MIA /SR000H09NA
159 */
160 HWTEST_F(CmParamTest, CmParamTest007, TestSize.Level0)
161 {
162 struct CmParamSet *paramSet = nullptr;
163 int32_t ret = CmInitParamSet(¶mSet);
164 EXPECT_EQ(ret, CM_SUCCESS);
165
166 struct CmBlob tempBlob = { 0, nullptr };
167 struct CmParam param[] = {
168 { .tag = CM_TAG_PARAM0_BUFFER, .blob = tempBlob },
169 };
170 ret = CmAddParams(paramSet, param, sizeof(param) / sizeof(struct CmParam));
171 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
172
173 CmFreeParamSet(¶mSet);
174 }
175
176 /**
177 * @tc.name: CmParamTest008
178 * @tc.desc: test CmAddParams param tag blob.size is invalid
179 * @tc.type: FUNC
180 * @tc.require: AR000H0MIA /SR000H09NA
181 */
182 HWTEST_F(CmParamTest, CmParamTest008, TestSize.Level0)
183 {
184 struct CmParamSet *paramSet = nullptr;
185 int32_t ret = CmInitParamSet(¶mSet);
186 EXPECT_EQ(ret, CM_SUCCESS);
187
188 uint8_t tempBuf[] = "this is for test";
189 struct CmBlob tempBlob = { UINT32_MAX, tempBuf };
190 struct CmParam param[] = {
191 { .tag = CM_TAG_PARAM0_BUFFER, .blob = tempBlob },
192 };
193 ret = CmAddParams(paramSet, param, sizeof(param) / sizeof(struct CmParam));
194 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
195
196 CmFreeParamSet(¶mSet);
197 }
198
199 /**
200 * @tc.name: CmParamTest009
201 * @tc.desc: test CmGetParam paramSet is nullptr
202 * @tc.type: FUNC
203 * @tc.require: AR000H0MIA /SR000H09NA
204 */
205 HWTEST_F(CmParamTest, CmParamTest009, TestSize.Level0)
206 {
207 struct CmParam *param = nullptr;
208 int32_t ret = CmGetParam(nullptr, CM_TAG_PARAM0_BUFFER, ¶m);
209 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
210 }
211
212 /**
213 * @tc.name: CmParamTest010
214 * @tc.desc: test CmGetParam out param is nullptr
215 * @tc.type: FUNC
216 * @tc.require: AR000H0MIA /SR000H09NA
217 */
218 HWTEST_F(CmParamTest, CmParamTest010, TestSize.Level0)
219 {
220 struct CmParamSet *paramSet = nullptr;
221 int32_t ret = CmInitParamSet(¶mSet);
222 EXPECT_EQ(ret, CM_SUCCESS);
223
224 ret = CmGetParam(paramSet, CM_TAG_PARAM0_BUFFER, nullptr);
225 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
226
227 CmFreeParamSet(¶mSet);
228 }
229
230 /**
231 * @tc.name: CmParamTest011
232 * @tc.desc: test CmGetParam paramSet size is invalid
233 * @tc.type: FUNC
234 * @tc.require: AR000H0MIA /SR000H09NA
235 */
236 HWTEST_F(CmParamTest, CmParamTest011, TestSize.Level0)
237 {
238 struct CmParamSet paramSet = {CM_PARAM_SET_MAX_SIZE + 1, 1 };
239 struct CmParam *param = nullptr;
240 int32_t ret = CmGetParam(¶mSet, CM_TAG_PARAM0_BUFFER, ¶m);
241 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
242 }
243
244 /**
245 * @tc.name: CmParamTest012
246 * @tc.desc: test CmGetParam paramSet size is invalid (smaller than struct size)
247 * @tc.type: FUNC
248 * @tc.require: AR000H0MIA /SR000H09NA
249 */
250 HWTEST_F(CmParamTest, CmParamTest012, TestSize.Level0)
251 {
252 struct CmParamSet paramSet = { sizeof(struct CmParamSet) - 1, 1 };
253 struct CmParam *param = nullptr;
254 int32_t ret = CmGetParam(¶mSet, CM_TAG_PARAM0_BUFFER, ¶m);
255 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
256 }
257
258 /**
259 * @tc.name: CmParamTest013
260 * @tc.desc: test CmGetParam paramSet cnt is invalid
261 * @tc.type: FUNC
262 * @tc.require: AR000H0MIA /SR000H09NA
263 */
264 HWTEST_F(CmParamTest, CmParamTest013, TestSize.Level0)
265 {
266 struct CmParamSet paramSet = { sizeof(struct CmParamSet), 1 };
267 struct CmParam *param = nullptr;
268 int32_t ret = CmGetParam(¶mSet, CM_TAG_PARAM0_BUFFER, ¶m);
269 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
270 }
271
ConstrutParamSet(struct CmParamSet ** paramSet)272 static void ConstrutParamSet(struct CmParamSet **paramSet)
273 {
274 int32_t ret = CmInitParamSet(paramSet);
275 EXPECT_EQ(ret, CM_SUCCESS);
276
277 struct CmParam param[] = {
278 { .tag = CM_TAG_PARAM0_BOOL, .boolParam = false },
279 };
280 ret = CmAddParams(*paramSet, param, sizeof(param) / sizeof(struct CmParam));
281 EXPECT_EQ(ret, CM_SUCCESS);
282
283 ret = CmBuildParamSet(paramSet);
284 EXPECT_EQ(ret, CM_SUCCESS);
285 }
286
287 /**
288 * @tc.name: CmParamTest014
289 * @tc.desc: test CmGetParam normal testcase
290 * @tc.type: FUNC
291 * @tc.require: AR000H0MIA /SR000H09NA
292 */
293 HWTEST_F(CmParamTest, CmParamTest014, TestSize.Level0)
294 {
295 struct CmParamSet *paramSet = nullptr;
296 ConstrutParamSet(¶mSet);
297
298 struct CmParam *param = nullptr;
299 int32_t ret = CmGetParam(paramSet, CM_TAG_PARAM0_BOOL, ¶m);
300 EXPECT_EQ(ret, CM_SUCCESS);
301
302 CmFreeParamSet(¶mSet);
303 }
304
305 /**
306 * @tc.name: CmParamTest015
307 * @tc.desc: test CmGetParam param not exist
308 * @tc.type: FUNC
309 * @tc.require: AR000H0MIA /SR000H09NA
310 */
311 HWTEST_F(CmParamTest, CmParamTest015, TestSize.Level0)
312 {
313 struct CmParamSet *paramSet = nullptr;
314 ConstrutParamSet(¶mSet);
315
316 struct CmParam *param = nullptr;
317 int32_t ret = CmGetParam(paramSet, CM_TAG_PARAM0_BUFFER, ¶m);
318 EXPECT_EQ(ret, CMR_ERROR_PARAM_NOT_EXIST);
319
320 CmFreeParamSet(¶mSet);
321 }
322
323 /**
324 * @tc.name: CmParamTest017
325 * @tc.desc: test CmBuildParamSet paramSet is nullptr
326 * @tc.type: FUNC
327 * @tc.require: AR000H0MIA /SR000H09NA
328 */
329 HWTEST_F(CmParamTest, CmParamTest017, TestSize.Level0)
330 {
331 int32_t ret = CmBuildParamSet(nullptr);
332 EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER);
333
334 /* test CmFreeParamSet paramSet is nullptr */
335 CmFreeParamSet(nullptr);
336 }
337
338 /**
339 * @tc.name: CmParamTest018
340 * @tc.desc: test CmBuildParamSet *paramSet is nullptr
341 * @tc.type: FUNC
342 * @tc.require: AR000H0MIA /SR000H09NA
343 */
344 HWTEST_F(CmParamTest, CmParamTest018, TestSize.Level0)
345 {
346 struct CmParamSet *paramSet = nullptr;
347 int32_t ret = CmBuildParamSet(¶mSet);
348 EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER);
349 }
350
351 /**
352 * @tc.name: CmParamTest019
353 * @tc.desc: test CmBuildParamSet paramSet size is invalid
354 * @tc.type: FUNC
355 * @tc.require: AR000H0MIA /SR000H09NA
356 */
357 HWTEST_F(CmParamTest, CmParamTest019, TestSize.Level0)
358 {
359 struct CmParamSet *paramSet = nullptr;
360 int32_t ret = CmInitParamSet(¶mSet);
361 ASSERT_EQ(ret, CM_SUCCESS);
362
363 paramSet->paramSetSize = sizeof(struct CmParamSet) - 1;
364
365 ret = CmBuildParamSet(¶mSet);
366 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
367
368 CmFreeParamSet(¶mSet);
369 }
370
371 /**
372 * @tc.name: CmParamTest020
373 * @tc.desc: test CmBuildParamSet param tag blob size is invalid
374 * @tc.type: FUNC
375 * @tc.require: AR000H0MIA /SR000H09NA
376 */
377 HWTEST_F(CmParamTest, CmParamTest020, TestSize.Level0)
378 {
379 struct CmParamSet *paramSet = nullptr;
380 int32_t ret = CmInitParamSet(¶mSet);
381 ASSERT_EQ(ret, CM_SUCCESS);
382
383 uint8_t tempBuf[] = "this is for test020";
384 paramSet->paramsCnt = 1;
385 paramSet->paramSetSize += sizeof(struct CmParam);
386 paramSet->params[0].tag = CM_TAG_PARAM1_BUFFER;
387 paramSet->params[0].blob.size = UINT32_MAX;
388 paramSet->params[0].blob.data = tempBuf;
389
390 ret = CmBuildParamSet(¶mSet);
391 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
392
393 CmFreeParamSet(¶mSet);
394 }
395
396 /**
397 * @tc.name: CmParamTest021
398 * @tc.desc: test CmBuildParamSet param tag blob data is invalid
399 * @tc.type: FUNC
400 * @tc.require: AR000H0MIA /SR000H09NA
401 */
402 HWTEST_F(CmParamTest, CmParamTest021, TestSize.Level0)
403 {
404 struct CmParamSet *paramSet = nullptr;
405 int32_t ret = CmInitParamSet(¶mSet);
406 ASSERT_EQ(ret, CM_SUCCESS);
407
408 uint8_t tempBuf[] = "this is for test021";
409 paramSet->paramsCnt = 1;
410 paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf);
411 paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
412 paramSet->params[0].blob.size = sizeof(tempBuf);
413 paramSet->params[0].blob.data = nullptr;
414
415 ret = CmBuildParamSet(¶mSet);
416 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
417
418 CmFreeParamSet(¶mSet);
419 }
420
421 /**
422 * @tc.name: CmParamTest022
423 * @tc.desc: test CmBuildParamSet paramSet size is invalid
424 * @tc.type: FUNC
425 * @tc.require: AR000H0MIA /SR000H09NA
426 */
427 HWTEST_F(CmParamTest, CmParamTest022, TestSize.Level0)
428 {
429 struct CmParamSet *paramSet = nullptr;
430 int32_t ret = CmInitParamSet(¶mSet);
431 ASSERT_EQ(ret, CM_SUCCESS);
432
433 uint8_t tempBuf[] = "this is for test022";
434 paramSet->paramsCnt = 1;
435 paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf) + 1; /* invalid size */
436 paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
437 paramSet->params[0].blob.size = sizeof(tempBuf);
438 paramSet->params[0].blob.data = tempBuf;
439
440 ret = CmBuildParamSet(¶mSet);
441 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
442
443 CmFreeParamSet(¶mSet);
444 }
445
446 /**
447 * @tc.name: CmParamTest023
448 * @tc.desc: test CmGetParamSet paramSet is nullptr
449 * @tc.type: FUNC
450 * @tc.require: AR000H0MIA /SR000H09NA
451 */
452 HWTEST_F(CmParamTest, CmParamTest023, TestSize.Level0)
453 {
454 struct CmParamSet *outParamSet = nullptr;
455 int32_t ret = CmGetParamSet(nullptr, 0, &outParamSet);
456 EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER);
457 }
458
459 /**
460 * @tc.name: CmParamTest024
461 * @tc.desc: test CmGetParamSet normal testcase
462 * @tc.type: FUNC
463 * @tc.require: AR000H0MIA /SR000H09NA
464 */
465 HWTEST_F(CmParamTest, CmParamTest024, TestSize.Level0)
466 {
467 struct CmParamSet *paramSet = nullptr;
468 ConstrutParamSet(¶mSet);
469 ASSERT_TRUE(paramSet != nullptr);
470
471 struct CmParamSet *outParamSet = nullptr;
472 int32_t ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
473 EXPECT_EQ(ret, CM_SUCCESS);
474
475 CmFreeParamSet(¶mSet);
476 CmFreeParamSet(&outParamSet);
477 }
478
479 /**
480 * @tc.name: CmParamTest025
481 * @tc.desc: test CmGetParamSet param tag blob size is invalid
482 * @tc.type: FUNC
483 * @tc.require: AR000H0MIA /SR000H09NA
484 */
485 HWTEST_F(CmParamTest, CmParamTest025, TestSize.Level0)
486 {
487 struct CmParamSet *paramSet = nullptr;
488 int32_t ret = CmInitParamSet(¶mSet);
489 ASSERT_EQ(ret, CM_SUCCESS);
490
491 uint8_t tempBuf[] = "this is for test025";
492 paramSet->paramsCnt = 1;
493 paramSet->paramSetSize += sizeof(struct CmParam);
494 paramSet->params[0].tag = CM_TAG_PARAM1_BUFFER;
495 paramSet->params[0].blob.size = UINT32_MAX;
496 paramSet->params[0].blob.data = tempBuf;
497
498 struct CmParamSet *outParamSet = nullptr;
499 ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
500 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
501
502 CmFreeParamSet(¶mSet);
503 CmFreeParamSet(&outParamSet);
504 }
505
506 /**
507 * @tc.name: CmParamTest026
508 * @tc.desc: test CmGetParamSet paramSet size is invalid
509 * @tc.type: FUNC
510 * @tc.require: AR000H0MIA /SR000H09NA
511 */
512 HWTEST_F(CmParamTest, CmParamTest026, TestSize.Level0)
513 {
514 struct CmParamSet *paramSet = nullptr;
515 int32_t ret = CmInitParamSet(¶mSet);
516 ASSERT_EQ(ret, CM_SUCCESS);
517
518 uint8_t tempBuf[] = "this is for test026";
519 paramSet->paramsCnt = 1;
520 paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf) + 1; /* invalid size */
521 paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
522 paramSet->params[0].blob.size = sizeof(tempBuf);
523 paramSet->params[0].blob.data = tempBuf;
524
525 struct CmParamSet *outParamSet = nullptr;
526 ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
527 EXPECT_EQ(ret, CMR_ERROR_INVALID_PARAMSET_ARG);
528
529 CmFreeParamSet(¶mSet);
530 CmFreeParamSet(&outParamSet);
531 }
532
533 /**
534 * @tc.name: CmParamTest027
535 * @tc.desc: test CmGetParamSet normal testcase tag include blob
536 * @tc.type: FUNC
537 * @tc.require: AR000H0MIA /SR000H09NA
538 */
539 HWTEST_F(CmParamTest, CmParamTest027, TestSize.Level0)
540 {
541 struct CmParamSet *paramSet = nullptr;
542 int32_t ret = CmInitParamSet(¶mSet);
543 ASSERT_EQ(ret, CM_SUCCESS);
544
545 uint8_t tempBuf[] = "this is for test027";
546 paramSet->paramsCnt = 1;
547 paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf);
548 paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
549 paramSet->params[0].blob.size = sizeof(tempBuf);
550 paramSet->params[0].blob.data = tempBuf;
551
552 struct CmParamSet *outParamSet = nullptr;
553 ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
554 EXPECT_EQ(ret, CM_SUCCESS);
555
556 CmFreeParamSet(¶mSet);
557 CmFreeParamSet(&outParamSet);
558 }
559 } // end of namespace
560