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 
21 using namespace std;
22 using namespace testing::ext;
23 using namespace OHOS;
24 using namespace OHOS::MediaAVCodec;
25 using namespace OHOS::Media;
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         Plugins::OutputFormat format = Plugins::OutputFormat::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         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 
Start(AVMuxerDemo* muxerDemo)75     int32_t Start(AVMuxerDemo* muxerDemo)
76     {
77         return muxerDemo->InnerStart();
78     }
79 
WriteSample(AVMuxerDemo* muxerDemo, uint32_t trackIndex)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 
Stop(AVMuxerDemo* muxerDemo)89     int32_t Stop(AVMuxerDemo* muxerDemo)
90     {
91         return muxerDemo->InnerStop();
92     }
93 
Destroy(AVMuxerDemo* muxerDemo)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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_001, TestSize.Level2)105 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_002, TestSize.Level2)125 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_003, TestSize.Level2)148 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_004, TestSize.Level2)170 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_005, TestSize.Level2)196 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_006, TestSize.Level2)225 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_007, TestSize.Level2)243 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_008, TestSize.Level2)264 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_009, TestSize.Level2)286 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_010, TestSize.Level2)312 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_011, TestSize.Level2)341 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_012, TestSize.Level2)361 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_013, TestSize.Level2)383 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_014, TestSize.Level2)408 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_015, TestSize.Level2)434 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_016, TestSize.Level2)463 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_017, TestSize.Level2)484 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_018, TestSize.Level2)508 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_019, TestSize.Level2)538 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_020, TestSize.Level2)565 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_021, TestSize.Level2)595 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_022, TestSize.Level2)625 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_023, TestSize.Level2)645 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_024, TestSize.Level2)668 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_025, TestSize.Level2)693 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_026, TestSize.Level2)722 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_027, TestSize.Level2)754 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_028, TestSize.Level2)772 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_029, TestSize.Level2)793 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_030, TestSize.Level2)815 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_031, TestSize.Level2)840 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_032, TestSize.Level2)868 HWTEST_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  */
HWTEST_F(InnerAVMuxerInterfaceDependCheckTest, SUB_MULTIMEDIA_MEDIA_MUXER_INTERFACE_DEPEND_CHECK_033, TestSize.Level2)899 HWTEST_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 }