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 <string>
21
22 #include "preferences.h"
23 #include "preferences_errno.h"
24 #include "preferences_helper.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::NativePreferences;
28
29 namespace {
30 class PreferencesXmlUtilsTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 };
37
SetUpTestCase(void)38 void PreferencesXmlUtilsTest::SetUpTestCase(void)
39 {
40 }
41
TearDownTestCase(void)42 void PreferencesXmlUtilsTest::TearDownTestCase(void)
43 {
44 }
45
SetUp(void)46 void PreferencesXmlUtilsTest::SetUp(void)
47 {
48 }
49
TearDown(void)50 void PreferencesXmlUtilsTest::TearDown(void)
51 {
52 }
53
54 /**
55 * @tc.name: NativePreferencesImplTest_001
56 * @tc.desc: normal testcase of DeletePreferences
57 * @tc.type: FUNC
58 */
59 HWTEST_F(PreferencesXmlUtilsTest, NativePreferencesHelperTest_001, TestSize.Level1)
60 {
61 std::vector<Element> settings = {};
62 bool ret = PreferencesXmlUtils::ReadSettingXml("", settings);
63 EXPECT_EQ(ret, false);
64
65 std::string path = "/data/test/test_helper" + std::string(4096, 't');
66 ret = PreferencesXmlUtils::ReadSettingXml(path, settings);
67 EXPECT_EQ(ret, false);
68
69 ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", settings);
70 EXPECT_EQ(ret, false);
71 }
72
73 /**
74 * @tc.name: UnnormalReadSettingXml_001
75 * @tc.desc: unnormal testcase of ReadSettingXml
76 * @tc.type: FUNC
77 */
78 HWTEST_F(PreferencesXmlUtilsTest, UnnormalReadSettingXml_001, TestSize.Level1)
79 {
80 std::vector<Element> settings = {};
81 PreferencesXmlUtils::WriteSettingXml("", settings);
82 bool ret = PreferencesXmlUtils::ReadSettingXml("", settings);
83 EXPECT_EQ(ret, false);
84
85 std::string path = "/data/test/test_helper" + std::string(4096, 't');
86 ret = PreferencesXmlUtils::ReadSettingXml(path, settings);
87 EXPECT_EQ(ret, false);
88
89 ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", settings);
90 EXPECT_EQ(ret, false);
91
92 Element elem;
93 settings.push_back(elem);
94 path = "data/test/test_helper";
95 PreferencesXmlUtils::WriteSettingXml(path, settings);
96 ret = PreferencesXmlUtils::ReadSettingXml(path, settings);
97 EXPECT_EQ(ret, false);
98 }
99
100 /**
101 * @tc.name: StringNodeElementTest_001
102 * @tc.desc: StringNodeElement testcase of PreferencesXmlUtils
103 * @tc.type: FUNC
104 */
105 HWTEST_F(PreferencesXmlUtilsTest, StringNodeElementTest_001, TestSize.Level1)
106 {
107 std::string file = "/data/test/test01";
108 std::remove(file.c_str());
109
110 std::vector<Element> settings;
111 Element elem;
112 elem.key_ = "stringKey";
113 elem.tag_ = std::string("string");
114 elem.value_ = "test";
115 settings.push_back(elem);
116 PreferencesXmlUtils::WriteSettingXml(file, settings);
117
118 int errCode = E_OK;
119 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
120 EXPECT_EQ(errCode, E_OK);
121 std::string retString = pref->GetString("stringKey", "");
122 EXPECT_EQ(retString, elem.value_);
123
124 int ret = PreferencesHelper::DeletePreferences(file);
125 EXPECT_EQ(ret, E_OK);
126 }
127
128 /**
129 * @tc.name: ArrayNodeElementTest_001
130 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
131 * @tc.type: FUNC
132 */
133 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_001, TestSize.Level1)
134 {
135 std::string file = "/data/test/test02";
136 std::remove(file.c_str());
137 std::vector<Element> settings;
138
139 Element elem;
140 elem.key_ = "stringArrayKey";
141 elem.tag_ = std::string("stringArray");
142 elem.value_ = "testStringArray";
143
144 Element elemChild;
145 elemChild.key_ = "stringKey";
146 elemChild.tag_ = std::string("string");
147
148 elemChild.value_ = "test_child1";
149 elem.children_.push_back(elemChild);
150 elemChild.value_ = "test_child2";
151 elem.children_.push_back(elemChild);
152 settings.push_back(elem);
153 std::vector<std::string> inputStringArray = { "test_child1", "test_child2" };
154 PreferencesXmlUtils::WriteSettingXml(file, settings);
155
156 int errCode = E_OK;
157 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
158 EXPECT_EQ(errCode, E_OK);
159
160 auto retStringArray = pref->Get("stringArrayKey", "");
161 EXPECT_EQ(retStringArray.operator std::vector<std::string>(), inputStringArray);
162
163 int ret = PreferencesHelper::DeletePreferences(file);
164 EXPECT_EQ(ret, E_OK);
165 }
166
167 /**
168 * @tc.name: ArrayNodeElementTest_001
169 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
170 * @tc.type: FUNC
171 */
172 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_002, TestSize.Level1)
173 {
174 std::string file = "/data/test/test03";
175 std::remove(file.c_str());
176 std::vector<Element> settings;
177
178 Element elem;
179 elem.key_ = "doubleArrayKey";
180 elem.tag_ = std::string("doubleArray");
181 elem.value_ = std::to_string(10.0);
182
183 Element elemChild;
184 elemChild.key_ = "doubleKey";
185 elemChild.tag_ = std::string("double");
186
187 elemChild.value_ = std::to_string(1.0);
188 elem.children_.push_back(elemChild);
189
190 elemChild.value_ = std::to_string(2.0);
191 elem.children_.push_back(elemChild);
192 settings.push_back(elem);
193 std::vector<double> inputDoubleArray = { 1.0, 2.0 };
194 PreferencesXmlUtils::WriteSettingXml(file, settings);
195
196 int errCode = E_OK;
197 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
198 EXPECT_EQ(errCode, E_OK);
199
200 auto retDoubleArray = pref->Get("doubleArrayKey", 10.0);
201 EXPECT_EQ(retDoubleArray.operator std::vector<double>(), inputDoubleArray);
202
203 int ret = PreferencesHelper::DeletePreferences(file);
204 EXPECT_EQ(ret, E_OK);
205 }
206
207 /**
208 * @tc.name: ArrayNodeElementTest_003
209 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
210 * @tc.type: FUNC
211 */
212 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_003, TestSize.Level1)
213 {
214 std::string file = "/data/test/test04";
215 std::remove(file.c_str());
216 std::vector<Element> settings;
217
218 Element elem;
219 elem.key_ = "boolArrayKey";
220 elem.tag_ = std::string("boolArray");
221 elem.value_ = std::to_string(false);
222
223 Element elemChild;
224 elemChild.key_ = "boolKey";
225 elemChild.tag_ = std::string("bool");
226
227 elemChild.value_ = "false";
228 elem.children_.push_back(elemChild);
229
230 elemChild.value_ = "true";
231 elem.children_.push_back(elemChild);
232 settings.push_back(elem);
233 std::vector<bool> inputBoolArray = { false, true };
234 PreferencesXmlUtils::WriteSettingXml(file, settings);
235
236 int errCode = E_OK;
237 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
238 EXPECT_EQ(errCode, E_OK);
239
240 auto retBoolArray = pref->Get("boolArrayKey", false);
241 EXPECT_EQ(retBoolArray.operator std::vector<bool>(), inputBoolArray);
242
243 int ret = PreferencesHelper::DeletePreferences(file);
244 EXPECT_EQ(ret, E_OK);
245 }
246
247 /**
248 * @tc.name: ArrayNodeElementTest_004
249 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
250 * @tc.type: FUNC
251 */
252 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_004, TestSize.Level1)
253 {
254 std::string file = "/data/test/test05";
255 std::remove(file.c_str());
256 std::vector<Element> settings;
257
258 Element elem;
259 elem.key_ = "boolArrayKey";
260 elem.tag_ = std::string("boolArray");
261 elem.value_ = std::to_string(false);
262
263 settings.push_back(elem);
264 PreferencesXmlUtils::WriteSettingXml(file, settings);
265
266 int errCode = E_OK;
267 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
268 EXPECT_EQ(errCode, E_OK);
269
270 auto retBoolArray = pref->Get("boolArrayKey", false);
271 EXPECT_EQ(retBoolArray.IsBoolArray(), true);
272 auto array = static_cast<std::vector<bool>>(retBoolArray);
273 EXPECT_EQ(array.empty(), true);
274
275 int ret = PreferencesHelper::DeletePreferences(file);
276 EXPECT_EQ(ret, E_OK);
277 }
278
279 /**
280 * @tc.name: ArrayNodeElementTest_005
281 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
282 * @tc.type: FUNC
283 */
284 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_005, TestSize.Level1)
285 {
286 std::string file = "/data/test/test06";
287 std::remove(file.c_str());
288 std::vector<Element> settings;
289
290 Element elem;
291 elem.key_ = "stringArrayKey";
292 elem.tag_ = std::string("stringArray");
293 elem.value_ = std::to_string(false);
294
295 settings.push_back(elem);
296 PreferencesXmlUtils::WriteSettingXml(file, settings);
297
298 int errCode = E_OK;
299 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
300 EXPECT_EQ(errCode, E_OK);
301
302 auto retStringArray = pref->Get("stringArrayKey", false);
303 EXPECT_EQ(retStringArray.IsStringArray(), true);
304 auto array = static_cast<std::vector<std::string>>(retStringArray);
305 EXPECT_EQ(array.empty(), true);
306
307 int ret = PreferencesHelper::DeletePreferences(file);
308 EXPECT_EQ(ret, E_OK);
309 }
310
311 /**
312 * @tc.name: ArrayNodeElementTest_006
313 * @tc.desc: ArrayNodeElement testcase of PreferencesXmlUtils
314 * @tc.type: FUNC
315 */
316 HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_006, TestSize.Level1)
317 {
318 std::string file = "/data/test/test07";
319 std::remove(file.c_str());
320 std::vector<Element> settings;
321
322 Element elem;
323 elem.key_ = "doubleArrayKey";
324 elem.tag_ = std::string("doubleArray");
325 elem.value_ = std::to_string(1);
326
327 settings.push_back(elem);
328 PreferencesXmlUtils::WriteSettingXml(file, settings);
329
330 int errCode = E_OK;
331 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
332 EXPECT_EQ(errCode, E_OK);
333
334 auto retDoubleArray = pref->Get("doubleArrayKey", 0);
335 EXPECT_EQ(retDoubleArray.IsDoubleArray(), true);
336 auto array = static_cast<std::vector<double>>(retDoubleArray);
337 EXPECT_EQ(array.empty(), true);
338
339 int ret = PreferencesHelper::DeletePreferences(file);
340 EXPECT_EQ(ret, E_OK);
341 }
342 }
343