1 /*
2 * Copyright (c) 2024 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 "cenc_info_capi_unit_test.h"
17 #include "avcodec_errors.h"
18 #include "avcodec_log.h"
19 #include "meta/meta.h"
20 #include "common/native_mfmagic.h"
21 #include "native_cencinfo.h"
22
23 using namespace testing::ext;
24 using namespace std;
25 using namespace OHOS::MediaAVCodec;
26 using namespace OHOS::Media;
27
28 namespace OHOS {
29 namespace CencInfoUT {
30
SetUpTestCase(void)31 void CencInfoCapiUnitTest::SetUpTestCase(void) {}
32
TearDownTestCase(void)33 void CencInfoCapiUnitTest::TearDownTestCase(void) {}
34
SetUp()35 void CencInfoCapiUnitTest::SetUp() {}
36
TearDown()37 void CencInfoCapiUnitTest::TearDown() {}
38
39 /**
40 * @tc.name: CencInfo_Create_001
41 * @tc.desc: Create a cencInfo object
42 */
43 HWTEST_F(CencInfoCapiUnitTest, CencInfo_Create_001, TestSize.Level0)
44 {
45 OH_AVErrCode errNo = AV_ERR_OK;
46 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
47 EXPECT_NE(cencInfo, nullptr);
48 errNo = OH_AVCencInfo_Destroy(cencInfo);
49 EXPECT_EQ(errNo, AV_ERR_OK);
50 }
51
52 /**
53 * @tc.name: CencInfo_Destroy_001
54 * @tc.desc: Destroy a cencInfo object
55 */
56 HWTEST_F(CencInfoCapiUnitTest, CencInfo_Destroy_001, TestSize.Level0)
57 {
58 OH_AVErrCode errNo = AV_ERR_OK;
59 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
60 EXPECT_NE(cencInfo, nullptr);
61 errNo = OH_AVCencInfo_Destroy(cencInfo);
62 EXPECT_EQ(errNo, AV_ERR_OK);
63 }
64
65 /**
66 * @tc.name: CencInfo_Destroy_002
67 * @tc.desc: Destroy a cencInfo null object
68 */
69 HWTEST_F(CencInfoCapiUnitTest, CencInfo_Destroy_002, TestSize.Level0)
70 {
71 OH_AVErrCode errNo = AV_ERR_OK;
72 errNo = OH_AVCencInfo_Destroy(nullptr);
73 EXPECT_NE(errNo, AV_ERR_OK);
74 }
75
76 /**
77 * @tc.name: CencInfo_SetAlgorithm_001
78 * @tc.desc: Set Algorithm
79 */
80 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetAlgorithm_001, TestSize.Level0)
81 {
82 OH_AVErrCode errNo = AV_ERR_OK;
83 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
84 EXPECT_NE(cencInfo, nullptr);
85
86 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_UNENCRYPTED);
87 EXPECT_EQ(errNo, AV_ERR_OK);
88
89 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_CTR);
90 EXPECT_EQ(errNo, AV_ERR_OK);
91
92 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_WV);
93 EXPECT_EQ(errNo, AV_ERR_OK);
94
95 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_CBC);
96 EXPECT_EQ(errNo, AV_ERR_OK);
97
98 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_SM4_CBC);
99 EXPECT_EQ(errNo, AV_ERR_OK);
100
101 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_SM4_CTR);
102 EXPECT_EQ(errNo, AV_ERR_OK);
103
104 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, static_cast<enum DrmCencAlgorithm>(DRM_ALG_CENC_SM4_CTR + 1));
105 EXPECT_EQ(errNo, AV_ERR_OK);
106
107 errNo = OH_AVCencInfo_Destroy(cencInfo);
108 EXPECT_EQ(errNo, AV_ERR_OK);
109 }
110
111 /**
112 * @tc.name: CencInfo_SetAlgorithm_002
113 * @tc.desc: Set cencInfo null object
114 */
115 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetAlgorithm_002, TestSize.Level0)
116 {
117 OH_AVErrCode errNo = AV_ERR_OK;
118 errNo = OH_AVCencInfo_SetAlgorithm(nullptr, DRM_ALG_CENC_SM4_CTR);
119 EXPECT_NE(errNo, AV_ERR_OK);
120 }
121
122 /**
123 * @tc.name: CencInfo_SetKeyIdAndIv_001
124 * @tc.desc: Set keyId and iv
125 */
126 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetKeyIdAndIv_001, TestSize.Level0)
127 {
128 OH_AVErrCode errNo = AV_ERR_OK;
129 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
130 uint8_t keyId[] = {
131 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
132 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
133 uint32_t ivLen = DRM_KEY_IV_SIZE;
134 uint8_t iv[] = {
135 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
136 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
137
138 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
139 EXPECT_NE(cencInfo, nullptr);
140 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen);
141 EXPECT_EQ(errNo, AV_ERR_OK);
142 errNo = OH_AVCencInfo_Destroy(cencInfo);
143 EXPECT_EQ(errNo, AV_ERR_OK);
144 }
145
146 /**
147 * @tc.name: CencInfo_SetKeyIdAndIv_002
148 * @tc.desc: Set cencInfo null object
149 */
150 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetKeyIdAndIv_002, TestSize.Level0)
151 {
152 OH_AVErrCode errNo = AV_ERR_OK;
153 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
154 uint8_t keyId[] = {
155 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
156 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
157 uint32_t ivLen = DRM_KEY_IV_SIZE;
158 uint8_t iv[] = {
159 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
160 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
161 errNo = OH_AVCencInfo_SetKeyIdAndIv(nullptr, keyId, keyIdLen, iv, ivLen);
162 EXPECT_NE(errNo, AV_ERR_OK);
163 }
164
165 /**
166 * @tc.name: CencInfo_SetKeyIdAndIv_003
167 * @tc.desc: Set the null keyId
168 */
169 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetKeyIdAndIv_003, TestSize.Level0)
170 {
171 OH_AVErrCode errNo = AV_ERR_OK;
172 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
173 uint32_t ivLen = DRM_KEY_IV_SIZE;
174 uint8_t iv[] = {
175 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
176 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
177
178 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
179 EXPECT_NE(cencInfo, nullptr);
180 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, nullptr, keyIdLen, iv, ivLen);
181 EXPECT_NE(errNo, AV_ERR_OK);
182 errNo = OH_AVCencInfo_Destroy(cencInfo);
183 EXPECT_EQ(errNo, AV_ERR_OK);
184 }
185
186 /**
187 * @tc.name: CencInfo_SetKeyIdAndIv_004
188 * @tc.desc: Set an invalid keyIdLen
189 */
190 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetKeyIdAndIv_004, TestSize.Level0)
191 {
192 OH_AVErrCode errNo = AV_ERR_OK;
193 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
194 uint8_t keyId[] = {
195 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
196 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
197 uint32_t ivLen = DRM_KEY_IV_SIZE;
198 uint8_t iv[] = {
199 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
200 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
201
202 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
203 EXPECT_NE(cencInfo, nullptr);
204 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen + 1, iv, ivLen);
205 EXPECT_NE(errNo, AV_ERR_OK);
206 errNo = OH_AVCencInfo_Destroy(cencInfo);
207 EXPECT_EQ(errNo, AV_ERR_OK);
208 }
209
210 /**
211 * @tc.name: CencInfo_SetKeyIdAndIv_005
212 * @tc.desc: Set the null iv
213 */
214 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetKeyIdAndIv_005, TestSize.Level0)
215 {
216 OH_AVErrCode errNo = AV_ERR_OK;
217 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
218 uint8_t keyId[] = {
219 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
220 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
221 uint32_t ivLen = DRM_KEY_IV_SIZE;
222
223 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
224 EXPECT_NE(cencInfo, nullptr);
225 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, nullptr, ivLen);
226 EXPECT_NE(errNo, AV_ERR_OK);
227 errNo = OH_AVCencInfo_Destroy(cencInfo);
228 EXPECT_EQ(errNo, AV_ERR_OK);
229 }
230
231 /**
232 * @tc.name: CencInfo_SetKeyIdAndIv_006
233 * @tc.desc: Set an invalid ivLen
234 */
235 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetKeyIdAndIv_006, TestSize.Level0)
236 {
237 OH_AVErrCode errNo = AV_ERR_OK;
238 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
239 uint8_t keyId[] = {
240 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
241 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
242 uint32_t ivLen = DRM_KEY_IV_SIZE;
243 uint8_t iv[] = {
244 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
245 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
246
247 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
248 EXPECT_NE(cencInfo, nullptr);
249 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen + 1);
250 EXPECT_NE(errNo, AV_ERR_OK);
251 errNo = OH_AVCencInfo_Destroy(cencInfo);
252 EXPECT_EQ(errNo, AV_ERR_OK);
253 }
254
255 /**
256 * @tc.name: CencInfo_SetSubsampleInfo_001
257 * @tc.desc: Set subsample info
258 */
259 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetSubsampleInfo_001, TestSize.Level0)
260 {
261 OH_AVErrCode errNo = AV_ERR_OK;
262 uint32_t encryptedBlockCount = 0;
263 uint32_t skippedBlockCount = 0;
264 uint32_t firstEncryptedOffset = 0;
265 uint32_t subsampleCount = 1;
266 DrmSubsample subsamples[1] = { {0x10, 0x16} };
267
268 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
269 EXPECT_NE(cencInfo, nullptr);
270 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
271 subsampleCount, subsamples);
272 EXPECT_EQ(errNo, AV_ERR_OK);
273 errNo = OH_AVCencInfo_Destroy(cencInfo);
274 EXPECT_EQ(errNo, AV_ERR_OK);
275 }
276
277 /**
278 * @tc.name: CencInfo_SetSubsampleInfo_002
279 * @tc.desc: Set cencInfo null object
280 */
281 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetSubsampleInfo_002, TestSize.Level0)
282 {
283 OH_AVErrCode errNo = AV_ERR_OK;
284 uint32_t encryptedBlockCount = 0;
285 uint32_t skippedBlockCount = 0;
286 uint32_t firstEncryptedOffset = 0;
287 uint32_t subsampleCount = 1;
288 DrmSubsample subsamples[1] = { {0x10, 0x16} };
289
290 errNo = OH_AVCencInfo_SetSubsampleInfo(nullptr, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
291 subsampleCount, subsamples);
292 EXPECT_NE(errNo, AV_ERR_OK);
293 }
294
295 /**
296 * @tc.name: CencInfo_SetSubsampleInfo_003
297 * @tc.desc: Set an invalid subsampleCount
298 */
299 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetSubsampleInfo_003, TestSize.Level0)
300 {
301 OH_AVErrCode errNo = AV_ERR_OK;
302 uint32_t encryptedBlockCount = 0;
303 uint32_t skippedBlockCount = 0;
304 uint32_t firstEncryptedOffset = 0;
305 uint32_t subsampleCount = DRM_KEY_MAX_SUB_SAMPLE_NUM;
306 DrmSubsample subsamples[1] = { {0x10, 0x16} };
307
308 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
309 EXPECT_NE(cencInfo, nullptr);
310 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
311 subsampleCount + 1, subsamples);
312 EXPECT_NE(errNo, AV_ERR_OK);
313 errNo = OH_AVCencInfo_Destroy(cencInfo);
314 EXPECT_EQ(errNo, AV_ERR_OK);
315 }
316
317 /**
318 * @tc.name: CencInfo_SetSubsampleInfo_004
319 * @tc.desc: Set the null subsamples
320 */
321 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetSubsampleInfo_004, TestSize.Level0)
322 {
323 OH_AVErrCode errNo = AV_ERR_OK;
324 uint32_t encryptedBlockCount = 0;
325 uint32_t skippedBlockCount = 0;
326 uint32_t firstEncryptedOffset = 0;
327 uint32_t subsampleCount = 1;
328
329 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
330 EXPECT_NE(cencInfo, nullptr);
331 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
332 subsampleCount, nullptr);
333 EXPECT_NE(errNo, AV_ERR_OK);
334 errNo = OH_AVCencInfo_Destroy(cencInfo);
335 EXPECT_EQ(errNo, AV_ERR_OK);
336 }
337
338 /**
339 * @tc.name: CencInfo_SetMode_001
340 * @tc.desc: Set mode
341 */
342 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetMode_001, TestSize.Level0)
343 {
344 OH_AVErrCode errNo = AV_ERR_OK;
345
346 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
347 EXPECT_NE(cencInfo, nullptr);
348
349 errNo = OH_AVCencInfo_SetMode(cencInfo, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_SET);
350 EXPECT_EQ(errNo, AV_ERR_OK);
351
352 errNo = OH_AVCencInfo_SetMode(cencInfo, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET);
353 EXPECT_EQ(errNo, AV_ERR_OK);
354
355 errNo = OH_AVCencInfo_SetMode(cencInfo,
356 static_cast<enum DrmCencInfoMode>(DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET + 1));
357 EXPECT_EQ(errNo, AV_ERR_OK);
358
359 errNo = OH_AVCencInfo_Destroy(cencInfo);
360 EXPECT_EQ(errNo, AV_ERR_OK);
361 }
362
363 /**
364 * @tc.name: CencInfo_SetMode_002
365 * @tc.desc: Set cencInfo null object
366 */
367 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetMode_002, TestSize.Level0)
368 {
369 OH_AVErrCode errNo = AV_ERR_OK;
370
371 errNo = OH_AVCencInfo_SetMode(nullptr, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_SET);
372 EXPECT_NE(errNo, AV_ERR_OK);
373 }
374
375 /**
376 * @tc.name: CencInfo_SetAVBuffer_001
377 * @tc.desc: Set avBuffer
378 */
379 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetAVBuffer_001, TestSize.Level0)
380 {
381 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
382 uint8_t keyId[] = {
383 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
384 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
385 uint32_t ivLen = DRM_KEY_IV_SIZE;
386 uint8_t iv[] = {
387 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
388 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
389 uint32_t encryptedBlockCount = 0;
390 uint32_t skippedBlockCount = 0;
391 uint32_t firstEncryptedOffset = 0;
392 uint32_t subsampleCount = 1;
393 DrmSubsample subsamples[1] = { {0x10, 0x16} };
394 OH_AVErrCode errNo = AV_ERR_OK;
395 MemoryFlag memFlag = MEMORY_READ_WRITE;
396
397 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
398 EXPECT_NE(avAllocator, nullptr);
399
400 std::shared_ptr<AVBuffer> inBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(DRM_KEY_ID_SIZE));
401 EXPECT_NE(inBuf, nullptr);
402 EXPECT_NE(inBuf->memory_, nullptr);
403 EXPECT_EQ(inBuf->memory_->GetCapacity(), DRM_KEY_ID_SIZE);
404
405 struct OH_AVBuffer *buffer = new (std::nothrow) OH_AVBuffer(inBuf);
406 EXPECT_NE(buffer, nullptr);
407
408 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
409 EXPECT_NE(cencInfo, nullptr);
410
411 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_CTR);
412 EXPECT_EQ(errNo, AV_ERR_OK);
413
414 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen);
415 EXPECT_EQ(errNo, AV_ERR_OK);
416
417 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
418 subsampleCount, subsamples);
419 EXPECT_EQ(errNo, AV_ERR_OK);
420
421 errNo = OH_AVCencInfo_SetMode(cencInfo, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_SET);
422 EXPECT_EQ(errNo, AV_ERR_OK);
423
424 errNo = OH_AVCencInfo_SetAVBuffer(cencInfo, buffer);
425 EXPECT_EQ(errNo, AV_ERR_OK);
426
427 errNo = OH_AVCencInfo_Destroy(cencInfo);
428 EXPECT_EQ(errNo, AV_ERR_OK);
429 delete buffer;
430 }
431
432 /**
433 * @tc.name: CencInfo_SetAVBuffer_002
434 * @tc.desc: Set cencInfo null object
435 */
436 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetAVBuffer_002, TestSize.Level0)
437 {
438 OH_AVErrCode errNo = AV_ERR_OK;
439 MemoryFlag memFlag = MEMORY_READ_WRITE;
440
441 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
442 EXPECT_NE(avAllocator, nullptr);
443
444 std::shared_ptr<AVBuffer> inBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(DRM_KEY_ID_SIZE));
445 EXPECT_NE(inBuf, nullptr);
446 EXPECT_NE(inBuf->memory_, nullptr);
447 EXPECT_EQ(inBuf->memory_->GetCapacity(), DRM_KEY_ID_SIZE);
448
449 struct OH_AVBuffer *buffer = new (std::nothrow) OH_AVBuffer(inBuf);
450 EXPECT_NE(buffer, nullptr);
451
452 errNo = OH_AVCencInfo_SetAVBuffer(nullptr, buffer);
453 EXPECT_NE(errNo, AV_ERR_OK);
454
455 delete buffer;
456 }
457
458 /**
459 * @tc.name: CencInfo_SetAVBuffer_003
460 * @tc.desc: Set buffer null
461 */
462 HWTEST_F(CencInfoCapiUnitTest, CencInfo_SetAVBuffer_003, TestSize.Level0)
463 {
464 OH_AVErrCode errNo = AV_ERR_OK;
465 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
466 EXPECT_NE(cencInfo, nullptr);
467
468 errNo = OH_AVCencInfo_SetAVBuffer(cencInfo, nullptr);
469 EXPECT_NE(errNo, AV_ERR_OK);
470
471 errNo = OH_AVCencInfo_Destroy(cencInfo);
472 EXPECT_EQ(errNo, AV_ERR_OK);
473 }
474
475 } // CencInfoUT
476 } // OHOS