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