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 "stream_demuxer_unittest.h"
17
18 using namespace OHOS;
19 using namespace OHOS::Media;
20 using namespace testing::ext;
21 using namespace testing;
22 using namespace std;
23 namespace OHOS {
24 namespace Media {
25 const static int32_t ID_TEST = 1;
26 const static int32_t NUM_TEST = 0;
27 const static int32_t INVALID_TEST = 5;
28 constexpr uint64_t CONTENT_LENGTH = 2147483646;
29 // const static int32_t INVALID_MODE = 4;
30
SetUpTestCase(void)31 void StreamDemuxerUnitTest::SetUpTestCase(void)
32 {
33 }
34
TearDownTestCase(void)35 void StreamDemuxerUnitTest::TearDownTestCase(void)
36 {
37 }
38
SetUp()39 void StreamDemuxerUnitTest::SetUp()
40 {
41 streamDemuxer_ = std::make_shared<StreamDemuxer>();
42 }
43
TearDown()44 void StreamDemuxerUnitTest::TearDown()
45 {
46 streamDemuxer_ = nullptr;
47 }
48
49 /**
50 * @tc.name: Test ReadFrameData API
51 * @tc.number: ReadFrameData_001
52 * @tc.desc: Test (IsDash() || GetIsDataSrcNoSeek()) == true
53 * Test cacheDataMap_.find(streamID) != cacheDataMap_.end()
54 * && cacheDataMap_[streamID].CheckCacheExist(offset)
55 * Test memory != nullptr && memory->GetSize() > 0
56 */
57 HWTEST_F(StreamDemuxerUnitTest, ReadFrameData_001, TestSize.Level0)
58 {
59 ASSERT_NE(streamDemuxer_, nullptr);
60 streamDemuxer_->isDash_ = true;
61 streamDemuxer_->isDataSrcNoSeek_ = true;
62 EXPECT_EQ(streamDemuxer_->IsDash(), true);
63 EXPECT_EQ(streamDemuxer_->GetIsDataSrcNoSeek(), true);
64 int32_t streamID = NUM_TEST;
65 uint64_t offset = NUM_TEST;
66 size_t size = NUM_TEST;
67 auto mockTest = std::make_shared<MockBuffer>();
68 EXPECT_CALL(*(mockTest), GetMemory()).WillRepeatedly(Return(nullptr));
69 std::shared_ptr<Buffer> bufferPtr = mockTest;
70 CacheData cacheDataTest;
71 auto mockBuffer = std::make_shared<MockBuffer>();
72 auto mockMemory = std::make_shared<MockMemory>(NUM_TEST);
73 EXPECT_CALL(*(mockBuffer), GetMemory()).WillRepeatedly(Return(mockMemory));
74 EXPECT_CALL(*(mockMemory), GetSize()).WillRepeatedly(Return(ID_TEST));
75 cacheDataTest.data = mockBuffer;
76 streamDemuxer_->cacheDataMap_[streamID] = cacheDataTest;
77 auto ret = streamDemuxer_->ReadFrameData(streamID, offset, size, bufferPtr);
78 EXPECT_EQ(ret, Status::ERROR_INVALID_OPERATION);
79 }
80
81 /**
82 * @tc.name: Test PullDataWithCache API
83 * @tc.number: PullDataWithCache_001
84 * @tc.desc: Test tempBuffer == nullptr
85 */
86 HWTEST_F(StreamDemuxerUnitTest, PullDataWithCache_001, TestSize.Level0)
87 {
88 ASSERT_NE(streamDemuxer_, nullptr);
89 const uint8_t numTest = NUM_TEST;
90 int32_t streamID = NUM_TEST;
91 uint64_t offset = NUM_TEST;
92 size_t size = ID_TEST;
93 auto mockMemory1 = std::make_shared<MockMemory>(NUM_TEST);
94 auto mockTest = std::make_shared<MockBuffer>();
95 EXPECT_CALL(*(mockTest), GetMemory()).WillRepeatedly(Return(mockMemory1));
96 EXPECT_CALL(*(mockMemory1), Write(_, _, _)).WillRepeatedly(Return(NUM_TEST));
97 std::shared_ptr<Buffer> bufferPtr = mockTest;
98 CacheData cacheDataTest;
99 auto mockBuffer = std::make_shared<MockBuffer>();
100 auto mockMemory2 = std::make_shared<MockMemory>(NUM_TEST);
101 EXPECT_CALL(*(mockBuffer), GetMemory()).WillRepeatedly(Return(mockMemory2));
102 EXPECT_CALL(*(mockMemory2), GetSize()).WillRepeatedly(Return(NUM_TEST));
103 EXPECT_CALL(*(mockMemory2), GetReadOnlyData(_)).WillRepeatedly(Return(&numTest));
104 cacheDataTest.data = mockBuffer;
105 streamDemuxer_->cacheDataMap_[streamID] = cacheDataTest;
106 auto ret = streamDemuxer_->PullDataWithCache(streamID, offset, size, bufferPtr);
107 EXPECT_EQ(ret, Status::ERROR_UNKNOWN);
108 }
109
110 /**
111 * @tc.name: Test ProcInnerDash API
112 * @tc.number: ProcInnerDash_001
113 * @tc.desc: Test tempBuffer == nullptr
114 */
115 HWTEST_F(StreamDemuxerUnitTest, ProcInnerDash_001, TestSize.Level0)
116 {
117 ASSERT_NE(streamDemuxer_, nullptr);
118 streamDemuxer_->isDash_ = true;
119 EXPECT_EQ(streamDemuxer_->IsDash(), true);
120 int32_t streamID = NUM_TEST;
121 uint64_t offset = NUM_TEST;
122 auto mockTest = std::make_shared<MockBuffer>();
123 EXPECT_CALL(*(mockTest), GetMemory()).WillRepeatedly(Return(nullptr));
124 std::shared_ptr<Buffer> bufferPtr = mockTest;
125 CacheData cacheDataTest;
126 auto mockBuffer = nullptr;
127 cacheDataTest.data = mockBuffer;
128 streamDemuxer_->cacheDataMap_[streamID] = cacheDataTest;
129 auto ret = streamDemuxer_->ProcInnerDash(streamID, offset, bufferPtr);
130 EXPECT_EQ(ret, Status::ERROR_UNKNOWN);
131 }
132
133 /**
134 * @tc.name: Test PullData API
135 * @tc.number: PullData_001
136 * @tc.desc: Test source_ == nullptr
137 */
138 HWTEST_F(StreamDemuxerUnitTest, PullData_001, TestSize.Level0)
139 {
140 ASSERT_NE(streamDemuxer_, nullptr);
141 streamDemuxer_->source_ = nullptr;
142 int32_t streamID = ID_TEST;
143 uint64_t offset = ID_TEST;
144 size_t size = ID_TEST;
145 auto mockTest = std::make_shared<MockBuffer>();
146 EXPECT_CALL(*(mockTest), GetMemory()).WillRepeatedly(Return(nullptr));
147 std::shared_ptr<Buffer> bufferPtr = mockTest;
148 bufferPtr->streamID = ID_TEST;
149 auto ret = streamDemuxer_->PullData(streamID, offset, size, bufferPtr);
150 EXPECT_EQ(ret, Status::ERROR_INVALID_OPERATION);
151 }
152
153 /**
154 * @tc.name: Test HandleReadHeader API
155 * @tc.number: HandleReadHeader_001
156 * @tc.desc: Test ret != Status::OK
157 * Test (offset + readSize) > totalSize
158 */
159 HWTEST_F(StreamDemuxerUnitTest, HandleReadHeader_001, TestSize.Level0)
160 {
161 ASSERT_NE(streamDemuxer_, nullptr);
162 streamDemuxer_->isDash_ = false;
163 int32_t streamID = ID_TEST;
164 uint64_t offset = ID_TEST;
165 size_t expectedLen = ID_TEST;
166 std::shared_ptr<Buffer> bufferPtr = nullptr;
__anon59a94e140102(int32_t param1, uint64_t param2, size_t param3, std::shared_ptr<Buffer>& buffer) 167 streamDemuxer_->getRange_ = [](int32_t param1, uint64_t param2, size_t param3, std::shared_ptr<Buffer>& buffer) {
168 return Status::END_OF_STREAM;
169 };
170 streamDemuxer_->mediaDataSize_ = CONTENT_LENGTH;
171 auto ret = streamDemuxer_->HandleReadHeader(streamID, offset, bufferPtr, expectedLen);
172 EXPECT_NE(ret, Status::OK);
173 streamDemuxer_->mediaDataSize_ = ID_TEST;
174 ret = streamDemuxer_->HandleReadHeader(streamID, offset, bufferPtr, expectedLen);
175 EXPECT_EQ(ret, Status::END_OF_STREAM);
176 }
177
178 /**
179 * @tc.name: Test HandleReadPacket API
180 * @tc.number: HandleReadPacket_001
181 * @tc.desc: Test ret == Status::OK
182 * Test buffer != nullptr && buffer->GetMemory() != nullptr &&
183 * buffer->GetMemory()->GetSize() == 0
184 */
185 HWTEST_F(StreamDemuxerUnitTest, HandleReadPacket_001, TestSize.Level0)
186 {
187 ASSERT_NE(streamDemuxer_, nullptr);
188 streamDemuxer_->isDash_ = false;
189 int32_t streamID = ID_TEST;
190 uint64_t offset = ID_TEST;
191 size_t expectedLen = ID_TEST;
__anon59a94e140202(int32_t param1, uint64_t param2, size_t param3, std::shared_ptr<Buffer>& buffer) 192 streamDemuxer_->getRange_ = [](int32_t param1, uint64_t param2, size_t param3, std::shared_ptr<Buffer>& buffer) {
193 return Status::OK;
194 };
195 streamDemuxer_->mediaDataSize_ = CONTENT_LENGTH;
196 auto mockMemory1 = std::make_shared<MockMemory>(NUM_TEST);
197 auto mockTest = std::make_shared<MockBuffer>();
198 EXPECT_CALL(*(mockTest), GetMemory()).WillRepeatedly(Return(mockMemory1));
199 EXPECT_CALL(*(mockMemory1), GetSize()).WillRepeatedly(Return(NUM_TEST));
200 std::shared_ptr<Buffer> bufferPtr = mockTest;
201 streamDemuxer_->HandleReadPacket(streamID, offset, bufferPtr, expectedLen);
202 EXPECT_EQ(bufferPtr->GetMemory()->GetSize(), 0);
203 }
204
205 /**
206 * @tc.name: Test CallbackReadAt API
207 * @tc.number: CallbackReadAt_001
208 * @tc.desc: Test case default
209 */
210 HWTEST_F(StreamDemuxerUnitTest, CallbackReadAt_001, TestSize.Level0)
211 {
212 ASSERT_NE(streamDemuxer_, nullptr);
213 streamDemuxer_->isInterruptNeeded_.store(false);
214 int32_t streamID = NUM_TEST;
215 uint64_t offset = ID_TEST;
216 size_t expectedLen = ID_TEST;
217 std::shared_ptr<Buffer> bufferPtr = nullptr;
218 streamDemuxer_->pluginStateMap_[0] = static_cast<DemuxerState>(INVALID_TEST);
219 auto ret = streamDemuxer_->CallbackReadAt(streamID, offset, bufferPtr, expectedLen);
220 EXPECT_EQ(ret, Status::OK);
221 }
222 } // Media
223 } // OHOS