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