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