1 /*
2 * Copyright (C) 2024 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 #include <sys/stat.h>
16 #include <fcntl.h>
17 #include <cinttypes>
18 #include "gtest/gtest.h"
19 #include "avcodec_errors.h"
20 #include "avcodec_info.h"
21 #include "media_description.h"
22 #include "source_unit_test.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::MediaAVCodec;
26 using namespace OHOS::Media;
27
28 namespace OHOS {
29 namespace Media {
30 const std::string MEDIA_ROOT = "file:///data/test/media/";
31 const std::string VIDEO_FILE1 = MEDIA_ROOT + "camera_info_parser.mp4";
32 const std::string BUNDLE_NAME_FIRST = "com";
33 const std::string BUNDLE_NAME_SECOND = "wei.hmos.photos";
SetUpTestCase(void)34 void SourceUnitTest::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void SourceUnitTest::TearDownTestCase(void)
39 {
40 }
41
SetUp(void)42 void SourceUnitTest::SetUp(void)
43 {
44 source_ = std::make_shared<Source>();
45 }
46
TearDown(void)47 void SourceUnitTest::TearDown(void)
48 {
49 }
50
51 class SourceCallback : public Plugins::Callback {
52 public:
OnEvent(const Plugins::PluginEvent & event)53 void OnEvent(const Plugins::PluginEvent &event) override
54 {
55 (void)event;
56 }
57
SetSelectBitRateFlag(bool flag,uint32_t desBitRate)58 void SetSelectBitRateFlag(bool flag, uint32_t desBitRate) override
59 {
60 (void)flag;
61 (void)desBitRate;
62 }
63
CanAutoSelectBitRate()64 bool CanAutoSelectBitRate() override
65 {
66 return true;
67 }
68 };
69 /**
70 * @tc.name: Source_SetBundleName_0100
71 * @tc.desc: Set callback
72 * @tc.type: FUNC
73 */
74 HWTEST_F(SourceUnitTest, Source_SetBundleName_0100, TestSize.Level1)
75 {
76 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
77 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
78 source_->SetBundleName("TEST_SOURCE");
79 EXPECT_EQ(Status::OK, source_->Stop());
80 }
81 /**
82 * @tc.name: Source_SetBundleName_0200
83 * @tc.desc: Set callback
84 * @tc.type: FUNC
85 */
86 HWTEST_F(SourceUnitTest, Source_SetBundleName_0200, TestSize.Level1)
87 {
88 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
89 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
90 source_->SetBundleName(BUNDLE_NAME_FIRST+BUNDLE_NAME_SECOND);
91 EXPECT_EQ(Status::OK, source_->Prepare());
92 EXPECT_EQ(Status::OK, source_->Start());
93 uint32_t time = 1; // 1 sleep
94 sleep(time);
95 std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>();
96 size_t expectedLen = 1024; // 1024 expectedLen
97 source_->Read(0, buffer, 0, expectedLen);
98 sleep(time);
99 EXPECT_EQ(Status::OK, source_->Pause());
100 sleep(time);
101 EXPECT_EQ(Status::OK, source_->Resume());
102 sleep(time);
103 EXPECT_EQ(Status::OK, source_->Stop());
104 }
105 /**
106 * @tc.name: Source_SetBundleName_0300
107 * @tc.desc: Source_SetBundleName_0300
108 * @tc.type: FUNC
109 */
110 HWTEST_F(SourceUnitTest, Source_SetBundleName_0300, TestSize.Level1)
111 {
112 source_->SetBundleName("testSource");
113 source_->SetCallback(nullptr);
114 EXPECT_EQ(Status::OK, source_->Prepare());
115 }
116 /**
117 * @tc.name: Source_Prepare_0100
118 * @tc.desc: Source_Prepare_0100
119 * @tc.type: FUNC
120 */
121 HWTEST_F(SourceUnitTest, Source_Prepare_0100, TestSize.Level1)
122 {
123 source_->Prepare();
124 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
125 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
126 source_->Prepare();
127 EXPECT_EQ(Status::OK, source_->Stop());
128 }
129
130 /**
131 * @tc.name: Source_Start_0100
132 * @tc.desc: Source_Start_0100
133 * @tc.type: FUNC
134 */
135 HWTEST_F(SourceUnitTest, Source_Start_0100, TestSize.Level1)
136 {
137 EXPECT_NE(Status::OK, source_->Start());
138 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
139 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
140 EXPECT_EQ(Status::OK, source_->Start());
141 EXPECT_EQ(Status::OK, source_->Stop());
142 }
143 /**
144 * @tc.name: Source_GetBitRate_0100
145 * @tc.desc: Source_GetBitRate_0100
146 * @tc.type: FUNC
147 */
148 HWTEST_F(SourceUnitTest, Source_GetBitRate_0100, TestSize.Level1)
149 {
150 std::vector<uint32_t> bitrate;
151 EXPECT_NE(Status::OK, source_->GetBitRates(bitrate));
152 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
153 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
154 EXPECT_EQ(Status::OK, source_->Prepare());
155 EXPECT_EQ(Status::OK, source_->GetBitRates(bitrate));
156 EXPECT_EQ(Status::OK, source_->Stop());
157 }
158 /**
159 * @tc.name: Source_SelectBitRate_0100
160 * @tc.desc: Source_SelectBitRate_0100
161 * @tc.type: FUNC
162 */
163 HWTEST_F(SourceUnitTest, Source_SelectBitRate_0100, TestSize.Level1)
164 {
165 uint32_t bitrate = 0;
166 EXPECT_NE(Status::OK, source_->SelectBitRate(bitrate));
167 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
168 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
169 EXPECT_EQ(Status::OK, source_->Prepare());
170 EXPECT_EQ(Status::OK, source_->SelectBitRate(bitrate));
171 EXPECT_EQ(Status::OK, source_->Stop());
172 }
173 /**
174 * @tc.name: Source_GetDownloadInfo_0100
175 * @tc.desc: Source_GetDownloadInfo_0100
176 * @tc.type: FUNC
177 */
178 HWTEST_F(SourceUnitTest, Source_GetDownloadInfo_0100, TestSize.Level1)
179 {
180 DownloadInfo downloadInfo;
181 EXPECT_NE(Status::OK, source_->GetDownloadInfo(downloadInfo));
182 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
183 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
184 EXPECT_EQ(Status::OK, source_->Prepare());
185 source_->GetDownloadInfo(downloadInfo);
186 EXPECT_EQ(Status::OK, source_->Stop());
187 }
188 /**
189 * @tc.name: Source_IsNeedPreDownload_0100
190 * @tc.desc: Source_IsNeedPreDownload_0100
191 * @tc.type: FUNC
192 */
193 HWTEST_F(SourceUnitTest, Source_IsNeedPreDownload_0100, TestSize.Level1)
194 {
195 EXPECT_NE(true, source_->IsNeedPreDownload());
196 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
197 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
198 EXPECT_EQ(Status::OK, source_->Prepare());
199 source_->IsNeedPreDownload();
200 EXPECT_EQ(Status::OK, source_->Stop());
201 }
202 /**
203 * @tc.name: Source_Pause_0100
204 * @tc.desc: Source_Pause_0100
205 * @tc.type: FUNC
206 */
207 HWTEST_F(SourceUnitTest, Source_Pause_0100, TestSize.Level1)
208 {
209 EXPECT_EQ(Status::OK, source_->Pause());
210 }
211 /**
212 * @tc.name: Source_Resume_0100
213 * @tc.desc: Source_Resume_0100
214 * @tc.type: FUNC
215 */
216 HWTEST_F(SourceUnitTest, Source_Resume_0100, TestSize.Level1)
217 {
218 EXPECT_EQ(Status::OK, source_->Resume());
219 }
220 /**
221 * @tc.name: Source_SetReadBlockingFlag_0100
222 * @tc.desc: Source_SetReadBlockingFlag_0100
223 * @tc.type: FUNC
224 */
225 HWTEST_F(SourceUnitTest, Source_SetReadBlockingFlag_0100, TestSize.Level1)
226 {
227 bool isReadBlockingAllowed = false;
228 EXPECT_EQ(Status::OK, source_->SetReadBlockingFlag(isReadBlockingAllowed));
229 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
230 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
231 EXPECT_EQ(Status::OK, source_->Prepare());
232 source_->SetReadBlockingFlag(isReadBlockingAllowed);
233 EXPECT_EQ(Status::OK, source_->Stop());
234 }
235 /**
236 * @tc.name: Source_GetDuration_0100
237 * @tc.desc: Source_GetDuration_0100
238 * @tc.type: FUNC
239 */
240 HWTEST_F(SourceUnitTest, Source_GetDuration_0100, TestSize.Level1)
241 {
242 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
243 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
244 EXPECT_EQ(Status::OK, source_->Prepare());
245 source_->GetDuration();
246 EXPECT_EQ(Status::OK, source_->Stop());
247 }
248 /**
249 * @tc.name: Source_OnEvent_0100
250 * @tc.desc: Source_OnEvent_0100
251 * @tc.type: FUNC
252 */
253 HWTEST_F(SourceUnitTest, Source_OnEvent_0100, TestSize.Level1)
254 {
255 std::shared_ptr<CallbackImpl> mediaDemuxerCallback_;
256 source_->mediaDemuxerCallback_ = std::shared_ptr<CallbackImpl>();
257 Plugins::PluginEvent event;
258 event.type = PluginEventType::CLIENT_ERROR;
259 source_->OnEvent(event);
260 event.type = PluginEventType::SOURCE_DRM_INFO_UPDATE;
261 source_->OnEvent(event);
262 event.type = PluginEventType::BUFFERING_END;
263 source_->OnEvent(event);
264 event.type = PluginEventType::SOURCE_BITRATE_START;
265 source_->OnEvent(event);
266 event.type = PluginEventType::CACHED_DURATION;
267 source_->OnEvent(event);
268 event.type = PluginEventType::EVENT_BUFFER_PROGRESS;
269 source_->OnEvent(event);
270 event.type = PluginEventType::EVENT_CHANNEL_CLOSED;
271 source_->OnEvent(event);
272 source_->isPluginReady_ = true;
273 source_->isAboveWaterline_ = true;
274 event.type = PluginEventType::ABOVE_LOW_WATERLINE;
275 source_->OnEvent(event);
276 EXPECT_FALSE(source_->isPluginReady_ && source_->isAboveWaterline_);
277 }
278 /**
279 * @tc.name: Source_GetUriSuffix_0100
280 * @tc.desc: Source_GetUriSuffix_0100
281 * @tc.type: FUNC
282 */
283 HWTEST_F(SourceUnitTest, Source_GetUriSuffix_0100, TestSize.Level1)
284 {
285 std::string uri = "test.jpg";
286 std::string expectedSuffix = "jpg";
287 std::string actualSuffix = source_->GetUriSuffix(uri);
288 EXPECT_EQ(expectedSuffix, actualSuffix);
289 uri = "test";
290 expectedSuffix = "";
291 actualSuffix = source_->GetUriSuffix(uri);
292 EXPECT_EQ(expectedSuffix, actualSuffix);
293 }
294 /**
295 * @tc.name: Source_GetProtocolByUri_0100
296 * @tc.desc: Source_GetProtocolByUri_0100
297 * @tc.type: FUNC
298 */
299 HWTEST_F(SourceUnitTest, Source_GetProtocolByUri_0100, TestSize.Level1)
300 {
301 source_->uri_ = "http://www.example.com";
302 EXPECT_TRUE(source_->GetProtocolByUri());
303 source_->uri_ = "example.com";
304 EXPECT_FALSE(source_->GetProtocolByUri());
305 }
306 /**
307 * @tc.name: Source_IsLocalFd_0100
308 * @tc.desc: Source_IsLocalFd_0100
309 * @tc.type: FUNC
310 */
311 HWTEST_F(SourceUnitTest, Source_IsLocalFd_0100, TestSize.Level1)
312 {
313 std::shared_ptr<Source> source = std::make_shared<Source>();
314 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
315 source->SetSource(mediaSource);
316 // source plugin is file_source_plugin, it is for local fd
317 EXPECT_TRUE(source->IsLocalFd());
318 }
319 } // namespace Media
320 } // namespace OHOS
321