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 "mem_mgr_client.h"
23 #include "bundle_priority_list.h"
24 #include "mem_mgr_constant.h"
25 #include "app_state_subscriber.h"
26 #undef private
27 #undef protected
28
29 namespace OHOS {
30 namespace Memory {
31 using namespace testing;
32 using namespace testing::ext;
33
34 constexpr int IPC_STUB_ERR = 300;
35 class AppStateSubscriberTest : public AppStateSubscriber {
36 public:
37 void OnConnected() override;
38 void OnDisconnected() override;
39 void OnAppStateChanged(int32_t pid, int32_t uid, int32_t state) override;
40 void ForceReclaim(int32_t pid, int32_t uid) override;
41 void OnTrim(SystemMemoryLevel level) override;
42 void OnRemoteDied(const wptr<IRemoteObject> &object) override;
43 };
44
OnConnected()45 void AppStateSubscriberTest::OnConnected()
46 {
47 }
48
OnDisconnected()49 void AppStateSubscriberTest::OnDisconnected()
50 {
51 }
52
OnAppStateChanged(int32_t pid,int32_t uid,int32_t state)53 void AppStateSubscriberTest::OnAppStateChanged(int32_t pid, int32_t uid, int32_t state)
54 {
55 }
56
ForceReclaim(int32_t pid,int32_t uid)57 void AppStateSubscriberTest::ForceReclaim(int32_t pid, int32_t uid)
58 {
59 }
60
OnTrim(SystemMemoryLevel level)61 void AppStateSubscriberTest::OnTrim(SystemMemoryLevel level)
62 {
63 }
64
OnRemoteDied(const wptr<IRemoteObject> & object)65 void AppStateSubscriberTest::OnRemoteDied(const wptr<IRemoteObject> &object)
66 {
67 }
68
69 class InnerkitsTest : public testing::Test {
70 public:
71 static void SetUpTestCase();
72 static void TearDownTestCase();
73 void SetUp();
74 void TearDown();
75 static std::shared_ptr<MemMgrClient> memMgrClient_;
76 static std::vector<std::shared_ptr<AppStateSubscriberTest>> appStateSubscriberTests;
77 };
78 std::vector<std::shared_ptr<AppStateSubscriberTest>> InnerkitsTest::appStateSubscriberTests =
79 std::vector<std::shared_ptr<AppStateSubscriberTest>>();
80
SetUpTestCase()81 void InnerkitsTest::SetUpTestCase()
82 {
83 }
84
TearDownTestCase()85 void InnerkitsTest::TearDownTestCase()
86 {
87 }
88
SetUp()89 void InnerkitsTest::SetUp()
90 {
91 }
92
TearDown()93 void InnerkitsTest::TearDown()
94 {
95 for (auto appStateSubscriberTest_ : appStateSubscriberTests) {
96 MemMgrClient::GetInstance().UnsubscribeAppState(*appStateSubscriberTest_);
97 }
98 appStateSubscriberTests.clear();
99 }
100
101 HWTEST_F(InnerkitsTest, GetBundlePriorityList_Test, TestSize.Level1)
102 {
103 BundlePriorityList bundlePrioList;
104 int32_t ret = MemMgrClient::GetInstance().GetBundlePriorityList(bundlePrioList);
105 EXPECT_EQ(ret, 0);
106 bundlePrioList.Show();
107 }
108
109 HWTEST_F(InnerkitsTest, GetPriorityDescTest, TestSize.Level1)
110 {
111 auto ptr = ReclaimPriorityMapping.find(RECLAIM_PRIORITY_SYSTEM);
112 EXPECT_EQ(ptr->second, "System");
113 }
114
115 HWTEST_F(InnerkitsTest, NotifyDistDevStatus_Test, TestSize.Level1)
116 {
117 int32_t ret = MemMgrClient::GetInstance().NotifyDistDevStatus(123, 456, "dist_dev_test", true);
118 EXPECT_EQ(ret, 0);
119 }
120
121 HWTEST_F(InnerkitsTest, GetKillLevelOfLmkd_Test, TestSize.Level1)
122 {
123 int32_t killLevel;
124 int32_t ret = MemMgrClient::GetInstance().GetKillLevelOfLmkd(killLevel);
125 EXPECT_EQ(ret, 0);
126 printf("lmkd kill level: %d\n", killLevel);
127 }
128
129 #ifdef USE_PURGEABLE_MEMORY
130
131 HWTEST_F(InnerkitsTest, RegisterActiveApps_Test, TestSize.Level1)
132 {
133 int32_t pid = 1234;
134 int32_t uid = 20012001;
135 int32_t ret = MemMgrClient::GetInstance().RegisterActiveApps(pid, uid);
136 EXPECT_EQ(ret, 0);
137 }
138
139 HWTEST_F(InnerkitsTest, DeregisterActiveApps_Test, TestSize.Level1)
140 {
141 int32_t pid = 1234;
142 int32_t uid = 20012001;
143 int32_t ret = MemMgrClient::GetInstance().DeregisterActiveApps(pid, uid);
144 EXPECT_EQ(ret, 0);
145 }
146
147 HWTEST_F(InnerkitsTest, SubscribeAppState_Test, TestSize.Level1)
148 {
149 std::shared_ptr<AppStateSubscriberTest> appStateSubscriberTest_1 = std::make_shared<AppStateSubscriberTest>();
150 EXPECT_NE(appStateSubscriberTest_1, nullptr);
151 int32_t ret = MemMgrClient::GetInstance().SubscribeAppState(*appStateSubscriberTest_1);
152 appStateSubscriberTests.emplace_back(appStateSubscriberTest_1);
153 EXPECT_EQ(ret, 0);
154 }
155
156 HWTEST_F(InnerkitsTest, UnsubscribeAppState_Test, TestSize.Level1)
157 {
158 std::shared_ptr<AppStateSubscriberTest> appStateSubscriberTest_1 = std::make_shared<AppStateSubscriberTest>();
159 EXPECT_NE(appStateSubscriberTest_1, nullptr);
160 MemMgrClient::GetInstance().SubscribeAppState(*appStateSubscriberTest_1);
161 appStateSubscriberTests.emplace_back(appStateSubscriberTest_1);
162 int32_t ret = MemMgrClient::GetInstance().UnsubscribeAppState(*appStateSubscriberTest_1);
163 EXPECT_EQ(ret, 0);
164 }
165
166 HWTEST_F(InnerkitsTest, GetAvailableMemory_Test, TestSize.Level1)
167 {
168 int32_t ret = MemMgrClient::GetInstance().GetAvailableMemory();
169 EXPECT_NE(ret, 0);
170 }
171 #else
172 HWTEST_F(InnerkitsTest, RegisterActiveApps_Test, TestSize.Level1)
173 {
174 int32_t pid = 1234;
175 int32_t uid = 20012001;
176 int32_t ret = MemMgrClient::GetInstance().RegisterActiveApps(pid, uid);
177 EXPECT_EQ(ret, -1);
178 }
179
180 HWTEST_F(InnerkitsTest, DeregisterActiveApps_Test, TestSize.Level1)
181 {
182 int32_t pid = 1234;
183 int32_t uid = 20012001;
184 int32_t ret = MemMgrClient::GetInstance().DeregisterActiveApps(pid, uid);
185 EXPECT_EQ(ret, -1);
186 }
187
188 HWTEST_F(InnerkitsTest, SubscribeAppState_Test, TestSize.Level1)
189 {
190 std::shared_ptr<AppStateSubscriberTest> appStateSubscriberTest_1 = std::make_shared<AppStateSubscriberTest>();
191 EXPECT_NE(appStateSubscriberTest_1, nullptr);
192 int32_t ret = MemMgrClient::GetInstance().SubscribeAppState(*appStateSubscriberTest_1);
193 appStateSubscriberTests.emplace_back(appStateSubscriberTest_1);
194 EXPECT_EQ(ret, -1);
195 }
196
197 HWTEST_F(InnerkitsTest, UnsubscribeAppState_Test, TestSize.Level1)
198 {
199 std::shared_ptr<AppStateSubscriberTest> appStateSubscriberTest_1 = std::make_shared<AppStateSubscriberTest>();
200 EXPECT_NE(appStateSubscriberTest_1, nullptr);
201 MemMgrClient::GetInstance().SubscribeAppState(*appStateSubscriberTest_1);
202 appStateSubscriberTests.emplace_back(appStateSubscriberTest_1);
203 int32_t ret = MemMgrClient::GetInstance().UnsubscribeAppState(*appStateSubscriberTest_1);
204 EXPECT_EQ(ret, -1);
205 }
206
207 HWTEST_F(InnerkitsTest, GetAvailableMemory_Test, TestSize.Level1)
208 {
209 int32_t ret = MemMgrClient::GetInstance().GetAvailableMemory();
210 EXPECT_EQ(ret, -1);
211 }
212 #endif // USE_PURGEABLE_MEMORY
213
214 HWTEST_F(InnerkitsTest, GetReclaimPriorityByPid_Test, TestSize.Level1)
215 {
216 int32_t pid = 1;
217 int32_t priority = 1001;
218 int32_t ret = MemMgrClient::GetInstance().GetReclaimPriorityByPid(pid, priority);
219 EXPECT_EQ(ret, IPC_STUB_ERR);
220 EXPECT_EQ(priority, 1001);
221 }
222
223 HWTEST_F(InnerkitsTest, NotifyProcessStateChangedSync_Test, TestSize.Level1)
224 {
225 MemMgrProcessStateInfo processStateInfo;
226 processStateInfo.pid_ = 1014;
227 processStateInfo.uid_ = 20100001;
228 processStateInfo.reason_ = ProcPriorityUpdateReason::START_ABILITY;
229 int32_t ret = MemMgrClient::GetInstance().NotifyProcessStateChangedSync(processStateInfo);
230 EXPECT_EQ(ret, IPC_STUB_ERR);
231 }
232
233 HWTEST_F(InnerkitsTest, NotifyProcessStateChangedAsync_Test, TestSize.Level1)
234 {
235 MemMgrProcessStateInfo processStateInfo;
236 processStateInfo.pid_ = 1034;
237 processStateInfo.uid_ = 20300001;
238 processStateInfo.reason_ = ProcPriorityUpdateReason::START_ABILITY;
239 int32_t ret = MemMgrClient::GetInstance().NotifyProcessStateChangedAsync(processStateInfo);
240 EXPECT_EQ(ret, IPC_STUB_ERR);
241 }
242
243 HWTEST_F(InnerkitsTest, NotifyProcessStatus_Test, TestSize.Level1)
244 {
245 pid_t pid = 1035;
246 int type = 1;
247 int status = 1;
248 int saId = 1000;
249 int ret = MemMgrClient::GetInstance().NotifyProcessStatus(pid, type, status, saId);
250 EXPECT_EQ(ret, 0);
251 }
252
253 HWTEST_F(InnerkitsTest, SetCritical_Test, TestSize.Level1)
254 {
255 pid_t pid = 1036;
256 int saId = 1000;
257 int ret = MemMgrClient::GetInstance().SetCritical(pid, true, saId);
258 EXPECT_EQ(ret, 0);
259 }
260 }
261 }
262