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 "avcodec_codec_name.h"
28 #include "native_avcapability.h"
29 using namespace std;
30 using namespace OHOS;
31 using namespace OHOS::Media;
32 using namespace testing::ext;
33 namespace OHOS {
34 namespace Media {
35 class HwdecStateNdkTest : public testing::Test {
36 public:
37 // SetUpTestCase: Called before all test cases
38 static void SetUpTestCase(void);
39 // TearDownTestCase: Called after all test case
40 static void TearDownTestCase(void);
41 // SetUp: Called before each test cases
42 void SetUp(void);
43 // TearDown: Called after each test cases
44 void TearDown(void);
45
46 protected:
47 const ::testing::TestInfo *testInfo_ = nullptr;
48 bool createCodecSuccess_ = false;
49 OH_AVCapability *cap = nullptr;
50 const string codecMime = "video/avc";
51 };
52
SetUpTestCase(void)53 void HwdecStateNdkTest::SetUpTestCase(void) {}
54
TearDownTestCase(void)55 void HwdecStateNdkTest::TearDownTestCase(void) {}
56
57 VDecNdkSample *vDecSample = NULL;
58
SetUp(void)59 void HwdecStateNdkTest::SetUp(void)
60 {
61 vDecSample = new VDecNdkSample();
62 cap = OH_AVCodec_GetCapabilityByCategory(codecMime.c_str(), false, HARDWARE);
63 string codeName = OH_AVCapability_GetName(cap);
64 cout << "codeName: " << codeName << endl;
65 int32_t ret = vDecSample->CreateVideoDecoder(codeName);
66 ASSERT_EQ(AV_ERR_OK, ret);
67 ret = vDecSample->SetVideoDecoderCallback();
68 ASSERT_EQ(AV_ERR_OK, ret);
69 ret = vDecSample->ConfigureVideoDecoder();
70 ASSERT_EQ(AV_ERR_OK, ret);
71 vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
72 }
73
TearDown(void)74 void HwdecStateNdkTest::TearDown(void)
75 {
76 vDecSample->Release();
77 delete vDecSample;
78 vDecSample = nullptr;
79 }
80 } // namespace Media
81 } // namespace OHOS
82
83 namespace {
84 /**
85 * @tc.number : VIDEO_HWDEC_STATE_0100
86 * @tc.name : create-configure-error
87 * @tc.desc : function test
88 */
89 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_0100, TestSize.Level2)
90 {
91 int32_t ret = vDecSample->Stop();
92 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
93 ret = vDecSample->Flush();
94 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
95 }
96
97 /**
98 * @tc.number : VIDEO_HWDEC_STATE_0200
99 * @tc.name : create-configure-start-stop-start
100 * @tc.desc : function test
101 */
102 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_0200, TestSize.Level2)
103 {
104 int32_t ret = vDecSample->Start();
105 ASSERT_EQ(AV_ERR_OK, ret);
106 ret = vDecSample->Stop();
107 ASSERT_EQ(AV_ERR_OK, ret);
108 ret = vDecSample->Start();
109 ASSERT_EQ(AV_ERR_OK, ret);
110 }
111
112 /**
113 * @tc.number : VIDEO_HWDEC_STATE_0300
114 * @tc.name : create-configure-start-stop-release
115 * @tc.desc : function test
116 */
117 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_0300, TestSize.Level2)
118 {
119 int32_t ret = vDecSample->Start();
120 ASSERT_EQ(AV_ERR_OK, ret);
121 ret = vDecSample->Stop();
122 ASSERT_EQ(AV_ERR_OK, ret);
123 ret = vDecSample->Release();
124 ASSERT_EQ(AV_ERR_OK, ret);
125 }
126
127 /**
128 * @tc.number : VIDEO_HWDEC_STATE_0400
129 * @tc.name : create-configure-start-stop-reset
130 * @tc.desc : function test
131 */
132 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_0400, TestSize.Level2)
133 {
134 int32_t ret = vDecSample->Start();
135 ASSERT_EQ(AV_ERR_OK, ret);
136 ret = vDecSample->Stop();
137 ASSERT_EQ(AV_ERR_OK, ret);
138 ret = vDecSample->Reset();
139 ASSERT_EQ(AV_ERR_OK, ret);
140 }
141
142 /**
143 * @tc.number : VIDEO_HWDEC_STATE_0500
144 * @tc.name : create-configure-start-stop-error
145 * @tc.desc : function test
146 */
147 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_0500, TestSize.Level2)
148 {
149 int32_t ret = vDecSample->Start();
150 ASSERT_EQ(AV_ERR_OK, ret);
151 ret = vDecSample->Stop();
152 ASSERT_EQ(AV_ERR_OK, ret);
153 ret = vDecSample->Flush();
154 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
155 }
156
157 /**
158 * @tc.number : VIDEO_HWDEC_STATE_0600
159 * @tc.name : create-configure-start-EOS-stop-start
160 * @tc.desc : function test
161 */
162 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_0700
178 * @tc.name : create-configure-start-EOS-stop-release
179 * @tc.desc : function test
180 */
181 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_0800
196 * @tc.name : create-configure-start-EOS-stop-reset
197 * @tc.desc : function test
198 */
199 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_0900
215 * @tc.name : create-configure-start-EOS-flush
216 * @tc.desc : function test
217 */
218 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_1000
231 * @tc.name : create-configure-start-EOS-flush-start
232 * @tc.desc : function test
233 */
234 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_1100
249 * @tc.name : create-configure-start-EOS-flush-stop
250 * @tc.desc : function test
251 */
252 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_1200
267 * @tc.name : create-configure-start-EOS-flush-reset
268 * @tc.desc : function test
269 */
270 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_1300
285 * @tc.name : create-configure-start-EOS-flush-error
286 * @tc.desc : function test
287 */
288 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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->Release();
298 ASSERT_EQ(AV_ERR_OK, ret);
299 ret = vDecSample->ConfigureVideoDecoder();
300 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
301 }
302
303 /**
304 * @tc.number : VIDEO_HWDEC_STATE_1400
305 * @tc.name : create-configure-start-EOS-reset-configure
306 * @tc.desc : function test
307 */
308 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_1400, TestSize.Level2)
309 {
310 int32_t ret = vDecSample->StartVideoDecoder();
311 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
312 vDecSample->WaitForEOS();
313 ASSERT_EQ(AV_ERR_OK, ret);
314 ASSERT_EQ(0, vDecSample->errCount);
315 ret = vDecSample->Reset();
316 ASSERT_EQ(AV_ERR_OK, ret);
317 ret = vDecSample->ConfigureVideoDecoder();
318 ASSERT_EQ(AV_ERR_OK, ret);
319 }
320
321 /**
322 * @tc.number : VIDEO_HWDEC_STATE_1500
323 * @tc.name : create-configure-start-EOS-reset-release
324 * @tc.desc : function test
325 */
326 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_1500, TestSize.Level2)
327 {
328 int32_t ret = vDecSample->StartVideoDecoder();
329 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
330 vDecSample->WaitForEOS();
331 ASSERT_EQ(AV_ERR_OK, ret);
332 ASSERT_EQ(0, vDecSample->errCount);
333 ret = vDecSample->Reset();
334 ASSERT_EQ(AV_ERR_OK, ret);
335 ret = vDecSample->Release();
336 ASSERT_EQ(AV_ERR_OK, ret);
337 }
338
339 /**
340 * @tc.number : VIDEO_HWDEC_STATE_1600
341 * @tc.name : create-configure-start-EOS-reset-error
342 * @tc.desc : function test
343 */
344 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_1600, TestSize.Level2)
345 {
346 int32_t ret = vDecSample->StartVideoDecoder();
347 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
348 vDecSample->WaitForEOS();
349 ASSERT_EQ(AV_ERR_OK, ret);
350 ASSERT_EQ(0, vDecSample->errCount);
351 ret = vDecSample->Reset();
352 ASSERT_EQ(AV_ERR_OK, ret);
353 ret = vDecSample->Start();
354 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
355 ret = vDecSample->Stop();
356 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
357 ret = vDecSample->Flush();
358 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
359 }
360
361 /**
362 * @tc.number : VIDEO_HWDEC_STATE_1700
363 * @tc.name : create-configure-start-flush-start-flush
364 * @tc.desc : function test
365 */
366 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_1800
380 * @tc.name : create-configure-start-flush-start-eos
381 * @tc.desc : function test
382 */
383 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_1900
397 * @tc.name : create-configure-start-flush-start-stop
398 * @tc.desc : function test
399 */
400 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_2000
414 * @tc.name : create-configure-start-flush-start-reset
415 * @tc.desc : function test
416 */
417 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_2100
431 * @tc.name : create-configure-start-flush-start-error
432 * @tc.desc : function test
433 */
434 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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_HWDEC_STATE_2200
450 * @tc.name : create-configure-start-flush-start-error
451 * @tc.desc : function test
452 */
453 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_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 cout << "set callback" << endl;
464 }
465
466 /**
467 * @tc.number : VIDEO_HWDEC_STATE_2300
468 * @tc.name : create-configure-start-flush-stop-start
469 * @tc.desc : function test
470 */
471 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_2300, TestSize.Level2)
472 {
473 int32_t ret = vDecSample->Start();
474 ASSERT_EQ(AV_ERR_OK, ret);
475 ret = vDecSample->Flush();
476 ASSERT_EQ(AV_ERR_OK, ret);
477 ret = vDecSample->Stop();
478 ASSERT_EQ(AV_ERR_OK, ret);
479 ret = vDecSample->Release();
480 ASSERT_EQ(AV_ERR_OK, ret);
481 }
482
483 /**
484 * @tc.number : VIDEO_HWDEC_STATE_2400
485 * @tc.name : create-configure-start-flush-stop-reset
486 * @tc.desc : function test
487 */
488 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_2400, TestSize.Level2)
489 {
490 int32_t ret = vDecSample->Start();
491 ASSERT_EQ(AV_ERR_OK, ret);
492 ret = vDecSample->Flush();
493 ASSERT_EQ(AV_ERR_OK, ret);
494 ret = vDecSample->Stop();
495 ASSERT_EQ(AV_ERR_OK, ret);
496 ret = vDecSample->Reset();
497 ASSERT_EQ(AV_ERR_OK, ret);
498 }
499
500 /**
501 * @tc.number : VIDEO_HWDEC_STATE_2500
502 * @tc.name : create-configure-start-flush-stop-error
503 * @tc.desc : function test
504 */
505 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_2500, TestSize.Level2)
506 {
507 int32_t ret = vDecSample->Start();
508 ASSERT_EQ(AV_ERR_OK, ret);
509 ret = vDecSample->Flush();
510 ASSERT_EQ(AV_ERR_OK, ret);
511 ret = vDecSample->Stop();
512 ASSERT_EQ(AV_ERR_OK, ret);
513 ret = vDecSample->Flush();
514 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
515 }
516
517 /**
518 * @tc.number : VIDEO_HWDEC_STATE_2600
519 * @tc.name : create-configure-start-flush-reset-configure
520 * @tc.desc : function test
521 */
522 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_2600, TestSize.Level2)
523 {
524 int32_t ret = vDecSample->Start();
525 ASSERT_EQ(AV_ERR_OK, ret);
526 ret = vDecSample->Flush();
527 ASSERT_EQ(AV_ERR_OK, ret);
528 ret = vDecSample->Reset();
529 ASSERT_EQ(AV_ERR_OK, ret);
530 ret = vDecSample->ConfigureVideoDecoder();
531 ASSERT_EQ(AV_ERR_OK, ret);
532 }
533
534 /**
535 * @tc.number : VIDEO_HWDEC_STATE_2700
536 * @tc.name : create-configure-start-flush-reset-release
537 * @tc.desc : function test
538 */
539 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_2700, TestSize.Level2)
540 {
541 int32_t ret = vDecSample->Start();
542 ASSERT_EQ(AV_ERR_OK, ret);
543 ret = vDecSample->Flush();
544 ASSERT_EQ(AV_ERR_OK, ret);
545 ret = vDecSample->Reset();
546 ASSERT_EQ(AV_ERR_OK, ret);
547 ret = vDecSample->Release();
548 ASSERT_EQ(AV_ERR_OK, ret);
549 }
550
551 /**
552 * @tc.number : VIDEO_HWDEC_STATE_2800
553 * @tc.name : create-configure-start-flush-reset-error
554 * @tc.desc : function test
555 */
556 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_2800, TestSize.Level2)
557 {
558 int32_t ret = vDecSample->Start();
559 ASSERT_EQ(AV_ERR_OK, ret);
560 ret = vDecSample->Flush();
561 ASSERT_EQ(AV_ERR_OK, ret);
562 ret = vDecSample->Reset();
563 ASSERT_EQ(AV_ERR_OK, ret);
564 ret = vDecSample->Start();
565 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
566 ret = vDecSample->Stop();
567 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
568 ret = vDecSample->Flush();
569 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
570 }
571
572 /**
573 * @tc.number : VIDEO_HWDEC_STATE_2900
574 * @tc.name : create-configure-start-reset-configure
575 * @tc.desc : function test
576 */
577 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_2900, TestSize.Level2)
578 {
579 int32_t ret = vDecSample->Start();
580 ASSERT_EQ(AV_ERR_OK, ret);
581 ret = vDecSample->Reset();
582 ASSERT_EQ(AV_ERR_OK, ret);
583 ret = vDecSample->ConfigureVideoDecoder();
584 ASSERT_EQ(AV_ERR_OK, ret);
585 }
586
587 /**
588 * @tc.number : VIDEO_HWDEC_STATE_3000
589 * @tc.name : create-configure-start-reset-release
590 * @tc.desc : function test
591 */
592 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_3000, TestSize.Level2)
593 {
594 int32_t ret = vDecSample->Start();
595 ASSERT_EQ(AV_ERR_OK, ret);
596 ret = vDecSample->Reset();
597 ASSERT_EQ(AV_ERR_OK, ret);
598 ret = vDecSample->Release();
599 ASSERT_EQ(AV_ERR_OK, ret);
600 }
601
602 /**
603 * @tc.number : VIDEO_HWDEC_STATE_3100
604 * @tc.name : create-configure-start-reset-error
605 * @tc.desc : function test
606 */
607 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_3100, TestSize.Level2)
608 {
609 int32_t ret = vDecSample->Start();
610 ASSERT_EQ(AV_ERR_OK, ret);
611 ret = vDecSample->Reset();
612 ASSERT_EQ(AV_ERR_OK, ret);
613 ret = vDecSample->Start();
614 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
615 ret = vDecSample->Stop();
616 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
617 ret = vDecSample->Flush();
618 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
619 }
620
621 /**
622 * @tc.number : VIDEO_HWDEC_STATE_3200
623 * @tc.name : create-configure-start-error
624 * @tc.desc : function test
625 */
626 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_3200, TestSize.Level2)
627 {
628 int32_t ret = vDecSample->Start();
629 ASSERT_EQ(AV_ERR_OK, ret);
630 ret = vDecSample->ConfigureVideoDecoder();
631 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
632 ret = vDecSample->Release();
633 ASSERT_EQ(AV_ERR_OK, ret);
634 }
635
636 /**
637 * @tc.number : VIDEO_HWDEC_STATE_3300
638 * @tc.name : create-configure-reset-configure
639 * @tc.desc : function test
640 */
641 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_3300, TestSize.Level2)
642 {
643 int32_t ret = vDecSample->Reset();
644 ASSERT_EQ(AV_ERR_OK, ret);
645 ret = vDecSample->ConfigureVideoDecoder();
646 ASSERT_EQ(AV_ERR_OK, ret);
647 }
648
649 /**
650 * @tc.number : VIDEO_HWDEC_STATE_3400
651 * @tc.name : create-configure-release
652 * @tc.desc : function test
653 */
654 HWTEST_F(HwdecStateNdkTest, VIDEO_HWDEC_STATE_3400, TestSize.Level2)
655 {
656 int32_t ret = vDecSample->Release();
657 ASSERT_EQ(AV_ERR_OK, ret);
658 }
659 } // namespace