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 }
74 
75 HWTEST_F(ReclaimStrategyManagerTest, NotifyAccountDiedTest, TestSize.Level1)
76 {
77     int pid = 1234567;
78     int appId = 111111;
79     std::string appName = "com.test";
80     int userId = 234561;
81     int score = 100;
82     std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
83         AppAction::CREATE_PROCESS_AND_APP);
84     ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(para);
85     sleep(3);
86     UserMemcg* memcg = MemcgMgr::GetInstance().GetUserMemcg(userId);
87     EXPECT_EQ(memcg != nullptr, true);
88     std::string memcgPath = memcg->GetMemcgPath_();
89     ReclaimStrategyManager::GetInstance().NotifyAccountDied(userId);
90     sleep(3);
91     EXPECT_EQ(MemcgMgr::GetInstance().GetUserMemcg(userId) == nullptr, true);
92     EXPECT_EQ(KernelInterface::GetInstance().IsDirExists(memcgPath), false);
93 }
94 
95 HWTEST_F(ReclaimStrategyManagerTest, NotifyAccountPriorityChangedTest, TestSize.Level1)
96 {
97     int pid = 1234567;
98     int appId = 111111;
99     std::string appName = "com.test";
100     int userId = 234561;
101     int score = 100;
102     ReclaimStrategyManager::GetInstance().NotifyAccountPriorityChanged(userId, score);
103     sleep(3);
104     EXPECT_EQ(MemcgMgr::GetInstance().GetUserMemcg(userId) == nullptr, true);
105 
106     std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
107         AppAction::CREATE_PROCESS_AND_APP);
108     ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(para);
109     sleep(3);
110     UserMemcg* memcg = MemcgMgr::GetInstance().GetUserMemcg(userId);
111     EXPECT_EQ(memcg != nullptr, true);
112     std::string memcgPath = memcg->GetMemcgPath_();
113     ReclaimStrategyManager::GetInstance().NotifyAccountPriorityChanged(userId, score + score);
114     sleep(3);
115     EXPECT_EQ(memcg->score_, score + score);
116     ReclaimStrategyManager::GetInstance().NotifyAccountDied(userId);
117     sleep(3);
118     EXPECT_EQ(KernelInterface::GetInstance().IsDirExists(memcgPath), false);
119 }
120 
121 HWTEST_F(ReclaimStrategyManagerTest, CreateEventHandlerTest, TestSize.Level1)
122 {
123     EXPECT_EQ(ReclaimStrategyManager::GetInstance().CreateEventHandler(), true);
124 }
125 
126 HWTEST_F(ReclaimStrategyManagerTest, HandleProcessCreateTest, TestSize.Level1)
127 {
128     int pid = 1234567;
129     int appId = 111111;
130     std::string appName = "com.test";
131     int userId = 234561;
132     int score = 100;
133     std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
134         AppAction::CREATE_PROCESS_AND_APP);
135     ReclaimStrategyManager::GetInstance().NotifyAppStateChanged(para);
136     sleep(3);
137     UserMemcg* memcg = MemcgMgr::GetInstance().GetUserMemcg(userId);
138     EXPECT_EQ(memcg != nullptr, true);
139     std::string memcgPath = memcg->GetMemcgPath_();
140     EXPECT_EQ(KernelInterface::GetInstance().IsDirExists(memcgPath), true);
141     EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), true);
142 }
143 
144 HWTEST_F(ReclaimStrategyManagerTest, GetReclaimRatiosByScoreTest, TestSize.Level1)
145 {
146     ReclaimRatios ratios(50, 50, 50);
147     EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(0, ratios), true);
148     EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(100, ratios), true);
149     EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(200, ratios), true);
150     EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(500, ratios), true);
151     EXPECT_EQ(ReclaimStrategyManager::GetInstance().GetReclaimRatiosByScore_(1000, ratios), true);
152 }
153 
154 HWTEST_F(ReclaimStrategyManagerTest, GetValidScoreTest, TestSize.Level1)
155 {
156     int score = RECLAIM_SCORE_MIN - 1;
157     ReclaimStrategyManager::GetInstance().GetValidScore_(score);
158     EXPECT_EQ(score, RECLAIM_SCORE_MIN);
159 
160     score = RECLAIM_SCORE_MIN;
161     ReclaimStrategyManager::GetInstance().GetValidScore_(score);
162     EXPECT_EQ(score, RECLAIM_SCORE_MIN);
163 
164     score = RECLAIM_SCORE_MAX;
165     ReclaimStrategyManager::GetInstance().GetValidScore_(score);
166     EXPECT_EQ(score, RECLAIM_SCORE_MAX);
167 
168     score = RECLAIM_SCORE_MAX + 1;
169     ReclaimStrategyManager::GetInstance().GetValidScore_(score);
170     EXPECT_EQ(score, RECLAIM_SCORE_MAX);
171 }
172 
173 HWTEST_F(ReclaimStrategyManagerTest, HandleAppStateChangedTest, TestSize.Level1)
174 {
175     int pid = 1234567;
176     int appId = 111111;
177     std::string appName = "com.test";
178     int userId = 234561;
179     int userId2 = VALID_USER_ID_MIN - 1;
180     int score = 100;
181     std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
182         AppAction::OTHERS);
183     std::shared_ptr<ReclaimParam> para2 = std::make_shared<ReclaimParam>(pid, appId, appName, userId2, score,
184         AppAction::OTHERS);
185     ReclaimStrategyManager::GetInstance().HandleProcessCreate_(para);
186     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAppStateChanged_(para2), false);
187     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAppStateChanged_(nullptr), false);
188     EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), true);
189 }
190 
191 HWTEST_F(ReclaimStrategyManagerTest, HandleAccountDiedTest, TestSize.Level1)
192 {
193     int pid = 1234567;
194     int appId = 111111;
195     std::string appName = "com.test";
196     int userId = 234561;
197     int score = 100;
198     std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
199         AppAction::OTHERS);
200     ReclaimStrategyManager::GetInstance().HandleProcessCreate_(para);
201     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), true);
202     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), false);
203     userId = 23456;
204     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), false);
205     EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), false);
206 }
207 
208 HWTEST_F(ReclaimStrategyManagerTest, HandleAccountPriorityChangedTest, TestSize.Level1)
209 {
210     int pid = 1234567;
211     int appId = 111111;
212     std::string appName = "com.test";
213     int userId = 234561;
214     int score = 100;
215     std::shared_ptr<ReclaimParam> para = std::make_shared<ReclaimParam>(pid, appId, appName, userId, score,
216         AppAction::OTHERS);
217     ReclaimStrategyManager::GetInstance().HandleProcessCreate_(para);
218     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountPriorityChanged_(userId, RECLAIM_SCORE_MIN), true);
219     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(userId), true);
220     EXPECT_EQ(ReclaimStrategyManager::GetInstance().HandleAccountDied_(RECLAIM_SCORE_MIN), false);
221     EXPECT_EQ(MemcgMgr::GetInstance().RemoveUserMemcg(userId), false);
222 }
223 }
224 }
225