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