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 "preferences.h"
17
18 #include <gtest/gtest.h>
19
20 #include <cctype>
21 #include <condition_variable>
22 #include <cstdint>
23 #include <iostream>
24 #include <memory>
25 #include <mutex>
26 #include <string>
27
28 #include "log_print.h"
29 #include "preferences_errno.h"
30 #include "preferences_file_operation.h"
31 #include "preferences_helper.h"
32 #include "preferences_observer.h"
33 #include "preferences_utils.h"
34 #include "preferences_value.h"
35
36 using namespace testing::ext;
37 using namespace OHOS::NativePreferences;
38
39 namespace {
40 const std::string LONG_KEY = std::string(Preferences::MAX_KEY_LENGTH, std::toupper('a'));
41 const std::string KEY_TEST_INT_ELEMENT = "key_test_int";
42 const std::string KEY_TEST_LONG_ELEMENT = "key_test_long";
43 const std::string KEY_TEST_FLOAT_ELEMENT = "key_test_float";
44 const std::string KEY_TEST_DOUBLE_ELEMENT = "key_test_double";
45 const std::string KEY_TEST_BOOL_ELEMENT = "key_test_bool";
46 const std::string KEY_TEST_STRING_ELEMENT = "key_test_string";
47 const std::string KEY_TEST_STRING_ARRAY_ELEMENT = "key_test_string_array";
48 const std::string KEY_TEST_BOOL_ARRAY_ELEMENT = "key_test_bool_array";
49 const std::string KEY_TEST_DOUBLE_ARRAY_ELEMENT = "key_test_double_array";
50 const std::string KEY_TEST_UINT8_ARRAY_ELEMENT = "key_test_uint8_array";
51 const std::string KEY_TEST_OBJECT_ELEMENT = "key_test_object";
52 const std::string KEY_TEST_BIGINT_ELEMENT = "key_test_bigint";
53 class PreferencesTest : public testing::Test {
54 public:
55 static void SetUpTestCase(void);
56 static void TearDownTestCase(void);
57 void SetUp();
58 void TearDown();
59
60 static std::shared_ptr<Preferences> pref;
61 };
62
63 std::shared_ptr<Preferences> PreferencesTest::pref = nullptr;
64
SetUpTestCase(void)65 void PreferencesTest::SetUpTestCase(void)
66 {
67 int errCode = E_OK;
68 pref = PreferencesHelper::GetPreferences("/data/test/test", errCode);
69 EXPECT_EQ(errCode, E_OK);
70 }
71
TearDownTestCase(void)72 void PreferencesTest::TearDownTestCase(void)
73 {
74 pref = nullptr;
75 int ret = PreferencesHelper::DeletePreferences("/data/test/test");
76 EXPECT_EQ(ret, E_OK);
77 }
78
SetUp(void)79 void PreferencesTest::SetUp(void)
80 {
81 }
82
TearDown(void)83 void PreferencesTest::TearDown(void)
84 {
85 /* clear all data after every case */
86 if (pref) {
87 pref->Clear();
88 pref->FlushSync();
89 }
90 }
91
92 class PreferencesObserverCounter : public PreferencesObserver {
93 public:
94 virtual ~PreferencesObserverCounter();
95 void OnChange(const std::string &key) override;
96 void OnChange(const std::map<std::string, OHOS::NativePreferences::PreferencesValue> &records) override;
97
98 std::atomic_int notifyTimes;
99 static const std::vector<std::string> NOTIFY_KEYS_VECTOR;
100 };
101
~PreferencesObserverCounter()102 PreferencesObserverCounter::~PreferencesObserverCounter()
103 {
104 }
105
OnChange(const std::string & key)106 void PreferencesObserverCounter::OnChange(const std::string &key)
107 {
108 for (auto it = NOTIFY_KEYS_VECTOR.cbegin(); it != NOTIFY_KEYS_VECTOR.cend(); it++) {
109 if (key.compare(*it)) {
110 notifyTimes++;
111 break;
112 }
113 }
114 }
115
OnChange(const std::map<std::string,OHOS::NativePreferences::PreferencesValue> & records)116 void PreferencesObserverCounter::OnChange(
117 const std::map<std::string, OHOS::NativePreferences::PreferencesValue> &records)
118 {
119 for (auto it = NOTIFY_KEYS_VECTOR.cbegin(); it != NOTIFY_KEYS_VECTOR.cend(); it++) {
120 for (auto iter = records.begin(); iter != records.end(); iter++) {
121 std::string key = iter->first;
122 if (key.compare(*it)) {
123 notifyTimes++;
124 return;
125 }
126 }
127 }
128 }
129
130 const std::vector<std::string> PreferencesObserverCounter::NOTIFY_KEYS_VECTOR = { KEY_TEST_INT_ELEMENT,
131 KEY_TEST_LONG_ELEMENT, KEY_TEST_FLOAT_ELEMENT, KEY_TEST_BOOL_ELEMENT, KEY_TEST_STRING_ELEMENT };
132
133 class PreferencesObserverCrossProcess : public PreferencesObserver {
134 public:
135 virtual ~PreferencesObserverCrossProcess();
136 void OnChange(const std::string &key) override;
137 void Wait();
138
139 std::mutex mut;
140 std::condition_variable cond;
141 std::string notifyKey;
142 bool result;
143 };
144
~PreferencesObserverCrossProcess()145 PreferencesObserverCrossProcess::~PreferencesObserverCrossProcess()
146 {
147 }
148
Wait()149 void PreferencesObserverCrossProcess::Wait()
150 {
151 std::unique_lock<std::mutex> lock(mut);
152 if (!result) {
153 cond.wait(lock, [this] { return result; });
154 }
155 }
156
OnChange(const std::string & key)157 void PreferencesObserverCrossProcess::OnChange(const std::string &key)
158 {
159 std::unique_lock<std::mutex> lock(mut);
160 notifyKey = key;
161 result = true;
162 cond.notify_all();
163 }
164
165 /**
166 * @tc.name: NativePreferencesGroupIdTest_001
167 * @tc.desc: normal testcase of GetGroupId
168 * @tc.type: FUNC
169 * @tc.author: lirui
170 */
171 HWTEST_F(PreferencesTest, NativePreferencesGroupIdTest_001, TestSize.Level0)
172 {
173 int errCode = E_OK;
174 Options option = Options("/data/test/test1", "ohos.test.demo", "2002001");
175 std::shared_ptr<Preferences> preferences = PreferencesHelper::GetPreferences(option, errCode);
176 EXPECT_EQ(errCode, E_OK);
177 EXPECT_EQ(preferences->GetGroupId(), "2002001");
178 EXPECT_EQ(preferences->GetBundleName(), "ohos.test.demo");
179
180 preferences = nullptr;
181 int ret = PreferencesHelper::DeletePreferences("/data/test/test1");
182 EXPECT_EQ(ret, E_OK);
183 }
184
185 /**
186 * @tc.name: NativePreferencesTest_001
187 * @tc.desc: normal testcase of FlushSync
188 * @tc.type: FUNC
189 * @tc.author: xiuhongju
190 */
191 HWTEST_F(PreferencesTest, NativePreferencesTest_001, TestSize.Level0)
192 {
193 pref->PutInt(KEY_TEST_INT_ELEMENT, 2);
194 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
195 pref->FlushSync();
196
197 int ret1 = pref->GetInt(KEY_TEST_INT_ELEMENT, 6);
198 EXPECT_EQ(ret1, 2);
199 std::string ret2 = pref->GetString(KEY_TEST_STRING_ELEMENT, "test1");
200 EXPECT_EQ(ret2, "test");
201 }
202
203 /**
204 * @tc.name: NativePreferencesTest_002
205 * @tc.desc: normal testcase of HasKey
206 * @tc.type: FUNC
207 * @tc.author: xiuhongju
208 */
209 HWTEST_F(PreferencesTest, NativePreferencesTest_002, TestSize.Level0)
210 {
211 bool ret = pref->HasKey(LONG_KEY + 'x');
212 EXPECT_EQ(ret, false);
213
214 ret = pref->HasKey(std::string());
215 EXPECT_EQ(ret, false);
216
217 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
218 ret = pref->HasKey(KEY_TEST_STRING_ELEMENT);
219 EXPECT_EQ(ret, true);
220
221 pref->FlushSync();
222 ret = pref->HasKey(KEY_TEST_STRING_ELEMENT);
223 EXPECT_EQ(ret, true);
224 }
225
226 /**
227 * @tc.name: NativePreferencesTest_003
228 * @tc.desc: normal testcase of pref
229 * @tc.type: FUNC
230 * @tc.author: xiuhongju
231 */
232 HWTEST_F(PreferencesTest, NativePreferencesTest_003, TestSize.Level0)
233 {
234 pref->PutString(KEY_TEST_STRING_ELEMENT, "test1");
235
236 std::string ret = pref->GetString(KEY_TEST_STRING_ELEMENT, "defaultvalue");
237 EXPECT_EQ(ret, "test1");
238
239 pref->FlushSync();
240 ret = pref->GetString(KEY_TEST_STRING_ELEMENT, "defaultvalue");
241 EXPECT_EQ(ret, "test1");
242 }
243
244 /**
245 * @tc.name: NativePreferencesTest_004
246 * @tc.desc: normal testcase of GetBool
247 * @tc.type: FUNC
248 * @tc.author: xiuhongju
249 */
250 HWTEST_F(PreferencesTest, NativePreferencesTest_004, TestSize.Level0)
251 {
252 bool ret = pref->GetBool(LONG_KEY + 'x', true);
253 EXPECT_EQ(ret, true);
254
255 ret = pref->GetBool("", true);
256 EXPECT_EQ(ret, true);
257
258 pref->PutBool(KEY_TEST_BOOL_ELEMENT, false);
259 pref->PutString(KEY_TEST_STRING_ELEMENT, "false");
260 pref->FlushSync();
261
262 ret = pref->GetBool(KEY_TEST_BOOL_ELEMENT, true);
263 EXPECT_EQ(ret, false);
264
265 ret = pref->GetBool(KEY_TEST_STRING_ELEMENT, true);
266 EXPECT_EQ(ret, true);
267 }
268
269 /**
270 * @tc.name: NativePreferencesTest_005
271 * @tc.desc: normal testcase of GetFloat
272 * @tc.type: FUNC
273 * @tc.author: xiuhongju
274 */
275 HWTEST_F(PreferencesTest, NativePreferencesTest_005, TestSize.Level0)
276 {
277 float ret = pref->GetFloat(LONG_KEY + 'x', 3.0f);
278 EXPECT_EQ(ret, 3.0f);
279
280 ret = pref->GetFloat("", 3.0f);
281 EXPECT_EQ(ret, 3.0f);
282
283 pref->PutFloat(KEY_TEST_FLOAT_ELEMENT, 5.0f);
284 pref->PutString(KEY_TEST_STRING_ELEMENT, "5.0");
285 pref->FlushSync();
286
287 ret = pref->GetFloat(KEY_TEST_FLOAT_ELEMENT, true);
288 EXPECT_EQ(ret, 5.0f);
289
290 ret = pref->GetFloat(KEY_TEST_STRING_ELEMENT, 3.0f);
291 EXPECT_EQ(ret, 3.0f);
292 }
293
294 /**
295 * @tc.name: NativePreferencesTest_006
296 * @tc.desc: normal testcase of GetInt
297 * @tc.type: FUNC
298 * @tc.author: xiuhongju
299 */
300 HWTEST_F(PreferencesTest, NativePreferencesTest_006, TestSize.Level0)
301 {
302 int ret = pref->GetInt(LONG_KEY + 'x', 35);
303 EXPECT_EQ(ret, 35);
304
305 ret = pref->GetInt("", 35);
306 EXPECT_EQ(ret, 35);
307
308 pref->PutInt(KEY_TEST_INT_ELEMENT, 5);
309 pref->PutString(KEY_TEST_STRING_ELEMENT, "5");
310 pref->FlushSync();
311
312 ret = pref->GetInt(KEY_TEST_INT_ELEMENT, 3);
313 EXPECT_EQ(ret, 5);
314
315 ret = pref->GetInt(KEY_TEST_STRING_ELEMENT, 3);
316 EXPECT_EQ(ret, 3);
317 }
318
319 /**
320 * @tc.name: NativePreferencesTest_007
321 * @tc.desc: normal testcase of GetLong
322 * @tc.type: FUNC
323 * @tc.author: xiuhongju
324 */
325 HWTEST_F(PreferencesTest, NativePreferencesTest_007, TestSize.Level0)
326 {
327 int64_t ret = pref->GetLong(LONG_KEY + 'x', 35L);
328 EXPECT_EQ(ret, 35L);
329
330 ret = pref->GetLong("", 35L);
331 EXPECT_EQ(ret, 35L);
332
333 pref->PutInt(KEY_TEST_INT_ELEMENT, 5);
334 pref->PutLong(KEY_TEST_LONG_ELEMENT, 5L);
335 pref->FlushSync();
336
337 ret = pref->GetLong(KEY_TEST_INT_ELEMENT, 3L);
338 EXPECT_EQ(ret, 3L);
339
340 ret = pref->GetLong(KEY_TEST_LONG_ELEMENT, 3L);
341 EXPECT_EQ(ret, 5L);
342 }
343
344 /**
345 * @tc.name: NativePreferencesTest_008
346 * @tc.desc: normal testcase of GetString
347 * @tc.type: FUNC
348 * @tc.author: xiuhongju
349 */
350 HWTEST_F(PreferencesTest, NativePreferencesTest_008, TestSize.Level0)
351 {
352 std::string ret = pref->GetString(LONG_KEY + 'x', "test");
353 EXPECT_EQ(ret, "test");
354
355 ret = pref->GetString("", "test");
356 EXPECT_EQ(ret, "test");
357
358 pref->PutInt(KEY_TEST_INT_ELEMENT, 5);
359 pref->PutString(KEY_TEST_LONG_ELEMENT, "test");
360 pref->FlushSync();
361
362 ret = pref->GetString(KEY_TEST_INT_ELEMENT, "defaultvalue");
363 EXPECT_EQ(ret, "defaultvalue");
364
365 ret = pref->GetString(KEY_TEST_LONG_ELEMENT, "defaultvalue");
366 EXPECT_EQ(ret, "test");
367 }
368
369 /**
370 * @tc.name: NativePreferencesTest_009
371 * @tc.desc: normal testcase of GetDefValue
372 * @tc.type: FUNC
373 * @tc.author: xiuhongju
374 */
375 HWTEST_F(PreferencesTest, NativePreferencesTest_009, TestSize.Level0)
376 {
377 int ret0 = pref->GetInt(KEY_TEST_INT_ELEMENT, -1);
378 EXPECT_EQ(ret0, -1);
379
380 float ret1 = pref->GetFloat(KEY_TEST_FLOAT_ELEMENT, 1.0f);
381 EXPECT_EQ(ret1, 1.0f);
382
383 int64_t ret2 = pref->GetLong(KEY_TEST_LONG_ELEMENT, 10000L);
384 EXPECT_EQ(ret2, 10000L);
385
386 bool ret3 = pref->GetBool(KEY_TEST_BOOL_ELEMENT, true);
387 EXPECT_EQ(ret3, true);
388
389 std::string ret4 = pref->GetString(KEY_TEST_STRING_ELEMENT, "test");
390 EXPECT_EQ(ret4, "test");
391 }
392
393 /**
394 * @tc.name: NativePreferencesTest_010
395 * @tc.desc: normal testcase of PutBool
396 * @tc.type: FUNC
397 * @tc.author: xiuhongju
398 */
399 HWTEST_F(PreferencesTest, NativePreferencesTest_010, TestSize.Level0)
400 {
401 pref->PutBool(LONG_KEY + 'x', true);
402 pref->PutBool("", true);
403 pref->FlushSync();
404
405 bool ret = pref->GetBool(LONG_KEY + 'x', false);
406 EXPECT_EQ(ret, false);
407 ret = pref->GetBool("", false);
408 EXPECT_EQ(ret, false);
409
410 pref->PutBool(LONG_KEY, true);
411 pref->PutBool(KEY_TEST_BOOL_ELEMENT, true);
412 pref->FlushSync();
413
414 ret = pref->GetBool(LONG_KEY, false);
415 EXPECT_EQ(ret, true);
416 ret = pref->GetBool(KEY_TEST_BOOL_ELEMENT, false);
417 EXPECT_EQ(ret, true);
418 }
419
420 /**
421 * @tc.name: NativePreferencesTest_011
422 * @tc.desc: normal testcase of PutFloat
423 * @tc.type: FUNC
424 * @tc.author: xiuhongju
425 */
426 HWTEST_F(PreferencesTest, NativePreferencesTest_011, TestSize.Level0)
427 {
428 pref->PutFloat(LONG_KEY + 'x', 3.0f);
429 pref->PutFloat("", 3.0f);
430 pref->FlushSync();
431
432 float ret = pref->GetFloat(LONG_KEY + 'x', 1.0f);
433 EXPECT_EQ(ret, 1.0f);
434 ret = pref->GetFloat("", 1.0f);
435 EXPECT_EQ(ret, 1.0f);
436
437 pref->PutFloat(LONG_KEY, 3.0f);
438 pref->PutFloat(KEY_TEST_FLOAT_ELEMENT, 3.0f);
439 pref->FlushSync();
440
441 ret = pref->GetFloat(LONG_KEY, 1.0f);
442 EXPECT_EQ(ret, 3.0f);
443 ret = pref->GetFloat(KEY_TEST_FLOAT_ELEMENT, 1.0f);
444 EXPECT_EQ(ret, 3.0f);
445 }
446
447 /**
448 * @tc.name: NativePreferencesTest_012
449 * @tc.desc: normal testcase of PutInt
450 * @tc.type: FUNC
451 * @tc.author: xiuhongju
452 */
453 HWTEST_F(PreferencesTest, NativePreferencesTest_012, TestSize.Level0)
454 {
455 pref->PutInt(LONG_KEY + 'x', 3);
456 pref->PutInt("", 3);
457 pref->FlushSync();
458
459 int ret = pref->GetInt(LONG_KEY + 'x', 1);
460 EXPECT_EQ(ret, 1);
461 ret = pref->GetInt("", 1);
462 EXPECT_EQ(ret, 1);
463
464 pref->PutInt(LONG_KEY, 3);
465 pref->PutInt(KEY_TEST_INT_ELEMENT, 3);
466 pref->FlushSync();
467
468 ret = pref->GetInt(LONG_KEY, 1);
469 EXPECT_EQ(ret, 3);
470 ret = pref->GetInt(KEY_TEST_INT_ELEMENT, 1);
471 EXPECT_EQ(ret, 3);
472 }
473
474 /**
475 * @tc.name: NativePreferencesTest_013
476 * @tc.desc: normal testcase of PutLong
477 * @tc.type: FUNC
478 * @tc.author: xiuhongju
479 */
480 HWTEST_F(PreferencesTest, NativePreferencesTest_013, TestSize.Level0)
481 {
482 pref->PutLong(LONG_KEY + 'x', 3L);
483 pref->PutLong("", 3L);
484 pref->FlushSync();
485
486 int64_t ret = pref->GetLong(LONG_KEY + 'x', 1L);
487 EXPECT_EQ(ret, 1L);
488 ret = pref->GetLong("", 1L);
489 EXPECT_EQ(ret, 1L);
490
491 pref->PutLong(LONG_KEY, 3L);
492 pref->PutLong(KEY_TEST_LONG_ELEMENT, 3L);
493 pref->FlushSync();
494
495 ret = pref->GetLong(LONG_KEY, 1L);
496 EXPECT_EQ(ret, 3L);
497 ret = pref->GetLong(KEY_TEST_LONG_ELEMENT, 1L);
498 EXPECT_EQ(ret, 3L);
499 }
500
501 /**
502 * @tc.name: NativePreferencesTest_014
503 * @tc.desc: normal testcase of PutString
504 * @tc.type: FUNC
505 * @tc.author: xiuhongju
506 */
507 HWTEST_F(PreferencesTest, NativePreferencesTest_014, TestSize.Level0)
508 {
509 pref->PutString(LONG_KEY + 'x', "test");
510 pref->PutString("", "test");
511 pref->FlushSync();
512
513 std::string ret = pref->GetString(LONG_KEY + 'x', "defaultValue");
514 EXPECT_EQ(ret, "defaultValue");
515 ret = pref->GetString("", "defaultValue");
516 EXPECT_EQ(ret, "defaultValue");
517
518 pref->PutString(LONG_KEY, "test");
519 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
520 pref->FlushSync();
521
522 ret = pref->GetString(LONG_KEY, "defaultValue");
523 EXPECT_EQ(ret, "test");
524 ret = pref->GetString(KEY_TEST_STRING_ELEMENT, "defaultValue");
525 EXPECT_EQ(ret, "test");
526 }
527
528 /**
529 * @tc.name: NativePreferencesTest_015
530 * @tc.desc: normal testcase of Delete
531 * @tc.type: FUNC
532 * @tc.author: xiuhongju
533 */
534 HWTEST_F(PreferencesTest, NativePreferencesTest_015, TestSize.Level0)
535 {
536 pref->PutString("test", "remove");
537 pref->FlushSync();
538
539 std::string ret = pref->GetString("test", "defaultValue");
540 EXPECT_EQ(ret, "remove");
541
542 pref->Delete("test");
543 pref->FlushSync();
544 ret = pref->GetString("test", "defaultValue");
545 EXPECT_EQ(ret, "defaultValue");
546 int res = pref->Delete("");
547 EXPECT_EQ(res, E_KEY_EMPTY);
548 }
549
550 /**
551 * @tc.name: NativePreferencesTest_016
552 * @tc.desc: normal testcase of RegisterPreferencesObserver
553 * @tc.type: FUNC
554 * @tc.author: xiuhongju
555 */
556 HWTEST_F(PreferencesTest, NativePreferencesTest_016, TestSize.Level0)
557 {
558 std::shared_ptr<PreferencesObserver> counter = std::make_shared<PreferencesObserverCounter>();
559 pref->RegisterObserver(counter);
560
561 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
562 pref->FlushSync();
563 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 1);
564
565 /* same value */
566 pref->PutInt(KEY_TEST_INT_ELEMENT, 2);
567 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
568 pref->FlushSync();
569 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
570
571 pref->UnRegisterObserver(counter);
572 }
573
574 /**
575 * @tc.name: NativePreferencesTest_017
576 * @tc.desc: normal testcase of UnRegisterPreferencesObserver
577 * @tc.type: FUNC
578 * @tc.author: xiuhongju
579 */
580 HWTEST_F(PreferencesTest, NativePreferencesTest_017, TestSize.Level0)
581 {
582 std::shared_ptr<PreferencesObserver> counter = std::make_shared<PreferencesObserverCounter>();
583 pref->RegisterObserver(counter);
584
585 pref->PutInt(KEY_TEST_INT_ELEMENT, 2);
586 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
587 pref->FlushSync();
588 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
589
590 pref->UnRegisterObserver(counter);
591
592 pref->PutInt(KEY_TEST_INT_ELEMENT, 6);
593 pref->PutString(KEY_TEST_STRING_ELEMENT, "test1");
594 pref->FlushSync();
595 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
596 }
597
598 /**
599 * @tc.name: NativePreferencesTest_018
600 * @tc.desc: normal testcase of Clear
601 * @tc.type: FUNC
602 * @tc.author: xiuhongju
603 */
604 HWTEST_F(PreferencesTest, NativePreferencesTest_018, TestSize.Level0)
605 {
606 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
607 pref->PutInt(KEY_TEST_INT_ELEMENT, 3);
608 pref->FlushSync();
609
610 pref->Clear();
611 std::string ret = pref->GetString(KEY_TEST_STRING_ELEMENT, "defaultvalue");
612 EXPECT_EQ(ret, "defaultvalue");
613 int ret1 = pref->GetInt(KEY_TEST_INT_ELEMENT, 0);
614 EXPECT_EQ(ret1, 0);
615
616 pref->FlushSync();
617 ret = pref->GetString(KEY_TEST_STRING_ELEMENT, "defaultvalue");
618 EXPECT_EQ(ret, "defaultvalue");
619 ret1 = pref->GetInt(KEY_TEST_INT_ELEMENT, 0);
620 EXPECT_EQ(ret1, 0);
621 }
622
623 /**
624 * @tc.name: NativePreferencesTest_019
625 * @tc.desc: normal testcase of GetDouble
626 * @tc.type: FUNC
627 * @tc.require: Na
628 * @tc.author: mang tsang
629 */
630 HWTEST_F(PreferencesTest, NativePreferencesTest_019, TestSize.Level0)
631 {
632 double ret = pref->GetDouble(LONG_KEY + 'x', 35.99999);
633 EXPECT_EQ(ret, 35.99999);
634
635 ret = pref->GetDouble("", 35.99999);
636 EXPECT_EQ(ret, 35.99999);
637
638 pref->PutDouble(KEY_TEST_DOUBLE_ELEMENT, (std::numeric_limits<double>::max)());
639 pref->PutString(KEY_TEST_STRING_ELEMENT, "5.99");
640 pref->FlushSync();
641
642 ret = pref->GetDouble(KEY_TEST_DOUBLE_ELEMENT, 3.99);
643 EXPECT_EQ(ret, (std::numeric_limits<double>::max)());
644
645 ret = pref->GetDouble(KEY_TEST_STRING_ELEMENT, 3.99);
646 EXPECT_EQ(ret, 3.99);
647 }
648
649 /**
650 * @tc.name: NativePreferencesTest_020
651 * @tc.desc: normal testcase of GetDouble without defaultValue
652 * @tc.type: FUNC
653 * @tc.require: Na
654 * @tc.author: lijuntao
655 */
656 HWTEST_F(PreferencesTest, NativePreferencesTest_020, TestSize.Level0)
657 {
658 int errCode;
659 std::shared_ptr<Preferences> pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
660 pref1->PutDouble(KEY_TEST_DOUBLE_ELEMENT, (std::numeric_limits<double>::max)());
661 pref1->FlushSync();
662 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
663 pref1.reset();
664 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
665 double ret = pref1->GetDouble(KEY_TEST_DOUBLE_ELEMENT);
666 EXPECT_EQ(ret, (std::numeric_limits<double>::max)());
667 PreferencesHelper::DeletePreferences("/data/test/test1");
668 }
669
670 /**
671 * @tc.name: NativePreferencesTest_021
672 * @tc.desc: normal testcase of GetString without defaultValue
673 * @tc.type: FUNC
674 * @tc.require: Na
675 * @tc.author: lijuntao
676 */
677 HWTEST_F(PreferencesTest, NativePreferencesTest_021, TestSize.Level0)
678 {
679 int errCode;
680 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
681 pref1->PutString(LONG_KEY, "test");
682 pref1->PutString(KEY_TEST_STRING_ELEMENT, "test1 test2");
683 pref1->FlushSync();
684
685 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
686 pref1.reset();
687 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
688
689 std::string ret = pref1->GetString(LONG_KEY);
690 EXPECT_EQ(ret, "test");
691 ret = pref1->GetString(KEY_TEST_STRING_ELEMENT);
692 EXPECT_EQ(ret, "test1 test2");
693 PreferencesHelper::DeletePreferences("/data/test/test1");
694 }
695
696 /**
697 * @tc.name: NativePreferencesTest_022
698 * @tc.desc: normal testcase of GetLong without defaultValue
699 * @tc.type: FUNC
700 * @tc.require: Na
701 * @tc.author: lijuntao
702 */
703 HWTEST_F(PreferencesTest, NativePreferencesTest_022, TestSize.Level0)
704 {
705 int errCode;
706 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
707 pref1->PutLong(LONG_KEY, 3L);
708 pref1->PutLong(KEY_TEST_LONG_ELEMENT, 3L);
709 pref1->FlushSync();
710
711 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
712 pref1.reset();
713 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
714
715 int64_t ret = pref1->GetLong(LONG_KEY);
716 EXPECT_EQ(ret, 3L);
717 ret = pref1->GetLong(KEY_TEST_LONG_ELEMENT);
718 EXPECT_EQ(ret, 3L);
719 PreferencesHelper::DeletePreferences("/data/test/test1");
720 }
721
722 /**
723 * @tc.name: NativePreferencesTest_023
724 * @tc.desc: normal testcase of GetInt without defaultValue
725 * @tc.type: FUNC
726 * @tc.require: Na
727 * @tc.author: lijuntao
728 */
729 HWTEST_F(PreferencesTest, NativePreferencesTest_023, TestSize.Level0)
730 {
731 int errCode;
732 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
733 pref1->PutInt(LONG_KEY, 3);
734 pref1->PutInt(KEY_TEST_INT_ELEMENT, 3);
735 pref1->FlushSync();
736
737 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
738 pref1.reset();
739 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
740
741 int32_t ret = pref1->GetInt(LONG_KEY);
742 EXPECT_EQ(ret, 3);
743 ret = pref1->GetInt(KEY_TEST_INT_ELEMENT);
744 EXPECT_EQ(ret, 3);
745 PreferencesHelper::DeletePreferences("/data/test/test1");
746 }
747
748 /**
749 * @tc.name: NativePreferencesTest_024
750 * @tc.desc: normal testcase of GetFloat without defaultValue
751 * @tc.type: FUNC
752 * @tc.require: Na
753 * @tc.author: lijuntao
754 */
755 HWTEST_F(PreferencesTest, NativePreferencesTest_024, TestSize.Level0)
756 {
757 int errCode;
758 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
759 pref1->PutFloat(LONG_KEY, 3.0f);
760 pref1->PutFloat(KEY_TEST_FLOAT_ELEMENT, 3.0f);
761 pref1->FlushSync();
762
763 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
764 pref1.reset();
765 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
766
767 float ret = pref1->GetFloat(LONG_KEY);
768 EXPECT_EQ(ret, 3.0f);
769 ret = pref1->GetFloat(KEY_TEST_FLOAT_ELEMENT);
770 EXPECT_EQ(ret, 3.0f);
771 PreferencesHelper::DeletePreferences("/data/test/test1");
772 }
773
774 /**
775 * @tc.name: NativePreferencesTest_025
776 * @tc.desc: normal testcase of GetBool without defaultValue
777 * @tc.type: FUNC
778 * @tc.require: Na
779 * @tc.author: lijuntao
780 */
781 HWTEST_F(PreferencesTest, NativePreferencesTest_025, TestSize.Level0)
782 {
783 int errCode;
784 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
785 pref1->PutBool(LONG_KEY, true);
786 pref1->PutBool(KEY_TEST_BOOL_ELEMENT, true);
787 pref1->FlushSync();
788
789 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
790 pref1.reset();
791 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
792
793 bool ret = pref1->GetBool(LONG_KEY);
794 EXPECT_EQ(ret, true);
795 ret = pref1->GetBool(KEY_TEST_BOOL_ELEMENT);
796 EXPECT_EQ(ret, true);
797 PreferencesHelper::DeletePreferences("/data/test/test1");
798 }
799
800 /**
801 * @tc.name: NativePreferencesTest_026
802 * @tc.desc: normal testcase of GetArray
803 * @tc.type: FUNC
804 * @tc.require: Na
805 * @tc.author: changjiaxing
806 */
807 HWTEST_F(PreferencesTest, NativePreferencesTest_026, TestSize.Level0)
808 {
809 int errCode;
810 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
811 std::vector<std::string> stringArray = { "str1", "str2" };
812 std::vector<bool> boolArray = { false, true };
813 std::vector<double> doubleArray = { 0.1, 0.2 };
814 std::vector<uint8_t> uint8Array = { 1, 2, 3, 4, 5, 6, 7 };
815 pref1->Put(KEY_TEST_STRING_ARRAY_ELEMENT, stringArray);
816 pref1->Put(KEY_TEST_BOOL_ARRAY_ELEMENT, boolArray);
817 pref1->Put(KEY_TEST_DOUBLE_ARRAY_ELEMENT, doubleArray);
818 pref1->Put(KEY_TEST_UINT8_ARRAY_ELEMENT, uint8Array);
819 pref1->FlushSync();
820
821 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
822 pref1.reset();
823 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
824
825 PreferencesValue defValue(static_cast<int64_t>(0));
826 PreferencesValue stringArrayRes = pref1->Get(KEY_TEST_STRING_ARRAY_ELEMENT, defValue);
827 EXPECT_EQ(stringArrayRes.IsStringArray(), true);
828 EXPECT_EQ(static_cast<std::vector<std::string>>(stringArrayRes), stringArray);
829
830 PreferencesValue boolArrayRes = pref1->Get(KEY_TEST_BOOL_ARRAY_ELEMENT, defValue);
831 EXPECT_EQ(boolArrayRes.IsBoolArray(), true);
832 EXPECT_EQ(static_cast<std::vector<bool>>(boolArrayRes), boolArray);
833
834 PreferencesValue doubleArrayRes = pref1->Get(KEY_TEST_DOUBLE_ARRAY_ELEMENT, defValue);
835 EXPECT_EQ(doubleArrayRes.IsDoubleArray(), true);
836 EXPECT_EQ(static_cast<std::vector<double>>(doubleArrayRes), doubleArray);
837
838 PreferencesValue uint8ArrayRes = pref1->Get(KEY_TEST_UINT8_ARRAY_ELEMENT, defValue);
839 EXPECT_EQ(uint8ArrayRes.IsUint8Array(), true);
840 EXPECT_EQ(static_cast<std::vector<uint8_t>>(uint8ArrayRes), uint8Array);
841 PreferencesHelper::DeletePreferences("/data/test/test1");
842 }
843
844 /**
845 * @tc.name: NativePreferencesTest_027
846 * @tc.desc: normal testcase of GetAll
847 * @tc.type: FUNC
848 * @tc.require: Na
849 * @tc.author: changjiaxing
850 */
851 HWTEST_F(PreferencesTest, NativePreferencesTest_027, TestSize.Level0)
852 {
853 int errCode;
854 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
855
856 std::map<std::string, PreferencesValue> map = { { KEY_TEST_INT_ELEMENT, 1 }, { KEY_TEST_FLOAT_ELEMENT, 0.1 },
857 { KEY_TEST_BOOL_ELEMENT, false }, { KEY_TEST_STRING_ELEMENT, "test" } };
858
859 for (auto i : map) {
860 pref1->Put(i.first, i.second);
861 }
862
863 auto ret = pref1->GetAll();
864
865 EXPECT_EQ(map.size(), ret.size());
866 auto iter1 = map.begin();
867 auto iter2 = ret.begin();
868 for (;iter1 != map.end(); ++iter1, ++iter2) {
869 EXPECT_EQ(iter1->first, iter2->first);
870 bool isequa = false;
871 if (iter1->second == iter2->second) {
872 isequa = true;
873 }
874 EXPECT_TRUE(isequa);
875 }
876 PreferencesHelper::DeletePreferences("/data/test/test1");
877 }
878
879 /**
880 * @tc.name: NativePreferencesTest_028
881 * @tc.desc: Cross process subscription testing
882 * @tc.type: FUNC
883 * @tc.require: Na
884 * @tc.author: changjiaxing
885 */
886 HWTEST_F(PreferencesTest, NativePreferencesTest_028, TestSize.Level0)
887 {
888 std::shared_ptr<PreferencesObserverCrossProcess> counter = std::make_shared<PreferencesObserverCrossProcess>();
889 int ret = pref->RegisterObserver(counter, RegisterMode::MULTI_PRECESS_CHANGE);
890 EXPECT_EQ(ret, E_OK);
891 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
892 pref->FlushSync();
893 counter->Wait();
894 EXPECT_EQ(counter->notifyKey, KEY_TEST_STRING_ELEMENT);
895
896 ret = pref->UnRegisterObserver(counter, RegisterMode::MULTI_PRECESS_CHANGE);
897 EXPECT_EQ(ret, E_OK);
898 }
899
900 /**
901 * @tc.name: NativePreferencesTest_029
902 * @tc.desc: normal testcase of GetBigInt without defaultValue
903 * @tc.type: FUNC
904 * @tc.require: Na
905 * @tc.author: changjiaxing
906 */
907 HWTEST_F(PreferencesTest, NativePreferencesTest_029, TestSize.Level0)
908 {
909 int errCode;
910 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
911 std::vector<uint64_t> words = { 1, 2, 3 };
912 BigInt bigint1(words, 0);
913 BigInt bigint2(words, 1);
914 pref1->Put(LONG_KEY, bigint1);
915 pref1->Put(KEY_TEST_BIGINT_ELEMENT, bigint2);
916 pref1->FlushSync();
917
918 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
919 pref1.reset();
920 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
921
922 BigInt ret = pref1->Get(LONG_KEY, BigInt());
923 EXPECT_EQ(ret, bigint1);
924 ret = pref1->Get(KEY_TEST_BIGINT_ELEMENT, BigInt());
925 EXPECT_EQ(ret, bigint2);
926 PreferencesHelper::DeletePreferences("/data/test/test1");
927 }
928
929 /**
930 * @tc.name: NativePreferencesTest_030
931 * @tc.desc: normal testcase of GetBigInt without defaultValue
932 * @tc.type: FUNC
933 * @tc.require: Na
934 * @tc.author: changjiaxing
935 */
936 HWTEST_F(PreferencesTest, NativePreferencesTest_030, TestSize.Level0)
937 {
938 int errCode;
939 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
940 std::vector<uint64_t> words = {};
941 BigInt bigint1(words, 0);
942 errCode = pref1->Put(LONG_KEY, bigint1);
943 EXPECT_EQ(errCode, E_ERROR);
944
945 PreferencesHelper::DeletePreferences("/data/test/test1");
946 }
947
948 /**
949 * @tc.name: NativePreferencesTest_031
950 * @tc.desc: normal testcase of get object
951 * @tc.type: FUNC
952 * @tc.require: Na
953 * @tc.author: bty
954 */
955 HWTEST_F(PreferencesTest, NativePreferencesTest_031, TestSize.Level0)
956 {
957 int errCode;
958 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
959 Object object("{\"key1\":\"value1\",\"key2\":222}");
960 EXPECT_EQ(pref1->Put(KEY_TEST_OBJECT_ELEMENT, object), E_OK);
961 pref1->FlushSync();
962
963 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
964 pref1.reset();
965 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
966 PreferencesValue defValue(static_cast<int64_t>(0));
967 PreferencesValue res = pref1->Get(KEY_TEST_OBJECT_ELEMENT, defValue);
968 EXPECT_EQ(static_cast<Object>(res), object);
969 PreferencesHelper::DeletePreferences("/data/test/test1");
970 }
971
972 /**
973 * @tc.name: NativePreferencesTest_032
974 * @tc.desc: normal testcase of OnChange DataChange
975 * @tc.type: FUNC
976 * @tc.require: Na
977 * @tc.author: lirui
978 */
979 HWTEST_F(PreferencesTest, NativePreferencesTest_032, TestSize.Level0)
980 {
981 std::shared_ptr<PreferencesObserver> counter = std::make_shared<PreferencesObserverCounter>();
982 std::vector<std::string> keys = { KEY_TEST_STRING_ELEMENT };
983 pref->RegisterDataObserver(counter, keys);
984 pref->PutString(KEY_TEST_STRING_ELEMENT, "test");
985 pref->FlushSync();
986 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 1);
987 }
988
989 /**
990 * @tc.name: NativePreferencesTest_033
991 * @tc.desc: RegisterObserver testing
992 * @tc.type: FUNC
993 */
994 HWTEST_F(PreferencesTest, NativePreferencesTest_033, TestSize.Level0)
995 {
996 vector<std::shared_ptr<PreferencesObserverCrossProcess>> counters;
997 for (int i = 0; i <= 50; i++) {
998 std::shared_ptr<PreferencesObserverCrossProcess> counter = std::make_shared<PreferencesObserverCrossProcess>();
999 counters.push_back(counter);
1000 int ret = pref->RegisterObserver(counter, RegisterMode::MULTI_PRECESS_CHANGE);
1001 EXPECT_EQ(ret, E_OK);
1002 }
1003 std::shared_ptr<PreferencesObserverCrossProcess> counter = std::make_shared<PreferencesObserverCrossProcess>();
1004 int ret = pref->RegisterObserver(counter, RegisterMode::MULTI_PRECESS_CHANGE);
1005 EXPECT_NE(ret, E_OK);
1006 for (auto counter : counters) {
1007 ret = pref->UnRegisterObserver(counter, RegisterMode::MULTI_PRECESS_CHANGE);
1008 EXPECT_EQ(ret, E_OK);
1009 }
1010 }
1011
1012 /**
1013 * @tc.name: OperatorTest_001
1014 * @tc.desc: normal testcase of PreferencesValue Operator
1015 * @tc.type: FUNC
1016 * @tc.author: xiuhongju
1017 */
1018 HWTEST_F(PreferencesTest, PreferencesValueTest_001, TestSize.Level0)
1019 {
1020 int valueInt = 1;
1021 int retInt = PreferencesValue(valueInt);
1022 EXPECT_EQ(valueInt, retInt);
1023
1024 int64_t valueInt64 = 1;
1025 int64_t retInt64 = PreferencesValue(valueInt64);
1026 EXPECT_EQ(valueInt64, retInt64);
1027
1028 float valueFloat = 1.0;
1029 float retFloat = PreferencesValue(valueFloat);
1030 EXPECT_EQ(valueFloat, retFloat);
1031
1032 double valueDouble = 1.0;
1033 double retDouble = PreferencesValue(valueDouble);
1034 EXPECT_EQ(valueDouble, retDouble);
1035
1036 bool valueBool = true;
1037 bool retBool = PreferencesValue(valueBool);
1038 EXPECT_EQ(valueBool, retBool);
1039
1040 string valueString = "test";
1041 string retString = PreferencesValue(valueString);
1042 EXPECT_EQ(valueString, retString);
1043
1044 std::vector<bool> valueVectorBool(2, true);
1045 std::vector<bool> retVectorBool = PreferencesValue(valueVectorBool);
1046 EXPECT_EQ(valueVectorBool, retVectorBool);
1047
1048 std::vector<double> valueVectorDouble(2, 1.0);
1049 std::vector<double> retVectorDouble = PreferencesValue(valueVectorDouble);
1050 EXPECT_EQ(valueVectorDouble, retVectorDouble);
1051
1052 std::vector<string> valueVectorString(2, "test");
1053 std::vector<string> retVectorString = PreferencesValue(valueVectorString);
1054 EXPECT_EQ(valueVectorString, retVectorString);
1055
1056 std::vector<uint8_t> valueVectorUint8(3, 1);
1057 std::vector<uint8_t> retVectorUint8 = PreferencesValue(valueVectorUint8);
1058 EXPECT_EQ(valueVectorUint8, retVectorUint8);
1059
1060 Object object("{\"key1\":\"value1\",\"key2\":222}");
1061 Object retObjecte = PreferencesValue(object);
1062 EXPECT_EQ(object, retObjecte);
1063
1064 std::vector<uint64_t> words = { 1, 2, 3 };
1065 BigInt bigint(words, 0);
1066 BigInt retBigint = PreferencesValue(bigint);
1067 EXPECT_EQ(bigint, retBigint);
1068 }
1069
1070 /**
1071 * @tc.name: NativePreferencesTest_035
1072 * @tc.desc: normal testcase of getAllData
1073 * @tc.type: FUNC
1074 * @tc.require: Na
1075 * @tc.author: bty
1076 */
1077 HWTEST_F(PreferencesTest, NativePreferencesTest_035, TestSize.Level0)
1078 {
1079 int errCode;
1080 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test035", errCode);
1081
1082 std::map<std::string, PreferencesValue> map = { { KEY_TEST_INT_ELEMENT, 1 }, { KEY_TEST_FLOAT_ELEMENT, 0.1 },
1083 { KEY_TEST_BOOL_ELEMENT, false }, { KEY_TEST_STRING_ELEMENT, "test" } };
1084
1085 for (auto i : map) {
1086 pref1->Put(i.first, i.second);
1087 }
1088
1089 auto ret = pref1->GetAllData();
1090
1091 EXPECT_EQ(map.size(), ret.second.size());
1092 for (auto iter1 = ret.second.begin(); iter1 != ret.second.end(); ++iter1) {
1093 auto iter2 = map.find(iter1->first);
1094 EXPECT_NE(iter2, map.end());
1095 bool isequa = false;
1096 if (iter1->second == iter2->second) {
1097 isequa = true;
1098 }
1099 EXPECT_TRUE(isequa);
1100 }
1101 pref1->Clear();
1102 ret = pref1->GetAllData();
1103 EXPECT_EQ(ret.second.size(), 0);
1104 PreferencesHelper::DeletePreferences("/data/test/test035");
1105 }
1106
1107 /**
1108 * @tc.name: NativePreferencesTest_036
1109 * @tc.desc: normal testcase of getAllDatas
1110 * @tc.type: FUNC
1111 * @tc.require: Na
1112 * @tc.author: Na
1113 */
1114 HWTEST_F(PreferencesTest, NativePreferencesTest_036, TestSize.Level0)
1115 {
1116 int errCode;
1117 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test036", errCode);
1118
1119 std::map<std::string, PreferencesValue> map = { { KEY_TEST_INT_ELEMENT, 1 }, { KEY_TEST_FLOAT_ELEMENT, 0.1 },
1120 { KEY_TEST_BOOL_ELEMENT, false }, { KEY_TEST_STRING_ELEMENT, "test" } };
1121
1122 for (auto i : map) {
1123 pref1->Put(i.first, i.second);
1124 }
1125
1126 auto ret = pref1->GetAllDatas();
1127
1128 EXPECT_EQ(map.size(), ret.size());
1129 for (auto iter1 = ret.begin(); iter1 != ret.end(); ++iter1) {
1130 auto iter2 = map.find(iter1->first);
1131 EXPECT_NE(iter2, map.end());
1132 bool isequa = false;
1133 if (iter1->second == iter2->second) {
1134 isequa = true;
1135 }
1136 EXPECT_TRUE(isequa);
1137 }
1138 pref1->Clear();
1139 ret = pref1->GetAllDatas();
1140 EXPECT_EQ(ret.size(), 0);
1141 PreferencesHelper::DeletePreferences("/data/test/test036");
1142 }
1143
1144 /**
1145 * @tc.name: NativePreferencesTest_037
1146 * @tc.desc: normal testcase of get value
1147 * @tc.type: FUNC
1148 * @tc.require: Na
1149 * @tc.author:
1150 */
1151 HWTEST_F(PreferencesTest, NativePreferencesTest_037, TestSize.Level0)
1152 {
1153 int errCode;
1154 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test037", errCode);
1155
1156 std::map<std::string, PreferencesValue> map = { { KEY_TEST_INT_ELEMENT, 1 }, { KEY_TEST_FLOAT_ELEMENT, 0.1 },
1157 { KEY_TEST_BOOL_ELEMENT, false }, { KEY_TEST_STRING_ELEMENT, "test" } };
1158
1159 for (auto i : map) {
1160 pref1->Put(i.first, i.second);
1161 }
1162
1163 PreferencesValue defValue(static_cast<int64_t>(0));
1164 auto ret = pref1->GetValue("", defValue);
1165 EXPECT_EQ(static_cast<int64_t>(ret.second), static_cast<int64_t>(defValue));
1166 auto res = pref1->GetValue("test", defValue);
1167 EXPECT_EQ(static_cast<int64_t>(res.second), static_cast<int64_t>(defValue));
1168 res = pref1->GetValue(KEY_TEST_INT_ELEMENT, 0);
1169 int val = res.second;
1170 EXPECT_EQ(val, 1);
1171 pref1->Clear();
1172 res = pref1->GetValue(KEY_TEST_STRING_ELEMENT, "default");
1173 std::string value = res.second;
1174 EXPECT_EQ(value, "default");
1175
1176 PreferencesHelper::DeletePreferences("/data/test/test037");
1177 }
1178
1179 /**
1180 * @tc.name: NativePreferencesTest_038
1181 * @tc.desc: normal testcase of has key
1182 * @tc.type: FUNC
1183 * @tc.require: Na
1184 * @tc.author:
1185 */
1186 HWTEST_F(PreferencesTest, NativePreferencesTest_038, TestSize.Level0)
1187 {
1188 int errCode;
1189 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test038", errCode);
1190
1191 std::map<std::string, PreferencesValue> map = { { KEY_TEST_INT_ELEMENT, 1 }, { KEY_TEST_FLOAT_ELEMENT, 0.1 },
1192 { KEY_TEST_BOOL_ELEMENT, false }, { KEY_TEST_STRING_ELEMENT, "test" } };
1193
1194 for (auto i : map) {
1195 pref1->Put(i.first, i.second);
1196 }
1197
1198 bool ret = pref1->HasKey(std::string());
1199 EXPECT_EQ(ret, false);
1200 ret = pref1->HasKey("test");
1201 EXPECT_EQ(ret, false);
1202 ret = pref1->HasKey(KEY_TEST_INT_ELEMENT);
1203 EXPECT_EQ(ret, true);
1204 pref1->Clear();
1205 ret = pref1->HasKey(KEY_TEST_STRING_ELEMENT);
1206 EXPECT_EQ(ret, false);
1207
1208 PreferencesHelper::DeletePreferences("/data/test/test038");
1209 }
1210
1211 /**
1212 * @tc.name: NativePreferencesTest_039
1213 * @tc.desc: normal testcase of delete key
1214 * @tc.type: FUNC
1215 * @tc.require: Na
1216 * @tc.author:
1217 */
1218 HWTEST_F(PreferencesTest, NativePreferencesTest_039, TestSize.Level0)
1219 {
1220 int errCode;
1221 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test038", errCode);
1222
1223 std::map<std::string, PreferencesValue> map = { { KEY_TEST_INT_ELEMENT, 1 }, { KEY_TEST_FLOAT_ELEMENT, 0.1 },
1224 { KEY_TEST_BOOL_ELEMENT, false }, { KEY_TEST_STRING_ELEMENT, "test" } };
1225
1226 for (auto i : map) {
1227 pref1->Put(i.first, i.second);
1228 }
1229
1230 int ret = pref1->Delete(std::string());
1231 EXPECT_EQ(ret, E_KEY_EMPTY);
1232 ret = pref1->Delete("test");
1233 EXPECT_EQ(ret, E_OK);
1234 ret = pref1->Delete(KEY_TEST_INT_ELEMENT);
1235 EXPECT_EQ(ret, E_OK);
1236 pref1->Clear();
1237 ret = pref1->Delete(KEY_TEST_STRING_ELEMENT);
1238 EXPECT_EQ(ret, E_OK);
1239
1240 PreferencesHelper::DeletePreferences("/data/test/test038");
1241 }
1242
1243 /**
1244 * @tc.name: NativePreferencesTest_040
1245 * @tc.desc: normal testcase of report object type
1246 * @tc.type: FUNC
1247 */
1248 HWTEST_F(PreferencesTest, NativePreferencesTest_040, TestSize.Level0)
1249 {
1250 std::string path = "/data/test/test040";
1251 std::string testKey = "testKey";
1252 int errCode;
1253 auto pref = PreferencesHelper::GetPreferences(path, errCode);
1254 EXPECT_NE(pref, nullptr);
1255 EXPECT_EQ(errCode, E_OK);
1256
1257 Object object("{\"key1\":\"value1\",\"key2\":222}");
1258 pref->Put(testKey, "testValue");
1259 pref->Put(testKey, object);
1260 pref->Put(testKey, object);
1261 pref->Put(testKey, "testValue");
1262 // Waiting for asynchronous task to create file
1263 sleep(1);
1264 std::string flagFilePath = PreferencesUtils::MakeFilePath(path, PreferencesUtils::STR_OBJECT_FLAG);
1265 EXPECT_EQ(Access(flagFilePath), 0);
1266
1267 PreferencesHelper::RemovePreferencesFromCache(path);
1268 pref = PreferencesHelper::GetPreferences(path, errCode);
1269 // There is a flag file created previously
1270 pref->Put(testKey, object);
1271
1272 PreferencesHelper::DeletePreferences(path);
1273 pref = nullptr;
1274 EXPECT_NE(Access(flagFilePath), 0);
1275 }
1276
1277 /**
1278 * @tc.name: NativePreferencesTest_041
1279 * @tc.desc: abnormal testcase of report object type
1280 * @tc.type: FUNC
1281 */
1282 HWTEST_F(PreferencesTest, NativePreferencesTest_041, TestSize.Level0)
1283 {
1284 std::string path = "/invalid/test/test041";
1285 std::string testKey = "testKey";
1286 int errCode;
1287 auto pref = PreferencesHelper::GetPreferences(path, errCode);
1288 EXPECT_NE(pref, nullptr);
1289 EXPECT_EQ(errCode, E_OK);
1290
1291 Object object("{\"key1\":\"value1\",\"key2\":222}");
1292 pref->Put(testKey, object);
1293 std::string flagFilePath = PreferencesUtils::MakeFilePath(path, PreferencesUtils::STR_OBJECT_FLAG);
1294 EXPECT_NE(Access(flagFilePath), 0);
1295
1296 PreferencesHelper::DeletePreferences(path);
1297 pref = nullptr;
1298 }
1299 } // namespace
1300