1 /*
2 * Copyright (c) 2024 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 "manage_keep_alive_apps_serializer_test.h"
19 #include "edm_constants.h"
20 #include "utils.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace EDM {
26 namespace TEST {
SetUpTestSuite(void)27 void ManageKeepAliveAppsSerializerTest::SetUpTestSuite(void)
28 {
29 Utils::SetEdmInitialEnv();
30 }
31
TearDownTestSuite(void)32 void ManageKeepAliveAppsSerializerTest::TearDownTestSuite(void)
33 {
34 Utils::ResetTokenTypeAndUid();
35 ASSERT_TRUE(Utils::IsOriginalUTEnv());
36 std::cout << "now ut process is orignal ut env : " << Utils::IsOriginalUTEnv() << std::endl;
37 }
38
39 /**
40 * @tc.name: TestSetDifferencePolicyDataEmpty
41 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::SetDifferencePolicy when data is empty
42 * @tc.type: FUNC
43 */
44 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestSetDifferencePolicyDataEmpty, TestSize.Level1)
45 {
46 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
47 std::vector<ManageKeepAliveAppInfo> data;
48 std::vector<ManageKeepAliveAppInfo> currentData;
49 std::vector<ManageKeepAliveAppInfo> res = serializer->SetDifferencePolicyData(data, currentData);
50 ASSERT_TRUE(res.empty());
51 }
52
53 /**
54 * @tc.name: TestSerializeEmpty
55 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::Serialize when jsonString is empty
56 * @tc.type: FUNC
57 */
58 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestSerializeEmpty, TestSize.Level1)
59 {
60 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
61 std::string jsonString;
62 std::vector<ManageKeepAliveAppInfo> dataObj;
63 bool ret = serializer->Serialize(dataObj, jsonString);
64 ASSERT_TRUE(ret);
65 ASSERT_TRUE(jsonString.empty());
66 }
67
68 /**
69 * @tc.name: TestSerializeSuc
70 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::Serialize
71 * @tc.type: FUNC
72 */
73 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestSerializeSuc, TestSize.Level1)
74 {
75 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
76 std::string jsonString;
77 std::vector<ManageKeepAliveAppInfo> dataObj;
78 ManageKeepAliveAppInfo info1;
79 info1.SetBundleName("test1");
80 info1.SetDisallowModify(true);
81 dataObj.push_back(info1);
82 bool ret = serializer->Serialize(dataObj, jsonString);
83 ASSERT_TRUE(ret);
84 ASSERT_FALSE(jsonString.empty());
85 }
86
87 /**
88 * @tc.name: TestDeserializeWithEmptyString
89 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::Deserialize jsonString is empty
90 * @tc.type: FUNC
91 */
92 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestDeserializeWithEmptyString, TestSize.Level1)
93 {
94 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
95 std::string jsonString = "";
96 std::vector<ManageKeepAliveAppInfo> dataObj;
97 bool ret = serializer->Deserialize(jsonString, dataObj);
98 ASSERT_TRUE(ret);
99 }
100
101 /**
102 * @tc.name: TestDeserializeWithJustBundleName
103 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::Deserialize WithJustBundleName
104 * @tc.type: FUNC
105 */
106 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestDeserializeWithJustBundleName, TestSize.Level1)
107 {
108 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
109 std::string jsonString = R"(["test1"])";
110 std::vector<ManageKeepAliveAppInfo> dataObj;
111 bool ret = serializer->Deserialize(jsonString, dataObj);
112 ASSERT_TRUE(ret);
113 ASSERT_TRUE(dataObj.size() == 1);
114 ASSERT_TRUE(dataObj[0].GetBundleName() == "test1");
115 ASSERT_TRUE(dataObj[0].GetDisallowModify());
116 }
117
118 /**
119 * @tc.name: TestDeserializeSuc
120 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::Deserialize
121 * @tc.type: FUNC
122 */
123 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestDeserializeSuc, TestSize.Level1)
124 {
125 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
126 std::string jsonString = R"([{"bundleName": "test", "disallowModify": false}])";
127 std::vector<ManageKeepAliveAppInfo> dataObj;
128 bool ret = serializer->Deserialize(jsonString, dataObj);
129 ASSERT_TRUE(ret);
130 ASSERT_EQ(dataObj.size(), 1);
131 ASSERT_EQ(dataObj[0].GetBundleName(), "test");
132 ASSERT_EQ(dataObj[0].GetDisallowModify(), false);
133 }
134
135 /**
136 * @tc.name: TestDeserializeMalformedJson
137 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::Deserialize MalformedJson
138 * @tc.type: FUNC
139 */
140 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestDeserializeMalformedJson, TestSize.Level1)
141 {
142 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
143 std::string jsonString = R"([
144 {"bundleName": "test1", "disallowModify": false,
145 {"bundleName": "test2", "disallowModify": true}
146 ])";
147 std::vector<ManageKeepAliveAppInfo> dataObj;
148 serializer->Deserialize(jsonString, dataObj);
149 ASSERT_TRUE(dataObj.empty());
150 }
151
152 /**
153 * @tc.name: TestGetPolicyOutOfRange
154 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::GetPolicy out of range
155 * @tc.type: FUNC
156 */
157 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestGetPolicyOutOfRange, TestSize.Level1)
158 {
159 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
160 MessageParcel data;
161 data.WriteInt32(EdmConstants::KEEP_ALIVE_APPS_MAX_SIZE + 1);
162 std::vector<ManageKeepAliveAppInfo> dataObj;
163 bool ret = serializer->GetPolicy(data, dataObj);
164 ASSERT_FALSE(ret);
165 }
166
167 /**
168 * @tc.name: TestGetPolicy
169 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::GetPolicy
170 * @tc.type: FUNC
171 */
172 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestGetPolicy, TestSize.Level1)
173 {
174 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
175 MessageParcel data;
176 std::vector<ManageKeepAliveAppInfo> dataObj;
177 data.WriteInt32(1);
178 data.WriteString("test1");
179 data.WriteBool(true);
180 bool ret = serializer->GetPolicy(data, dataObj);
181 ASSERT_TRUE(ret);
182 ASSERT_TRUE(dataObj[0].GetBundleName() == "test1");
183 ASSERT_TRUE(dataObj[0].GetDisallowModify());
184 }
185
186 /**
187 * @tc.name: TestWritePolicy
188 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::WritePolicy
189 * @tc.type: FUNC
190 */
191 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestWritePolicy, TestSize.Level1)
192 {
193 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
194 MessageParcel reply;
195 std::vector<ManageKeepAliveAppInfo> dataObj;
196 bool ret = serializer->WritePolicy(reply, dataObj);
197 ASSERT_TRUE(ret);
198 }
199
200 /**
201 * @tc.name: TestMergePolicy
202 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::MergePolicy
203 * @tc.type: FUNC
204 */
205 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestMergePolicy, TestSize.Level1)
206 {
207 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
208 std::vector<std::vector<ManageKeepAliveAppInfo>> dataObj;
209 std::vector<ManageKeepAliveAppInfo> data;
210 ManageKeepAliveAppInfo id1;
211 id1.SetBundleName("test1");
212 id1.SetDisallowModify(true);
213 data.push_back(id1);
214 dataObj.push_back(data);
215
216 std::vector<ManageKeepAliveAppInfo> data2;
217 ManageKeepAliveAppInfo id2;
218 id2.SetBundleName("test1");
219 id2.SetDisallowModify(false);
220 data2.push_back(id2);
221 dataObj.push_back(data2);
222 std::vector<ManageKeepAliveAppInfo> result;
223 serializer->MergePolicy(dataObj, result);
224 ASSERT_TRUE(result.size() == 1);
225 ASSERT_TRUE(result[0].GetDisallowModify());
226 }
227
228 /**
229 * @tc.name: TestUpdateByMergePolicy
230 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::UpdateByMergePolicy
231 * @tc.type: FUNC
232 */
233 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestUpdateByMergePolicy, TestSize.Level1)
234 {
235 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
236 std::vector<ManageKeepAliveAppInfo> data;
237 ManageKeepAliveAppInfo id1;
238 id1.SetBundleName("test1");
239 id1.SetDisallowModify(true);
240 data.push_back(id1);
241
242 ManageKeepAliveAppInfo id2;
243 id2.SetBundleName("test2");
244 id2.SetDisallowModify(true);
245 data.push_back(id2);
246
247 std::vector<ManageKeepAliveAppInfo> data2;
248 ManageKeepAliveAppInfo id3;
249 id3.SetBundleName("test2");
250 id3.SetDisallowModify(false);
251 data2.push_back(id3);
252
253 ManageKeepAliveAppInfo id4;
254 id4.SetBundleName("test3");
255 id4.SetDisallowModify(false);
256 data2.push_back(id3);
257
258 ManageKeepAliveAppInfo id5;
259 id5.SetBundleName("test4");
260 id5.SetDisallowModify(false);
261 data2.push_back(id5);
262
263 serializer->UpdateByMergePolicy(data, data2);
264 ASSERT_TRUE(data.size() == 2);
265 ASSERT_FALSE(data[1].GetDisallowModify());
266 }
267
268 /**
269 * @tc.name: TestSetIntersectionPolicyData
270 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::SetIntersectionPolicyData
271 * @tc.type: FUNC
272 */
273 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestSetIntersectionPolicyData, TestSize.Level1)
274 {
275 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
276 std::vector<std::string> bundleNames;
277 bundleNames.push_back("test1");
278 bundleNames.push_back("test2");
279
280 std::vector<ManageKeepAliveAppInfo> data;
281 ManageKeepAliveAppInfo id1;
282 id1.SetBundleName("test1");
283 id1.SetDisallowModify(true);
284 data.push_back(id1);
285
286 ManageKeepAliveAppInfo id2;
287 id2.SetBundleName("test3");
288 id2.SetDisallowModify(true);
289 data.push_back(id2);
290
291 std::vector<ManageKeepAliveAppInfo>result = serializer->SetIntersectionPolicyData(bundleNames, data);
292 ASSERT_TRUE(result.size() == 1);
293 ASSERT_TRUE(result[0].GetBundleName() == "test1");
294 }
295
296 /**
297 * @tc.name: TestSetNeedRemoveMergePolicyData
298 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::SetNeedRemoveMergePolicyData
299 * @tc.type: FUNC
300 */
301 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestSetNeedRemoveMergePolicyData, TestSize.Level1)
302 {
303 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
304 std::vector<ManageKeepAliveAppInfo> data;
305 ManageKeepAliveAppInfo id1;
306 id1.SetBundleName("test1");
307 id1.SetDisallowModify(true);
308 data.push_back(id1);
309
310 ManageKeepAliveAppInfo id2;
311 id2.SetBundleName("test2");
312 id2.SetDisallowModify(true);
313 data.push_back(id2);
314
315 std::vector<ManageKeepAliveAppInfo> mergeData;
316 ManageKeepAliveAppInfo id3;
317 id3.SetBundleName("test1");
318 id3.SetDisallowModify(true);
319 mergeData.push_back(id3);
320
321 ManageKeepAliveAppInfo id4;
322 id4.SetBundleName("test3");
323 id4.SetDisallowModify(true);
324 mergeData.push_back(id4);
325
326 ManageKeepAliveAppInfo id5;
327 id5.SetBundleName("test4");
328 id5.SetDisallowModify(true);
329 mergeData.push_back(id5);
330
331 std::vector<ManageKeepAliveAppInfo>result = serializer->SetNeedRemoveMergePolicyData(mergeData, data);
332 ASSERT_TRUE(result.size() == 1);
333 ASSERT_TRUE(result[0].GetBundleName() == "test2");
334 }
335
336 /**
337 * @tc.name: TestSetUnionPolicyData
338 * @tc.desc: Test ManageKeepAliveAppsSerializerTest::SetUnionPolicyData
339 * @tc.type: FUNC
340 */
341 HWTEST_F(ManageKeepAliveAppsSerializerTest, TestSetUnionPolicyData, TestSize.Level1)
342 {
343 auto serializer = ManageKeepAliveAppsSerializer::GetInstance();
344 std::vector<ManageKeepAliveAppInfo> data;
345 ManageKeepAliveAppInfo id1;
346 id1.SetBundleName("test1");
347 id1.SetDisallowModify(true);
348 data.push_back(id1);
349
350 ManageKeepAliveAppInfo id2;
351 id2.SetBundleName("test2");
352 id2.SetDisallowModify(true);
353 data.push_back(id2);
354
355 std::vector<ManageKeepAliveAppInfo> mergeData;
356 ManageKeepAliveAppInfo id3;
357 id3.SetBundleName("test1");
358 id3.SetDisallowModify(false);
359 mergeData.push_back(id3);
360
361 ManageKeepAliveAppInfo id4;
362 id4.SetBundleName("test3");
363 id4.SetDisallowModify(true);
364 mergeData.push_back(id4);
365
366 ManageKeepAliveAppInfo id5;
367 id5.SetBundleName("test4");
368 id5.SetDisallowModify(true);
369 mergeData.push_back(id5);
370
371 std::vector<ManageKeepAliveAppInfo>result = serializer->SetUnionPolicyData(data, mergeData);
372 ASSERT_TRUE(result.size() == 4);
373 ASSERT_TRUE(result[0].GetBundleName() == "test1");
374 ASSERT_FALSE(result[0].GetDisallowModify());
375 }
376 } // namespace TEST
377 } // namespace EDM
378 } // namespace OHOS