• 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_map_serializer.h"
18 #include "array_string_serializer.h"
19 #include "bool_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 #include "utils/json_serializer.h"
25 
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::EDM;
29 
30 namespace OHOS {
31 namespace EDM {
32 namespace TEST {
33 class PolicySerializerTest : public testing::Test {};
34 
35 /**
36  * @tc.name: BOOL
37  * @tc.desc: Test BoolSerializer.
38  * @tc.type: FUNC
39  */
40 HWTEST_F(PolicySerializerTest, BOOL, TestSize.Level1)
41 {
42     auto serializer = BoolSerializer::GetInstance();
43     string boolJsonString;
44     ASSERT_TRUE(serializer->Serialize(true, boolJsonString));
45     ASSERT_EQ(boolJsonString, "true");
46     ASSERT_NE(boolJsonString, "false");
47 
48     bool boolValue = false;
49     ASSERT_FALSE(serializer->Deserialize("", boolValue));
50     ASSERT_TRUE(serializer->Deserialize("true", boolValue));
51     ASSERT_EQ(boolValue, true);
52     ASSERT_FALSE(serializer->Deserialize("truee", boolValue));
53 
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     ASSERT_TRUE(serializer->MergePolicy(policyValues, boolValue));
68     ASSERT_EQ(boolValue, true);
69 
70     boolValue = true;
71     policyValues = { false, false, false, false, false };
72     ASSERT_TRUE(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     ASSERT_TRUE(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     ASSERT_TRUE(serializer->MergePolicy(policyValues, value));
156     ASSERT_TRUE(value.size() == 9);
157 }
158 
159 /**
160  * @tc.name: ArrayMapStringSerializer
161  * @tc.desc: Test ArrayMapSerializer::Serialize.
162  * @tc.type: FUNC
163  */
164 HWTEST_F(PolicySerializerTest, ArrayMapStringSerializer, TestSize.Level1)
165 {
166     auto serializer = ArrayMapSerializer::GetInstance();
167     vector<map<string, string>> value = {
168         {
169             { "id", "1" },
170             { "name", "leon" },
171             { "desc", "hello" },
172         },
173         {
174             { "id", "2" },
175             { "name", "job" },
176             { "desc", "world" },
177         }
178     };
179     string exceptStr;
180     string jsonString;
181     ASSERT_TRUE(serializer->Serialize(value, jsonString));
182     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
183     jsonString.erase(sd, jsonString.end());
184     exceptStr = R"(["{\n\"desc\":\"hello\",\n\"id\":\"1\",\n\"name\":\"leon\"\n}")";
185     exceptStr.append(R"(,"{\n\"desc\":\"world\",\n\"id\":\"2\",\n\"name\":\"job\"\n}"])");
186     ASSERT_EQ(jsonString, exceptStr);
187 }
188 
189 /**
190  * @tc.name: ArrayMapStringDeserialize
191  * @tc.desc: Test ArrayMapSerializer::Deserialize.
192  * @tc.type: FUNC
193  */
194 HWTEST_F(PolicySerializerTest, ArrayMapStringDeserialize, TestSize.Level1)
195 {
196     auto serializer = ArrayMapSerializer::GetInstance();
197     vector<map<string, string>> value;
198     std::string jsonString = R"([{"desc":"hello","id":"1","name":"leon"},{"desc":"world","id":"2","name":"job"}])";
199     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
200     ASSERT_TRUE(value.size() == 2);
201 
202     map<string, string> expectZero = {
203         { "id",   "1" },
204         { "name", "leon" },
205         { "desc", "hello" },
206     };
207     ASSERT_TRUE(value.at(0) == expectZero);
208     map<string, string> expectOne = {
209         { "id",   "2" },
210         { "name", "job" },
211         { "desc", "world" },
212     };
213     ASSERT_TRUE(value.at(1) == expectOne);
214 }
215 
216 /**
217  * @tc.name: ArrayMapStringGetPolicy
218  * @tc.desc: Test ArrayMapSerializer::GetPolicy.
219  * @tc.type: FUNC
220  */
221 HWTEST_F(PolicySerializerTest, ArrayMapStringGetPolicy, TestSize.Level1)
222 {
223     auto serializer = ArrayMapSerializer::GetInstance();
224     vector<map<string, string>> value;
225     MessageParcel messageParcel1;
226     vector<std::string> value2 = {
227         R"({"id":"1","name":"leon","desc":"hello world"})",
228         R"({"id":"2","name":"job","desc":"two"})",
229         R"({"id":"3","name":"james","desc":"three"})",
230         R"({"id":"4","name":"bao","desc":"four"})",
231         R"({"id":"5","name":"fox","desc":"five"})"
232     };
233     messageParcel1.WriteStringVector(value2);
234     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
235     ASSERT_TRUE(value.size() == 5);
236     serializer->Deduplication(value);
237     ASSERT_TRUE(value.size() == 5);
238 }
239 
240 /**
241  * @tc.name: ArrayMapStringWritePolicy
242  * @tc.desc: Test ArrayMapSerializer::WritePolicy.
243  * @tc.type: FUNC
244  */
245 HWTEST_F(PolicySerializerTest, ArrayMapStringWritePolicy, TestSize.Level1)
246 {
247     MessageParcel messageParcel2;
248     auto serializer = ArrayMapSerializer::GetInstance();
249     vector<map<string, string>> value = {
250         {
251             { "id", "1" },
252             { "name", "leon" },
253             { "desc", "hello" },
254         },
255         {
256             { "id", "2" },
257             { "name", "job" },
258             { "desc", "world" },
259         }
260     };
261     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
262 
263     value = {};
264     ASSERT_TRUE(serializer->GetPolicy(messageParcel2, value));
265     ASSERT_TRUE(value.size() == 2);
266     serializer->Deduplication(value);
267     ASSERT_TRUE(value.size() == 2);
268 }
269 
270 /**
271  * @tc.name: ArrayMapStringMergePolicy
272  * @tc.desc: Test ArrayMapSerializer::MergePolicy.
273  * @tc.type: FUNC
274  */
275 HWTEST_F(PolicySerializerTest, ArrayMapStringMergePolicy, TestSize.Level1)
276 {
277     auto serializer = ArrayMapSerializer::GetInstance();
278     vector<map<string, string>> value;
279     vector<vector<map<string, string>>> policyValues {
280         {
281             {
282                 { "id", "1" },
283                 { "name", "leon" },
284                 { "desc", "hello" },
285             },
286             {
287                 { "id", "2" },
288                 { "name", "job" },
289                 { "desc", "world" },
290             }
291         },
292         {
293             {
294                 { "id", "1" },
295                 { "name", "leon" },
296                 { "desc", "hello" },
297             },
298             {
299                 { "id", "3" },
300                 { "name", "james" },
301             }
302         }
303     };
304     ASSERT_TRUE(serializer->MergePolicy(policyValues, value));
305     ASSERT_TRUE(value.size() == 3);
306 }
307 
308 /**
309  * @tc.name: MAP_STRING
310  * @tc.desc: Test MapStringSerializer.
311  * @tc.type: FUNC
312  */
313 HWTEST_F(PolicySerializerTest, MAP_STRING, TestSize.Level1)
314 {
315     auto serializer = MapStringSerializer::GetInstance();
316     map<string, string> value = {
317         { "k1", "v1" },
318         { "k2", "v2" },
319         { "k3", "v3" },
320         { "k4", "v4" },
321     };
322     string jsonString;
323     ASSERT_TRUE(serializer->Serialize(value, jsonString));
324     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
325     jsonString.erase(sd, jsonString.end());
326     ASSERT_EQ(jsonString, R"({"k1":"v1","k2":"v2","k3":"v3","k4":"v4"})");
327 
328     jsonString = R"({"k1":"v1","k2":"v2","k3":"v3","k4":"v4"})";
329     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
330     ASSERT_TRUE(value.size() == 4);
331     ASSERT_FALSE(serializer->Deserialize(R"(["v1","v2","v3","v4","v5","v6"])", value));
332 
333     MessageParcel messageParcel1;
334     vector<std::string> key2 = {
335         "一", "二", "三",
336         "四", "五", "六",
337         "七" };
338     messageParcel1.WriteStringVector(key2);
339     vector<std::string> value2 = {
340         "值", "值", "值",
341         "值", "值", "值",
342         "值" };
343     messageParcel1.WriteStringVector(value2);
344     value = {};
345     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
346     ASSERT_TRUE(value.size() == 7);
347     for (auto const &entry:value) {
348         ASSERT_EQ(entry.second, "值");
349     }
350 }
351 
352 /**
353  * @tc.name: MAP_STRING_002
354  * @tc.desc: Test MapStringSerializer.
355  * @tc.type: FUNC
356  */
357 HWTEST_F(PolicySerializerTest, MAP_STRING_002, TestSize.Level1)
358 {
359     auto serializer = MapStringSerializer::GetInstance();
360     map<string, string> value = {
361         { "k1", "v1" },
362         { "k2", "v2" },
363         { "k3", "v3" },
364         { "k4", "v4" },
365     };
366     MessageParcel messageParcel2;
367     value = {
368         { "k1", "v1" },
369         { "k2", "v2" },
370         { "k3", "v3" },
371         { "k4", "v4" },
372     };
373     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
374     vector<std::string> key4;
375     vector<std::string> value4;
376     messageParcel2.ReadStringVector(&key4);
377     messageParcel2.ReadStringVector(&value4);
378     ASSERT_TRUE(key4.size() == 4);
379     for (std::uint32_t i = 0; i < key4.size(); ++i) {
380         ASSERT_EQ(key4.at(i), "k" + std::to_string(i + 1));
381     }
382     ASSERT_TRUE(value4.size() == 4);
383     for (std::uint32_t i = 0; i < value4.size(); ++i) {
384         ASSERT_EQ(value4.at(i), "v" + std::to_string(i + 1));
385     }
386 
387     map<string, string> value1 = {
388         { "k1", "v1" },
389     };
390     map<string, string> value2 = {
391         { "k1", "v1" },
392         { "k2", "v2" },
393         { "k3", "v3" },
394     };
395     map<string, string> value3 = {
396         { "k3", "v3" },
397         { "k4", "v4" },
398     };
399     value = {};
400     vector<map<string, string>> policyValues { value1, value2, value3 };
401     ASSERT_TRUE(serializer->MergePolicy(policyValues, value));
402     ASSERT_TRUE(value3 == value);
403 }
404 
405 /**
406  * @tc.name: MAP_STRING_Serializer_Deserialize
407  * @tc.desc: Test MapStringSerializer.
408  * @tc.type: FUNC
409  */
410 HWTEST_F(PolicySerializerTest, MAP_STRING_Serializer_Deserialize, TestSize.Level1)
411 {
412     auto serializer = MapStringSerializer::GetInstance();
413     Json::Value root;
414     root["string"] = "str";
415     root["bool"] = true;
416     root["int"] = 1;
417     Json::StreamWriterBuilder builder;
418     builder["indentation"] = "    ";
419     std::string jsonString = Json::writeString(builder, root);
420     std::map<std::string, std::string> result;
421     ASSERT_TRUE(serializer->Deserialize(jsonString, result));
422     ASSERT_TRUE(result["string"] == "str");
423     ASSERT_TRUE(result["bool"] == "true");
424     ASSERT_TRUE(result["int"] == "1");
425 }
426 
427 /**
428  * @tc.name: MAP_STRING_Serializer_DeserializeFail
429  * @tc.desc: Test MapStringSerializer.
430  * @tc.type: FUNC
431  */
432 HWTEST_F(PolicySerializerTest, MAP_STRING_Serializer_DeserializeFail, TestSize.Level1)
433 {
434     auto serializer = MapStringSerializer::GetInstance();
435     Json::Value root;
436     Json::Value sub;
437     sub["key"] = "value";
438     root["object"] = sub;
439     Json::StreamWriterBuilder builder;
440     builder["indentation"] = "    ";
441     std::string jsonString = Json::writeString(builder, root);
442     std::map<std::string, std::string> result;
443     ASSERT_FALSE(serializer->Deserialize(jsonString, result));
444     ASSERT_TRUE(result.empty());
445 }
446 
447 /**
448  * @tc.name: JSON
449  * @tc.desc: Test JsonSerializer.
450  * @tc.type: FUNC
451  */
452 HWTEST_F(PolicySerializerTest, JSON, TestSize.Level1)
453 {
454     auto serializer = JsonSerializer::GetInstance();
455     Json::Value value;
456     value["k1"] = "v1";
457     value["k2"] = "v2";
458     value["k3"] = 3;
459     string jsonString;
460     ASSERT_TRUE(serializer->Serialize(value, jsonString));
461     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
462     jsonString.erase(sd, jsonString.end());
463     ASSERT_EQ(jsonString, R"({"k1":"v1","k2":"v2","k3":3})");
464 
465     jsonString = R"(["v1","v2","v3","v4","v5","v6"])";
466     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
467     ASSERT_TRUE(value.isArray() && value.size() == 6);
468 
469     MessageParcel messageParcel1;
470     std::string value2 = R"(["v1","v2"])";
471     messageParcel1.WriteString(value2);
472     value = {};
473     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
474     ASSERT_TRUE(value.isArray() && value.size() == 2);
475 
476     MessageParcel messageParcel2;
477     value = Json::Value(Json::arrayValue);
478     value[0] = 1;
479     value[1] = 2;
480     value[3] = 3;
481     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
482     value2 = "";
483     messageParcel2.ReadString(value2);
484     jsonString = value2;
485     sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
486     jsonString.erase(sd, jsonString.end());
487     ASSERT_EQ(jsonString, R"([1,2,null,3])");
488 
489     std::vector<Json::Value> vec = {jsonString};
490     ASSERT_TRUE(serializer->MergePolicy(vec, value));
491     ASSERT_TRUE(vec.size() == 1);
492 }
493 
494 /**
495  * @tc.name: Long
496  * @tc.desc: Test LongSerializer.
497  * @tc.type: FUNC
498  */
499 HWTEST_F(PolicySerializerTest, Long, TestSize.Level1)
500 {
501     auto serializer = LongSerializer::GetInstance();
502     std::string testString = "123456";
503     std::string jsonString = testString;
504     int64_t res = 0;
505     ASSERT_TRUE(serializer->Deserialize(jsonString, res));
506     ASSERT_EQ(res, 123456);
507 
508     jsonString = "";
509     ASSERT_TRUE(serializer->Serialize(res, jsonString));
510     ASSERT_EQ(jsonString, testString);
511 
512     MessageParcel data;
513     data.WriteInt64(1);
514     ASSERT_TRUE(serializer->GetPolicy(data, res));
515     ASSERT_TRUE(res == 1);
516 
517     MessageParcel reply;
518     res = 1;
519     ASSERT_TRUE(serializer->WritePolicy(reply, res));
520     int64_t temp = 0;
521     reply.ReadInt64(temp);
522     ASSERT_TRUE(temp == 1);
523 
524     std::vector<int64_t> vec = {1, 2, 3, 4, 5};
525     serializer->MergePolicy(vec, res);
526     ASSERT_TRUE(res == 5);
527 }
528 } // namespace TEST
529 } // namespace EDM
530 } // namespace OHOS
531