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_mem_manage_unit_test.h"
17 #include <unistd.h>
18 #include <functional>
19 #include "media_log.h"
20 #include "media_errors.h"
21 #include "hiplayer_impl.h"
22
23 namespace OHOS {
24 namespace Media {
25 using namespace std;
26 using namespace testing::ext;
27 static const int32_t SEC_TEST = 200;
28 static const int32_t ERR_TEST = -10;
29
SetUpTestCase(void)30 void PlayerMemManageUnitTest::SetUpTestCase(void)
31 {
32 }
33
TearDownTestCase(void)34 void PlayerMemManageUnitTest::TearDownTestCase(void)
35 {
36 }
37
SetUp(void)38 void PlayerMemManageUnitTest::SetUp(void)
39 {
40 playerServerMem_ = std::make_shared<PlayerMemManage>();
41 playerServerMem_->probeTaskQueue_ = make_unique<TaskQueue>("test_TaskQueueName");
42 playerServerMem_->appStateListener_ = std::make_shared<AppStateListener>();
43 testCall1.resetFrontGroundRecall = []() {
44 std::cout << "This is a test_lambda function." << std::endl;
45 };
46 testCall1.resetBackGroundRecall = []() {
47 std::cout << "This is a test_lambda function." << std::endl;
48 };
49 testCall1.resetMemmgrRecall = []() {
50 std::cout << "This is a test_lambda function." << std::endl;
51 };
52 testCall1.recoverRecall = []() {
53 std::cout << "This is a test_lambda function." << std::endl;
54 };
55 testCall1.signAddr = nullptr;
56 testCall2.resetFrontGroundRecall = []() {
57 std::cout << "This is a test_lambda function." << std::endl;
58 };
59 testCall2.resetBackGroundRecall = []() {
60 std::cout << "This is a test_lambda function." << std::endl;
61 };
62 testCall2.resetMemmgrRecall = []() {
63 std::cout << "This is a test_lambda function." << std::endl;
64 };
65 testCall2.recoverRecall = []() {
66 std::cout << "This is a test_lambda function." << std::endl;
67 };
68 testCall2.signAddr = nullptr;
69 }
70
TearDown(void)71 void PlayerMemManageUnitTest::TearDown(void)
72 {
73 playerServerMem_ = nullptr;
74 }
75
76 /**
77 * @tc.name : PlayerMemManageGetInstance_001
78 * @tc.number: PlayerMemManageGetInstance_001
79 * @tc.desc : Test GetInstance interface
80 */
81 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageGetInstance_001, TestSize.Level0)
82 {
83 ASSERT_NE(nullptr, playerServerMem_);
84 PlayerMemManage::AppPlayerInfo appPlayerInfo;
85 PlayerMemManage::PidPlayersInfo testInfo1;
86 testInfo1.emplace(1, appPlayerInfo);
87 playerServerMem_->playerManage_.emplace(1, testInfo1);
88 PlayerMemManage &test = PlayerMemManage::GetInstance();
89 EXPECT_NE(test.isParsed_, playerServerMem_->isParsed_);
90 }
91
92 /**
93 * @tc.name : PlayerMemManageFindBackGroundPlayerFromVec_001
94 * @tc.number: PlayerMemManageFindBackGroundPlayerFromVec_001
95 * @tc.desc : Test FindBackGroundPlayerFromVec interface
96 */
97 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageFindBackGroundPlayerFromVec_001, TestSize.Level0)
98 {
99 ASSERT_NE(nullptr, playerServerMem_);
100 PlayerMemManage::AppPlayerInfo appPlayerInfo;
101 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_BACK_GROUND);
102 testCall2.signAddr = nullptr;
103 appPlayerInfo.memRecallStructVec.push_back(testCall1);
104 appPlayerInfo.memRecallStructVec.push_back(testCall2);
105 std::chrono::seconds duration(SEC_TEST);
106 appPlayerInfo.appEnterFrontTime = (std::chrono::steady_clock::now() + duration);
107
108 PlayerMemManage::PidPlayersInfo testInfo1;
109 testInfo1.emplace(1, appPlayerInfo);
110 playerServerMem_->playerManage_.emplace(1, testInfo1);
111
112 playerServerMem_->FindBackGroundPlayerFromVec(appPlayerInfo);
113 EXPECT_NE(playerServerMem_, nullptr);
114 }
115
116 /**
117 * @tc.name : PlayerMemManageFindFrontGroundPlayerFromVec_001
118 * @tc.number: PlayerMemManageFindFrontGroundPlayerFromVec_001
119 * @tc.desc : Test FindFrontGroundPlayerFromVec interface
120 */
121 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageFindFrontGroundPlayerFromVec_001, TestSize.Level0)
122 {
123 ASSERT_NE(nullptr, playerServerMem_);
124 PlayerMemManage::AppPlayerInfo appPlayerInfo;
125 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_FRONT_GROUND);
126 appPlayerInfo.memRecallStructVec.push_back(testCall1);
127 appPlayerInfo.memRecallStructVec.push_back(testCall2);
128 std::chrono::seconds duration(SEC_TEST);
129 appPlayerInfo.appEnterFrontTime = (std::chrono::steady_clock::now() + duration);
130
131 PlayerMemManage::PidPlayersInfo testInfo1;
132 testInfo1.emplace(1, appPlayerInfo);
133 playerServerMem_->playerManage_.emplace(1, testInfo1);
134
135 playerServerMem_->FindFrontGroundPlayerFromVec(appPlayerInfo);
136 EXPECT_NE(appPlayerInfo.appEnterFrontTime, std::chrono::steady_clock::now());
137 }
138
139 /**
140 * @tc.name : PlayerMemManageFindProbeTaskPlayer_001
141 * @tc.number: PlayerMemManageFindProbeTaskPlayer_001
142 * @tc.desc : Test FindProbeTaskPlayer interface
143 */
144 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageFindProbeTaskPlayer_001, TestSize.Level0)
145 {
146 ASSERT_NE(nullptr, playerServerMem_);
147 PlayerMemManage::AppPlayerInfo appPlayerInfo;
148 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_FRONT_GROUND);
149 appPlayerInfo.memRecallStructVec.push_back(testCall1);
150 appPlayerInfo.memRecallStructVec.push_back(testCall2);
151 PlayerMemManage::PidPlayersInfo testInfo1;
152 testInfo1.emplace(1, appPlayerInfo);
153 PlayerMemManage::PidPlayersInfo testInfo2;
154 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_BACK_GROUND);
155 testInfo2.emplace(2, appPlayerInfo);
156 playerServerMem_->playerManage_.emplace(1, testInfo1);
157 playerServerMem_->playerManage_.emplace(2, testInfo2);
158 playerServerMem_->FindProbeTaskPlayer();
159 EXPECT_NE(appPlayerInfo.appEnterFrontTime, std::chrono::steady_clock::now());
160 }
161
162 /**
163 * @tc.name : PlayerMemManageInit_001
164 * @tc.number: PlayerMemManageInit_001
165 * @tc.desc : Test Init interface
166 */
167 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageInit_001, TestSize.Level0)
168 {
169 ASSERT_NE(nullptr, playerServerMem_);
170 playerServerMem_->isParsed_ = true;
171 playerServerMem_->isAppStateListenerRemoteDied_ = false;
172 bool ret = false;
173
174 PlayerMemManage::AppPlayerInfo appPlayerInfo;
175 PlayerMemManage::PidPlayersInfo testInfo1;
176 testInfo1.emplace(1, appPlayerInfo);
177 playerServerMem_->playerManage_.emplace(1, testInfo1);
178
179 ret = playerServerMem_->Init();
180 EXPECT_EQ(ret, true);
181 }
182
183 /**
184 * @tc.name : PlayerMemManageHandleForceReclaim_001
185 * @tc.number: PlayerMemManageHandleForceReclaim_001
186 * @tc.desc : Test HandleForceReclaim interface
187 */
188 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageHandleForceReclaim_001, TestSize.Level0)
189 {
190 ASSERT_NE(nullptr, playerServerMem_);
191 int32_t uid = 2;
192 int32_t pid = 1;
193 int32_t ret = -1;
194 PlayerMemManage::AppPlayerInfo appPlayerInfo;
195 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_FRONT_GROUND);
196 appPlayerInfo.memRecallStructVec.push_back(testCall1);
197 appPlayerInfo.memRecallStructVec.push_back(testCall2);
198 PlayerMemManage::PidPlayersInfo testInfo1;
199 testInfo1.emplace(1, appPlayerInfo);
200 PlayerMemManage::PidPlayersInfo testInfo2;
201 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_BACK_GROUND);
202 testInfo2.emplace(2, appPlayerInfo);
203 playerServerMem_->playerManage_.emplace(1, testInfo1);
204 playerServerMem_->playerManage_.emplace(2, testInfo2);
205 ret = playerServerMem_->HandleForceReclaim(3, pid);
206 EXPECT_EQ(ret, 0);
207 ret = playerServerMem_->HandleForceReclaim(uid, 3);
208 EXPECT_EQ(ret, 0);
209 ret = playerServerMem_->HandleForceReclaim(uid, pid);
210 EXPECT_EQ(ret, 0);
211 }
212
213 /**
214 * @tc.name : PlayerMemManageHandleForceReclaim_002
215 * @tc.number: PlayerMemManageHandleForceReclaim_002
216 * @tc.desc : Test HandleForceReclaim interface
217 */
218 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageHandleForceReclaim_002, TestSize.Level0)
219 {
220 ASSERT_NE(nullptr, playerServerMem_);
221 int32_t ret = -1;
222 PlayerMemManage::AppPlayerInfo appPlayerInfo;
223 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_BACK_GROUND);
224 appPlayerInfo.memRecallStructVec.push_back(testCall1);
225 appPlayerInfo.memRecallStructVec.push_back(testCall2);
226 PlayerMemManage::PidPlayersInfo testInfo2;
227 testInfo2.emplace(2, appPlayerInfo);
228 playerServerMem_->playerManage_.emplace(2, testInfo2);
229 ret = playerServerMem_->HandleForceReclaim(2, 2);
230 EXPECT_EQ(ret, 0);
231 }
232
233 /**
234 * @tc.name : PlayerMemManageHandleOnTrimLevelLow_001
235 * @tc.number: PlayerMemManageHandleOnTrimLevelLow_001
236 * @tc.desc : Test HandleOnTrimLevelLow interface
237 */
238 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageHandleOnTrimLevelLow_001, TestSize.Level0)
239 {
240 ASSERT_NE(nullptr, playerServerMem_);
241 PlayerMemManage::AppPlayerInfo appPlayerInfo;
242 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_FRONT_GROUND);
243 appPlayerInfo.memRecallStructVec.push_back(testCall1);
244 appPlayerInfo.memRecallStructVec.push_back(testCall2);
245 PlayerMemManage::PidPlayersInfo testInfo1;
246 testInfo1.emplace(1, appPlayerInfo);
247 PlayerMemManage::PidPlayersInfo testInfo2;
248 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_BACK_GROUND);
249 testInfo2.emplace(2, appPlayerInfo);
250 playerServerMem_->playerManage_.emplace(1, testInfo1);
251 playerServerMem_->playerManage_.emplace(2, testInfo2);
252 playerServerMem_->HandleOnTrimLevelLow();
253 EXPECT_EQ(playerServerMem_->isParsed_, false);
254 }
255
256 /**
257 * @tc.name : PlayerMemManageHandleOnTrim_001
258 * @tc.number: PlayerMemManageHandleOnTrim_001
259 * @tc.desc : Test HandleOnTrim interface
260 */
261 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageHandleOnTrim_001, TestSize.Level0)
262 {
263 ASSERT_NE(nullptr, playerServerMem_);
264 int32_t ret = -1;
265 ::OHOS::Memory::SystemMemoryLevel testLevel = ::OHOS::Memory::SystemMemoryLevel::MEMORY_LEVEL_MODERATE;
266
267 PlayerMemManage::AppPlayerInfo appPlayerInfo;
268 PlayerMemManage::PidPlayersInfo testInfo1;
269 testInfo1.emplace(1, appPlayerInfo);
270 playerServerMem_->playerManage_.emplace(1, testInfo1);
271
272 ret = playerServerMem_->HandleOnTrim(testLevel);
273 EXPECT_EQ(ret, 0);
274 ret = playerServerMem_->HandleOnTrim(::OHOS::Memory::SystemMemoryLevel::MEMORY_LEVEL_LOW);
275 EXPECT_EQ(ret, 0);
276 ret = playerServerMem_->HandleOnTrim(::OHOS::Memory::SystemMemoryLevel::MEMORY_LEVEL_CRITICAL);
277 EXPECT_EQ(ret, 0);
278 }
279
280 /**
281 * @tc.name : PlayerMemManageRecordAppState_001
282 * @tc.number: PlayerMemManageRecordAppState_001
283 * @tc.desc : Test RecordAppState interface
284 */
285 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageRecordAppState_001, TestSize.Level0)
286 {
287 ASSERT_NE(nullptr, playerServerMem_);
288 int32_t ret = -1;
289 PlayerMemManage::AppPlayerInfo appPlayerInfo;
290 appPlayerInfo.appState = static_cast<int32_t>(AppState::APP_STATE_BACK_GROUND);
291 appPlayerInfo.memRecallStructVec.push_back(testCall1);
292 appPlayerInfo.memRecallStructVec.push_back(testCall2);
293 PlayerMemManage::PidPlayersInfo testInfo2;
294 testInfo2.emplace(2, appPlayerInfo);
295 playerServerMem_->playerManage_.emplace(2, testInfo2);
296 ret = playerServerMem_->RecordAppState(3, 3, 3);
297 EXPECT_EQ(ret, 0);
298 }
299
300 /**
301 * @tc.name : PlayerMemManageHandleOnConnected_001
302 * @tc.number: PlayerMemManageHandleOnConnected_001
303 * @tc.desc : Test HandleOnConnected interface
304 */
305 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageHandleOnConnected_001, TestSize.Level0)
306 {
307 ASSERT_NE(nullptr, playerServerMem_);
308 playerServerMem_->isAppStateListenerRemoteDied_ = true;
309 playerServerMem_->HandleOnConnected();
310 EXPECT_EQ(playerServerMem_->isAppStateListenerRemoteDied_, false);
311 EXPECT_EQ(playerServerMem_->isAppStateListenerConnected_, true);
312 }
313
314 /**
315 * @tc.name : PlayerMemManageWritePurgeableEvent_001
316 * @tc.number: PlayerMemManageWritePurgeableEvent_001
317 * @tc.desc : Test WritePurgeableEvent interface
318 */
319 HWTEST_F(PlayerMemManageUnitTest, PlayerMemManageWritePurgeableEvent_001, TestSize.Level0)
320 {
321 ASSERT_NE(nullptr, playerServerMem_);
322 playerServerMem_->isParsed_ = true;
323
324 PlayerMemManage::AppPlayerInfo appPlayerInfo;
325 PlayerMemManage::PidPlayersInfo testInfo1;
326 testInfo1.emplace(1, appPlayerInfo);
327 playerServerMem_->playerManage_.emplace(1, testInfo1);
328
329 playerServerMem_->WritePurgeableEvent(ERR_TEST, ERR_TEST);
330 EXPECT_EQ(playerServerMem_->isAppStateListenerRemoteDied_, false);
331 }
332 } // namespace Media
333 } // namespace OHOS
334