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