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 "preferences_xml_utils.h"
17 
18 #include <gtest/gtest.h>
19 
20 #include <fstream>
21 #include <string>
22 
23 #include "preferences.h"
24 #include "preferences_errno.h"
25 #include "preferences_helper.h"
26 #include "preferences_impl.h"
27 
28 using namespace testing::ext;
29 using namespace OHOS::NativePreferences;
30 
31 namespace {
32 class PreferencesXmlUtilsTest : public testing::Test {
33 public:
34     static void SetUpTestCase(void);
35     static void TearDownTestCase(void);
36     void SetUp();
37     void TearDown();
38 };
39 
SetUpTestCase(void)40 void PreferencesXmlUtilsTest::SetUpTestCase(void)
41 {
42 }
43 
TearDownTestCase(void)44 void PreferencesXmlUtilsTest::TearDownTestCase(void)
45 {
46 }
47 
SetUp(void)48 void PreferencesXmlUtilsTest::SetUp(void)
49 {
50 }
51 
TearDown(void)52 void PreferencesXmlUtilsTest::TearDown(void)
53 {
54 }
55 
56 /**
57 * @tc.name: ReadSettingXmlTest_001
58 * @tc.desc: normal testcase of ReadSettingXml
59 * @tc.type: FUNC
60 */
61 HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_001, TestSize.Level1)
62 {
63     std::vector<Element> settings = {};
64     bool ret = PreferencesXmlUtils::ReadSettingXml("", "", "", settings);
65     EXPECT_EQ(ret, false);
66 
67     std::string path = "/data/test/test_helper" + std::string(4096, 't');
68     ret = PreferencesXmlUtils::ReadSettingXml(path, "", "", settings);
69     EXPECT_EQ(ret, false);
70 
71     ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", "", settings);
72     EXPECT_EQ(ret, false);
73 }
74 
75 /**
76 * @tc.name: ReadSettingXmlTest_002
77 * @tc.desc: ReadSettingXml testcase of PreferencesXmlUtils, reading a corrupt file
78 * @tc.type: FUNC
79 */
80 HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_002, TestSize.Level1)
81 {
82     std::string fileName = "/data/test/test01";
83 
84     std::ofstream oss(fileName);
85     oss << "corrupted";
86 
87     int errCode = E_OK;
88     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(fileName, errCode);
89     EXPECT_EQ(errCode, E_OK);
90 
91     int ret = PreferencesHelper::DeletePreferences(fileName);
92     EXPECT_EQ(ret, E_OK);
93 }
94 
95 /**
96 * @tc.name: ReadSettingXmlTest_003
97 * @tc.desc: ReadSettingXml testcase of PreferencesXmlUtils, no empty dataGroupId
98 * @tc.type: FUNC
99 */
100 HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_003, TestSize.Level1)
101 {
102     std::string file = "/data/test/test01";
103 
104     std::vector<Element> settings;
105     Element elem;
106     elem.key_ = "testKet";
107     elem.tag_ = "int";
108     elem.value_ = "999";
109     settings.push_back(elem);
110     PreferencesXmlUtils::WriteSettingXml(file, "", "123456", settings);
111 
112     std::vector<Element> settingsRes = {};
113     bool ret = PreferencesXmlUtils::ReadSettingXml(file, "", "123456", settingsRes);
114     EXPECT_EQ(ret, true);
115     EXPECT_EQ(settingsRes.empty(), false);
116     EXPECT_EQ(elem.key_, settingsRes.front().key_);
117     EXPECT_EQ(elem.tag_, settingsRes.front().tag_);
118     EXPECT_EQ(elem.value_, settingsRes.front().value_);
119 
120     std::remove(file.c_str());
121 }
122 
123 /**
124 * @tc.name: UnnormalReadSettingXml_001
125 * @tc.desc: unnormal testcase of ReadSettingXml
126 * @tc.type: FUNC
127 */
128 HWTEST_F(PreferencesXmlUtilsTest, UnnormalReadSettingXml_001, TestSize.Level1)
129 {
130     std::vector<Element> settings = {};
131     PreferencesXmlUtils::WriteSettingXml("", "", "", settings);
132     bool ret = PreferencesXmlUtils::ReadSettingXml("", "", "", settings);
133     EXPECT_EQ(ret, false);
134 
135     std::string path = "/data/test/test_helper" + std::string(4096, 't');
136     ret = PreferencesXmlUtils::ReadSettingXml(path, "", "", settings);
137     EXPECT_EQ(ret, false);
138 
139     ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", "", settings);
140     EXPECT_EQ(ret, false);
141 
142     Element elem;
143     settings.push_back(elem);
144     path = "data/test/test_helper";
145     PreferencesXmlUtils::WriteSettingXml(path, "", "", settings);
146     ret = PreferencesXmlUtils::ReadSettingXml(path, "", "", settings);
147     EXPECT_EQ(ret, false);
148 }
149 
150 /**
151 * @tc.name: StringNodeElementTest_001
152 * @tc.desc: StringNodeElement testcase of PreferencesXmlUtils
153 * @tc.type: FUNC
154 */
155 HWTEST_F(PreferencesXmlUtilsTest, StringNodeElementTest_001, TestSize.Level1)
156 {
157     std::string file = "/data/test/test01";
158     std::remove(file.c_str());
159 
160     std::vector<Element> settings;
161     Element elem;
162     elem.key_ = "stringKey";
163     elem.tag_ = std::string("string");
164     elem.value_ = "test";
165     settings.push_back(elem);
166     PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
167 
168     int errCode = E_OK;
169     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
170     EXPECT_EQ(errCode, E_OK);
171     std::string retString = pref->GetString("stringKey", "");
172     EXPECT_EQ(retString, elem.value_);
173 
174     int ret = PreferencesHelper::DeletePreferences(file);
175     EXPECT_EQ(ret, E_OK);
176 }
177 
178 /**
179 * @tc.name: ArrayNodeElementTest_001
180 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
181 * @tc.type: FUNC
182 */
183 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_001, TestSize.Level1)
184 {
185     std::string file = "/data/test/test02";
186     std::remove(file.c_str());
187     std::vector<Element> settings;
188 
189     Element elem;
190     elem.key_ = "stringArrayKey";
191     elem.tag_ = std::string("stringArray");
192     elem.value_ = "testStringArray";
193 
194     Element elemChild;
195     elemChild.key_ = "stringKey";
196     elemChild.tag_ = std::string("string");
197 
198     elemChild.value_ = "test_child1";
199     elem.children_.push_back(elemChild);
200     elemChild.value_ = "test_child2";
201     elem.children_.push_back(elemChild);
202     settings.push_back(elem);
203     std::vector<std::string> inputStringArray = { "test_child1", "test_child2" };
204     PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
205 
206     int errCode = E_OK;
207     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
208     EXPECT_EQ(errCode, E_OK);
209 
210     auto retStringArray = pref->Get("stringArrayKey", "");
211     EXPECT_EQ(retStringArray.operator std::vector<std::string>(), inputStringArray);
212 
213     int ret = PreferencesHelper::DeletePreferences(file);
214     EXPECT_EQ(ret, E_OK);
215 }
216 
217 /**
218 * @tc.name: ArrayNodeElementTest_001
219 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
220 * @tc.type: FUNC
221 */
222 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_002, TestSize.Level1)
223 {
224     std::string file = "/data/test/test03";
225     std::remove(file.c_str());
226     std::vector<Element> settings;
227 
228     Element elem;
229     elem.key_ = "doubleArrayKey";
230     elem.tag_ = std::string("doubleArray");
231     elem.value_ = std::to_string(10.0);
232 
233     Element elemChild;
234     elemChild.key_ = "doubleKey";
235     elemChild.tag_ = std::string("double");
236 
237     elemChild.value_ = std::to_string(1.0);
238     elem.children_.push_back(elemChild);
239 
240     elemChild.value_ = std::to_string(2.0);
241     elem.children_.push_back(elemChild);
242     settings.push_back(elem);
243     std::vector<double> inputDoubleArray = { 1.0, 2.0 };
244     PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
245 
246     int errCode = E_OK;
247     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
248     EXPECT_EQ(errCode, E_OK);
249 
250     auto retDoubleArray = pref->Get("doubleArrayKey", 10.0);
251     EXPECT_EQ(retDoubleArray.operator std::vector<double>(), inputDoubleArray);
252 
253     int ret = PreferencesHelper::DeletePreferences(file);
254     EXPECT_EQ(ret, E_OK);
255 }
256 
257 /**
258 * @tc.name: ArrayNodeElementTest_003
259 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
260 * @tc.type: FUNC
261 */
262 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_003, TestSize.Level1)
263 {
264     std::string file = "/data/test/test04";
265     std::remove(file.c_str());
266     std::vector<Element> settings;
267 
268     Element elem;
269     elem.key_ = "boolArrayKey";
270     elem.tag_ = std::string("boolArray");
271     elem.value_ = std::to_string(false);
272 
273     Element elemChild;
274     elemChild.key_ = "boolKey";
275     elemChild.tag_ = std::string("bool");
276 
277     elemChild.value_ = "false";
278     elem.children_.push_back(elemChild);
279 
280     elemChild.value_ = "true";
281     elem.children_.push_back(elemChild);
282     settings.push_back(elem);
283     std::vector<bool> inputBoolArray = { false, true };
284     PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
285 
286     int errCode = E_OK;
287     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
288     EXPECT_EQ(errCode, E_OK);
289 
290     auto retBoolArray = pref->Get("boolArrayKey", false);
291     EXPECT_EQ(retBoolArray.operator std::vector<bool>(), inputBoolArray);
292 
293     int ret = PreferencesHelper::DeletePreferences(file);
294     EXPECT_EQ(ret, E_OK);
295 }
296 
297 /**
298 * @tc.name: ArrayNodeElementTest_004
299 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
300 * @tc.type: FUNC
301 */
302 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_004, TestSize.Level1)
303 {
304     std::string file = "/data/test/test05";
305     std::remove(file.c_str());
306     std::vector<Element> settings;
307 
308     Element elem;
309     elem.key_ = "boolArrayKey";
310     elem.tag_ = std::string("boolArray");
311     elem.value_ = std::to_string(false);
312 
313     settings.push_back(elem);
314     PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
315 
316     int errCode = E_OK;
317     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
318     EXPECT_EQ(errCode, E_OK);
319 
320     auto retBoolArray = pref->Get("boolArrayKey", false);
321     EXPECT_EQ(retBoolArray.IsBoolArray(), true);
322     auto array = static_cast<std::vector<bool>>(retBoolArray);
323     EXPECT_EQ(array.empty(), true);
324 
325     int ret = PreferencesHelper::DeletePreferences(file);
326     EXPECT_EQ(ret, E_OK);
327 }
328 
329 /**
330 * @tc.name: ArrayNodeElementTest_005
331 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
332 * @tc.type: FUNC
333 */
334 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_005, TestSize.Level1)
335 {
336     std::string file = "/data/test/test06";
337     std::remove(file.c_str());
338     std::vector<Element> settings;
339 
340     Element elem;
341     elem.key_ = "stringArrayKey";
342     elem.tag_ = std::string("stringArray");
343     elem.value_ = std::to_string(false);
344 
345     settings.push_back(elem);
346     PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
347 
348     int errCode = E_OK;
349     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
350     EXPECT_EQ(errCode, E_OK);
351 
352     auto retStringArray = pref->Get("stringArrayKey", false);
353     EXPECT_EQ(retStringArray.IsStringArray(), true);
354     auto array = static_cast<std::vector<std::string>>(retStringArray);
355     EXPECT_EQ(array.empty(), true);
356 
357     int ret = PreferencesHelper::DeletePreferences(file);
358     EXPECT_EQ(ret, E_OK);
359 }
360 
361 /**
362 * @tc.name: ArrayNodeElementTest_006
363 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
364 * @tc.type: FUNC
365 */
366 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_006, TestSize.Level1)
367 {
368     std::string file = "/data/test/test07";
369     std::remove(file.c_str());
370     std::vector<Element> settings;
371 
372     Element elem;
373     elem.key_ = "doubleArrayKey";
374     elem.tag_ = std::string("doubleArray");
375     elem.value_ = std::to_string(1);
376 
377     settings.push_back(elem);
378     PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
379 
380     int errCode = E_OK;
381     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
382     EXPECT_EQ(errCode, E_OK);
383 
384     auto retDoubleArray = pref->Get("doubleArrayKey", 0);
385     EXPECT_EQ(retDoubleArray.IsDoubleArray(), true);
386     auto array = static_cast<std::vector<double>>(retDoubleArray);
387     EXPECT_EQ(array.empty(), true);
388 
389     int ret = PreferencesHelper::DeletePreferences(file);
390     EXPECT_EQ(ret, E_OK);
391 }
392 
393 /**
394 * @tc.name: RenameToBrokenFileTest_001
395 * @tc.desc: RenameToBrokenFile testcase of PreferencesXmlUtils
396 * @tc.type: FUNC
397 */
398 HWTEST_F(PreferencesXmlUtilsTest, RenameToBrokenFileTest_001, TestSize.Level1)
399 {
400     std::string fileName = "/data/test/test01";
401     // construct an unreadable file
402     std::ofstream oss(fileName);
403     oss << "corrupted";
404 
405     std::vector<Element> settings;
406     Element elem;
407     elem.key_ = "intKey";
408     elem.tag_ = "int";
409     elem.value_ = "2";
410 
411     settings.push_back(elem);
412     PreferencesXmlUtils::WriteSettingXml(MakeFilePath(fileName, STR_BACKUP), "", "", settings);
413 
414     int errCode = E_OK;
415     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(fileName, errCode);
416     EXPECT_EQ(errCode, E_OK);
417 
418     int value = pref->Get("intKey", 0);
419     EXPECT_EQ(value, 2);
420 
421     int ret = PreferencesHelper::DeletePreferences(fileName);
422     EXPECT_EQ(ret, E_OK);
423 }
424 }
425