• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022 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 <string>
17 #include "gtest/gtest.h"
18 #include "AVMuxerDemo.h"
19 #include "avcodec_info.h"
20 #include "avcodec_errors.h"
21 
22 using namespace std;
23 using namespace testing::ext;
24 using namespace OHOS;
25 using namespace OHOS::MediaAVCodec;
26 constexpr uint32_t SAMPLE_RATE_48000 = 48000;
27 constexpr uint32_t Buffer_Size = 100;
28 constexpr uint32_t BITRATE_320000 = 320000;
29 
30 
31 namespace {
32     class InnerAVMuxerInterfaceDependCheckTest : public testing::Test {
33     public:
34         static void SetUpTestCase();
35         static void TearDownTestCase();
36         void SetUp() override;
37         void TearDown() override;
38     };
39 
SetUpTestCase()40     void InnerAVMuxerInterfaceDependCheckTest::SetUpTestCase() {}
TearDownTestCase()41     void InnerAVMuxerInterfaceDependCheckTest::TearDownTestCase() {}
SetUp()42     void InnerAVMuxerInterfaceDependCheckTest::SetUp() {}
TearDown()43     void InnerAVMuxerInterfaceDependCheckTest::TearDown() {}
44 
Create(AVMuxerDemo * muxerDemo)45     int32_t Create(AVMuxerDemo* muxerDemo)
46     {
47         OutputFormat format = OUTPUT_FORMAT_MPEG_4;
48         int32_t fd = muxerDemo->InnergetFdByMode(format);
49         return muxerDemo->InnerCreate(fd, format);
50     }
51 
SetRotation(AVMuxerDemo * muxerDemo)52     int32_t SetRotation(AVMuxerDemo* muxerDemo)
53     {
54         int32_t rotation = 0;
55 
56         return muxerDemo->InnerSetRotation(rotation);
57     }
58 
AddTrack(AVMuxerDemo * muxerDemo)59     int32_t AddTrack(AVMuxerDemo* muxerDemo)
60     {
61         MediaDescription audioParams;
62         uint8_t a[100];
63         int32_t trackIndex = 0;
64 
65         audioParams.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, CodecMimeType::AUDIO_AAC);
66         audioParams.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, BITRATE_320000);
67         audioParams.PutBuffer(MediaDescriptionKey::MD_KEY_CODEC_CONFIG, a, Buffer_Size);
68         audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, 1);
69         audioParams.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, SAMPLE_RATE_48000);
70 
71         return muxerDemo->InnerAddTrack(trackIndex, audioParams);
72     }
73 
Start(AVMuxerDemo * muxerDemo)74     int32_t Start(AVMuxerDemo* muxerDemo)
75     {
76         return muxerDemo->InnerStart();
77     }
78 
WriteSample(AVMuxerDemo * muxerDemo,uint32_t trackIndex)79     int32_t WriteSample(AVMuxerDemo* muxerDemo, uint32_t trackIndex)
80     {
81         uint8_t data[100];
82         AVCodecBufferInfo info;
83         info.presentationTimeUs = 0;
84         info.size = Buffer_Size;
85         AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
86         info.offset = 0;
87 
88         std::shared_ptr<AVSharedMemoryBase> avMemBuffer = std::make_shared<AVSharedMemoryBase>
89         (info.size, AVSharedMemory::FLAGS_READ_ONLY, "sampleData");
90         avMemBuffer->Init();
91         auto ret = memcpy_s(avMemBuffer->GetBase(), avMemBuffer->GetSize(), data, info.size);
92         if (ret != EOK) {
93             printf("WriteSample memcpy_s failed, ret:%d\n", ret);
94             return ret;
95         }
96         return muxerDemo->InnerWriteSample(trackIndex, avMemBuffer, info, flag);
97     }
98 
Stop(AVMuxerDemo * muxerDemo)99     int32_t Stop(AVMuxerDemo* muxerDemo)
100     {
101         return muxerDemo->InnerStop();
102     }
103 
Destroy(AVMuxerDemo * muxerDemo)104     int32_t Destroy(AVMuxerDemo* muxerDemo)
105     {
106         return muxerDemo->InnerDestroy();
107     }
108 }
109 
110 /**
111  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_001
112  * @tc.name      : Create -> SetRotation
113  * @tc.desc      : interface depend check
114  */
115 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_001, TestSize.Level2)
116 {
117     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
118     Create(muxerDemo);
119 
120     int32_t ret;
121 
122     ret = SetRotation(muxerDemo);
123     ASSERT_EQ(AVCS_ERR_OK, ret);
124 
125     Destroy(muxerDemo);
126     delete muxerDemo;
127 }
128 
129 
130 /**
131  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_002
132  * @tc.name      : Create -> SetRotation -> SetRotation
133  * @tc.desc      : interface depend check
134  */
135 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_002, TestSize.Level2)
136 {
137     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
138     Create(muxerDemo);
139 
140     int32_t ret;
141 
142     ret = SetRotation(muxerDemo);
143     ASSERT_EQ(AVCS_ERR_OK, ret);
144 
145     ret = SetRotation(muxerDemo);
146     ASSERT_EQ(AVCS_ERR_OK, ret);
147 
148     Destroy(muxerDemo);
149     delete muxerDemo;
150 }
151 
152 
153 /**
154  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_003
155  * @tc.name      : Create -> AddTrack -> SetRotation
156  * @tc.desc      : interface depend check
157  */
158 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_003, TestSize.Level2)
159 {
160     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
161     Create(muxerDemo);
162 
163     int32_t ret;
164 
165     int32_t trackId = AddTrack(muxerDemo);
166     ASSERT_EQ(0, trackId);
167 
168     ret = SetRotation(muxerDemo);
169     ASSERT_EQ(AVCS_ERR_OK, ret);
170 
171     Destroy(muxerDemo);
172     delete muxerDemo;
173 }
174 
175 /**
176  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_004
177  * @tc.name      : Create -> AddTrack -> Start -> SetRotation
178  * @tc.desc      : interface depend check
179  */
180 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_004, TestSize.Level2)
181 {
182     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
183     Create(muxerDemo);
184 
185     int32_t ret;
186 
187     int32_t trackId = AddTrack(muxerDemo);
188     ASSERT_EQ(0, trackId);
189 
190     ret = Start(muxerDemo);
191     ASSERT_EQ(AVCS_ERR_OK, ret);
192 
193     ret = SetRotation(muxerDemo);
194     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
195 
196     Destroy(muxerDemo);
197     delete muxerDemo;
198 }
199 
200 
201 /**
202  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_005
203  * @tc.name      : Create -> AddTrack -> Start -> Stop -> SetRotation
204  * @tc.desc      : interface depend check
205  */
206 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_005, TestSize.Level2)
207 {
208     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
209     Create(muxerDemo);
210 
211     int32_t ret;
212 
213     int32_t trackId = AddTrack(muxerDemo);
214     ASSERT_EQ(0, trackId);
215 
216     ret = Start(muxerDemo);
217     ASSERT_EQ(AVCS_ERR_OK, ret);
218 
219     ret = Stop(muxerDemo);
220     ASSERT_EQ(AVCS_ERR_OK, ret);
221 
222     ret = SetRotation(muxerDemo);
223     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
224 
225     Destroy(muxerDemo);
226     delete muxerDemo;
227 }
228 
229 
230 /**
231  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_006
232  * @tc.name      : Create -> AddTrack
233  * @tc.desc      : interface depend check
234  */
235 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_006, TestSize.Level2)
236 {
237     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
238     Create(muxerDemo);
239 
240     int32_t trackId = AddTrack(muxerDemo);
241     ASSERT_EQ(0, trackId);
242 
243     Destroy(muxerDemo);
244     delete muxerDemo;
245 }
246 
247 
248 /**
249  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_007
250  * @tc.name      : Create -> AddTrack -> AddTrack
251  * @tc.desc      : interface depend check
252  */
253 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_007, TestSize.Level2)
254 {
255     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
256     Create(muxerDemo);
257 
258     int32_t trackId = AddTrack(muxerDemo);
259     ASSERT_EQ(0, trackId);
260 
261     trackId = AddTrack(muxerDemo);
262     ASSERT_EQ(0, trackId);
263 
264     Destroy(muxerDemo);
265     delete muxerDemo;
266 }
267 
268 
269 /**
270  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_008
271  * @tc.name      : Create -> SetRotation -> AddTrack
272  * @tc.desc      : interface depend check
273  */
274 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_008, TestSize.Level2)
275 {
276     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
277     Create(muxerDemo);
278 
279     int32_t ret;
280 
281     ret = SetRotation(muxerDemo);
282     ASSERT_EQ(AVCS_ERR_OK, ret);
283 
284     int32_t trackId = AddTrack(muxerDemo);
285     ASSERT_EQ(0, trackId);
286 
287     Destroy(muxerDemo);
288     delete muxerDemo;
289 }
290 
291 /**
292  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_009
293  * @tc.name      : Create -> AddTrack -> Start -> AddTrack
294  * @tc.desc      : interface depend check
295  */
296 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_009, TestSize.Level2)
297 {
298     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
299     Create(muxerDemo);
300 
301     int32_t ret;
302 
303     int32_t trackId = AddTrack(muxerDemo);
304     ASSERT_EQ(0, trackId);
305 
306     ret = Start(muxerDemo);
307     ASSERT_EQ(AVCS_ERR_OK, ret);
308 
309     trackId = AddTrack(muxerDemo);
310     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, trackId);
311 
312     Destroy(muxerDemo);
313     delete muxerDemo;
314 }
315 
316 
317 /**
318  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_010
319  * @tc.name      : Create -> AddTrack -> Start -> Stop -> AddTrack
320  * @tc.desc      : interface depend check
321  */
322 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_010, TestSize.Level2)
323 {
324     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
325     Create(muxerDemo);
326 
327     int32_t ret;
328 
329     int32_t trackId = AddTrack(muxerDemo);
330     ASSERT_EQ(0, trackId);
331 
332     ret = Start(muxerDemo);
333     ASSERT_EQ(AVCS_ERR_OK, ret);
334 
335     ret = Stop(muxerDemo);
336     ASSERT_EQ(AVCS_ERR_OK, ret);
337 
338     trackId = AddTrack(muxerDemo);
339     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, trackId);
340 
341     Destroy(muxerDemo);
342     delete muxerDemo;
343 }
344 
345 
346 /**
347  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_011
348  * @tc.name      : Create -> Start
349  * @tc.desc      : interface depend check
350  */
351 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_011, TestSize.Level2)
352 {
353     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
354     Create(muxerDemo);
355 
356     int32_t ret;
357 
358     ret = Start(muxerDemo);
359     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
360 
361     Destroy(muxerDemo);
362     delete muxerDemo;
363 }
364 
365 
366 /**
367  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_012
368  * @tc.name      : Create -> AddTrack -> Start
369  * @tc.desc      : interface depend check
370  */
371 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_012, TestSize.Level2)
372 {
373     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
374     Create(muxerDemo);
375 
376     int32_t ret;
377 
378     int32_t trackId = AddTrack(muxerDemo);
379     ASSERT_EQ(0, trackId);
380 
381     ret = Start(muxerDemo);
382     ASSERT_EQ(AVCS_ERR_OK, ret);
383 
384     Destroy(muxerDemo);
385     delete muxerDemo;
386 }
387 
388 /**
389  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_013
390  * @tc.name      : Create -> SetRotation -> AddTrack -> Start
391  * @tc.desc      : interface depend check
392  */
393 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_013, TestSize.Level2)
394 {
395     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
396     Create(muxerDemo);
397 
398     int32_t ret;
399 
400     ret = SetRotation(muxerDemo);
401     ASSERT_EQ(AVCS_ERR_OK, ret);
402 
403     int32_t trackId = AddTrack(muxerDemo);
404     ASSERT_EQ(0, trackId);
405 
406     ret = Start(muxerDemo);
407     ASSERT_EQ(AVCS_ERR_OK, ret);
408 
409     Destroy(muxerDemo);
410     delete muxerDemo;
411 }
412 
413 /**
414  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_014
415  * @tc.name      : Create -> AddTrack -> Start -> Start
416  * @tc.desc      : interface depend check
417  */
418 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_014, TestSize.Level2)
419 {
420     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
421     Create(muxerDemo);
422 
423     int32_t ret;
424 
425     int32_t trackId = AddTrack(muxerDemo);
426     ASSERT_EQ(0, trackId);
427 
428     ret = Start(muxerDemo);
429     ASSERT_EQ(AVCS_ERR_OK, ret);
430 
431     ret = Start(muxerDemo);
432     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
433 
434     Destroy(muxerDemo);
435     delete muxerDemo;
436 }
437 
438 
439 /**
440  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_015
441  * @tc.name      : Create -> AddTrack -> Start -> Stop -> Start
442  * @tc.desc      : interface depend check
443  */
444 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_015, TestSize.Level2)
445 {
446     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
447     Create(muxerDemo);
448 
449     int32_t ret;
450 
451     int32_t trackId = AddTrack(muxerDemo);
452     ASSERT_EQ(0, trackId);
453 
454     ret = Start(muxerDemo);
455     ASSERT_EQ(AVCS_ERR_OK, ret);
456 
457     ret = Stop(muxerDemo);
458     ASSERT_EQ(AVCS_ERR_OK, ret);
459 
460     ret = Start(muxerDemo);
461     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
462 
463     Destroy(muxerDemo);
464     delete muxerDemo;
465 }
466 
467 
468 /**
469  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_016
470  * @tc.name      : Create -> WriteSample
471  * @tc.desc      : interface depend check
472  */
473 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_016, TestSize.Level2)
474 {
475     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
476     Create(muxerDemo);
477 
478     int32_t ret;
479     int32_t trackId = -1;
480 
481     ret = WriteSample(muxerDemo, trackId);
482     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
483 
484     Destroy(muxerDemo);
485     delete muxerDemo;
486 }
487 
488 
489 /**
490  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_017
491  * @tc.name      : Create -> AddTrack -> WriteSample
492  * @tc.desc      : interface depend check
493  */
494 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_017, TestSize.Level2)
495 {
496     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
497     Create(muxerDemo);
498 
499     int32_t ret;
500     int32_t trackId = -1;
501 
502     trackId = AddTrack(muxerDemo);
503     ASSERT_EQ(0, trackId);
504 
505     ret = WriteSample(muxerDemo, trackId);
506     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
507 
508     Destroy(muxerDemo);
509     delete muxerDemo;
510 }
511 
512 
513 /**
514  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_018
515  * @tc.name      : Create -> SetRotation -> AddTrack -> Start -> WriteSampleBuffer
516  * @tc.desc      : interface depend check
517  */
518 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_018, TestSize.Level2)
519 {
520     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
521     Create(muxerDemo);
522 
523     int32_t ret;
524     int32_t trackId = -1;
525 
526     ret = SetRotation(muxerDemo);
527     ASSERT_EQ(AVCS_ERR_OK, ret);
528 
529     trackId = AddTrack(muxerDemo);
530     ASSERT_EQ(AVCS_ERR_OK, trackId);
531 
532     ret = Start(muxerDemo);
533     ASSERT_EQ(AVCS_ERR_OK, ret);
534 
535     ret = WriteSample(muxerDemo, trackId);
536     ASSERT_EQ(AVCS_ERR_OK, ret);
537 
538     Destroy(muxerDemo);
539     delete muxerDemo;
540 }
541 
542 
543 /**
544  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_019
545  * @tc.name      : Create -> AddTrack -> Start -> WriteSample
546  * @tc.desc      : interface depend check
547  */
548 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_019, TestSize.Level2)
549 {
550     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
551     Create(muxerDemo);
552 
553     int32_t ret;
554     int32_t trackId = -1;
555 
556     trackId = AddTrack(muxerDemo);
557     ASSERT_EQ(0, trackId);
558 
559     ret = Start(muxerDemo);
560     ASSERT_EQ(AVCS_ERR_OK, ret);
561 
562     ret = WriteSample(muxerDemo, trackId);
563     ASSERT_EQ(AVCS_ERR_OK, ret);
564 
565     Destroy(muxerDemo);
566     delete muxerDemo;
567 }
568 
569 
570 /**
571  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_020
572  * @tc.name      : Create -> AddTrack -> Start -> WriteSample -> WriteSample
573  * @tc.desc      : interface depend check
574  */
575 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_020, TestSize.Level2)
576 {
577     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
578     Create(muxerDemo);
579 
580     int32_t ret;
581     int32_t trackId = -1;
582 
583     trackId = AddTrack(muxerDemo);
584     ASSERT_EQ(0, trackId);
585 
586     ret = Start(muxerDemo);
587     ASSERT_EQ(AVCS_ERR_OK, ret);
588 
589     ret = WriteSample(muxerDemo, trackId);
590     ASSERT_EQ(AVCS_ERR_OK, ret);
591 
592     ret = WriteSample(muxerDemo, trackId);
593     ASSERT_EQ(AVCS_ERR_OK, ret);
594 
595     Destroy(muxerDemo);
596     delete muxerDemo;
597 }
598 
599 
600 /**
601  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_021
602  * @tc.name      : Create -> AddTrack -> Start -> Stop -> WriteSample
603  * @tc.desc      : interface depend check
604  */
605 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_021, TestSize.Level2)
606 {
607     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
608     Create(muxerDemo);
609 
610     int32_t ret;
611     int32_t trackId = -1;
612 
613     trackId = AddTrack(muxerDemo);
614     ASSERT_EQ(0, trackId);
615 
616     ret = Start(muxerDemo);
617     ASSERT_EQ(AVCS_ERR_OK, ret);
618 
619     ret = Stop(muxerDemo);
620     ASSERT_EQ(AVCS_ERR_OK, ret);
621 
622     ret = WriteSample(muxerDemo, trackId);
623     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
624 
625     Destroy(muxerDemo);
626     delete muxerDemo;
627 }
628 
629 
630 /**
631  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_022
632  * @tc.name      : Create -> Stop
633  * @tc.desc      : interface depend check
634  */
635 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_022, TestSize.Level2)
636 {
637     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
638     Create(muxerDemo);
639 
640     int32_t ret;
641 
642     ret = Stop(muxerDemo);
643     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
644 
645     Destroy(muxerDemo);
646     delete muxerDemo;
647 }
648 
649 
650 /**
651  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_023
652  * @tc.name      : Create -> AddTrack -> Stop
653  * @tc.desc      : interface depend check
654  */
655 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_023, TestSize.Level2)
656 {
657     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
658     Create(muxerDemo);
659 
660     int32_t ret;
661 
662     int32_t trackId = AddTrack(muxerDemo);
663     ASSERT_EQ(0, trackId);
664 
665     ret = Stop(muxerDemo);
666     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
667 
668     Destroy(muxerDemo);
669     delete muxerDemo;
670 }
671 
672 
673 /**
674  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_024
675  * @tc.name      : Create -> AddTrack -> Start -> Stop
676  * @tc.desc      : interface depend check
677  */
678 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_024, TestSize.Level2)
679 {
680     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
681     Create(muxerDemo);
682 
683     int32_t ret;
684 
685     int32_t trackId = AddTrack(muxerDemo);
686     ASSERT_EQ(0, trackId);
687 
688     ret = Start(muxerDemo);
689     ASSERT_EQ(AVCS_ERR_OK, ret);
690 
691     ret = Stop(muxerDemo);
692     ASSERT_EQ(AVCS_ERR_OK, ret);
693 
694     Destroy(muxerDemo);
695     delete muxerDemo;
696 }
697 
698 /**
699  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_025
700  * @tc.name      : Create -> SetRotation -> AddTrack -> Start -> Stop
701  * @tc.desc      : interface depend check
702  */
703 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_025, TestSize.Level2)
704 {
705     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
706     Create(muxerDemo);
707 
708     int32_t ret;
709 
710     ret = SetRotation(muxerDemo);
711     ASSERT_EQ(AVCS_ERR_OK, ret);
712 
713     int32_t trackId = AddTrack(muxerDemo);
714     ASSERT_EQ(0, trackId);
715 
716     ret = Start(muxerDemo);
717     ASSERT_EQ(AVCS_ERR_OK, ret);
718 
719     ret = Stop(muxerDemo);
720     ASSERT_EQ(AVCS_ERR_OK, ret);
721 
722     Destroy(muxerDemo);
723     delete muxerDemo;
724 }
725 
726 
727 /**
728  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_026
729  * @tc.name      : Create -> AddTrack -> Start -> WriteSample -> Stop -> Stop
730  * @tc.desc      : interface depend check
731  */
732 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_026, TestSize.Level2)
733 {
734     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
735     Create(muxerDemo);
736 
737     int32_t ret;
738 
739     int32_t trackId = AddTrack(muxerDemo);
740     ASSERT_EQ(0, trackId);
741 
742     ret = Start(muxerDemo);
743     ASSERT_EQ(AVCS_ERR_OK, ret);
744 
745     ret = WriteSample(muxerDemo, trackId);
746     ASSERT_EQ(AVCS_ERR_OK, ret);
747 
748     ret = Stop(muxerDemo);
749     ASSERT_EQ(AVCS_ERR_OK, ret);
750 
751     ret = Stop(muxerDemo);
752     ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, ret);
753 
754     Destroy(muxerDemo);
755     delete muxerDemo;
756 }
757 
758 
759 /**
760  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_027
761  * @tc.name      : Create -> Destroy
762  * @tc.desc      : interface depend check
763  */
764 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_027, TestSize.Level2)
765 {
766     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
767     Create(muxerDemo);
768 
769     int32_t ret;
770 
771     ret = Destroy(muxerDemo);
772     ASSERT_EQ(AVCS_ERR_OK, ret);
773 
774     delete muxerDemo;
775 }
776 
777 /**
778  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_028
779  * @tc.name      : Create -> SetRotation -> Destroy
780  * @tc.desc      : interface depend check
781  */
782 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_028, TestSize.Level2)
783 {
784     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
785     Create(muxerDemo);
786 
787     int32_t ret;
788 
789     ret = SetRotation(muxerDemo);
790     ASSERT_EQ(AVCS_ERR_OK, ret);
791 
792     ret = Destroy(muxerDemo);
793     ASSERT_EQ(AVCS_ERR_OK, ret);
794 
795     delete muxerDemo;
796 }
797 
798 /**
799  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_029
800  * @tc.name      : Create -> AddTrack -> Destroy
801  * @tc.desc      : interface depend check
802  */
803 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_029, TestSize.Level2)
804 {
805     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
806     Create(muxerDemo);
807 
808     int32_t ret;
809 
810     int32_t trackId = AddTrack(muxerDemo);
811     ASSERT_EQ(0, trackId);
812 
813     ret = Destroy(muxerDemo);
814     ASSERT_EQ(AVCS_ERR_OK, ret);
815 
816     delete muxerDemo;
817 }
818 
819 
820 /**
821  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_030
822  * @tc.name      : Create -> AddTrack -> Start -> Destroy
823  * @tc.desc      : interface depend check
824  */
825 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_030, TestSize.Level2)
826 {
827     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
828     Create(muxerDemo);
829 
830     int32_t ret;
831 
832     int32_t trackId = AddTrack(muxerDemo);
833     ASSERT_EQ(0, trackId);
834 
835     ret = Start(muxerDemo);
836     ASSERT_EQ(AVCS_ERR_OK, ret);
837 
838     ret = Destroy(muxerDemo);
839     ASSERT_EQ(AVCS_ERR_OK, ret);
840 
841     delete muxerDemo;
842 }
843 
844 
845 /**
846  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_031
847  * @tc.name      : Create -> AddTrack -> Start -> WriteSample -> Destroy
848  * @tc.desc      : interface depend check
849  */
850 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_031, TestSize.Level2)
851 {
852     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
853     Create(muxerDemo);
854 
855     int32_t ret;
856 
857     int32_t trackId = AddTrack(muxerDemo);
858     ASSERT_EQ(0, trackId);
859 
860     ret = Start(muxerDemo);
861     ASSERT_EQ(AVCS_ERR_OK, ret);
862 
863     ret = WriteSample(muxerDemo, trackId);
864     ASSERT_EQ(AVCS_ERR_OK, ret);
865 
866     ret = Destroy(muxerDemo);
867     ASSERT_EQ(AVCS_ERR_OK, ret);
868 
869     delete muxerDemo;
870 }
871 
872 
873 /**
874  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_032
875  * @tc.name      : Create -> AddTrack -> Start -> WriteSample -> Stop -> Destroy
876  * @tc.desc      : interface depend check
877  */
878 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_032, TestSize.Level2)
879 {
880     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
881     Create(muxerDemo);
882 
883     int32_t ret;
884 
885     int32_t trackId = AddTrack(muxerDemo);
886     ASSERT_EQ(0, trackId);
887 
888     ret = Start(muxerDemo);
889     ASSERT_EQ(AVCS_ERR_OK, ret);
890 
891     ret = WriteSample(muxerDemo, trackId);
892     ASSERT_EQ(AVCS_ERR_OK, ret);
893 
894     ret = Stop(muxerDemo);
895     ASSERT_EQ(AVCS_ERR_OK, ret);
896 
897     ret = Destroy(muxerDemo);
898     ASSERT_EQ(AVCS_ERR_OK, ret);
899 
900     delete muxerDemo;
901 }
902 
903 
904 /**
905  * @tc.number    : SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_033
906  * @tc.name      : Create -> SetRotation -> AddTrack -> Start -> WriteSample -> Stop -> Destroy
907  * @tc.desc      : interface depend check
908  */
909 HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_033, TestSize.Level2)
910 {
911     AVMuxerDemo* muxerDemo = new AVMuxerDemo();
912     Create(muxerDemo);
913 
914     int32_t ret;
915 
916     ret = SetRotation(muxerDemo);
917     ASSERT_EQ(AVCS_ERR_OK, ret);
918 
919     int32_t trackId = AddTrack(muxerDemo);
920     ASSERT_EQ(0, trackId);
921 
922     ret = Start(muxerDemo);
923     ASSERT_EQ(AVCS_ERR_OK, ret);
924 
925     ret = WriteSample(muxerDemo, trackId);
926     ASSERT_EQ(AVCS_ERR_OK, ret);
927 
928     ret = Stop(muxerDemo);
929     ASSERT_EQ(AVCS_ERR_OK, ret);
930 
931     ret = Destroy(muxerDemo);
932     ASSERT_EQ(AVCS_ERR_OK, ret);
933 
934     delete muxerDemo;
935 }