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