1 /*
2  * Copyright (c) 2022 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_ARGUMENT);
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_ARGUMENT);
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(&paramSet);
87     EXPECT_EQ(ret, CM_SUCCESS);
88 
89     ret = CmAddParams(paramSet, nullptr, 0);
90     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
91 
92     CmFreeParamSet(&paramSet);
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(&paramSet, param, sizeof(param) / sizeof(struct CmParam));
108     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
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(&paramSet);
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_ARGUMENT);
128 
129     CmFreeParamSet(&paramSet);
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(&paramSet);
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_ARGUMENT);
150 
151     CmFreeParamSet(&paramSet);
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(&paramSet);
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_ARGUMENT);
172 
173     CmFreeParamSet(&paramSet);
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(&paramSet);
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_ARGUMENT);
195 
196     CmFreeParamSet(&paramSet);
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, &param);
209     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
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(&paramSet);
222     EXPECT_EQ(ret, CM_SUCCESS);
223 
224     ret = CmGetParam(paramSet, CM_TAG_PARAM0_BUFFER, nullptr);
225     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
226 
227     CmFreeParamSet(&paramSet);
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(&paramSet, CM_TAG_PARAM0_BUFFER, &param);
241     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
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(&paramSet, CM_TAG_PARAM0_BUFFER, &param);
255     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
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(&paramSet, CM_TAG_PARAM0_BUFFER, &param);
269     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
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(&paramSet);
297 
298     struct CmParam *param = nullptr;
299     int32_t ret = CmGetParam(paramSet, CM_TAG_PARAM0_BOOL, &param);
300     EXPECT_EQ(ret, CM_SUCCESS);
301 
302     CmFreeParamSet(&paramSet);
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(&paramSet);
315 
316     struct CmParam *param = nullptr;
317     int32_t ret = CmGetParam(paramSet, CM_TAG_PARAM0_BUFFER, &param);
318     EXPECT_EQ(ret, CMR_ERROR_PARAM_NOT_EXIST);
319 
320     CmFreeParamSet(&paramSet);
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(&paramSet);
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(&paramSet);
361     EXPECT_EQ(ret, CM_SUCCESS);
362     if (ret != CM_SUCCESS) {
363         return;
364     }
365     paramSet->paramSetSize = sizeof(struct CmParamSet) - 1;
366 
367     ret = CmBuildParamSet(&paramSet);
368     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
369 
370     CmFreeParamSet(&paramSet);
371 }
372 
373 /**
374 * @tc.name: CmParamTest020
375 * @tc.desc: test CmBuildParamSet param tag blob size is invalid
376 * @tc.type: FUNC
377 * @tc.require: AR000H0MIA /SR000H09NA
378 */
379 HWTEST_F(CmParamTest, CmParamTest020, TestSize.Level0)
380 {
381     struct CmParamSet *paramSet = nullptr;
382     int32_t ret = CmInitParamSet(&paramSet);
383     EXPECT_EQ(ret, CM_SUCCESS);
384     if (ret != CM_SUCCESS) {
385         return;
386     }
387 
388     uint8_t tempBuf[] = "this is for test020";
389     paramSet->paramsCnt = 1;
390     paramSet->paramSetSize += sizeof(struct CmParam);
391     paramSet->params[0].tag = CM_TAG_PARAM1_BUFFER;
392     paramSet->params[0].blob.size = UINT32_MAX;
393     paramSet->params[0].blob.data = tempBuf;
394 
395     ret = CmBuildParamSet(&paramSet);
396     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
397 
398     CmFreeParamSet(&paramSet);
399 }
400 
401 /**
402 * @tc.name: CmParamTest021
403 * @tc.desc: test CmBuildParamSet param tag blob data is invalid
404 * @tc.type: FUNC
405 * @tc.require: AR000H0MIA /SR000H09NA
406 */
407 HWTEST_F(CmParamTest, CmParamTest021, TestSize.Level0)
408 {
409     struct CmParamSet *paramSet = nullptr;
410     int32_t ret = CmInitParamSet(&paramSet);
411     EXPECT_EQ(ret, CM_SUCCESS);
412     if (ret != CM_SUCCESS) {
413         return;
414     }
415 
416     uint8_t tempBuf[] = "this is for test021";
417     paramSet->paramsCnt = 1;
418     paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf);
419     paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
420     paramSet->params[0].blob.size = sizeof(tempBuf);
421     paramSet->params[0].blob.data = nullptr;
422 
423     ret = CmBuildParamSet(&paramSet);
424     EXPECT_EQ(ret, CMR_ERROR_INVALID_OPERATION);
425 
426     CmFreeParamSet(&paramSet);
427 }
428 
429 /**
430 * @tc.name: CmParamTest022
431 * @tc.desc: test CmBuildParamSet paramSet size is invalid
432 * @tc.type: FUNC
433 * @tc.require: AR000H0MIA /SR000H09NA
434 */
435 HWTEST_F(CmParamTest, CmParamTest022, TestSize.Level0)
436 {
437     struct CmParamSet *paramSet = nullptr;
438     int32_t ret = CmInitParamSet(&paramSet);
439     EXPECT_EQ(ret, CM_SUCCESS);
440     if (ret != CM_SUCCESS) {
441         return;
442     }
443 
444     uint8_t tempBuf[] = "this is for test022";
445     paramSet->paramsCnt = 1;
446     paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf) + 1; /* invalid size */
447     paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
448     paramSet->params[0].blob.size = sizeof(tempBuf);
449     paramSet->params[0].blob.data = tempBuf;
450 
451     ret = CmBuildParamSet(&paramSet);
452     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
453 
454     CmFreeParamSet(&paramSet);
455 }
456 
457 /**
458 * @tc.name: CmParamTest023
459 * @tc.desc: test CmGetParamSet paramSet is nullptr
460 * @tc.type: FUNC
461 * @tc.require: AR000H0MIA /SR000H09NA
462 */
463 HWTEST_F(CmParamTest, CmParamTest023, TestSize.Level0)
464 {
465     struct CmParamSet *outParamSet = nullptr;
466     int32_t ret = CmGetParamSet(nullptr, 0, &outParamSet);
467     EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER);
468 }
469 
470 /**
471 * @tc.name: CmParamTest024
472 * @tc.desc: test CmGetParamSet normal testcase
473 * @tc.type: FUNC
474 * @tc.require: AR000H0MIA /SR000H09NA
475 */
476 HWTEST_F(CmParamTest, CmParamTest024, TestSize.Level0)
477 {
478     struct CmParamSet *paramSet = nullptr;
479     ConstrutParamSet(&paramSet);
480     if (paramSet == nullptr) {
481         return;
482     }
483 
484     struct CmParamSet *outParamSet = nullptr;
485     int32_t ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
486     EXPECT_EQ(ret, CM_SUCCESS);
487 
488     CmFreeParamSet(&paramSet);
489     CmFreeParamSet(&outParamSet);
490 }
491 
492 /**
493 * @tc.name: CmParamTest025
494 * @tc.desc: test CmGetParamSet param tag blob size is invalid
495 * @tc.type: FUNC
496 * @tc.require: AR000H0MIA /SR000H09NA
497 */
498 HWTEST_F(CmParamTest, CmParamTest025, TestSize.Level0)
499 {
500     struct CmParamSet *paramSet = nullptr;
501     int32_t ret = CmInitParamSet(&paramSet);
502     EXPECT_EQ(ret, CM_SUCCESS);
503     if (ret != CM_SUCCESS) {
504         return;
505     }
506 
507     uint8_t tempBuf[] = "this is for test025";
508     paramSet->paramsCnt = 1;
509     paramSet->paramSetSize += sizeof(struct CmParam);
510     paramSet->params[0].tag = CM_TAG_PARAM1_BUFFER;
511     paramSet->params[0].blob.size = UINT32_MAX;
512     paramSet->params[0].blob.data = tempBuf;
513 
514     struct CmParamSet *outParamSet = nullptr;
515     ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
516     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
517 
518     CmFreeParamSet(&paramSet);
519     CmFreeParamSet(&outParamSet);
520 }
521 
522 /**
523 * @tc.name: CmParamTest026
524 * @tc.desc: test CmGetParamSet paramSet size is invalid
525 * @tc.type: FUNC
526 * @tc.require: AR000H0MIA /SR000H09NA
527 */
528 HWTEST_F(CmParamTest, CmParamTest026, TestSize.Level0)
529 {
530     struct CmParamSet *paramSet = nullptr;
531     int32_t ret = CmInitParamSet(&paramSet);
532     EXPECT_EQ(ret, CM_SUCCESS);
533     if (ret != CM_SUCCESS) {
534         return;
535     }
536 
537     uint8_t tempBuf[] = "this is for test026";
538     paramSet->paramsCnt = 1;
539     paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf) + 1; /* invalid size */
540     paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
541     paramSet->params[0].blob.size = sizeof(tempBuf);
542     paramSet->params[0].blob.data = tempBuf;
543 
544     struct CmParamSet *outParamSet = nullptr;
545     ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
546     EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
547 
548     CmFreeParamSet(&paramSet);
549     CmFreeParamSet(&outParamSet);
550 }
551 
552 /**
553 * @tc.name: CmParamTest027
554 * @tc.desc: test CmGetParamSet normal testcase tag include blob
555 * @tc.type: FUNC
556 * @tc.require: AR000H0MIA /SR000H09NA
557 */
558 HWTEST_F(CmParamTest, CmParamTest027, TestSize.Level0)
559 {
560     struct CmParamSet *paramSet = nullptr;
561     int32_t ret = CmInitParamSet(&paramSet);
562     EXPECT_EQ(ret, CM_SUCCESS);
563     if (ret != CM_SUCCESS) {
564         return;
565     }
566 
567     uint8_t tempBuf[] = "this is for test027";
568     paramSet->paramsCnt = 1;
569     paramSet->paramSetSize += sizeof(struct CmParam) + sizeof(tempBuf);
570     paramSet->params[0].tag = CM_TAG_PARAM0_BUFFER;
571     paramSet->params[0].blob.size = sizeof(tempBuf);
572     paramSet->params[0].blob.data = tempBuf;
573 
574     struct CmParamSet *outParamSet = nullptr;
575     ret = CmGetParamSet(paramSet, paramSet->paramSetSize, &outParamSet);
576     EXPECT_EQ(ret, CM_SUCCESS);
577 
578     CmFreeParamSet(&paramSet);
579     CmFreeParamSet(&outParamSet);
580 }
581 } // end of namespace
582