1 /*
2 * Copyright (c) 2025 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 "hitranscode_impl_unittest.h"
17 #include "media_errors.h"
18
19 namespace OHOS {
20 namespace Media {
21 using namespace std;
22 using namespace testing;
23 using namespace testing::ext;
24
25 const static int32_t TIMES_ONE = 1;
26 const static int32_t TIMES_TWO = 2;
27 const std::string MEDIA_ROOT = "files:///data/test/media/";
28
SetUpTestCase(void)29 void HitranscodeImplUnitTest::SetUpTestCase(void)
30 {
31 }
32
TearDownTestCase(void)33 void HitranscodeImplUnitTest::TearDownTestCase(void)
34 {
35 }
36
SetUp(void)37 void HitranscodeImplUnitTest::SetUp(void)
38 {
39 int32_t appUid = 0;
40 int32_t appPid = 0;
41 uint32_t appTokenId = 0;
42 uint64_t appFullTokenId = 0;
43
44 demuxerFilter_ = std::make_shared<Pipeline::DemuxerFilter>("mockDemuxerFilter",
45 Pipeline::FilterType::FILTERTYPE_DEMUXER);
46 mockCallbackLooper_ = std::make_shared<MockHiTransCoderCallbackLooper>();
47 transcoder_ = std::make_unique<HiTransCoderImpl>(appUid, appPid, appTokenId, appFullTokenId);
48 }
49
TearDown(void)50 void HitranscodeImplUnitTest::TearDown(void)
51 {
52 demuxerFilter_.reset();
53 mockCallbackLooper_.reset();
54 transcoder_.reset();
55 }
56
57 /**
58 * @tc.name : Test SetInputFile
59 * @tc.number: SetInputFile_001
60 * @tc.desc : Test SetInputFile demuxerFilter_ == nullptr
61 * Test ~HiTransCoderImpl transCoderEventReceiver_ == nullptr
62 * Test ~HiTransCoderImpl transCoderFilterCallback_ == nullptr
63 */
64 HWTEST_F(HitranscodeImplUnitTest, SetInputFile_001, TestSize.Level1)
65 {
66 // Test SetInputFile demuxerFilter_ == nullptr
67 Pipeline::FilterFactory::Instance().generators.clear();
68
69 // Test ~HiTransCoderImpl transCoderEventReceiver_ == nullptr
70 transcoder_->transCoderEventReceiver_ = nullptr;
71
72 // Test ~HiTransCoderImpl transCoderFilterCallback_ == nullptr
73 transcoder_->transCoderFilterCallback_ = nullptr;
74
75 int32_t ret = transcoder_->SetInputFile(MEDIA_ROOT);
76 EXPECT_EQ(ret, MSERR_NO_MEMORY);
77 }
78
79 /**
80 * @tc.name : Test SetInputFile
81 * @tc.number: SetInputFile_002
82 * @tc.desc : Test SetInputFile TransTranscoderStatus != MSERR_OK
83 */
84 HWTEST_F(HitranscodeImplUnitTest, SetInputFile_002, TestSize.Level1)
85 {
86 Pipeline::FilterFactory::Instance().RegisterFilter<Pipeline::DemuxerFilter>(
87 "builtin.player.demuxer", Pipeline::FilterType::FILTERTYPE_DEMUXER,
__anon13975f3a0102(const std::string& name, const Pipeline::FilterType type) 88 [](const std::string& name, const Pipeline::FilterType type) {
89 return std::make_shared<Pipeline::DemuxerFilter>(name, Pipeline::FilterType::FILTERTYPE_DEMUXER);
90 }
91 );
92 int32_t ret = transcoder_->SetInputFile(MEDIA_ROOT);
93 EXPECT_EQ(ret, MSERR_UNSUPPORT_CONTAINER_TYPE);
94 }
95
96 /**
97 * @tc.name : Test ConfigureVideoAudioMetaData
98 * @tc.number: ConfigureVideoAudioMetaData_001
99 * @tc.desc : Test ConfigureVideoAudioMetaData trackCount == 0
100 */
101 HWTEST_F(HitranscodeImplUnitTest, ConfigureVideoAudioMetaData_001, TestSize.Level1)
102 {
103 transcoder_->demuxerFilter_ = demuxerFilter_;
104 Status ret = transcoder_->ConfigureVideoAudioMetaData();
105 EXPECT_EQ(ret, Status::ERROR_NO_TRACK);
106 }
107
108 /**
109 * @tc.name : Test Prepare
110 * @tc.number: Prepare_001
111 * @tc.desc : Test Prepare pipeline_->Prepare() != Status::OK
112 */
113 HWTEST_F(HitranscodeImplUnitTest, Prepare_001, TestSize.Level1)
114 {
115 transcoder_->demuxerFilter_ = demuxerFilter_;
116 transcoder_->pipeline_->filters_.push_back(demuxerFilter_);
117 transcoder_->demuxerFilter_->curState_ = Pipeline::FilterState::ERROR;
118 transcoder_->isExistVideoTrack_ = false;
119 int32_t ret = transcoder_->Prepare();
120 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
121 }
122
123 /**
124 * @tc.name : Test Prepare
125 * @tc.number: Prepare_002
126 * @tc.desc : Test Prepare SetSurfacePipeline(width, height) == Status::ERROR_UNKNOWN
127 */
128 HWTEST_F(HitranscodeImplUnitTest, Prepare_002, TestSize.Level1)
129 {
130 transcoder_->demuxerFilter_ = demuxerFilter_;
131 transcoder_->pipeline_->filters_.clear();
132 transcoder_->isExistVideoTrack_ = false;
133 int32_t ret = transcoder_->Prepare();
134 EXPECT_EQ(ret, MSERR_UNKNOWN);
135 }
136
137 /**
138 * @tc.name : Test Start
139 * @tc.number: Start_001
140 * @tc.desc : Test Start TransTranscoderStatus(pipeline_->Start()) != MSERR_OK
141 */
142 HWTEST_F(HitranscodeImplUnitTest, Start_001, TestSize.Level1)
143 {
144 transcoder_->demuxerFilter_ = demuxerFilter_;
145 transcoder_->pipeline_->filters_.push_back(demuxerFilter_);
146 transcoder_->demuxerFilter_->demuxer_.reset();
147 int32_t ret = transcoder_->Start();
148 EXPECT_EQ(ret, MSERR_UNKNOWN);
149 }
150
151 /**
152 * @tc.name : Test Pause
153 * @tc.number: Pause_001
154 * @tc.desc : Test Pause TransTranscoderStatus(pipeline_->Pause()) != MSERR_OK
155 */
156 HWTEST_F(HitranscodeImplUnitTest, Pause_001, TestSize.Level1)
157 {
158 EXPECT_CALL(*mockCallbackLooper_, OnError(_, _)).Times(TIMES_ONE);
159 transcoder_->callbackLooper_ = mockCallbackLooper_;
160
161 transcoder_->demuxerFilter_ = demuxerFilter_;
162 transcoder_->pipeline_->filters_.push_back(demuxerFilter_);
163 transcoder_->demuxerFilter_->demuxer_.reset();
164 int32_t ret = transcoder_->Pause();
165 EXPECT_EQ(ret, MSERR_UNKNOWN);
166 }
167
168 /**
169 * @tc.name : Test Pause
170 * @tc.number: Pause_002
171 * @tc.desc : Test Pause startTime_ == -1
172 */
173 HWTEST_F(HitranscodeImplUnitTest, Pause_002, TestSize.Level1)
174 {
175 transcoder_->demuxerFilter_ = demuxerFilter_;
176 transcoder_->callbackLooper_ = std::make_shared<HiTransCoderCallbackLooper>();
177 transcoder_->startTime_ = -1;
178 int32_t ret = transcoder_->Pause();
179 EXPECT_EQ(ret, MSERR_OK);
180 }
181
182 /**
183 * @tc.name : Test Resume
184 * @tc.number: Resume_001
185 * @tc.desc : Test Resume TransTranscoderStatus(pipeline_->Resume()) != MSERR_OK
186 */
187 HWTEST_F(HitranscodeImplUnitTest, Resume_001, TestSize.Level1)
188 {
189 transcoder_->demuxerFilter_ = demuxerFilter_;
190 transcoder_->pipeline_->filters_.push_back(demuxerFilter_);
191 transcoder_->demuxerFilter_->demuxer_.reset();
192 int32_t ret = transcoder_->Resume();
193 EXPECT_EQ(ret, MSERR_UNKNOWN);
194 }
195
196 /**
197 * @tc.name : Test Cancel
198 * @tc.number: Cancel_001
199 * @tc.desc : Test Cancel TransTranscoderStatus(pipeline_->Stop()) != MSERR_OK
200 */
201 HWTEST_F(HitranscodeImplUnitTest, Cancel_001, TestSize.Level1)
202 {
203 EXPECT_CALL(*mockCallbackLooper_, OnError(_, _)).Times(TIMES_ONE);
204 transcoder_->callbackLooper_ = mockCallbackLooper_;
205
206 transcoder_->demuxerFilter_ = demuxerFilter_;
207 transcoder_->pipeline_->filters_.push_back(demuxerFilter_);
208 transcoder_->demuxerFilter_->demuxer_.reset();
209 int32_t ret = transcoder_->Cancel();
210 EXPECT_EQ(ret, MSERR_UNKNOWN);
211 }
212
213 /**
214 * @tc.name : Test HandleErrorEvent
215 * @tc.number: HandleErrorEvent_001
216 * @tc.desc : Test HandleErrorEvent pipeline_ == nullptr
217 * Test OnEvent event.type == EventType::EVENT_COMPLETE
218 * Test OnEvent event.type == default
219 */
220 HWTEST_F(HitranscodeImplUnitTest, HandleErrorEvent_001, TestSize.Level1)
221 {
222 // Test OnEvent event.type == EventType::EVENT_COMPLETE
223 Event event { .type = EventType::EVENT_COMPLETE };
224 transcoder_->OnEvent(event);
225
226 // Test OnEvent event.type == default
227 event.type = EventType::EVENT_READY;
228 transcoder_->OnEvent(event);
229
230 // Test HandleErrorEvent pipeline_ == nullptr
231 EXPECT_CALL(*mockCallbackLooper_, OnError(_, _)).Times(TIMES_ONE);
232 transcoder_->ignoreError_ = false;
233 transcoder_->callbackLooper_ = mockCallbackLooper_;
234 transcoder_->pipeline_.reset();
235 int32_t errorCode = MSERR_OK;
236 transcoder_->HandleErrorEvent(errorCode);
237 }
238
239 /**
240 * @tc.name : Test HandleCompleteEvent
241 * @tc.number: HandleCompleteEvent_001
242 * @tc.desc : Test HandleCompleteEvent obs_.lock() == nullptr
243 * Test HandleCompleteEvent pipeline_ == nullptr
244 */
245 HWTEST_F(HitranscodeImplUnitTest, HandleCompleteEvent_001, TestSize.Level1)
246 {
247 // Test HandleCompleteEvent obs_.lock() == nullptr
248 transcoder_->obs_.reset();
249
250 // Test HandleCompleteEvent pipeline_ == nullptr
251 transcoder_->pipeline_.reset();
252
253 transcoder_->callbackLooper_ = mockCallbackLooper_;
254 transcoder_->HandleCompleteEvent();
255 EXPECT_EQ(transcoder_->callbackLooper_->taskStarted_, false);
256 }
257
258 /**
259 * @tc.name : Test HandleCompleteEvent
260 * @tc.number: HandleCompleteEvent_002
261 * @tc.desc : Test HandleCompleteEvent obs_.lock() != nullptr
262 * Test HandleCompleteEvent pipeline_ != nullptr
263 */
264 HWTEST_F(HitranscodeImplUnitTest, HandleCompleteEvent_002, TestSize.Level1)
265 {
266 transcoder_->callbackLooper_ = mockCallbackLooper_;
267 auto mockEngineObs = std::make_shared<MockITransCoderEngineObs>();
268 EXPECT_CALL(*mockEngineObs, OnInfo(_, _)).Times(TIMES_TWO);
269 transcoder_->obs_ = mockEngineObs;
270 transcoder_->HandleCompleteEvent();
271 }
272 } // namespace Media
273 } // namespace OHOS