• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 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 #include "array_string_serializer.h"
18 #include "bool_serializer.h"
19 #include "cjson_serializer.h"
20 #include "func_code_utils.h"
21 #include "long_serializer.h"
22 #include "map_string_serializer.h"
23 #include "string_serializer.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::EDM;
28 
29 namespace OHOS {
30 namespace EDM {
31 namespace TEST {
32 class PolicySerializerTest : public testing::Test {};
33 
34 /**
35  * @tc.name: BOOL
36  * @tc.desc: Test BoolSerializer.
37  * @tc.type: FUNC
38  */
39 HWTEST_F(PolicySerializerTest, BOOL, TestSize.Level1)
40 {
41     auto serializer = BoolSerializer::GetInstance();
42     string boolJsonString;
43     ASSERT_TRUE(serializer->Serialize(true, boolJsonString));
44     ASSERT_EQ(boolJsonString, "true");
45     ASSERT_NE(boolJsonString, "false");
46 
47     bool boolValue = false;
48     ASSERT_TRUE(serializer->Deserialize("", boolValue));
49     ASSERT_TRUE(serializer->Deserialize("true", boolValue));
50     ASSERT_EQ(boolValue, true);
51     ASSERT_FALSE(serializer->Deserialize("truee", boolValue));
52 
53     boolValue = true;
54     MessageParcel messageParcel1;
55     messageParcel1.WriteBool(false);
56     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, boolValue));
57     ASSERT_EQ(boolValue, false);
58 
59     MessageParcel messageParcel2;
60     boolValue = true;
61     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, boolValue));
62     ASSERT_EQ(messageParcel2.ReadBool(), true);
63 
64 
65     boolValue = false;
66     vector<bool> policyValues { false, true, false, false, true };
67     serializer->MergePolicy(policyValues, boolValue);
68     ASSERT_EQ(boolValue, true);
69 
70     boolValue = true;
71     policyValues = { false, false, false, false, false };
72     serializer->MergePolicy(policyValues, boolValue);
73     ASSERT_EQ(boolValue, false);
74 }
75 
76 /**
77  * @tc.name: STRING
78  * @tc.desc: Test StringSerializer.
79  * @tc.type: FUNC
80  */
81 HWTEST_F(PolicySerializerTest, STRING, TestSize.Level1)
82 {
83     auto serializer = StringSerializer::GetInstance();
84     string value = "s1";
85     string jsonString;
86     ASSERT_TRUE(serializer->Serialize(value, jsonString));
87     ASSERT_EQ(jsonString, "s1");
88 
89     jsonString = "s2";
90     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
91     ASSERT_TRUE(value.length() == 2);
92 
93     MessageParcel messageParcel1;
94     std::string value2 = "s一";
95     messageParcel1.WriteString(value2);
96     value = "";
97     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
98     ASSERT_TRUE(value == "s一");
99 
100     MessageParcel messageParcel2;
101     value = "s二";
102     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
103     value2 = "";
104     ASSERT_TRUE(messageParcel2.ReadString(value2));
105     ASSERT_TRUE(value2 == "s二");
106 
107     vector<string> policyValues { "v1", "v2", "v3" };
108     serializer->MergePolicy(policyValues, value);
109     ASSERT_TRUE(value == "v3");
110 }
111 
112 /**
113  * @tc.name: ARRAY_STRING
114  * @tc.desc: Test ArrayStringSerializer.
115  * @tc.type: FUNC
116  */
117 HWTEST_F(PolicySerializerTest, ARRAY_STRING, TestSize.Level1)
118 {
119     auto serializer = ArrayStringSerializer::GetInstance();
120     vector<string> value = { "v1", "v2", "v3", "v4", "v5" };
121     string jsonString;
122     ASSERT_TRUE(serializer->Serialize(value, jsonString));
123     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
124     jsonString.erase(sd, jsonString.end());
125     ASSERT_EQ(jsonString, R"(["v1","v2","v3","v4","v5"])");
126 
127     jsonString = R"(["v1","v2","v3","v4","v5","v6"])";
128     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
129     ASSERT_TRUE(value.size() == 6);
130     ASSERT_FALSE(serializer->Deserialize(R"(["v1","v2","v3","v4","v5""v6"])", value));
131 
132     MessageParcel messageParcel1;
133     vector<std::string> value2 = { "一", "二", "三", "四", "五", "六", "七" };
134     messageParcel1.WriteStringVector(value2);
135     value = {};
136     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
137     ASSERT_TRUE(value.size() == 7);
138     serializer->Deduplication(value);
139     ASSERT_TRUE(value.size() == 7);
140     ArraySerializer<std::string, std::vector<std::string>> testArraySerializer;
141     testArraySerializer.Deduplication(value);
142     ASSERT_TRUE(value.size() == 7);
143     MessageParcel messageParcel2;
144     value = { "v1", "v2", "v3" };
145     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
146     value2 = {};
147     messageParcel2.ReadStringVector(&value2);
148     ASSERT_TRUE(value2.size() == 3);
149 
150     vector<vector<string>> policyValues {{ "v1",   "v2",   "v3" },
151                                          { "vv1",  "vv2",  "vv3" },
152                                          { "vvv1", "vvv2", "vvv3" },
153                                          { "v1",   "v2",   "v3" },
154                                          { "vv1",  "vv2",  "vv3" }};
155     serializer->MergePolicy(policyValues, value);
156     ASSERT_TRUE(value.size() == 9);
157 }
158 
159 /**
160  * @tc.name: MAP_STRING
161  * @tc.desc: Test MapStringSerializer.
162  * @tc.type: FUNC
163  */
164 HWTEST_F(PolicySerializerTest, MAP_STRING, TestSize.Level1)
165 {
166     auto serializer = MapStringSerializer::GetInstance();
167     map<string, string> value = {
168         { "k1", "v1" },
169         { "k2", "v2" },
170         { "k3", "v3" },
171         { "k4", "v4" },
172     };
173     string jsonString;
174     ASSERT_TRUE(serializer->Serialize(value, jsonString));
175     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
176     jsonString.erase(sd, jsonString.end());
177     ASSERT_EQ(jsonString, R"({"k1":"v1","k2":"v2","k3":"v3","k4":"v4"})");
178 
179     jsonString = R"({"k1":"v1","k2":"v2","k3":"v3","k4":"v4"})";
180     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
181     ASSERT_TRUE(value.size() == 4);
182     ASSERT_FALSE(serializer->Deserialize(R"(["v1","v2","v3","v4","v5","v6"])", value));
183 
184     MessageParcel messageParcel1;
185     vector<std::string> key2 = {
186         "一", "二", "三",
187         "四", "五", "六",
188         "七" };
189     messageParcel1.WriteStringVector(key2);
190     vector<std::string> value2 = {
191         "值", "值", "值",
192         "值", "值", "值",
193         "值" };
194     messageParcel1.WriteStringVector(value2);
195     value = {};
196     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
197     ASSERT_TRUE(value.size() == 7);
198     for (auto const &entry:value) {
199         ASSERT_EQ(entry.second, "值");
200     }
201 }
202 
203 /**
204  * @tc.name: MAP_STRING_002
205  * @tc.desc: Test MapStringSerializer.
206  * @tc.type: FUNC
207  */
208 HWTEST_F(PolicySerializerTest, MAP_STRING_002, TestSize.Level1)
209 {
210     auto serializer = MapStringSerializer::GetInstance();
211     map<string, string> value = {
212         { "k1", "v1" },
213         { "k2", "v2" },
214         { "k3", "v3" },
215         { "k4", "v4" },
216     };
217     MessageParcel messageParcel2;
218     value = {
219         { "k1", "v1" },
220         { "k2", "v2" },
221         { "k3", "v3" },
222         { "k4", "v4" },
223     };
224     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
225     vector<std::string> key4;
226     vector<std::string> value4;
227     messageParcel2.ReadStringVector(&key4);
228     messageParcel2.ReadStringVector(&value4);
229     ASSERT_TRUE(key4.size() == 4);
230     for (std::uint32_t i = 0; i < key4.size(); ++i) {
231         ASSERT_EQ(key4.at(i), "k" + std::to_string(i + 1));
232     }
233     ASSERT_TRUE(value4.size() == 4);
234     for (std::uint32_t i = 0; i < value4.size(); ++i) {
235         ASSERT_EQ(value4.at(i), "v" + std::to_string(i + 1));
236     }
237 
238     map<string, string> value1 = {
239         { "k1", "v1" },
240     };
241     map<string, string> value2 = {
242         { "k1", "v1" },
243         { "k2", "v2" },
244         { "k3", "v3" },
245     };
246     map<string, string> value3 = {
247         { "k3", "v3" },
248         { "k4", "v4" },
249     };
250     value = {};
251     vector<map<string, string>> policyValues { value1, value2, value3 };
252     serializer->MergePolicy(policyValues, value);
253     ASSERT_TRUE(value3 == value);
254 }
255 
256 /**
257  * @tc.name: MAP_STRING_Serializer_Deserialize
258  * @tc.desc: Test MapStringSerializer.
259  * @tc.type: FUNC
260  */
261 HWTEST_F(PolicySerializerTest, MAP_STRING_Serializer_Deserialize, TestSize.Level1)
262 {
263     auto serializer = MapStringSerializer::GetInstance();
264 
265     cJSON* root = cJSON_CreateObject();
266     cJSON_AddStringToObject(root, "string", "str");
267     cJSON_AddStringToObject(root, "bool", "true");
268     cJSON_AddStringToObject(root, "int", "1");
269 
270     char* jsonString = cJSON_PrintUnformatted(root);
271     std::string jsonStr(jsonString);
272     cJSON_free(jsonString);
273 
274     std::map<std::string, std::string> result;
275     ASSERT_TRUE(serializer->Deserialize(jsonStr, result));
276     ASSERT_TRUE(result["string"] == "str");
277     ASSERT_TRUE(result["bool"] == "true");
278     ASSERT_TRUE(result["int"] == "1");
279 
280     cJSON_Delete(root);
281 }
282 
283 /**
284  * @tc.name: MAP_STRING_Serializer_DeserializeFail
285  * @tc.desc: Test MapStringSerializer.
286  * @tc.type: FUNC
287  */
288 HWTEST_F(PolicySerializerTest, MAP_STRING_Serializer_DeserializeFail, TestSize.Level1)
289 {
290     auto serializer = MapStringSerializer::GetInstance();
291 
292     cJSON* root = cJSON_CreateObject();
293     cJSON* sub = cJSON_CreateObject();
294     cJSON_AddStringToObject(sub, "key", "value");
295     cJSON_AddItemToObject(root, "object", sub);
296 
297     char* jsonString = cJSON_Print(root);
298     std::string jsonStr(jsonString);
299     cJSON_free(jsonString);
300 
301     std::map<std::string, std::string> result;
302     ASSERT_FALSE(serializer->Deserialize(jsonStr, result));
303     ASSERT_TRUE(result.empty());
304 
305     cJSON_Delete(root);
306 }
307 
308 /**
309  * @tc.name: JSON
310  * @tc.desc: Test JsonSerializer.
311  * @tc.type: FUNC
312  */
313 HWTEST_F(PolicySerializerTest, JSON, TestSize.Level1)
314 {
315     auto serializer = CjsonSerializer::GetInstance();
316 
317     cJSON* value = cJSON_CreateObject();
318     cJSON_AddStringToObject(value, "k1", "v1");
319     cJSON_AddStringToObject(value, "k2", "v2");
320     cJSON_AddNumberToObject(value, "k3", 3);
321 
322     std::string jsonString;
323     ASSERT_TRUE(serializer->Serialize(value, jsonString));
324     auto sd = std::remove_if(jsonString.begin(), jsonString.end(), isspace);
325     jsonString.erase(sd, jsonString.end());
326     ASSERT_EQ(jsonString, R"({"k1":"v1","k2":"v2","k3":3})");
327     cJSON_Delete(value);
328 
329     jsonString = R"(["v1","v2","v3","v4","v5","v6"])";
330     value = nullptr;
331     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
332     ASSERT_TRUE(cJSON_IsArray(value) && cJSON_GetArraySize(value) == 6);
333     cJSON_Delete(value);
334 
335     MessageParcel messageParcel1;
336     std::string value2 = R"(["v1","v2"])";
337     messageParcel1.WriteString(value2);
338     value = nullptr;
339     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
340     ASSERT_TRUE(cJSON_IsArray(value) && cJSON_GetArraySize(value) == 2);
341     cJSON_Delete(value);
342 
343     MessageParcel messageParcel2;
344     value = cJSON_CreateArray();
345     cJSON_AddItemToArray(value, cJSON_CreateNumber(1));
346     cJSON_AddItemToArray(value, cJSON_CreateNumber(2));
347     cJSON_AddItemToArray(value, cJSON_CreateNull());
348     cJSON_AddItemToArray(value, cJSON_CreateNumber(3));
349     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
350     value2 = "";
351     messageParcel2.ReadString(value2);
352     jsonString = value2;
353     sd = std::remove_if(jsonString.begin(), jsonString.end(), isspace);
354     jsonString.erase(sd, jsonString.end());
355     ASSERT_EQ(jsonString, R"([1,2,null,3])");
356     cJSON_Delete(value);
357 
358     std::vector<cJSON*> vec;
359     value = cJSON_Parse(jsonString.c_str());
360     ASSERT_TRUE(value != nullptr);
361     vec.push_back(value);
362     serializer->MergePolicy(vec, value);
363     ASSERT_TRUE(vec.size() == 1);
364     cJSON_Delete(value);
365 }
366 
367 /**
368  * @tc.name: Long
369  * @tc.desc: Test LongSerializer.
370  * @tc.type: FUNC
371  */
372 HWTEST_F(PolicySerializerTest, Long, TestSize.Level1)
373 {
374     auto serializer = LongSerializer::GetInstance();
375     std::string testString = "123456";
376     std::string jsonString = testString;
377     int64_t res = 0;
378     ASSERT_TRUE(serializer->Deserialize(jsonString, res));
379     ASSERT_EQ(res, 123456);
380 
381     jsonString = "";
382     ASSERT_TRUE(serializer->Serialize(res, jsonString));
383     ASSERT_EQ(jsonString, testString);
384 
385     MessageParcel data;
386     data.WriteInt64(1);
387     ASSERT_TRUE(serializer->GetPolicy(data, res));
388     ASSERT_TRUE(res == 1);
389 
390     MessageParcel reply;
391     res = 1;
392     ASSERT_TRUE(serializer->WritePolicy(reply, res));
393     int64_t temp = 0;
394     reply.ReadInt64(temp);
395     ASSERT_TRUE(temp == 1);
396 
397     std::vector<int64_t> vec = {1, 2, 3, 4, 5};
398     serializer->MergePolicy(vec, res);
399     ASSERT_TRUE(res == 5);
400 }
401 } // namespace TEST
402 } // namespace EDM
403 } // namespace OHOS
404