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_utils.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::unordered_map<std::string, PreferencesValue> allDatas;
64 bool ret = PreferencesXmlUtils::ReadSettingXml("", "", allDatas);
65 EXPECT_EQ(ret, false);
66
67 std::string path = "/data/test/test_helper" + std::string(4096, 't');
68 ret = PreferencesXmlUtils::ReadSettingXml(path, "", allDatas);
69 EXPECT_EQ(ret, false);
70
71 ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", allDatas);
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::unordered_map<std::string, PreferencesValue> values;
105 values.insert({"testKey", 999});
106 PreferencesXmlUtils::WriteSettingXml(file, "", values);
107
108 std::unordered_map<std::string, PreferencesValue> allDatas;
109 bool ret = PreferencesXmlUtils::ReadSettingXml(file, "", allDatas);
110 EXPECT_EQ(ret, true);
111 EXPECT_EQ(allDatas.empty(), false);
112 auto it = allDatas.find("testKey");
113 EXPECT_EQ(it != allDatas.end(), true);
114 EXPECT_EQ(999, int(it->second));
115
116 std::remove(file.c_str());
117 }
118
119 /**
120 * @tc.name: UnnormalReadSettingXml_001
121 * @tc.desc: unnormal testcase of ReadSettingXml
122 * @tc.type: FUNC
123 */
124 HWTEST_F(PreferencesXmlUtilsTest, UnnormalReadSettingXml_001, TestSize.Level1)
125 {
126 std::unordered_map<std::string, PreferencesValue> values;
127 PreferencesXmlUtils::WriteSettingXml("", "", values);
128 bool ret = PreferencesXmlUtils::ReadSettingXml("", "", values);
129 EXPECT_EQ(ret, false);
130
131 std::string path = "/data/test/test_helper" + std::string(4096, 't');
132 ret = PreferencesXmlUtils::ReadSettingXml(path, "", values);
133 EXPECT_EQ(ret, false);
134
135 ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", values);
136 EXPECT_EQ(ret, false);
137
138 values.insert({});
139 path = "data/test/test_helper";
140 PreferencesXmlUtils::WriteSettingXml(path, "", values);
141 ret = PreferencesXmlUtils::ReadSettingXml(path, "", values);
142 EXPECT_EQ(ret, false);
143 }
144
145 /**
146 * @tc.name: StringNodeElementTest_001
147 * @tc.desc: StringNodeElement testcase of PreferencesXmlUtils
148 * @tc.type: FUNC
149 */
150 HWTEST_F(PreferencesXmlUtilsTest, StringNodeElementTest_001, TestSize.Level1)
151 {
152 std::string file = "/data/test/test01";
153 std::remove(file.c_str());
154
155 std::unordered_map<std::string, PreferencesValue> values;
156 values.insert({"stringKey", "test"});
157 PreferencesXmlUtils::WriteSettingXml(file, "", values);
158
159 int errCode = E_OK;
160 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
161 EXPECT_EQ(errCode, E_OK);
162 std::string retString = pref->GetString("stringKey", "");
163 EXPECT_EQ(retString, "test");
164
165 int ret = PreferencesHelper::DeletePreferences(file);
166 EXPECT_EQ(ret, E_OK);
167 }
168
169 /**
170 * @tc.name: ArrayNodeElementTest_001
171 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
172 * @tc.type: FUNC
173 */
174 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_001, TestSize.Level1)
175 {
176 std::string file = "/data/test/test02";
177 std::remove(file.c_str());
178 std::unordered_map<std::string, PreferencesValue> values;
179 std::vector<std::string> inputStringArray = { "test_child1", "test_child2" };
180 values.insert({"stringArrayKey", inputStringArray});
181 PreferencesXmlUtils::WriteSettingXml(file, "", values);
182
183 int errCode = E_OK;
184 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
185 EXPECT_EQ(errCode, E_OK);
186
187 auto retStringArray = pref->Get("stringArrayKey", "");
188 EXPECT_EQ(retStringArray.operator std::vector<std::string>(), inputStringArray);
189
190 int ret = PreferencesHelper::DeletePreferences(file);
191 EXPECT_EQ(ret, E_OK);
192 }
193
194 /**
195 * @tc.name: ArrayNodeElementTest_001
196 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
197 * @tc.type: FUNC
198 */
199 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_002, TestSize.Level1)
200 {
201 std::string file = "/data/test/test03";
202 std::remove(file.c_str());
203 std::unordered_map<std::string, PreferencesValue> values;
204 std::vector<double> inputDoubleArray = { 1.0, 2.0 };
205 values.insert({"doubleArrayKey", inputDoubleArray});
206 PreferencesXmlUtils::WriteSettingXml(file, "", values);
207
208 int errCode = E_OK;
209 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
210 EXPECT_EQ(errCode, E_OK);
211
212 auto retDoubleArray = pref->Get("doubleArrayKey", 10.0);
213 EXPECT_EQ(retDoubleArray.operator std::vector<double>(), inputDoubleArray);
214
215 int ret = PreferencesHelper::DeletePreferences(file);
216 EXPECT_EQ(ret, E_OK);
217 }
218
219 /**
220 * @tc.name: ArrayNodeElementTest_003
221 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
222 * @tc.type: FUNC
223 */
224 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_003, TestSize.Level1)
225 {
226 std::string file = "/data/test/test04";
227 std::remove(file.c_str());
228 std::unordered_map<std::string, PreferencesValue> values;
229 std::vector<bool> inputBoolArray = { false, true };
230 values.insert({"boolArrayKey", inputBoolArray});
231 PreferencesXmlUtils::WriteSettingXml(file, "", values);
232
233 int errCode = E_OK;
234 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
235 EXPECT_EQ(errCode, E_OK);
236
237 auto retBoolArray = pref->Get("boolArrayKey", false);
238 EXPECT_EQ(retBoolArray.operator std::vector<bool>(), inputBoolArray);
239
240 int ret = PreferencesHelper::DeletePreferences(file);
241 EXPECT_EQ(ret, E_OK);
242 }
243
244 /**
245 * @tc.name: ArrayNodeElementTest_004
246 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
247 * @tc.type: FUNC
248 */
249 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_004, TestSize.Level1)
250 {
251 std::string file = "/data/test/testttt05";
252 std::remove(file.c_str());
253 std::unordered_map<std::string, PreferencesValue> values;
254 std::vector<bool> value = {};
255 values.insert({"boolArrayKey", value});
256 PreferencesXmlUtils::WriteSettingXml(file, "", values);
257
258 int errCode = E_OK;
259 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
260 EXPECT_EQ(errCode, E_OK);
261
262 auto retBoolArray = pref->Get("boolArrayKey", false);
263 EXPECT_EQ(retBoolArray.IsBoolArray(), true);
264 auto array = static_cast<std::vector<bool>>(retBoolArray);
265 EXPECT_EQ(array.empty(), true);
266
267 int ret = PreferencesHelper::DeletePreferences(file);
268 EXPECT_EQ(ret, E_OK);
269 }
270
271 /**
272 * @tc.name: ArrayNodeElementTest_005
273 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
274 * @tc.type: FUNC
275 */
276 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_005, TestSize.Level1)
277 {
278 std::string file = "/data/test/testttt06";
279 std::remove(file.c_str());
280 std::unordered_map<std::string, PreferencesValue> values;
281 std::vector<std::string> value = {};
282 values.insert({"stringArrayKey", value});
283 PreferencesXmlUtils::WriteSettingXml(file, "", values);
284
285 int errCode = E_OK;
286 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
287 EXPECT_EQ(errCode, E_OK);
288
289 auto retStringArray = pref->Get("stringArrayKey", false);
290 EXPECT_EQ(retStringArray.IsStringArray(), true);
291 auto array = static_cast<std::vector<std::string>>(retStringArray);
292 EXPECT_EQ(array.empty(), true);
293
294 int ret = PreferencesHelper::DeletePreferences(file);
295 EXPECT_EQ(ret, E_OK);
296 }
297
298 /**
299 * @tc.name: ArrayNodeElementTest_006
300 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
301 * @tc.type: FUNC
302 */
303 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_006, TestSize.Level1)
304 {
305 std::string file = "/data/test/test07";
306 std::remove(file.c_str());
307 std::unordered_map<std::string, PreferencesValue> values;
308 std::vector<double> value = {};
309 values.insert({"doubleArrayKey", value});
310 PreferencesXmlUtils::WriteSettingXml(file, "", values);
311
312 int errCode = E_OK;
313 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
314 EXPECT_EQ(errCode, E_OK);
315
316 auto retDoubleArray = pref->Get("doubleArrayKey", 0);
317 EXPECT_EQ(retDoubleArray.IsDoubleArray(), true);
318 auto array = static_cast<std::vector<double>>(retDoubleArray);
319 EXPECT_EQ(array.empty(), true);
320
321 int ret = PreferencesHelper::DeletePreferences(file);
322 EXPECT_EQ(ret, E_OK);
323 }
324
325 /**
326 * @tc.name: RenameToBrokenFileTest_001
327 * @tc.desc: RenameToBrokenFile testcase of PreferencesXmlUtils
328 * @tc.type: FUNC
329 */
330 HWTEST_F(PreferencesXmlUtilsTest, RenameToBrokenFileTest_001, TestSize.Level1)
331 {
332 std::string fileName = "/data/test/test01";
333 // construct an unreadable file
334 std::ofstream oss(fileName);
335 oss << "corrupted";
336
337 std::unordered_map<std::string, PreferencesValue> values;
338 values.insert({"intKey", 2});
339 PreferencesXmlUtils::WriteSettingXml(MakeFilePath(fileName, STR_BACKUP), "", values);
340
341 int errCode = E_OK;
342 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(fileName, errCode);
343 EXPECT_EQ(errCode, E_OK);
344
345 int value = pref->Get("intKey", 0);
346 EXPECT_EQ(value, 2);
347
348 int ret = PreferencesHelper::DeletePreferences(fileName);
349 EXPECT_EQ(ret, E_OK);
350 }
351
352 /**
353 * @tc.name: ReadSettingXmlTest_004
354 * @tc.desc: RenameToBrokenFile testcase of PreferencesXmlUtils
355 * @tc.type: FUNC
356 */
357 HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_004, TestSize.Level1)
358 {
359 std::string fileName = "/data/test/test01";
360 // construct an unreadable file
361 std::ofstream oss(fileName);
362 oss << "corrupted";
363
364 std::ofstream ossBak(MakeFilePath(fileName, STR_BACKUP));
365 ossBak << "corruptedBak";
366
367 std::unordered_map<std::string, PreferencesValue> values;
368 bool res = PreferencesXmlUtils::ReadSettingXml(fileName, "", values);
369 EXPECT_EQ(res, false);
370
371 int ret = PreferencesHelper::DeletePreferences(fileName);
372 EXPECT_EQ(ret, E_OK);
373 }
374
375 /**
376 * @tc.name: WriteSettingXmlWhenFileIsNotExistTest_001
377 * @tc.desc: RenameToBrokenFile testcase of PreferencesXmlUtils
378 * @tc.type: FUNC
379 */
380 HWTEST_F(PreferencesXmlUtilsTest, WriteSettingXmlWhenFileIsNotExistTest_001, TestSize.Level1)
381 {
382 std::string fileName = "/data/test/test01";
383 std::unordered_map<std::string, PreferencesValue> values;
384 values.insert({"stringKey", ""});
385 bool result = PreferencesXmlUtils::WriteSettingXml("/data/test/preferences/testttt01", "", values);
386 EXPECT_EQ(result, false);
387
388 result = PreferencesXmlUtils::WriteSettingXml(fileName, "", values);
389 EXPECT_EQ(result, true);
390 }
391
392 /**
393 * @tc.name: ReadSettingXmlTest_005
394 * @tc.desc: Restore testcase of PreferencesXmlUtils
395 * @tc.type: FUNC
396 */
397 HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_005, TestSize.Level1)
398 {
399 std::string fileName = "/data/test/test01";
400 std::string bakFileName = "/data/test/test01.bak";
401 // construct an unreadable file
402 std::ofstream oss(fileName);
403 oss << "corrupted";
404
405 std::unordered_map<std::string, PreferencesValue> values;
406 values.insert({"stringKey", ""});
407 bool result = PreferencesXmlUtils::WriteSettingXml(MakeFilePath(fileName, STR_BACKUP), "", values);
408 EXPECT_EQ(result, true);
409
410 std::unordered_map<std::string, PreferencesValue> allDatas;
411 bool res = PreferencesXmlUtils::ReadSettingXml(fileName, "", values);
412 EXPECT_EQ(res, true);
413
414 int ret = PreferencesHelper::DeletePreferences(fileName);
415 EXPECT_EQ(ret, E_OK);
416 }
417 }
418