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