• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "array_map_serializer.h"
18 #include "array_string_serializer.h"
19 #include "bool_serializer.h"
20 #include "func_code_utils.h"
21 #include "json_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_FALSE(serializer->Deserialize("", boolValue));
49     ASSERT_TRUE(serializer->Deserialize("true", boolValue));
50     ASSERT_EQ(boolValue, true);
51     ASSERT_FALSE(serializer->Deserialize("truee", boolValue));
52 
53     MessageParcel messageParcel1;
54     messageParcel1.WriteBool(false);
55     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, boolValue));
56     ASSERT_EQ(boolValue, false);
57 
58     MessageParcel messageParcel2;
59     boolValue = true;
60     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, boolValue));
61     ASSERT_EQ(messageParcel2.ReadBool(), true);
62 
63 
64     boolValue = false;
65     vector<bool> policyValues { false, true, false, false, true };
66     ASSERT_TRUE(serializer->MergePolicy(policyValues, boolValue));
67     ASSERT_EQ(boolValue, true);
68 
69     boolValue = true;
70     policyValues = { false, false, false, false, false };
71     ASSERT_TRUE(serializer->MergePolicy(policyValues, boolValue));
72     ASSERT_EQ(boolValue, false);
73 }
74 
75 /**
76  * @tc.name: STRING
77  * @tc.desc: Test StringSerializer.
78  * @tc.type: FUNC
79  */
80 HWTEST_F(PolicySerializerTest, STRING, TestSize.Level1)
81 {
82     auto serializer = StringSerializer::GetInstance();
83     string value = "s1";
84     string jsonString;
85     ASSERT_TRUE(serializer->Serialize(value, jsonString));
86     ASSERT_EQ(jsonString, "s1");
87 
88     jsonString = "s2";
89     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
90     ASSERT_TRUE(value.length() == 2);
91 
92     MessageParcel messageParcel1;
93     std::u16string value16 = u"s一";
94     messageParcel1.WriteString16(value16);
95     value = "";
96     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
97     ASSERT_TRUE(value == "s一");
98 
99     MessageParcel messageParcel2;
100     value = "s二";
101     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
102     value16 = u"";
103     ASSERT_TRUE(messageParcel2.ReadString16(value16));
104     ASSERT_TRUE(value16 == u"s二");
105 
106     vector<string> policyValues { "v1", "v2", "v3" };
107     ASSERT_TRUE(serializer->MergePolicy(policyValues, value));
108     ASSERT_TRUE(value == "v3");
109 }
110 
111 /**
112  * @tc.name: ARRAY_STRING
113  * @tc.desc: Test ArrayStringSerializer.
114  * @tc.type: FUNC
115  */
116 HWTEST_F(PolicySerializerTest, ARRAY_STRING, TestSize.Level1)
117 {
118     auto serializer = ArrayStringSerializer::GetInstance();
119     vector<string> value = { "v1", "v2", "v3", "v4", "v5" };
120     string jsonString;
121     ASSERT_TRUE(serializer->Serialize(value, jsonString));
122     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
123     jsonString.erase(sd, jsonString.end());
124     ASSERT_EQ(jsonString, R"(["v1","v2","v3","v4","v5"])");
125 
126     jsonString = R"(["v1","v2","v3","v4","v5","v6"])";
127     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
128     ASSERT_TRUE(value.size() == 6);
129     ASSERT_FALSE(serializer->Deserialize(R"(["v1","v2","v3","v4","v5""v6"])", value));
130 
131     MessageParcel messageParcel1;
132     vector<std::u16string> value16 = {
133         Str8ToStr16("一"), Str8ToStr16("二"), Str8ToStr16("三"),
134         Str8ToStr16("四"), Str8ToStr16("五"), Str8ToStr16("六"),
135         Str8ToStr16("七") };
136     messageParcel1.WriteString16Vector(value16);
137     value = {};
138     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
139     ASSERT_TRUE(value.size() == 7);
140 
141     MessageParcel messageParcel2;
142     value = { "v1", "v2", "v3" };
143     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
144     value16 = {};
145     messageParcel2.ReadString16Vector(&value16);
146     ASSERT_TRUE(value16.size() == 3);
147 
148     vector<vector<string>> policyValues {{ "v1",   "v2",   "v3" },
149                                          { "vv1",  "vv2",  "vv3" },
150                                          { "vvv1", "vvv2", "vvv3" },
151                                          { "v1",   "v2",   "v3" },
152                                          { "vv1",  "vv2",  "vv3" }};
153     ASSERT_TRUE(serializer->MergePolicy(policyValues, value));
154     ASSERT_TRUE(value.size() == 9);
155 }
156 
157 /**
158  * @tc.name: ArrayMapStringSerializer
159  * @tc.desc: Test ArrayMapSerializer::Serialize.
160  * @tc.type: FUNC
161  */
162 HWTEST_F(PolicySerializerTest, ArrayMapStringSerializer, TestSize.Level1)
163 {
164     auto serializer = ArrayMapSerializer::GetInstance();
165     vector<map<string, string>> value = {
166         {
167             { "id", "1" },
168             { "name", "leon" },
169             { "desc", "hello" },
170         },
171         {
172             { "id", "2" },
173             { "name", "job" },
174             { "desc", "world" },
175         }
176     };
177     string exceptStr;
178     string jsonString;
179     ASSERT_TRUE(serializer->Serialize(value, jsonString));
180     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
181     jsonString.erase(sd, jsonString.end());
182     exceptStr = R"(["{\n\"desc\":\"hello\",\n\"id\":\"1\",\n\"name\":\"leon\"\n}")";
183     exceptStr.append(R"(,"{\n\"desc\":\"world\",\n\"id\":\"2\",\n\"name\":\"job\"\n}"])");
184     ASSERT_EQ(jsonString, exceptStr);
185 }
186 
187 /**
188  * @tc.name: ArrayMapStringDeserialize
189  * @tc.desc: Test ArrayMapSerializer::Deserialize.
190  * @tc.type: FUNC
191  */
192 HWTEST_F(PolicySerializerTest, ArrayMapStringDeserialize, TestSize.Level1)
193 {
194     auto serializer = ArrayMapSerializer::GetInstance();
195     vector<map<string, string>> value;
196     std::string jsonString = R"([{"desc":"hello","id":"1","name":"leon"},{"desc":"world","id":"2","name":"job"}])";
197     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
198     ASSERT_TRUE(value.size() == 2);
199 
200     map<string, string> expectZero = {
201         { "id",   "1" },
202         { "name", "leon" },
203         { "desc", "hello" },
204     };
205     ASSERT_TRUE(value.at(0) == expectZero);
206     map<string, string> expectOne = {
207         { "id",   "2" },
208         { "name", "job" },
209         { "desc", "world" },
210     };
211     ASSERT_TRUE(value.at(1) == expectOne);
212 }
213 
214 /**
215  * @tc.name: ArrayMapStringGetPolicy
216  * @tc.desc: Test ArrayMapSerializer::GetPolicy.
217  * @tc.type: FUNC
218  */
219 HWTEST_F(PolicySerializerTest, ArrayMapStringGetPolicy, TestSize.Level1)
220 {
221     auto serializer = ArrayMapSerializer::GetInstance();
222     vector<map<string, string>> value;
223     MessageParcel messageParcel1;
224     vector<std::u16string> value16 = {
225         uR"({"id":"1","name":"leon","desc":"hello world"})", uR"({"id":"2","name":"job","desc":"two"})",
226         uR"({"id":"3","name":"james","desc":"three"})", uR"({"id":"4","name":"bao","desc":"four"})",
227         uR"({"id":"5","name":"fox","desc":"five"})"
228     };
229     messageParcel1.WriteString16Vector(value16);
230     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
231     ASSERT_TRUE(value.size() == 5);
232 }
233 
234 /**
235  * @tc.name: ArrayMapStringWritePolicy
236  * @tc.desc: Test ArrayMapSerializer::WritePolicy.
237  * @tc.type: FUNC
238  */
239 HWTEST_F(PolicySerializerTest, ArrayMapStringWritePolicy, TestSize.Level1)
240 {
241     MessageParcel messageParcel2;
242     auto serializer = ArrayMapSerializer::GetInstance();
243     vector<map<string, string>> value = {
244         {
245             { "id", "1" },
246             { "name", "leon" },
247             { "desc", "hello" },
248         },
249         {
250             { "id", "2" },
251             { "name", "job" },
252             { "desc", "world" },
253         }
254     };
255     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
256 
257     value = {};
258     ASSERT_TRUE(serializer->GetPolicy(messageParcel2, value));
259     ASSERT_TRUE(value.size() == 2);
260 }
261 
262 /**
263  * @tc.name: ArrayMapStringMergePolicy
264  * @tc.desc: Test ArrayMapSerializer::MergePolicy.
265  * @tc.type: FUNC
266  */
267 HWTEST_F(PolicySerializerTest, ArrayMapStringMergePolicy, TestSize.Level1)
268 {
269     auto serializer = ArrayMapSerializer::GetInstance();
270     vector<map<string, string>> value;
271     vector<vector<map<string, string>>> policyValues {
272         {
273             {
274                 { "id", "1" },
275                 { "name", "leon" },
276                 { "desc", "hello" },
277             },
278             {
279                 { "id", "2" },
280                 { "name", "job" },
281                 { "desc", "world" },
282             }
283         },
284         {
285             {
286                 { "id", "1" },
287                 { "name", "leon" },
288                 { "desc", "hello" },
289             },
290             {
291                 { "id", "3" },
292                 { "name", "james" },
293             }
294         }
295     };
296     ASSERT_TRUE(serializer->MergePolicy(policyValues, value));
297     ASSERT_TRUE(value.size() == 3);
298 }
299 
300 /**
301  * @tc.name: MAP_STRING
302  * @tc.desc: Test MapStringSerializer.
303  * @tc.type: FUNC
304  */
305 HWTEST_F(PolicySerializerTest, MAP_STRING, TestSize.Level1)
306 {
307     auto serializer = MapStringSerializer::GetInstance();
308     map<string, string> value = {
309         { "k1", "v1" },
310         { "k2", "v2" },
311         { "k3", "v3" },
312         { "k4", "v4" },
313     };
314     string jsonString;
315     ASSERT_TRUE(serializer->Serialize(value, jsonString));
316     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
317     jsonString.erase(sd, jsonString.end());
318     ASSERT_EQ(jsonString, R"({"k1":"v1","k2":"v2","k3":"v3","k4":"v4"})");
319 
320     jsonString = R"({"k1":"v1","k2":"v2","k3":"v3","k4":"v4"})";
321     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
322     ASSERT_TRUE(value.size() == 4);
323     ASSERT_FALSE(serializer->Deserialize(R"(["v1","v2","v3","v4","v5","v6"])", value));
324 
325     MessageParcel messageParcel1;
326     vector<std::u16string> key16 = {
327         Str8ToStr16("一"), Str8ToStr16("二"), Str8ToStr16("三"),
328         Str8ToStr16("四"), Str8ToStr16("五"), Str8ToStr16("六"),
329         Str8ToStr16("七") };
330     messageParcel1.WriteString16Vector(key16);
331     vector<std::u16string> value16 = {
332         Str8ToStr16("值"), Str8ToStr16("值"), Str8ToStr16("值"),
333         Str8ToStr16("值"), Str8ToStr16("值"), Str8ToStr16("值"),
334         Str8ToStr16("值") };
335     messageParcel1.WriteString16Vector(value16);
336     value = {};
337     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
338     ASSERT_TRUE(value.size() == 7);
339     for (auto const &entry:value) {
340         ASSERT_EQ(entry.second, "值");
341     }
342 }
343 
344 /**
345  * @tc.name: MAP_STRING_002
346  * @tc.desc: Test MapStringSerializer.
347  * @tc.type: FUNC
348  */
349 HWTEST_F(PolicySerializerTest, MAP_STRING_002, TestSize.Level1)
350 {
351     auto serializer = MapStringSerializer::GetInstance();
352     map<string, string> value = {
353         { "k1", "v1" },
354         { "k2", "v2" },
355         { "k3", "v3" },
356         { "k4", "v4" },
357     };
358     MessageParcel messageParcel2;
359     value = {
360         { "k1", "v1" },
361         { "k2", "v2" },
362         { "k3", "v3" },
363         { "k4", "v4" },
364     };
365     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
366     vector<std::u16string> key16;
367     vector<std::u16string> value16;
368     messageParcel2.ReadString16Vector(&key16);
369     messageParcel2.ReadString16Vector(&value16);
370     ASSERT_TRUE(key16.size() == 4);
371     for (std::uint32_t i = 0; i < key16.size(); ++i) {
372         ASSERT_EQ(Str16ToStr8(key16.at(i)), "k" + std::to_string(i + 1));
373     }
374     ASSERT_TRUE(value16.size() == 4);
375     for (std::uint32_t i = 0; i < value16.size(); ++i) {
376         ASSERT_EQ(Str16ToStr8(value16.at(i)), "v" + std::to_string(i + 1));
377     }
378 
379     map<string, string> value1 = {
380         { "k1", "v1" },
381     };
382     map<string, string> value2 = {
383         { "k1", "v1" },
384         { "k2", "v2" },
385         { "k3", "v3" },
386     };
387     map<string, string> value3 = {
388         { "k3", "v3" },
389         { "k4", "v4" },
390     };
391     value = {};
392     vector<map<string, string>> policyValues { value1, value2, value3 };
393     ASSERT_TRUE(serializer->MergePolicy(policyValues, value));
394     ASSERT_TRUE(value3 == value);
395 }
396 
397 /**
398  * @tc.name: JSON
399  * @tc.desc: Test JsonSerializer.
400  * @tc.type: FUNC
401  */
402 HWTEST_F(PolicySerializerTest, JSON, TestSize.Level1)
403 {
404     auto serializer = JsonSerializer::GetInstance();
405     Json::Value value;
406     value["k1"] = "v1";
407     value["k2"] = "v2";
408     value["k3"] = 3;
409     string jsonString;
410     ASSERT_TRUE(serializer->Serialize(value, jsonString));
411     auto sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
412     jsonString.erase(sd, jsonString.end());
413     ASSERT_EQ(jsonString, R"({"k1":"v1","k2":"v2","k3":3})");
414 
415     jsonString = R"(["v1","v2","v3","v4","v5","v6"])";
416     ASSERT_TRUE(serializer->Deserialize(jsonString, value));
417     ASSERT_TRUE(value.isArray() && value.size() == 6);
418 
419     MessageParcel messageParcel1;
420     std::u16string value16 = Str8ToStr16(R"(["v1","v2"])");
421     messageParcel1.WriteString16(value16);
422     value = {};
423     ASSERT_TRUE(serializer->GetPolicy(messageParcel1, value));
424     ASSERT_TRUE(value.isArray() && value.size() == 2);
425 
426     MessageParcel messageParcel2;
427     value = Json::Value(Json::arrayValue);
428     value[0] = 1;
429     value[1] = 2;
430     value[3] = 3;
431     ASSERT_TRUE(serializer->WritePolicy(messageParcel2, value));
432     value16 = Str8ToStr16("");
433     messageParcel2.ReadString16(value16);
434     jsonString = Str16ToStr8(value16);
435     sd = remove_if(jsonString.begin(), jsonString.end(), isspace);
436     jsonString.erase(sd, jsonString.end());
437     ASSERT_EQ(jsonString, R"([1,2,null,3])");
438 }
439 } // namespace TEST
440 } // namespace EDM
441 } // namespace OHOS
442