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 "player_server_mem_unittest.h"
17 #include "media_errors.h"
18 #include "hiplayer_impl.h"
19
20 namespace OHOS {
21 namespace Media {
22 using namespace std;
23 using namespace testing;
24 using namespace testing::ext;
25 const static int32_t TEST_TIMES_ONE = 1;
26 const static int32_t TEST_FD = -1;
27 const static int64_t TEST_OFFSET = 0;
28 const static int64_t TEST_SIZE = 0;
29 const static int32_t TEST_PLAY_BACK_POSITION = 1;
30 const static int32_t TEST_PLAY_BACK_POSITION_DEF = 0;
31 const static uint32_t TEST_BIT_RATE = 1000;
32 constexpr int32_t CONTINUE_RESET_MAX_NUM = 5;
33
SetUpTestCase(void)34 void PlayerServerMemUnitTest::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void PlayerServerMemUnitTest::TearDownTestCase(void)
39 {
40 }
41
SetUp(void)42 void PlayerServerMemUnitTest::SetUp(void)
43 {
44 playerServerMem_ = std::make_shared<PlayerServerMem>();
45 }
46
TearDown(void)47 void PlayerServerMemUnitTest::TearDown(void)
48 {
49 playerServerMem_ = nullptr;
50 }
51
52 /**
53 * @tc.name : Test PlayerServerMem SetSourceInternal API
54 * @tc.number: SetSourceInternal_001
55 * @tc.desc : Test SetSourceInternal recoverConfig_.sourceType == PlayerSourceType::SOURCE_TYPE_DATASRC
56 */
57 HWTEST_F(PlayerServerMemUnitTest, SetSourceInternal_001, TestSize.Level1)
58 {
59 playerServerMem_->recoverConfig_.sourceType = static_cast<int32_t>(PlayerSourceType::SOURCE_TYPE_DATASRC);
60 int32_t ret = playerServerMem_->SetSourceInternal();
61 EXPECT_EQ(ret, MSERR_INVALID_VAL);
62 }
63
64 /**
65 * @tc.name : Test PlayerServerMem SetSourceInternal API
66 * @tc.number: SetSourceInternal_002
67 * @tc.desc : Test SetSourceInternal recoverConfig_.sourceType == PlayerSourceType::SOURCE_TYPE_FD
68 */
69 HWTEST_F(PlayerServerMemUnitTest, SetSourceInternal_002, TestSize.Level1)
70 {
71 playerServerMem_->recoverConfig_.sourceType = static_cast<int32_t>(PlayerSourceType::SOURCE_TYPE_FD);
72 int32_t ret = playerServerMem_->SetSourceInternal();
73 EXPECT_EQ(ret, MSERR_INVALID_VAL);
74 }
75
76 /**
77 * @tc.name : Test PlayerServerMem SetConfigInternal API
78 * @tc.number: SetConfigInternal_001
79 * @tc.desc : Test SetConfigInternal recoverConfig_.bitRate != 0
80 */
81 HWTEST_F(PlayerServerMemUnitTest, SetConfigInternal_001, TestSize.Level1)
82 {
83 std::unique_ptr<MockIPlayerEngine> mockPlayerEngine = std::make_unique<MockIPlayerEngine>();
84 EXPECT_CALL(*(mockPlayerEngine), SetVideoScaleType(_))
85 .Times(TEST_TIMES_ONE)
86 .WillOnce(Return(MSERR_OK));
87 EXPECT_CALL(*(mockPlayerEngine), SelectBitRate(_, _))
88 .Times(TEST_TIMES_ONE)
89 .WillOnce(Return(MSERR_OK));
90 playerServerMem_->playerEngine_ = std::move(mockPlayerEngine);
91 playerServerMem_->recoverConfig_.videoScaleType = static_cast<int32_t>(VideoScaleType::VIDEO_SCALE_TYPE_FIT);
92 playerServerMem_->recoverConfig_.bitRate = TEST_BIT_RATE;
93 playerServerMem_->SetConfigInternal();
94 }
95
96 /**
97 * @tc.name : Test PlayerServerMem SetSource API
98 * @tc.number: SetSource_001
99 * @tc.desc : Test SetSource PlayerServer::SetSource(url) != MSERR_OK
100 */
101 HWTEST_F(PlayerServerMemUnitTest, SetSource_001, TestSize.Level1)
102 {
103 playerServerMem_->isLocalResource_ = false;
104 playerServerMem_->isReleaseMemByManage_ = false;
105 int32_t ret = playerServerMem_->SetSource("");
106 EXPECT_EQ(ret, MSERR_INVALID_VAL);
107 }
108
109 /**
110 * @tc.name : Test PlayerServerMem SetSource API
111 * @tc.number: SetSource_002
112 * @tc.desc : Test SetSource PlayerServer::SetSource(fd, offset, size) != MSERR_OK
113 */
114 HWTEST_F(PlayerServerMemUnitTest, SetSource_002, TestSize.Level1)
115 {
116 playerServerMem_->isLocalResource_ = false;
117 playerServerMem_->isReleaseMemByManage_ = false;
118 int32_t fd = TEST_FD;
119 int64_t offset = TEST_OFFSET;
120 int64_t size = TEST_SIZE;
121 playerServerMem_->SetSource(fd, offset, size);
122 EXPECT_EQ(playerServerMem_->isLocalResource_, false);
123 }
124
125 /**
126 * @tc.name : Test PlayerServerMem GetPlaybackPosition API
127 * @tc.number: GetPlaybackPosition_001
128 * @tc.desc : Test Release RecoverMemByUser() != MSERR_OK
129 * Test GetPlaybackPosition isLocalResource_ == false && isReleaseMemByManage_ == false
130 */
131 HWTEST_F(PlayerServerMemUnitTest, GetPlaybackPosition_001, TestSize.Level1)
132 {
133 // Test Release RecoverMemByUser() != MSERR_OK
134 playerServerMem_->isLocalResource_ = false;
135 playerServerMem_->isReleaseMemByManage_ = true;
136 playerServerMem_->Release();
137
138 // Test GetPlaybackPosition isLocalResource_ == false && isReleaseMemByManage_ == false
139 playerServerMem_->isLocalResource_ = false;
140 playerServerMem_->isReleaseMemByManage_ = false;
141 int32_t playbackPosition = TEST_PLAY_BACK_POSITION;
142 int32_t ret = playerServerMem_->GetPlaybackPosition(playbackPosition);
143 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
144 }
145
146 /**
147 * @tc.name : Test PlayerServerMem GetPlaybackPosition API
148 * @tc.number: GetPlaybackPosition_002
149 * @tc.desc : Test GetPlaybackPosition isLocalResource_ == false && isReleaseMemByManage_ == true
150 */
151 HWTEST_F(PlayerServerMemUnitTest, GetPlaybackPosition_002, TestSize.Level1)
152 {
153 playerServerMem_->isLocalResource_ = false;
154 playerServerMem_->isReleaseMemByManage_ = true;
155 int32_t playbackPosition = TEST_PLAY_BACK_POSITION;
156 int32_t ret = playerServerMem_->GetPlaybackPosition(playbackPosition);
157 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
158 }
159
160 /**
161 * @tc.name : Test PlayerServerMem GetPlaybackPosition API
162 * @tc.number: GetPlaybackPosition_003
163 * @tc.desc : Test GetPlaybackPosition isLocalResource_ == true && isReleaseMemByManage_ == false
164 */
165 HWTEST_F(PlayerServerMemUnitTest, GetPlaybackPosition_003, TestSize.Level1)
166 {
167 playerServerMem_->isLocalResource_ = true;
168 playerServerMem_->isReleaseMemByManage_ = false;
169 int32_t playbackPosition = TEST_PLAY_BACK_POSITION;
170 int32_t ret = playerServerMem_->GetPlaybackPosition(playbackPosition);
171 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
172 }
173
174 /**
175 * @tc.name : Test PlayerServerMem GetPlaybackPosition API
176 * @tc.number: GetPlaybackPosition_004
177 * @tc.desc : Test GetPlaybackPosition isLocalResource_ == true && isReleaseMemByManage_ == true
178 */
179 HWTEST_F(PlayerServerMemUnitTest, GetPlaybackPosition_004, TestSize.Level1)
180 {
181 playerServerMem_->isLocalResource_ = true;
182 playerServerMem_->isReleaseMemByManage_ = true;
183 int32_t playbackPosition = TEST_PLAY_BACK_POSITION;
184 int32_t ret = playerServerMem_->GetPlaybackPosition(playbackPosition);
185 EXPECT_EQ(ret, MSERR_OK);
186 EXPECT_EQ(playbackPosition, TEST_PLAY_BACK_POSITION_DEF);
187 }
188
189 /**
190 * @tc.name : Test PlayerServerMem ResetFrontGroundForMemManage API
191 * @tc.number: ResetFrontGroundForMemManage_001
192 * @tc.desc : Test ResetFrontGroundForMemManage lastSetToNow.count() <= APP_FRONT_GROUND_DESTROY_MEMERY_LAST_SET_TIME
193 */
194 HWTEST_F(PlayerServerMemUnitTest, ResetFrontGroundForMemManage_001, TestSize.Level1)
195 {
196 playerServerMem_->isAudioPlayer_ = false;
197 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_IDLE;
198 playerServerMem_->continueReset = CONTINUE_RESET_MAX_NUM;
199 playerServerMem_->lastestUserSetTime_ = std::chrono::steady_clock::now();
200 playerServerMem_->isReleaseMemByManage_ = false;
201 playerServerMem_->ResetFrontGroundForMemManage();
202 EXPECT_EQ(playerServerMem_->continueReset, 0);
203 }
204
205 /**
206 * @tc.name : Test PlayerServerMem ResetFrontGroundForMemManage API
207 * @tc.number: ResetFrontGroundForMemManage_002
208 * @tc.desc : Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = false
209 * Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = false
210 * Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = true
211 * Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = true
212 */
213 HWTEST_F(PlayerServerMemUnitTest, ResetFrontGroundForMemManage_002, TestSize.Level1)
214 {
215 // Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = false
216 playerServerMem_->isAudioPlayer_ = false;
217 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_IDLE;
218 playerServerMem_->ResetFrontGroundForMemManage();
219 EXPECT_EQ(playerServerMem_->continueReset, 0);
220
221 // Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = false
222 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_PREPARED;
223 playerServerMem_->ResetFrontGroundForMemManage();
224 EXPECT_EQ(playerServerMem_->continueReset, 1);
225
226 // Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = true
227 playerServerMem_->isAudioPlayer_ = true;
228 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_IDLE;
229 playerServerMem_->ResetFrontGroundForMemManage();
230 EXPECT_EQ(playerServerMem_->continueReset, 0);
231
232 // Test ResetFrontGroundForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = true
233 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_PREPARED;
234 playerServerMem_->ResetFrontGroundForMemManage();
235 EXPECT_EQ(playerServerMem_->continueReset, 0);
236 }
237
238 /**
239 * @tc.name : Test PlayerServerMem ResetBackGroundForMemManage API
240 * @tc.number: ResetBackGroundForMemManage_001
241 * @tc.desc : Test ResetBackGroundForMemManage lastSetToNow.count() <= APP_BACK_GROUND_DESTROY_MEMERY_LAST_SET_TIME
242 */
243 HWTEST_F(PlayerServerMemUnitTest, ResetBackGroundForMemManage_001, TestSize.Level1)
244 {
245 playerServerMem_->isAudioPlayer_ = false;
246 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_IDLE;
247 playerServerMem_->continueReset = CONTINUE_RESET_MAX_NUM;
248 playerServerMem_->lastestUserSetTime_ = std::chrono::steady_clock::now();
249 playerServerMem_->isReleaseMemByManage_ = false;
250 playerServerMem_->ResetBackGroundForMemManage();
251 EXPECT_EQ(playerServerMem_->continueReset, 0);
252 }
253
254 /**
255 * @tc.name : Test PlayerServerMem ResetMemmgrForMemManage API
256 * @tc.number: ResetMemmgrForMemManage_001
257 * @tc.desc : Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = false
258 * Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = false
259 * Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = true
260 * Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = true
261 */
262 HWTEST_F(PlayerServerMemUnitTest, ResetMemmgrForMemManage_001, TestSize.Level1)
263 {
264 // Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = false
265 playerServerMem_->isAudioPlayer_ = false;
266 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_IDLE;
267 playerServerMem_->ResetMemmgrForMemManage();
268
269 // Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = false
270 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_PREPARED;
271 playerServerMem_->ResetMemmgrForMemManage();
272
273 // Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = false || isAudioPlayer_ = true
274 playerServerMem_->isAudioPlayer_ = true;
275 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_IDLE;
276 playerServerMem_->ResetMemmgrForMemManage();
277
278 // Test ResetMemmgrForMemManage PlayerServer::IsPrepared() = true || isAudioPlayer_ = true
279 playerServerMem_->lastOpStatus_ = PlayerStates::PLAYER_PREPARED;
280 playerServerMem_->ResetMemmgrForMemManage();
281
282 EXPECT_EQ(playerServerMem_->isReleaseMemByManage_, false);
283 }
284 } // namespace Media
285 } // namespace OHOS