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_SetCallback_0100
71 * @tc.desc: Set callback
72 * @tc.type: FUNC
73 */
74 HWTEST_F(SourceUnitTest, Source_SetCallback_0100, TestSize.Level1)
75 {
76 source_->SetCallback(nullptr);
77 }
78 /**
79 * @tc.name: Source_SetBundleName_0100
80 * @tc.desc: Set callback
81 * @tc.type: FUNC
82 */
83 HWTEST_F(SourceUnitTest, Source_SetBundleName_0100, TestSize.Level1)
84 {
85 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
86 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
87 source_->SetBundleName("TEST_SOURCE");
88 EXPECT_EQ(Status::OK, source_->Stop());
89 }
90 /**
91 * @tc.name: Source_SetBundleName_0200
92 * @tc.desc: Set callback
93 * @tc.type: FUNC
94 */
95 HWTEST_F(SourceUnitTest, Source_SetBundleName_0200, TestSize.Level1)
96 {
97 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
98 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
99 source_->SetBundleName(BUNDLE_NAME_FIRST+BUNDLE_NAME_SECOND);
100 EXPECT_EQ(Status::OK, source_->Prepare());
101 EXPECT_EQ(Status::OK, source_->Start());
102 uint32_t time = 1; // 1 sleep
103 sleep(time);
104 std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>();
105 size_t expectedLen = 1024; // 1024 expectedLen
106 source_->Read(0, buffer, 0, expectedLen);
107 sleep(time);
108 EXPECT_EQ(Status::OK, source_->Pause());
109 sleep(time);
110 EXPECT_EQ(Status::OK, source_->Resume());
111 sleep(time);
112 EXPECT_EQ(Status::OK, source_->Stop());
113 }
114 /**
115 * @tc.name: Source_SetBundleName_0300
116 * @tc.desc: Source_SetBundleName_0300
117 * @tc.type: FUNC
118 */
119 HWTEST_F(SourceUnitTest, Source_SetBundleName_0300, TestSize.Level1)
120 {
121 source_->SetBundleName("testSource");
122 }
123 /**
124 * @tc.name: Source_Prepare_0100
125 * @tc.desc: Source_Prepare_0100
126 * @tc.type: FUNC
127 */
128 HWTEST_F(SourceUnitTest, Source_Prepare_0100, TestSize.Level1)
129 {
130 source_->Prepare();
131 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
132 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
133 source_->Prepare();
134 EXPECT_EQ(Status::OK, source_->Stop());
135 }
136
137 /**
138 * @tc.name: Source_Start_0100
139 * @tc.desc: Source_Start_0100
140 * @tc.type: FUNC
141 */
142 HWTEST_F(SourceUnitTest, Source_Start_0100, TestSize.Level1)
143 {
144 EXPECT_NE(Status::OK, source_->Start());
145 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
146 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
147 EXPECT_EQ(Status::OK, source_->Start());
148 EXPECT_EQ(Status::OK, source_->Stop());
149 }
150 /**
151 * @tc.name: Source_GetBitRate_0100
152 * @tc.desc: Source_GetBitRate_0100
153 * @tc.type: FUNC
154 */
155 HWTEST_F(SourceUnitTest, Source_GetBitRate_0100, TestSize.Level1)
156 {
157 std::vector<uint32_t> bitrate;
158 EXPECT_NE(Status::OK, source_->GetBitRates(bitrate));
159 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
160 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
161 EXPECT_EQ(Status::OK, source_->Prepare());
162 EXPECT_EQ(Status::OK, source_->GetBitRates(bitrate));
163 EXPECT_EQ(Status::OK, source_->Stop());
164 }
165 /**
166 * @tc.name: Source_SelectBitRate_0100
167 * @tc.desc: Source_SelectBitRate_0100
168 * @tc.type: FUNC
169 */
170 HWTEST_F(SourceUnitTest, Source_SelectBitRate_0100, TestSize.Level1)
171 {
172 uint32_t bitrate = 0;
173 EXPECT_NE(Status::OK, source_->SelectBitRate(bitrate));
174 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
175 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
176 EXPECT_EQ(Status::OK, source_->Prepare());
177 EXPECT_EQ(Status::OK, source_->SelectBitRate(bitrate));
178 EXPECT_EQ(Status::OK, source_->Stop());
179 }
180 /**
181 * @tc.name: Source_GetDownloadInfo_0100
182 * @tc.desc: Source_GetDownloadInfo_0100
183 * @tc.type: FUNC
184 */
185 HWTEST_F(SourceUnitTest, Source_GetDownloadInfo_0100, TestSize.Level1)
186 {
187 DownloadInfo downloadInfo;
188 EXPECT_NE(Status::OK, source_->GetDownloadInfo(downloadInfo));
189 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
190 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
191 EXPECT_EQ(Status::OK, source_->Prepare());
192 source_->GetDownloadInfo(downloadInfo);
193 EXPECT_EQ(Status::OK, source_->Stop());
194 }
195 /**
196 * @tc.name: Source_IsNeedPreDownload_0100
197 * @tc.desc: Source_IsNeedPreDownload_0100
198 * @tc.type: FUNC
199 */
200 HWTEST_F(SourceUnitTest, Source_IsNeedPreDownload_0100, TestSize.Level1)
201 {
202 EXPECT_NE(true, source_->IsNeedPreDownload());
203 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
204 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
205 EXPECT_EQ(Status::OK, source_->Prepare());
206 source_->IsNeedPreDownload();
207 EXPECT_EQ(Status::OK, source_->Stop());
208 }
209 /**
210 * @tc.name: Source_Pause_0100
211 * @tc.desc: Source_Pause_0100
212 * @tc.type: FUNC
213 */
214 HWTEST_F(SourceUnitTest, Source_Pause_0100, TestSize.Level1)
215 {
216 EXPECT_EQ(Status::OK, source_->Pause());
217 }
218 /**
219 * @tc.name: Source_Resume_0100
220 * @tc.desc: Source_Resume_0100
221 * @tc.type: FUNC
222 */
223 HWTEST_F(SourceUnitTest, Source_Resume_0100, TestSize.Level1)
224 {
225 EXPECT_EQ(Status::OK, source_->Resume());
226 }
227 /**
228 * @tc.name: Source_SetReadBlockingFlag_0100
229 * @tc.desc: Source_SetReadBlockingFlag_0100
230 * @tc.type: FUNC
231 */
232 HWTEST_F(SourceUnitTest, Source_SetReadBlockingFlag_0100, TestSize.Level1)
233 {
234 bool isReadBlockingAllowed = false;
235 EXPECT_EQ(Status::OK, source_->SetReadBlockingFlag(isReadBlockingAllowed));
236 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
237 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
238 EXPECT_EQ(Status::OK, source_->Prepare());
239 source_->SetReadBlockingFlag(isReadBlockingAllowed);
240 EXPECT_EQ(Status::OK, source_->Stop());
241 }
242 /**
243 * @tc.name: Source_GetDuration_0100
244 * @tc.desc: Source_GetDuration_0100
245 * @tc.type: FUNC
246 */
247 HWTEST_F(SourceUnitTest, Source_GetDuration_0100, TestSize.Level1)
248 {
249 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
250 EXPECT_EQ(Status::OK, source_->SetSource(mediaSource));
251 EXPECT_EQ(Status::OK, source_->Prepare());
252 source_->GetDuration();
253 EXPECT_EQ(Status::OK, source_->Stop());
254 }
255 /**
256 * @tc.name: Source_OnEvent_0100
257 * @tc.desc: Source_OnEvent_0100
258 * @tc.type: FUNC
259 */
260 HWTEST_F(SourceUnitTest, Source_OnEvent_0100, TestSize.Level1)
261 {
262 std::shared_ptr<CallbackImpl> mediaDemuxerCallback_;
263 source_->mediaDemuxerCallback_ = std::shared_ptr<CallbackImpl>();
264 Plugins::PluginEvent event;
265 event.type = PluginEventType::CLIENT_ERROR;
266 source_->OnEvent(event);
267 event.type = PluginEventType::SOURCE_DRM_INFO_UPDATE;
268 source_->OnEvent(event);
269 event.type = PluginEventType::BUFFERING_END;
270 source_->OnEvent(event);
271 event.type = PluginEventType::SOURCE_BITRATE_START;
272 source_->OnEvent(event);
273 event.type = PluginEventType::CACHED_DURATION;
274 source_->OnEvent(event);
275 event.type = PluginEventType::EVENT_BUFFER_PROGRESS;
276 source_->OnEvent(event);
277 event.type = PluginEventType::EVENT_CHANNEL_CLOSED;
278 source_->OnEvent(event);
279 source_->isPluginReady_ = true;
280 source_->isAboveWaterline_ = true;
281 event.type = PluginEventType::ABOVE_LOW_WATERLINE;
282 source_->OnEvent(event);
283 EXPECT_FALSE(source_->isPluginReady_ && source_->isAboveWaterline_);
284 }
285 /**
286 * @tc.name: Source_GetUriSuffix_0100
287 * @tc.desc: Source_GetUriSuffix_0100
288 * @tc.type: FUNC
289 */
290 HWTEST_F(SourceUnitTest, Source_GetUriSuffix_0100, TestSize.Level1)
291 {
292 std::string uri = "test.jpg";
293 std::string expectedSuffix = "jpg";
294 std::string actualSuffix = source_->GetUriSuffix(uri);
295 EXPECT_EQ(expectedSuffix, actualSuffix);
296 uri = "test";
297 expectedSuffix = "";
298 actualSuffix = source_->GetUriSuffix(uri);
299 EXPECT_EQ(expectedSuffix, actualSuffix);
300 }
301 /**
302 * @tc.name: Source_GetProtocolByUri_0100
303 * @tc.desc: Source_GetProtocolByUri_0100
304 * @tc.type: FUNC
305 */
306 HWTEST_F(SourceUnitTest, Source_GetProtocolByUri_0100, TestSize.Level1)
307 {
308 source_->uri_ = "http://www.example.com";
309 EXPECT_TRUE(source_->GetProtocolByUri());
310 source_->uri_ = "example.com";
311 EXPECT_FALSE(source_->GetProtocolByUri());
312 }
313 } // namespace Media
314 } // namespace OHOS
315