1 /*
2 * Copyright (c) 2021 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
18 #include <string>
19 #include <thread>
20
21 #include "log_print.h"
22 #include "preferences.h"
23 #include "preferences_errno.h"
24 #include "preferences_file_operation.h"
25 #include "preferences_helper.h"
26 #include "preferences_xml_utils.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::NativePreferences;
30
31 namespace {
32 class PreferencesFileTest : 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 PreferencesFileTest::SetUpTestCase(void)
41 {
42 }
43
TearDownTestCase(void)44 void PreferencesFileTest::TearDownTestCase(void)
45 {
46 }
47
SetUp(void)48 void PreferencesFileTest::SetUp(void)
49 {
50 }
51
TearDown(void)52 void PreferencesFileTest::TearDown(void)
53 {
54 }
55
PreferencesPutValue(std::shared_ptr<Preferences> pref,const std::string & intKey,int intValue,const std::string & strKey,const std::string & strValue)56 int PreferencesPutValue(std::shared_ptr<Preferences> pref, const std::string &intKey, int intValue,
57 const std::string &strKey, const std::string &strValue)
58 {
59 pref->PutInt(intKey, intValue);
60 pref->PutString(strKey, strValue);
61 int ret = pref->FlushSync();
62 return ret;
63 }
64
65 /**
66 * @tc.name: NativePreferencesFileTest_001
67 * @tc.desc: normal testcase of backup file
68 * @tc.type: FUNC
69 * @tc.author: liulinna
70 */
71 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_001, TestSize.Level1)
72 {
73 std::string file = "/data/test/test";
74 std::string backupFile = "/data/test/test.bak";
75
76 std::remove(file.c_str());
77 std::remove(backupFile.c_str());
78
79 std::unordered_map<std::string, PreferencesValue> values;
80 values.insert({"intKey", 10});
81 PreferencesXmlUtils::WriteSettingXml(backupFile, "", values);
82
83 int errCode = E_OK;
84 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
85 EXPECT_EQ(errCode, E_OK);
86 int ret = pref->GetInt("intKey", 0);
87 EXPECT_EQ(ret, 10);
88
89 struct stat st = { 0 };
90 ret = stat(file.c_str(), &st);
91 EXPECT_EQ(ret, 0);
92 ret = (st.st_mode & (S_IXUSR | S_IXGRP | S_IRWXO));
93 EXPECT_EQ(ret, 0);
94
95 pref = nullptr;
96 ret = PreferencesHelper::DeletePreferences(file);
97 EXPECT_EQ(ret, E_OK);
98 }
99
100 /**
101 * @tc.name: NativePreferencesFileTest_002
102 * @tc.desc: normal testcase of file permission
103 * @tc.type: FUNC
104 * @tc.author: liulinna
105 */
106 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_002, TestSize.Level1)
107 {
108 std::string file = "/data/test/test";
109 std::remove(file.c_str());
110
111 int errCode = E_OK;
112 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
113 EXPECT_EQ(errCode, E_OK);
114
115 int ret = PreferencesPutValue(pref, "key1", 2, "key2", "test");
116 EXPECT_EQ(ret, E_OK);
117
118 struct stat st = { 0 };
119 int result = stat(file.c_str(), &st);
120 EXPECT_EQ(result, 0);
121 result = st.st_mode & (S_IXUSR | S_IXGRP | S_IRWXO);
122 EXPECT_EQ(result, 0);
123
124 pref = nullptr;
125 result = PreferencesHelper::DeletePreferences(file);
126 EXPECT_EQ(result, E_OK);
127 }
128
129 /**
130 * @tc.name: NativePreferencesFileTest_003
131 * @tc.desc: test FlushSync one times and five times
132 * @tc.type: FUNC
133 * @tc.author: liulinna
134 */
135 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_003, TestSize.Level1)
136 {
137 std::string file = "/data/test/test";
138 int ret = PreferencesHelper::DeletePreferences(file);
139 EXPECT_EQ(ret, E_OK);
140
141 int errCode = E_OK;
142 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
143 EXPECT_EQ(errCode, E_OK);
144
145 ret = PreferencesPutValue(pref, "intKey", 1, "stringKey", "string1");
146 EXPECT_EQ(ret, E_OK);
147
148 EXPECT_EQ(1, pref->GetInt("intKey", 0));
149 EXPECT_EQ("string1", pref->GetString("stringKey", ""));
150
151 pref = nullptr;
152 ret = PreferencesHelper::RemovePreferencesFromCache("/data/test/test_helper");
153 EXPECT_EQ(ret, E_OK);
154
155 errCode = E_OK;
156 pref = PreferencesHelper::GetPreferences(file, errCode);
157 EXPECT_EQ(errCode, E_OK);
158
159 EXPECT_EQ(1, pref->GetInt("intKey", 0));
160 EXPECT_EQ("string1", pref->GetString("stringKey", ""));
161
162 for (int i = 2; i <= 5; i++) {
163 ret = PreferencesPutValue(pref, "intKey", i, "stringKey", "string" + std::to_string(i));
164 EXPECT_EQ(ret, E_OK);
165 }
166
167 EXPECT_EQ(5, pref->GetInt("intKey", 0));
168 EXPECT_EQ("string5", pref->GetString("stringKey", ""));
169
170 pref = nullptr;
171 ret = PreferencesHelper::RemovePreferencesFromCache("/data/test/test_helper");
172 EXPECT_EQ(ret, E_OK);
173
174 errCode = E_OK;
175 pref = PreferencesHelper::GetPreferences(file, errCode);
176 EXPECT_EQ(errCode, E_OK);
177
178 EXPECT_EQ(5, pref->GetInt("intKey", 0));
179 EXPECT_EQ("string5", pref->GetString("stringKey", ""));
180
181 pref = nullptr;
182 ret = PreferencesHelper::DeletePreferences("/data/test/test_helper");
183 EXPECT_EQ(ret, E_OK);
184 }
185
186 /**
187 * @tc.name: NativePreferencesFileTest_004
188 * @tc.desc: test Flush one times and five times
189 * @tc.type: FUNC
190 * @tc.author: liulinna
191 */
192 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_004, TestSize.Level3)
193 {
194 std::string file = "/data/test/test";
195 int ret = PreferencesHelper::DeletePreferences(file);
196 EXPECT_EQ(ret, E_OK);
197
198 int errCode = E_OK;
199 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
200 EXPECT_EQ(errCode, E_OK);
201
202 ret = PreferencesPutValue(pref, "intKey", 1, "stringKey", "string1");
203 EXPECT_EQ(ret, E_OK);
204
205 EXPECT_EQ(1, pref->GetInt("intKey", 0));
206 EXPECT_EQ("string1", pref->GetString("stringKey", ""));
207
208 std::this_thread::sleep_for(std::chrono::milliseconds(20));
209
210 pref = nullptr;
211 ret = PreferencesHelper::RemovePreferencesFromCache("/data/test/test_helper");
212 EXPECT_EQ(ret, E_OK);
213
214 errCode = E_OK;
215 pref = PreferencesHelper::GetPreferences(file, errCode);
216 EXPECT_EQ(errCode, E_OK);
217
218 EXPECT_EQ(1, pref->GetInt("intKey", 0));
219 EXPECT_EQ("string1", pref->GetString("stringKey", ""));
220
221 for (int i = 2; i <= 5; i++) {
222 ret = PreferencesPutValue(pref, "intKey", i, "stringKey", "string" + std::to_string(i));
223 EXPECT_EQ(ret, E_OK);
224 }
225
226 EXPECT_EQ(5, pref->GetInt("intKey", 0));
227 EXPECT_EQ("string5", pref->GetString("stringKey", ""));
228
229 std::this_thread::sleep_for(std::chrono::milliseconds(20));
230
231 pref = nullptr;
232 ret = PreferencesHelper::RemovePreferencesFromCache("/data/test/test_helper");
233 EXPECT_EQ(ret, E_OK);
234
235 errCode = E_OK;
236 pref = PreferencesHelper::GetPreferences(file, errCode);
237 EXPECT_EQ(errCode, E_OK);
238
239 EXPECT_EQ(5, pref->GetInt("intKey", 0));
240 EXPECT_EQ("string5", pref->GetString("stringKey", ""));
241
242 pref = nullptr;
243 ret = PreferencesHelper::DeletePreferences("/data/test/test_helper");
244 EXPECT_EQ(ret, E_OK);
245 }
246
247 /**
248 * @tc.name: NativePreferencesFileTest_005
249 * @tc.desc: normal testcase of fallback logic
250 * @tc.type: FUNC
251 */
252 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_005, TestSize.Level1)
253 {
254 std::string path = "/data/test/file_test005";
255 std::string file = path + "/test";
256 int ret = PreferencesHelper::DeletePreferences(file);
257 EXPECT_EQ(ret, E_OK);
258
259 int errCode = E_OK;
260 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
261 EXPECT_EQ(errCode, E_OK);
262 ret = pref->GetInt("intKey", 0);
263 EXPECT_EQ(ret, 0);
264 ret = pref->GetInt("intKey1", 0);
265 EXPECT_EQ(ret, 0);
266 pref->PutInt("intKey", 2);
267
268 OHOS::NativePreferences::Mkdir(path);
269 std::unordered_map<std::string, PreferencesValue> values;
270 values.insert({"intKey", 10});
271 values.insert({"intKey1", 10});
272 PreferencesXmlUtils::WriteSettingXml(file, "", values);
273 ret = pref->GetInt("intKey", 0);
274 EXPECT_EQ(ret, 2);
275 ret = pref->GetInt("intKey1", 0);
276 EXPECT_EQ(ret, 10);
277
278 pref = nullptr;
279 ret = PreferencesHelper::DeletePreferences(file);
280 EXPECT_EQ(ret, E_OK);
281 rmdir(path.c_str());
282 }
283
284 /**
285 * @tc.name: NativePreferencesFileTest_006
286 * @tc.desc: normal testcase of fallback logic
287 * @tc.type: FUNC
288 */
289 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_006, TestSize.Level1)
290 {
291 std::string path = "/data/test/file_test006";
292 std::string file = path + "/test";
293 int ret = PreferencesHelper::DeletePreferences(file);
294 EXPECT_EQ(ret, E_OK);
295
296 int errCode = E_OK;
297 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
298 EXPECT_EQ(errCode, E_OK);
299 EXPECT_EQ(false, pref->HasKey("intKey"));
300 EXPECT_EQ(false, pref->HasKey("intKey1"));
301 pref->PutInt("intKey", 2);
302
303 OHOS::NativePreferences::Mkdir(path);
304 std::unordered_map<std::string, PreferencesValue> values;
305 int value = 20;
306 values.insert({"intKey", value});
307 values.insert({"intKey1", value});
308 PreferencesXmlUtils::WriteSettingXml(file, "", values);
309
310 pref->FlushSync();
311
312 std::unordered_map<std::string, PreferencesValue> allDatas;
313 bool res = PreferencesXmlUtils::ReadSettingXml(file, "", allDatas);
314 EXPECT_EQ(res, true);
315 EXPECT_EQ(allDatas.empty(), false);
316 auto it = allDatas.find("intKey");
317 EXPECT_EQ(it != allDatas.end(), true);
318 EXPECT_EQ(2, int(it->second));
319
320 it = allDatas.find("intKey1");
321 EXPECT_EQ(it != allDatas.end(), true);
322 EXPECT_EQ(PreferencesValue(value) == it->second, true);
323
324 pref = nullptr;
325 ret = PreferencesHelper::DeletePreferences(file);
326 EXPECT_EQ(ret, E_OK);
327 rmdir(path.c_str());
328 }
329
330 /**
331 * @tc.name: NativePreferencesFileTest_007
332 * @tc.desc: normal testcase of fallback logic
333 * @tc.type: FUNC
334 */
335 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_007, TestSize.Level1)
336 {
337 std::string file = "/data/test/test";
338 int ret = PreferencesHelper::DeletePreferences(file);
339 EXPECT_EQ(ret, E_OK);
340
341 int errCode = E_OK;
342 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
343 EXPECT_EQ(errCode, E_OK);
344 pref->PutInt("intKey", 7);
345
346 std::unordered_map<std::string, PreferencesValue> values;
347 values.insert({"intKey", 70});
348 values.insert({"intKey1", 70});
349 PreferencesXmlUtils::WriteSettingXml(file, "", values);
350
351 ret = pref->GetInt("intKey", 0);
352 EXPECT_EQ(ret, 7);
353 ret = pref->GetInt("intKey1", 0);
354 EXPECT_EQ(ret, 70);
355
356 pref = nullptr;
357 ret = PreferencesHelper::DeletePreferences(file);
358 EXPECT_EQ(ret, E_OK);
359 }
360
361 /**
362 * @tc.name: NativePreferencesFileTest_008
363 * @tc.desc: normal testcase of fallback logic
364 * @tc.type: FUNC
365 */
366 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_008, TestSize.Level1)
367 {
368 std::string file = "/data/test/test";
369 int ret = PreferencesHelper::DeletePreferences(file);
370 EXPECT_EQ(ret, E_OK);
371
372 int errCode = E_OK;
373 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
374 EXPECT_EQ(errCode, E_OK);
375 EXPECT_EQ(false, pref->HasKey("intKey"));
376 EXPECT_EQ(false, pref->HasKey("intKey1"));
377 pref->PutInt("intKey", 8);
378
379 std::unordered_map<std::string, PreferencesValue> values;
380 int value = 80;
381 values.insert({"intKey", value});
382 values.insert({"intKey1", value});
383 PreferencesXmlUtils::WriteSettingXml(file, "", values);
384
385 pref->FlushSync();
386
387 std::unordered_map<std::string, PreferencesValue> allDatas;
388 bool res = PreferencesXmlUtils::ReadSettingXml(file, "", allDatas);
389 EXPECT_EQ(res, true);
390 EXPECT_EQ(allDatas.empty(), false);
391 auto it = allDatas.find("intKey");
392 EXPECT_EQ(it != allDatas.end(), true);
393 EXPECT_EQ(8, int(it->second));
394
395 it = allDatas.find("intKey1");
396 EXPECT_EQ(it != allDatas.end(), true);
397 EXPECT_EQ(PreferencesValue(value) == it->second, true);
398
399 pref = nullptr;
400 ret = PreferencesHelper::DeletePreferences(file);
401 EXPECT_EQ(ret, E_OK);
402 }
403
404 /**
405 * @tc.name: NativePreferencesFileTest_009
406 * @tc.desc: normal testcase of fallback logic
407 * @tc.type: FUNC
408 */
409 HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_009, TestSize.Level1)
410 {
411 std::string file = "/data/test/test";
412 int ret = PreferencesHelper::DeletePreferences(file);
413 EXPECT_EQ(ret, E_OK);
414
415 int errCode = E_OK;
416 std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
417 EXPECT_EQ(errCode, E_OK);
418 pref->PutInt("intKey", 9);
419
420 pref->FlushSync();
421
422 std::unordered_map<std::string, PreferencesValue> allDatas;
423 bool res = PreferencesXmlUtils::ReadSettingXml(file, "", allDatas);
424 EXPECT_EQ(res, true);
425 EXPECT_EQ(allDatas.empty(), false);
426 auto it = allDatas.find("intKey");
427 EXPECT_EQ(it != allDatas.end(), true);
428 EXPECT_EQ(9, int(it->second));
429
430 pref = nullptr;
431 ret = PreferencesHelper::DeletePreferences(file);
432 EXPECT_EQ(ret, E_OK);
433 }
434 }