1 /*
2 * Copyright (c) 2022 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 "gtest/gtest.h"
17
18 #include "utils.h"
19
20 #define private public
21 #define protected public
22 #include "kernel_interface.h"
23 #include "reclaim_strategy_manager.h"
24 #include "reclaim_strategy_constants.h"
25 #undef private
26 #undef protected
27
28 namespace OHOS {
29 namespace Memory {
30 using namespace testing;
31 using namespace testing::ext;
32
33 class ReclaimStrategyManagerTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase()41 void ReclaimStrategyManagerTest::SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 void ReclaimStrategyManagerTest::TearDownTestCase()
46 {
47 }
48
SetUp()49 void ReclaimStrategyManagerTest::SetUp()
50 {
51 }
52
TearDown()53 void ReclaimStrategyManagerTest::TearDown()
54 {
55 }
56
57 HWTEST_F(ReclaimStrategyManagerTest, InitTest, TestSize.Level1)
58 {
59 EXPECT_EQ(ReclaimStrategyManager::GetInstance().Init(), true);
60 }
61
62 HWTEST_F(ReclaimStrategyManagerTest, NotifyAppStateChangedTest, TestSize.Level1)
63 {
64 int pid = 1234567;
65 int appId = 111111;
66 std::string appName = "com.test";
67 int userId = 234561;
68 int score = 100;
69 std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
70 AppAction::OTHERS);
71 ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(para);
72 ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(nullptr);
73 EXPECT_NE(para, nullptr);
74 }
75
76 HWTEST_F(ReclaimStrategyManagerTest, NotifyAccountDiedTest, TestSize.Level1)
77 {
78 int pid = 1234567;
79 int appId = 111111;
80 std::string appName = "com.test";
81 int userId = 234561;
82 int score = 100;
83 std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
84 AppAction::CREATE_PROCESS_AND_APP);
85 ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(para);
86 sleep(3);
87 UserMemcg* memcg = MemcgMgr::GetInstance().GetUserMemcg(userId);
88 EXPECT_EQ(memcg != nullptr, true);
89 std::string memcgPath = memcg->GetMemcgPath_();
90 ReclaimStrategyManager::GetInstance().NotifyAccountDied(userId);
91 sleep(3);
92 EXPECT_EQ(MemcgMgr::GetInstance().GetUserMemcg(userId) == nullptr, true);
93 EXPECT_EQ(KernelInterface::GetInstance().IsDirExists(memcgPath), false);
94 }
95
96 HWTEST_F(ReclaimStrategyManagerTest, NotifyAccountPriorityChangedTest, TestSize.Level1)
97 {
98 int pid = 1234567;
99 int appId = 111111;
100 std::string appName = "com.test";
101 int userId = 234561;
102 int score = 100;
103 ReclaimStrategyManager::GetInstance().NotifyAccountPriorityChanged(userId, score);
104 sleep(3);
105 EXPECT_EQ(MemcgMgr::GetInstance().GetUserMemcg(userId) == nullptr, true);
106
107 std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
108 AppAction::CREATE_PROCESS_AND_APP);
109 ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(para);
110 sleep(3);
111 UserMemcg* memcg = MemcgMgr::GetInstance().GetUserMemcg(userId);
112 EXPECT_EQ(memcg != nullptr, true);
113 std::string memcgPath = memcg->GetMemcgPath_();
114 ReclaimStrategyManager::GetInstance().NotifyAccountPriorityChanged(userId, score + score);
115 sleep(3);
116 EXPECT_EQ(memcg->score_, score + score);
117 ReclaimStrategyManager::GetInstance().NotifyAccountDied(userId);
118 sleep(3);
119 EXPECT_EQ(KernelInterface::GetInstance().IsDirExists(memcgPath), false);
120 }
121
122 HWTEST_F(ReclaimStrategyManagerTest, CreateEventHandlerTest, TestSize.Level1)
123 {
124 EXPECT_EQ(ReclaimStrategyManager::GetInstance().CreateEventHandler(), true);
125 }
126
127 HWTEST_F(ReclaimStrategyManagerTest, HandleProcessCreateTest, TestSize.Level1)
128 {
129 int pid = 1234567;
130 int appId = 111111;
131 std::string appName = "com.test";
132 int userId = 234561;
133 int score = 100;
134 std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
135 AppAction::CREATE_PROCESS_AND_APP);
136 ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(para);
137 sleep(3);
138 UserMemcg* memcg = MemcgMgr::GetInstance().GetUserMemcg(userId);
139 EXPECT_EQ(memcg != nullptr, true);
140 std::string memcgPath = memcg->GetMemcgPath_();
141 EXPECT_EQ(KernelInterface::GetInstance().IsDirExists(memcgPath), true);
142 EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), true);
143 }
144
145 HWTEST_F(ReclaimStrategyManagerTest, GetReclaimRatiosByScoreTest, TestSize.Level1)
146 {
147 ReclaimRatios ratios(50, 50, 50);
148 EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(0, ratios), true);
149 EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(100, ratios), true);
150 EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(200, ratios), true);
151 EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(500, ratios), true);
152 EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(1000, ratios), true);
153 }
154
155 HWTEST_F(ReclaimStrategyManagerTest, GetValidScoreTest, TestSize.Level1)
156 {
157 int score = RECLAIM_SCORE_MIN - 1;
158 ReclaimStrategyManager::GetInstance().GetValidScore_(score);
159 EXPECT_EQ(score, RECLAIM_SCORE_MIN);
160
161 score = RECLAIM_SCORE_MIN;
162 ReclaimStrategyManager::GetInstance().GetValidScore_(score);
163 EXPECT_EQ(score, RECLAIM_SCORE_MIN);
164
165 score = RECLAIM_SCORE_MAX;
166 ReclaimStrategyManager::GetInstance().GetValidScore_(score);
167 EXPECT_EQ(score, RECLAIM_SCORE_MAX);
168
169 score = RECLAIM_SCORE_MAX + 1;
170 ReclaimStrategyManager::GetInstance().GetValidScore_(score);
171 EXPECT_EQ(score, RECLAIM_SCORE_MAX);
172 }
173
174 HWTEST_F(ReclaimStrategyManagerTest, HandleAppStateChangedTest, TestSize.Level1)
175 {
176 int pid = 1234567;
177 int appId = 111111;
178 std::string appName = "com.test";
179 int userId = 234561;
180 int userId2 = VALID_USER_ID_MIN - 1;
181 int score = 100;
182 std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
183 AppAction::OTHERS);
184 std::shared_ptr<ReclaimParam> para2 = std::make_shared<ReclaimParam>(pid, appId, appName, userId2, score,
185 AppAction::OTHERS);
186 ReclaimStrategyManager::GetInstance().HandleProcessCreate_(para);
187 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAppStateChanged_(para2), false);
188 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAppStateChanged_(nullptr), false);
189 EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), true);
190 }
191
192 HWTEST_F(ReclaimStrategyManagerTest, HandleAccountDiedTest, TestSize.Level1)
193 {
194 int pid = 1234567;
195 int appId = 111111;
196 std::string appName = "com.test";
197 int userId = 234561;
198 int score = 100;
199 std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
200 AppAction::OTHERS);
201 ReclaimStrategyManager::GetInstance().HandleProcessCreate_(para);
202 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), true);
203 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), false);
204 userId = 23456;
205 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), false);
206 EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), false);
207 }
208
209 HWTEST_F(ReclaimStrategyManagerTest, HandleAccountPriorityChangedTest, TestSize.Level1)
210 {
211 int pid = 1234567;
212 int appId = 111111;
213 std::string appName = "com.test";
214 int userId = 234561;
215 int score = 100;
216 std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
217 AppAction::OTHERS);
218 ReclaimStrategyManager::GetInstance().HandleProcessCreate_(para);
219 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountPriorityChanged_(userId, RECLAIM_SCORE_MIN), true);
220 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), true);
221 EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(RECLAIM_SCORE_MIN), false);
222 EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), false);
223 }
224 }
225 }
226