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 <cstdio>
17 #include <iostream>
18 #include <atomic>
19 #include <fstream>
20 #include <mutex>
21 #include <queue>
22 #include <string>
23 #include <thread>
24
25 #include "gtest/gtest.h"
26 #include "videodec_ndk_sample.h"
27 #include "native_avcapability.h"
28 namespace {
29 OH_AVCapability *cap = nullptr;
30 } // namespace
31 using namespace std;
32 using namespace OHOS;
33 using namespace OHOS::Media;
34 using namespace testing::ext;
35 namespace OHOS {
36 namespace Media {
37 class SwdecStateNdkTest : public testing::Test {
38 public:
39 // SetUpTestCase: Called before all test cases
40 static void SetUpTestCase(void);
41 // TearDownTestCase: Called after all test case
42 static void TearDownTestCase(void);
43 // SetUp: Called before each test cases
44 void SetUp(void);
45 // TearDown: Called after each test cases
46 void TearDown(void);
47
48 protected:
49 const ::testing::TestInfo *testInfo_ = nullptr;
50 bool createCodecSuccess_ = false;
51 };
52
SetUpTestCase(void)53 void SwdecStateNdkTest::SetUpTestCase(void) {}
TearDownTestCase(void)54 void SwdecStateNdkTest::TearDownTestCase(void) {}
55 VDecNdkSample *vDecSample = NULL;
56
SetUp(void)57 void SwdecStateNdkTest::SetUp(void)
58 {
59 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
60 if (cap) {
61 vDecSample = new VDecNdkSample();
62 string codeName = "OH.Media.Codec.Decoder.Video.AVC";
63 int32_t ret = vDecSample->CreateVideoDecoder(codeName);
64 ASSERT_EQ(AV_ERR_OK, ret);
65 ret = vDecSample->SetVideoDecoderCallback();
66 ASSERT_EQ(AV_ERR_OK, ret);
67 ret = vDecSample->ConfigureVideoDecoder();
68 ASSERT_EQ(AV_ERR_OK, ret);
69 vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
70 }
71 }
72
TearDown(void)73 void SwdecStateNdkTest::TearDown(void)
74 {
75 vDecSample->Release();
76 delete vDecSample;
77 vDecSample = nullptr;
78 }
79 } // namespace Media
80 } // namespace OHOS
81
82 namespace {
83 /**
84 * @tc.number : VIDEO_SWDEC_STATE_0100
85 * @tc.name : create-configure-error
86 * @tc.desc : function test
87 */
88 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0100, TestSize.Level2)
89 {
90 int32_t ret = vDecSample->Flush();
91 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
92 ret = vDecSample->SetVideoDecoderCallback();
93 ASSERT_EQ(AV_ERR_OK, ret);
94 }
95
96 /**
97 * @tc.number : VIDEO_SWDEC_STATE_0101
98 * @tc.name : create-configure-stop
99 * @tc.desc : function test
100 */
101 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0101, TestSize.Level2)
102 {
103 int32_t ret = vDecSample->Stop();
104 ASSERT_EQ(AV_ERR_OK, ret);
105 }
106
107 /**
108 * @tc.number : VIDEO_SWDEC_STATE_0200
109 * @tc.name : create-configure-start-stop-start
110 * @tc.desc : function test
111 */
112 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0200, TestSize.Level2)
113 {
114 int32_t ret = vDecSample->Start();
115 ASSERT_EQ(AV_ERR_OK, ret);
116 ret = vDecSample->Stop();
117 ASSERT_EQ(AV_ERR_OK, ret);
118 ret = vDecSample->Start();
119 ASSERT_EQ(AV_ERR_OK, ret);
120 }
121
122 /**
123 * @tc.number : VIDEO_SWDEC_STATE_0300
124 * @tc.name : create-configure-start-stop-release
125 * @tc.desc : function test
126 */
127 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0300, TestSize.Level2)
128 {
129 int32_t ret = vDecSample->Start();
130 ASSERT_EQ(AV_ERR_OK, ret);
131 ret = vDecSample->Stop();
132 ASSERT_EQ(AV_ERR_OK, ret);
133 ret = vDecSample->Release();
134 ASSERT_EQ(AV_ERR_OK, ret);
135 }
136
137 /**
138 * @tc.number : VIDEO_SWDEC_STATE_0400
139 * @tc.name : create-configure-start-stop-reset
140 * @tc.desc : function test
141 */
142 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0400, TestSize.Level2)
143 {
144 int32_t ret = vDecSample->Start();
145 ASSERT_EQ(AV_ERR_OK, ret);
146 ret = vDecSample->Stop();
147 ASSERT_EQ(AV_ERR_OK, ret);
148 ret = vDecSample->Reset();
149 ASSERT_EQ(AV_ERR_OK, ret);
150 }
151
152 /**
153 * @tc.number : VIDEO_SWDEC_STATE_0500
154 * @tc.name : create-configure-start-stop-error
155 * @tc.desc : function test
156 */
157 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0500, TestSize.Level2)
158 {
159 int32_t ret = vDecSample->Start();
160 ASSERT_EQ(AV_ERR_OK, ret);
161 ret = vDecSample->Stop();
162 ASSERT_EQ(AV_ERR_OK, ret);
163 ret = vDecSample->Flush();
164 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
165 ret = vDecSample->SetVideoDecoderCallback();
166 ASSERT_EQ(AV_ERR_OK, ret);
167 }
168
169 /**
170 * @tc.number : VIDEO_SWDEC_STATE_0600
171 * @tc.name : create-configure-start-EOS-stop-start
172 * @tc.desc : function test
173 */
174 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0600, TestSize.Level2)
175 {
176 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
177 int32_t ret = vDecSample->StartVideoDecoder();
178 ASSERT_EQ(AV_ERR_OK, ret);
179 vDecSample->WaitForEOS();
180 ASSERT_EQ(AV_ERR_OK, ret);
181 ASSERT_EQ(0, vDecSample->errCount);
182 ret = vDecSample->Stop();
183 ASSERT_EQ(AV_ERR_OK, ret);
184 ret = vDecSample->Start();
185 ASSERT_EQ(AV_ERR_OK, ret);
186 }
187
188 /**
189 * @tc.number : VIDEO_SWDEC_STATE_0700
190 * @tc.name : create-configure-start-EOS-stop-release
191 * @tc.desc : function test
192 */
193 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0700, TestSize.Level2)
194 {
195 int32_t ret = vDecSample->StartVideoDecoder();
196 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
197 vDecSample->WaitForEOS();
198 ASSERT_EQ(AV_ERR_OK, ret);
199 ASSERT_EQ(0, vDecSample->errCount);
200 ret = vDecSample->Stop();
201 ASSERT_EQ(AV_ERR_OK, ret);
202 ret = vDecSample->Release();
203 ASSERT_EQ(AV_ERR_OK, ret);
204 }
205
206 /**
207 * @tc.number : VIDEO_SWDEC_STATE_0800
208 * @tc.name : create-configure-start-EOS-stop-reset
209 * @tc.desc : function test
210 */
211 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0800, TestSize.Level2)
212 {
213 int32_t ret = vDecSample->StartVideoDecoder();
214 ASSERT_EQ(AV_ERR_OK, ret);
215 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
216 vDecSample->WaitForEOS();
217 ASSERT_EQ(AV_ERR_OK, ret);
218 ASSERT_EQ(0, vDecSample->errCount);
219 ret = vDecSample->Stop();
220 ASSERT_EQ(AV_ERR_OK, ret);
221 ret = vDecSample->Reset();
222 ASSERT_EQ(AV_ERR_OK, ret);
223 }
224
225 /**
226 * @tc.number : VIDEO_SWDEC_STATE_0900
227 * @tc.name : create-configure-start-EOS-flush
228 * @tc.desc : function test
229 */
230 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0900, TestSize.Level2)
231 {
232 int32_t ret = vDecSample->StartVideoDecoder();
233 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
234 vDecSample->WaitForEOS();
235 ASSERT_EQ(AV_ERR_OK, ret);
236 ASSERT_EQ(0, vDecSample->errCount);
237 ret = vDecSample->Flush();
238 ASSERT_EQ(AV_ERR_OK, ret);
239 }
240
241 /**
242 * @tc.number : VIDEO_SWDEC_STATE_1000
243 * @tc.name : create-configure-start-EOS-flush-start
244 * @tc.desc : function test
245 */
246 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1000, TestSize.Level2)
247 {
248 int32_t ret = vDecSample->StartVideoDecoder();
249 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
250 vDecSample->WaitForEOS();
251 ASSERT_EQ(AV_ERR_OK, ret);
252 ASSERT_EQ(0, vDecSample->errCount);
253 ret = vDecSample->Flush();
254 ASSERT_EQ(AV_ERR_OK, ret);
255 ret = vDecSample->Start();
256 ASSERT_EQ(AV_ERR_OK, ret);
257 }
258
259 /**
260 * @tc.number : VIDEO_SWDEC_STATE_1100
261 * @tc.name : create-configure-start-EOS-flush-stop
262 * @tc.desc : function test
263 */
264 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1100, TestSize.Level2)
265 {
266 int32_t ret = vDecSample->StartVideoDecoder();
267 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
268 vDecSample->WaitForEOS();
269 ASSERT_EQ(AV_ERR_OK, ret);
270 ASSERT_EQ(0, vDecSample->errCount);
271 ret = vDecSample->Flush();
272 ASSERT_EQ(AV_ERR_OK, ret);
273 ret = vDecSample->Stop();
274 ASSERT_EQ(AV_ERR_OK, ret);
275 }
276
277 /**
278 * @tc.number : VIDEO_SWDEC_STATE_1200
279 * @tc.name : create-configure-start-EOS-flush-reset
280 * @tc.desc : function test
281 */
282 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1200, TestSize.Level2)
283 {
284 int32_t ret = vDecSample->StartVideoDecoder();
285 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
286 vDecSample->WaitForEOS();
287 ASSERT_EQ(AV_ERR_OK, ret);
288 ASSERT_EQ(0, vDecSample->errCount);
289 ret = vDecSample->Flush();
290 ASSERT_EQ(AV_ERR_OK, ret);
291 ret = vDecSample->Reset();
292 ASSERT_EQ(AV_ERR_OK, ret);
293 }
294
295 /**
296 * @tc.number : VIDEO_SWDEC_STATE_1300
297 * @tc.name : create-configure-start-EOS-flush-error
298 * @tc.desc : function test
299 */
300 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1300, TestSize.Level2)
301 {
302 int32_t ret = vDecSample->StartVideoDecoder();
303 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
304 vDecSample->WaitForEOS();
305 ASSERT_EQ(AV_ERR_OK, ret);
306 ASSERT_EQ(0, vDecSample->errCount);
307 ret = vDecSample->Flush();
308 ASSERT_EQ(AV_ERR_OK, ret);
309 ret = vDecSample->Release();
310 ASSERT_EQ(AV_ERR_OK, ret);
311 ret = vDecSample->ConfigureVideoDecoder();
312 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
313 }
314
315 /**
316 * @tc.number : VIDEO_SWDEC_STATE_1400
317 * @tc.name : create-configure-start-EOS-reset-configure
318 * @tc.desc : function test
319 */
320 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1400, TestSize.Level2)
321 {
322 int32_t ret = vDecSample->StartVideoDecoder();
323 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
324 vDecSample->WaitForEOS();
325 ASSERT_EQ(AV_ERR_OK, ret);
326 ASSERT_EQ(0, vDecSample->errCount);
327 ret = vDecSample->Reset();
328 ASSERT_EQ(AV_ERR_OK, ret);
329 ret = vDecSample->ConfigureVideoDecoder();
330 ASSERT_EQ(AV_ERR_OK, ret);
331 }
332
333 /**
334 * @tc.number : VIDEO_SWDEC_STATE_1500
335 * @tc.name : create-configure-start-EOS-reset-release
336 * @tc.desc : function test
337 */
338 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1500, TestSize.Level2)
339 {
340 int32_t ret = vDecSample->StartVideoDecoder();
341 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
342 vDecSample->WaitForEOS();
343 ASSERT_EQ(AV_ERR_OK, ret);
344 ASSERT_EQ(0, vDecSample->errCount);
345 ret = vDecSample->Reset();
346 ASSERT_EQ(AV_ERR_OK, ret);
347 ret = vDecSample->Release();
348 ASSERT_EQ(AV_ERR_OK, ret);
349 }
350
351 /**
352 * @tc.number : VIDEO_SWDEC_STATE_1600
353 * @tc.name : create-configure-start-EOS-reset-error
354 * @tc.desc : function test
355 */
356 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1600, TestSize.Level2)
357 {
358 int32_t ret = vDecSample->StartVideoDecoder();
359 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
360 vDecSample->WaitForEOS();
361 ASSERT_EQ(AV_ERR_OK, ret);
362 ASSERT_EQ(0, vDecSample->errCount);
363 ret = vDecSample->Reset();
364 ASSERT_EQ(AV_ERR_OK, ret);
365 ret = vDecSample->Start();
366 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
367 ret = vDecSample->Stop();
368 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
369 ret = vDecSample->Flush();
370 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
371 }
372
373 /**
374 * @tc.number : VIDEO_SWDEC_STATE_1700
375 * @tc.name : create-configure-start-flush-start-flush
376 * @tc.desc : function test
377 */
378 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1700, TestSize.Level2)
379 {
380 int32_t ret = vDecSample->Start();
381 ASSERT_EQ(AV_ERR_OK, ret);
382 ret = vDecSample->Flush();
383 ASSERT_EQ(AV_ERR_OK, ret);
384 ret = vDecSample->Start();
385 ASSERT_EQ(AV_ERR_OK, ret);
386 ret = vDecSample->Flush();
387 ASSERT_EQ(AV_ERR_OK, ret);
388 }
389
390 /**
391 * @tc.number : VIDEO_SWDEC_STATE_1800
392 * @tc.name : create-configure-start-flush-start-eos
393 * @tc.desc : function test
394 */
395 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1800, TestSize.Level2)
396 {
397 int32_t ret = vDecSample->Start();
398 ASSERT_EQ(AV_ERR_OK, ret);
399 ret = vDecSample->Flush();
400 ASSERT_EQ(AV_ERR_OK, ret);
401 ret = vDecSample->Start();
402 ASSERT_EQ(AV_ERR_OK, ret);
403 ret = vDecSample->state_EOS();
404 ASSERT_EQ(AV_ERR_OK, ret);
405 }
406
407 /**
408 * @tc.number : VIDEO_SWDEC_STATE_1900
409 * @tc.name : create-configure-start-flush-start-stop
410 * @tc.desc : function test
411 */
412 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1900, TestSize.Level2)
413 {
414 int32_t ret = vDecSample->Start();
415 ASSERT_EQ(AV_ERR_OK, ret);
416 ret = vDecSample->Flush();
417 ASSERT_EQ(AV_ERR_OK, ret);
418 ret = vDecSample->Start();
419 ASSERT_EQ(AV_ERR_OK, ret);
420 ret = vDecSample->Stop();
421 ASSERT_EQ(AV_ERR_OK, ret);
422 }
423
424 /**
425 * @tc.number : VIDEO_SWDEC_STATE_2000
426 * @tc.name : create-configure-start-flush-start-reset
427 * @tc.desc : function test
428 */
429 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2000, TestSize.Level2)
430 {
431 int32_t ret = vDecSample->Start();
432 ASSERT_EQ(AV_ERR_OK, ret);
433 ret = vDecSample->Flush();
434 ASSERT_EQ(AV_ERR_OK, ret);
435 ret = vDecSample->Start();
436 ASSERT_EQ(AV_ERR_OK, ret);
437 ret = vDecSample->Reset();
438 ASSERT_EQ(AV_ERR_OK, ret);
439 }
440
441 /**
442 * @tc.number : VIDEO_SWDEC_STATE_2100
443 * @tc.name : create-configure-start-flush-start-error
444 * @tc.desc : function test
445 */
446 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2100, TestSize.Level2)
447 {
448 int32_t ret = vDecSample->Start();
449 ASSERT_EQ(AV_ERR_OK, ret);
450 ret = vDecSample->Flush();
451 ASSERT_EQ(AV_ERR_OK, ret);
452 ret = vDecSample->Start();
453 ASSERT_EQ(AV_ERR_OK, ret);
454 ret = vDecSample->ConfigureVideoDecoder();
455 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
456 ret = vDecSample->SetVideoDecoderCallback();
457 ASSERT_EQ(AV_ERR_OK, ret);
458 ret = vDecSample->Release();
459 ASSERT_EQ(AV_ERR_OK, ret);
460 }
461
462 /**
463 * @tc.number : VIDEO_SWDEC_STATE_2200
464 * @tc.name : create-configure-start-flush-start
465 * @tc.desc : function test
466 */
467 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2200, TestSize.Level2)
468 {
469 int32_t ret = vDecSample->Start();
470 ASSERT_EQ(AV_ERR_OK, ret);
471 ret = vDecSample->Flush();
472 ASSERT_EQ(AV_ERR_OK, ret);
473 ret = vDecSample->Stop();
474 ASSERT_EQ(AV_ERR_OK, ret);
475 ret = vDecSample->Start();
476 ASSERT_EQ(AV_ERR_OK, ret);
477 }
478
479 /**
480 * @tc.number : VIDEO_SWDEC_STATE_2300
481 * @tc.name : create-configure-start-flush-stop-start
482 * @tc.desc : function test
483 */
484 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2300, TestSize.Level2)
485 {
486 int32_t ret = vDecSample->Start();
487 ASSERT_EQ(AV_ERR_OK, ret);
488 ret = vDecSample->Flush();
489 ASSERT_EQ(AV_ERR_OK, ret);
490 ret = vDecSample->Stop();
491 ASSERT_EQ(AV_ERR_OK, ret);
492 ret = vDecSample->Release();
493 ASSERT_EQ(AV_ERR_OK, ret);
494 }
495
496 /**
497 * @tc.number : VIDEO_SWDEC_STATE_2400
498 * @tc.name : create-configure-start-flush-stop-reset
499 * @tc.desc : function test
500 */
501 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2400, TestSize.Level2)
502 {
503 int32_t ret = vDecSample->Start();
504 ASSERT_EQ(AV_ERR_OK, ret);
505 ret = vDecSample->Flush();
506 ASSERT_EQ(AV_ERR_OK, ret);
507 ret = vDecSample->Stop();
508 ASSERT_EQ(AV_ERR_OK, ret);
509 ret = vDecSample->Reset();
510 ASSERT_EQ(AV_ERR_OK, ret);
511 }
512
513 /**
514 * @tc.number : VIDEO_SWDEC_STATE_2500
515 * @tc.name : create-configure-start-flush-stop-error
516 * @tc.desc : function test
517 */
518 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2500, TestSize.Level2)
519 {
520 int32_t ret = vDecSample->Start();
521 ASSERT_EQ(AV_ERR_OK, ret);
522 ret = vDecSample->Flush();
523 ASSERT_EQ(AV_ERR_OK, ret);
524 ret = vDecSample->Stop();
525 ASSERT_EQ(AV_ERR_OK, ret);
526 ret = vDecSample->Flush();
527 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
528 ret = vDecSample->SetVideoDecoderCallback();
529 ASSERT_EQ(AV_ERR_OK, ret);
530 }
531
532 /**
533 * @tc.number : VIDEO_SWDEC_STATE_2600
534 * @tc.name : create-configure-start-flush-reset-configure
535 * @tc.desc : function test
536 */
537 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2600, TestSize.Level2)
538 {
539 int32_t ret = vDecSample->Start();
540 ASSERT_EQ(AV_ERR_OK, ret);
541 ret = vDecSample->Flush();
542 ASSERT_EQ(AV_ERR_OK, ret);
543 ret = vDecSample->Reset();
544 ASSERT_EQ(AV_ERR_OK, ret);
545 ret = vDecSample->ConfigureVideoDecoder();
546 ASSERT_EQ(AV_ERR_OK, ret);
547 }
548
549 /**
550 * @tc.number : VIDEO_SWDEC_STATE_2700
551 * @tc.name : create-configure-start-flush-reset-release
552 * @tc.desc : function test
553 */
554 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2700, TestSize.Level2)
555 {
556 int32_t ret = vDecSample->Start();
557 ASSERT_EQ(AV_ERR_OK, ret);
558 ret = vDecSample->Flush();
559 ASSERT_EQ(AV_ERR_OK, ret);
560 ret = vDecSample->Reset();
561 ASSERT_EQ(AV_ERR_OK, ret);
562 ret = vDecSample->Release();
563 ASSERT_EQ(AV_ERR_OK, ret);
564 }
565
566 /**
567 * @tc.number : VIDEO_SWDEC_STATE_2800
568 * @tc.name : create-configure-start-flush-reset-error
569 * @tc.desc : function test
570 */
571 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2800, TestSize.Level2)
572 {
573 int32_t ret = vDecSample->Start();
574 ASSERT_EQ(AV_ERR_OK, ret);
575 ret = vDecSample->Flush();
576 ASSERT_EQ(AV_ERR_OK, ret);
577 ret = vDecSample->Reset();
578 ASSERT_EQ(AV_ERR_OK, ret);
579 ret = vDecSample->Start();
580 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
581 ret = vDecSample->Stop();
582 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
583 ret = vDecSample->Flush();
584 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
585 ret = vDecSample->SetVideoDecoderCallback();
586 ASSERT_EQ(AV_ERR_OK, ret);
587 }
588
589 /**
590 * @tc.number : VIDEO_SWDEC_STATE_2900
591 * @tc.name : create-configure-start-reset-configure
592 * @tc.desc : function test
593 */
594 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2900, TestSize.Level2)
595 {
596 int32_t ret = vDecSample->Start();
597 ASSERT_EQ(AV_ERR_OK, ret);
598 ret = vDecSample->Reset();
599 ASSERT_EQ(AV_ERR_OK, ret);
600 ret = vDecSample->ConfigureVideoDecoder();
601 ASSERT_EQ(AV_ERR_OK, ret);
602 }
603
604 /**
605 * @tc.number : VIDEO_SWDEC_STATE_3000
606 * @tc.name : create-configure-start-reset-release
607 * @tc.desc : function test
608 */
609 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3000, TestSize.Level2)
610 {
611 int32_t ret = vDecSample->Start();
612 ASSERT_EQ(AV_ERR_OK, ret);
613 ret = vDecSample->Reset();
614 ASSERT_EQ(AV_ERR_OK, ret);
615 ret = vDecSample->Release();
616 ASSERT_EQ(AV_ERR_OK, ret);
617 }
618
619 /**
620 * @tc.number : VIDEO_SWDEC_STATE_3100
621 * @tc.name : create-configure-start-reset-error
622 * @tc.desc : function test
623 */
624 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3100, TestSize.Level2)
625 {
626 int32_t ret = vDecSample->Start();
627 ASSERT_EQ(AV_ERR_OK, ret);
628 ret = vDecSample->Reset();
629 ASSERT_EQ(AV_ERR_OK, ret);
630 ret = vDecSample->Start();
631 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
632 ret = vDecSample->Stop();
633 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
634 ret = vDecSample->Flush();
635 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
636 ret = vDecSample->SetVideoDecoderCallback();
637 ASSERT_EQ(AV_ERR_OK, ret);
638 }
639
640 /**
641 * @tc.number : VIDEO_SWDEC_STATE_3200
642 * @tc.name : create-configure-start-error
643 * @tc.desc : function test
644 */
645 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3200, TestSize.Level2)
646 {
647 int32_t ret = vDecSample->Start();
648 ASSERT_EQ(AV_ERR_OK, ret);
649 ret = vDecSample->ConfigureVideoDecoder();
650 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
651 ret = vDecSample->SetVideoDecoderCallback();
652 ASSERT_EQ(AV_ERR_OK, ret);
653 ret = vDecSample->Release();
654 ASSERT_EQ(AV_ERR_OK, ret);
655 }
656
657 /**
658 * @tc.number : VIDEO_SWDEC_STATE_3300
659 * @tc.name : create-configure-reset-configure
660 * @tc.desc : function test
661 */
662 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3300, TestSize.Level2)
663 {
664 int32_t ret = vDecSample->Reset();
665 ASSERT_EQ(AV_ERR_OK, ret);
666 ret = vDecSample->ConfigureVideoDecoder();
667 ASSERT_EQ(AV_ERR_OK, ret);
668 }
669
670 /**
671 * @tc.number : VIDEO_SWDEC_STATE_3400
672 * @tc.name : create-configure-release
673 * @tc.desc : function test
674 */
675 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3400, TestSize.Level2)
676 {
677 int32_t ret = vDecSample->Release();
678 ASSERT_EQ(AV_ERR_OK, ret);
679 }
680 } // namespace