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 <iostream>
22 #include <string>
23
24 #include "log_print.h"
25 #include "preferences_errno.h"
26 #include "preferences_helper.h"
27 #include "preferences_observer.h"
28 #include "preferences_value.h"
29
30 using namespace testing::ext;
31 using namespace OHOS::NativePreferences;
32
33 namespace {
34 class PreferencesTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40
41 static std::shared_ptr<Preferences> pref;
42
43 static const std::string LONG_KEY;
44
45 static const std::string KEY_TEST_INT_ELEMENT;
46 static const std::string KEY_TEST_LONG_ELEMENT;
47 static const std::string KEY_TEST_FLOAT_ELEMENT;
48 static const std::string KEY_TEST_DOUBLE_ELEMENT;
49 static const std::string KEY_TEST_BOOL_ELEMENT;
50 static const std::string KEY_TEST_STRING_ELEMENT;
51 static const std::string KEY_TEST_STRING_ARRAY_ELEMENT;
52 static const std::string KEY_TEST_BOOL_ARRAY_ELEMENT;
53 static const std::string KEY_TEST_DOUBLE_ARRAY_ELEMENT;
54 };
55
56 std::shared_ptr<Preferences> PreferencesTest::pref = nullptr;
57
58 const std::string PreferencesTest::LONG_KEY = std::string(Preferences::MAX_KEY_LENGTH, std::toupper('a'));
59 ;
60
61 const std::string PreferencesTest::KEY_TEST_INT_ELEMENT = "key_test_int";
62 const std::string PreferencesTest::KEY_TEST_LONG_ELEMENT = "key_test_long";
63 const std::string PreferencesTest::KEY_TEST_FLOAT_ELEMENT = "key_test_float";
64 const std::string PreferencesTest::KEY_TEST_DOUBLE_ELEMENT = "key_test_double";
65 const std::string PreferencesTest::KEY_TEST_BOOL_ELEMENT = "key_test_bool";
66 const std::string PreferencesTest::KEY_TEST_STRING_ELEMENT = "key_test_string";
67 const std::string PreferencesTest::KEY_TEST_STRING_ARRAY_ELEMENT = "key_test_string_array";
68 const std::string PreferencesTest::KEY_TEST_BOOL_ARRAY_ELEMENT = "key_test_bool_array";
69 const std::string PreferencesTest::KEY_TEST_DOUBLE_ARRAY_ELEMENT = "key_test_double_array";
70
SetUpTestCase(void)71 void PreferencesTest::SetUpTestCase(void)
72 {
73 int errCode = E_OK;
74 pref = PreferencesHelper::GetPreferences("/data/test/test", errCode);
75 EXPECT_EQ(errCode, E_OK);
76 }
77
TearDownTestCase(void)78 void PreferencesTest::TearDownTestCase(void)
79 {
80 pref = nullptr;
81 int ret = PreferencesHelper::DeletePreferences("/data/test/test");
82 EXPECT_EQ(ret, E_OK);
83 }
84
SetUp(void)85 void PreferencesTest::SetUp(void)
86 {
87 }
88
TearDown(void)89 void PreferencesTest::TearDown(void)
90 {
91 /* clear all data after every case */
92 if (pref) {
93 pref->Clear();
94 pref->FlushSync();
95 }
96 }
97
98 class PreferencesObserverCounter : public PreferencesObserver {
99 public:
100 virtual ~PreferencesObserverCounter();
101 void OnChange(const std::string &key) override;
102
103 std::atomic_int notifyTimes;
104 static const std::vector<std::string> NOTIFY_KEYS_VECTOR;
105 };
106
~PreferencesObserverCounter()107 PreferencesObserverCounter::~PreferencesObserverCounter()
108 {
109 }
110
OnChange(const std::string & key)111 void PreferencesObserverCounter::OnChange(const std::string &key)
112 {
113 for (auto it = NOTIFY_KEYS_VECTOR.cbegin(); it != NOTIFY_KEYS_VECTOR.cend(); it++) {
114 if (key.compare(*it)) {
115 notifyTimes++;
116 break;
117 }
118 }
119 }
120
121 const std::vector<std::string> PreferencesObserverCounter::NOTIFY_KEYS_VECTOR = { PreferencesTest::KEY_TEST_INT_ELEMENT,
122 PreferencesTest::KEY_TEST_LONG_ELEMENT, PreferencesTest::KEY_TEST_FLOAT_ELEMENT,
123 PreferencesTest::KEY_TEST_BOOL_ELEMENT, PreferencesTest::KEY_TEST_STRING_ELEMENT };
124
125 /**
126 * @tc.name: NativePreferencesTest_001
127 * @tc.desc: normal testcase of FlushSync
128 * @tc.type: FUNC
129 * @tc.require: AR000CU2BN
130 * @tc.author: xiuhongju
131 */
132 HWTEST_F(PreferencesTest, NativePreferencesTest_001, TestSize.Level1)
133 {
134 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 2);
135 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
136 pref->FlushSync();
137
138 int ret1 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 6);
139 EXPECT_EQ(ret1, 2);
140 std::string ret2 = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test1");
141 EXPECT_EQ(ret2, "test");
142 }
143
144 /**
145 * @tc.name: NativePreferencesTest_002
146 * @tc.desc: normal testcase of HasKey
147 * @tc.type: FUNC
148 * @tc.require: AR000CU2BN
149 * @tc.author: xiuhongju
150 */
151 HWTEST_F(PreferencesTest, NativePreferencesTest_002, TestSize.Level1)
152 {
153 bool ret = pref->HasKey(LONG_KEY + 'x');
154 EXPECT_EQ(ret, false);
155
156 ret = pref->HasKey(std::string());
157 EXPECT_EQ(ret, false);
158
159 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
160 ret = pref->HasKey(KEY_TEST_STRING_ELEMENT);
161 EXPECT_EQ(ret, true);
162
163 pref->Flush();
164 ret = pref->HasKey(KEY_TEST_STRING_ELEMENT);
165 EXPECT_EQ(ret, true);
166 }
167
168 /**
169 * @tc.name: NativePreferencesTest_003
170 * @tc.desc: normal testcase of pref
171 * @tc.type: FUNC
172 * @tc.require: AR000CU2BN
173 * @tc.author: xiuhongju
174 */
175 HWTEST_F(PreferencesTest, NativePreferencesTest_003, TestSize.Level1)
176 {
177 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test1");
178
179 std::string ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
180 EXPECT_EQ(ret, "test1");
181
182 pref->Flush();
183 ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
184 EXPECT_EQ(ret, "test1");
185 }
186
187 /**
188 * @tc.name: NativePreferencesTest_004
189 * @tc.desc: normal testcase of GetBool
190 * @tc.type: FUNC
191 * @tc.require: AR000CU2BN
192 * @tc.author: xiuhongju
193 */
194 HWTEST_F(PreferencesTest, NativePreferencesTest_004, TestSize.Level1)
195 {
196 bool ret = pref->GetBool(PreferencesTest::LONG_KEY + 'x', true);
197 EXPECT_EQ(ret, true);
198
199 ret = pref->GetBool("", true);
200 EXPECT_EQ(ret, true);
201
202 pref->PutBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, false);
203 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "false");
204 pref->Flush();
205
206 ret = pref->GetBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, true);
207 EXPECT_EQ(ret, false);
208
209 ret = pref->GetBool(PreferencesTest::KEY_TEST_STRING_ELEMENT, true);
210 EXPECT_EQ(ret, true);
211 }
212
213 /**
214 * @tc.name: NativePreferencesTest_005
215 * @tc.desc: normal testcase of GetFloat
216 * @tc.type: FUNC
217 * @tc.require: AR000CU2BN
218 * @tc.author: xiuhongju
219 */
220 HWTEST_F(PreferencesTest, NativePreferencesTest_005, TestSize.Level1)
221 {
222 float ret = pref->GetFloat(PreferencesTest::LONG_KEY + 'x', 3.0f);
223 EXPECT_EQ(ret, 3.0f);
224
225 ret = pref->GetFloat("", 3.0f);
226 EXPECT_EQ(ret, 3.0f);
227
228 pref->PutFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 5.0f);
229 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "5.0");
230 pref->Flush();
231
232 ret = pref->GetFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, true);
233 EXPECT_EQ(ret, 5.0f);
234
235 ret = pref->GetFloat(PreferencesTest::KEY_TEST_STRING_ELEMENT, 3.0f);
236 EXPECT_EQ(ret, 3.0f);
237 }
238
239 /**
240 * @tc.name: NativePreferencesTest_006
241 * @tc.desc: normal testcase of GetInt
242 * @tc.type: FUNC
243 * @tc.require: AR000CU2BN
244 * @tc.author: xiuhongju
245 */
246 HWTEST_F(PreferencesTest, NativePreferencesTest_006, TestSize.Level1)
247 {
248 int ret = pref->GetInt(PreferencesTest::LONG_KEY + 'x', 35);
249 EXPECT_EQ(ret, 35);
250
251 ret = pref->GetInt("", 35);
252 EXPECT_EQ(ret, 35);
253
254 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 5);
255 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "5");
256 pref->Flush();
257
258 ret = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 3);
259 EXPECT_EQ(ret, 5);
260
261 ret = pref->GetInt(PreferencesTest::KEY_TEST_STRING_ELEMENT, 3);
262 EXPECT_EQ(ret, 3);
263 }
264
265 /**
266 * @tc.name: NativePreferencesTest_007
267 * @tc.desc: normal testcase of GetLong
268 * @tc.type: FUNC
269 * @tc.require: AR000CU2BN
270 * @tc.author: xiuhongju
271 */
272 HWTEST_F(PreferencesTest, NativePreferencesTest_007, TestSize.Level1)
273 {
274 int64_t ret = pref->GetLong(PreferencesTest::LONG_KEY + 'x', 35L);
275 EXPECT_EQ(ret, 35L);
276
277 ret = pref->GetLong("", 35L);
278 EXPECT_EQ(ret, 35L);
279
280 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 5);
281 pref->PutLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 5L);
282 pref->Flush();
283
284 ret = pref->GetLong(PreferencesTest::KEY_TEST_INT_ELEMENT, 3L);
285 EXPECT_EQ(ret, 3L);
286
287 ret = pref->GetLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 3L);
288 EXPECT_EQ(ret, 5L);
289 }
290
291 /**
292 * @tc.name: NativePreferencesTest_008
293 * @tc.desc: normal testcase of GetString
294 * @tc.type: FUNC
295 * @tc.require: AR000CU2BN
296 * @tc.author: xiuhongju
297 */
298 HWTEST_F(PreferencesTest, NativePreferencesTest_008, TestSize.Level1)
299 {
300 std::string ret = pref->GetString(PreferencesTest::LONG_KEY + 'x', "test");
301 EXPECT_EQ(ret, "test");
302
303 ret = pref->GetString("", "test");
304 EXPECT_EQ(ret, "test");
305
306 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 5);
307 pref->PutString(PreferencesTest::KEY_TEST_LONG_ELEMENT, "test");
308 pref->Flush();
309
310 ret = pref->GetString(PreferencesTest::KEY_TEST_INT_ELEMENT, "defaultvalue");
311 EXPECT_EQ(ret, "defaultvalue");
312
313 ret = pref->GetString(PreferencesTest::KEY_TEST_LONG_ELEMENT, "defaultvalue");
314 EXPECT_EQ(ret, "test");
315 }
316
317 /**
318 * @tc.name: NativePreferencesTest_009
319 * @tc.desc: normal testcase of GetDefValue
320 * @tc.type: FUNC
321 * @tc.require: AR000CU2BN
322 * @tc.author: xiuhongju
323 */
324 HWTEST_F(PreferencesTest, NativePreferencesTest_009, TestSize.Level1)
325 {
326 int ret0 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, -1);
327 EXPECT_EQ(ret0, -1);
328
329 float ret1 = pref->GetFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 1.0f);
330 EXPECT_EQ(ret1, 1.0f);
331
332 int64_t ret2 = pref->GetLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 10000L);
333 EXPECT_EQ(ret2, 10000L);
334
335 bool ret3 = pref->GetBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, true);
336 EXPECT_EQ(ret3, true);
337
338 std::string ret4 = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
339 EXPECT_EQ(ret4, "test");
340 }
341
342 /**
343 * @tc.name: NativePreferencesTest_010
344 * @tc.desc: normal testcase of PutBool
345 * @tc.type: FUNC
346 * @tc.require: AR000CU2BN
347 * @tc.author: xiuhongju
348 */
349 HWTEST_F(PreferencesTest, NativePreferencesTest_010, TestSize.Level1)
350 {
351 pref->PutBool(PreferencesTest::LONG_KEY + 'x', true);
352 pref->PutBool("", true);
353 pref->Flush();
354
355 bool ret = pref->GetBool(PreferencesTest::LONG_KEY + 'x', false);
356 EXPECT_EQ(ret, false);
357 ret = pref->GetBool("", false);
358 EXPECT_EQ(ret, false);
359
360 pref->PutBool(PreferencesTest::LONG_KEY, true);
361 pref->PutBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, true);
362 pref->Flush();
363
364 ret = pref->GetBool(PreferencesTest::LONG_KEY, false);
365 EXPECT_EQ(ret, true);
366 ret = pref->GetBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, false);
367 EXPECT_EQ(ret, true);
368 }
369
370 /**
371 * @tc.name: NativePreferencesTest_011
372 * @tc.desc: normal testcase of PutFloat
373 * @tc.type: FUNC
374 * @tc.require: AR000CU2BN
375 * @tc.author: xiuhongju
376 */
377 HWTEST_F(PreferencesTest, NativePreferencesTest_011, TestSize.Level1)
378 {
379 pref->PutFloat(PreferencesTest::LONG_KEY + 'x', 3.0f);
380 pref->PutFloat("", 3.0f);
381 pref->Flush();
382
383 float ret = pref->GetFloat(PreferencesTest::LONG_KEY + 'x', 1.0f);
384 EXPECT_EQ(ret, 1.0f);
385 ret = pref->GetFloat("", 1.0f);
386 EXPECT_EQ(ret, 1.0f);
387
388 pref->PutFloat(PreferencesTest::LONG_KEY, 3.0f);
389 pref->PutFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 3.0f);
390 pref->Flush();
391
392 ret = pref->GetFloat(PreferencesTest::LONG_KEY, 1.0f);
393 EXPECT_EQ(ret, 3.0f);
394 ret = pref->GetFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 1.0f);
395 EXPECT_EQ(ret, 3.0f);
396 }
397
398 /**
399 * @tc.name: NativePreferencesTest_012
400 * @tc.desc: normal testcase of PutInt
401 * @tc.type: FUNC
402 * @tc.require: AR000CU2BN
403 * @tc.author: xiuhongju
404 */
405 HWTEST_F(PreferencesTest, NativePreferencesTest_012, TestSize.Level1)
406 {
407 pref->PutInt(PreferencesTest::LONG_KEY + 'x', 3);
408 pref->PutInt("", 3);
409 pref->Flush();
410
411 int ret = pref->GetInt(PreferencesTest::LONG_KEY + 'x', 1);
412 EXPECT_EQ(ret, 1);
413 ret = pref->GetInt("", 1);
414 EXPECT_EQ(ret, 1);
415
416 pref->PutInt(PreferencesTest::LONG_KEY, 3);
417 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 3);
418 pref->Flush();
419
420 ret = pref->GetInt(PreferencesTest::LONG_KEY, 1);
421 EXPECT_EQ(ret, 3);
422 ret = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 1);
423 EXPECT_EQ(ret, 3);
424 }
425
426 /**
427 * @tc.name: NativePreferencesTest_013
428 * @tc.desc: normal testcase of PutLong
429 * @tc.type: FUNC
430 * @tc.require: AR000CU2BN
431 * @tc.author: xiuhongju
432 */
433 HWTEST_F(PreferencesTest, NativePreferencesTest_013, TestSize.Level1)
434 {
435 pref->PutLong(PreferencesTest::LONG_KEY + 'x', 3L);
436 pref->PutLong("", 3L);
437 pref->Flush();
438
439 int64_t ret = pref->GetLong(PreferencesTest::LONG_KEY + 'x', 1L);
440 EXPECT_EQ(ret, 1L);
441 ret = pref->GetLong("", 1L);
442 EXPECT_EQ(ret, 1L);
443
444 pref->PutLong(PreferencesTest::LONG_KEY, 3L);
445 pref->PutLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 3L);
446 pref->Flush();
447
448 ret = pref->GetLong(PreferencesTest::LONG_KEY, 1L);
449 EXPECT_EQ(ret, 3L);
450 ret = pref->GetLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 1L);
451 EXPECT_EQ(ret, 3L);
452 }
453
454 /**
455 * @tc.name: NativePreferencesTest_014
456 * @tc.desc: normal testcase of PutString
457 * @tc.type: FUNC
458 * @tc.require: AR000CU2BN
459 * @tc.author: xiuhongju
460 */
461 HWTEST_F(PreferencesTest, NativePreferencesTest_014, TestSize.Level1)
462 {
463 pref->PutString(PreferencesTest::LONG_KEY + 'x', "test");
464 pref->PutString("", "test");
465 pref->Flush();
466
467 std::string ret = pref->GetString(PreferencesTest::LONG_KEY + 'x', "defaultValue");
468 EXPECT_EQ(ret, "defaultValue");
469 ret = pref->GetString("", "defaultValue");
470 EXPECT_EQ(ret, "defaultValue");
471
472 pref->PutString(PreferencesTest::LONG_KEY, "test");
473 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
474 pref->Flush();
475
476 ret = pref->GetString(PreferencesTest::LONG_KEY, "defaultValue");
477 EXPECT_EQ(ret, "test");
478 ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultValue");
479 EXPECT_EQ(ret, "test");
480 }
481
482 /**
483 * @tc.name: NativePreferencesTest_015
484 * @tc.desc: normal testcase of Delete
485 * @tc.type: FUNC
486 * @tc.require: AR000CU2BN
487 * @tc.author: xiuhongju
488 */
489 HWTEST_F(PreferencesTest, NativePreferencesTest_015, TestSize.Level1)
490 {
491 pref->PutString("test", "remove");
492 pref->Flush();
493
494 std::string ret = pref->GetString("test", "defaultValue");
495 EXPECT_EQ(ret, "remove");
496
497 pref->Delete("test");
498 pref->Flush();
499 ret = pref->GetString("test", "defaultValue");
500 EXPECT_EQ(ret, "defaultValue");
501 }
502
503 /**
504 * @tc.name: NativePreferencesTest_016
505 * @tc.desc: normal testcase of RegisterPreferencesObserver
506 * @tc.type: FUNC
507 * @tc.require: AR000CU2BN
508 * @tc.author: xiuhongju
509 */
510 HWTEST_F(PreferencesTest, NativePreferencesTest_016, TestSize.Level1)
511 {
512 std::shared_ptr<PreferencesObserver> counter = std::make_shared<PreferencesObserverCounter>();
513 pref->RegisterObserver(counter);
514
515 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
516 pref->Flush();
517 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 1);
518
519 /* same value */
520 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 2);
521 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
522 pref->Flush();
523 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
524
525 pref->UnRegisterObserver(counter);
526 }
527
528 /**
529 * @tc.name: NativePreferencesTest_017
530 * @tc.desc: normal testcase of UnRegisterPreferencesObserver
531 * @tc.type: FUNC
532 * @tc.require: AR000CU2BN
533 * @tc.author: xiuhongju
534 */
535 HWTEST_F(PreferencesTest, NativePreferencesTest_017, TestSize.Level1)
536 {
537 std::shared_ptr<PreferencesObserver> counter = std::make_shared<PreferencesObserverCounter>();
538 pref->RegisterObserver(counter);
539
540 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 2);
541 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
542 pref->Flush();
543 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
544
545 pref->UnRegisterObserver(counter);
546
547 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 6);
548 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test1");
549 pref->Flush();
550 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
551 }
552
553 /**
554 * @tc.name: NativePreferencesTest_018
555 * @tc.desc: normal testcase of Clear
556 * @tc.type: FUNC
557 * @tc.require: AR000CU2BN
558 * @tc.author: xiuhongju
559 */
560 HWTEST_F(PreferencesTest, NativePreferencesTest_018, TestSize.Level1)
561 {
562 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
563 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 3);
564 pref->Flush();
565
566 pref->Clear();
567 std::string ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
568 EXPECT_EQ(ret, "defaultvalue");
569 int ret1 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 0);
570 EXPECT_EQ(ret1, 0);
571
572 pref->Flush();
573 ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
574 EXPECT_EQ(ret, "defaultvalue");
575 ret1 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 0);
576 EXPECT_EQ(ret1, 0);
577 }
578
579 /**
580 * @tc.name: NativePreferencesTest_019
581 * @tc.desc: normal testcase of GetDouble
582 * @tc.type: FUNC
583 * @tc.require: Na
584 * @tc.author: mang tsang
585 */
586 HWTEST_F(PreferencesTest, NativePreferencesTest_019, TestSize.Level1)
587 {
588 double ret = pref->GetDouble(PreferencesTest::LONG_KEY + 'x', 35.99999);
589 EXPECT_EQ(ret, 35.99999);
590
591 ret = pref->GetDouble("", 35.99999);
592 EXPECT_EQ(ret, 35.99999);
593
594 pref->PutDouble(PreferencesTest::KEY_TEST_DOUBLE_ELEMENT, (std::numeric_limits<double>::max)());
595 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "5.99");
596 pref->Flush();
597
598 ret = pref->GetDouble(PreferencesTest::KEY_TEST_DOUBLE_ELEMENT, 3.99);
599 EXPECT_EQ(ret, (std::numeric_limits<double>::max)());
600
601 ret = pref->GetDouble(PreferencesTest::KEY_TEST_STRING_ELEMENT, 3.99);
602 EXPECT_EQ(ret, 3.99);
603 }
604
605 /**
606 * @tc.name: NativePreferencesTest_020
607 * @tc.desc: normal testcase of GetDouble without defaultValue
608 * @tc.type: FUNC
609 * @tc.require: Na
610 * @tc.author: lijuntao
611 */
612 HWTEST_F(PreferencesTest, NativePreferencesTest_020, TestSize.Level1)
613 {
614 int errCode;
615 std::shared_ptr<Preferences> pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
616 pref1->PutDouble(PreferencesTest::KEY_TEST_DOUBLE_ELEMENT, (std::numeric_limits<double>::max)());
617 pref1->Flush();
618 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
619 pref1.reset();
620 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
621 double ret = pref1->GetDouble(PreferencesTest::KEY_TEST_DOUBLE_ELEMENT);
622 EXPECT_EQ(ret, (std::numeric_limits<double>::max)());
623 PreferencesHelper::DeletePreferences("/data/test/test1");
624 }
625
626 /**
627 * @tc.name: NativePreferencesTest_021
628 * @tc.desc: normal testcase of GetString without defaultValue
629 * @tc.type: FUNC
630 * @tc.require: Na
631 * @tc.author: lijuntao
632 */
633 HWTEST_F(PreferencesTest, NativePreferencesTest_021, TestSize.Level1)
634 {
635 int errCode;
636 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
637 pref1->PutString(PreferencesTest::LONG_KEY, "test");
638 pref1->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test1 test2");
639 pref1->Flush();
640
641 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
642 pref1.reset();
643 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
644
645 std::string ret = pref1->GetString(PreferencesTest::LONG_KEY);
646 EXPECT_EQ(ret, "test");
647 ret = pref1->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT);
648 EXPECT_EQ(ret, "test1 test2");
649 PreferencesHelper::DeletePreferences("/data/test/test1");
650 }
651
652 /**
653 * @tc.name: NativePreferencesTest_022
654 * @tc.desc: normal testcase of GetLong without defaultValue
655 * @tc.type: FUNC
656 * @tc.require: Na
657 * @tc.author: lijuntao
658 */
659 HWTEST_F(PreferencesTest, NativePreferencesTest_022, TestSize.Level1)
660 {
661 int errCode;
662 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
663 pref1->PutLong(PreferencesTest::LONG_KEY, 3L);
664 pref1->PutLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 3L);
665 pref1->Flush();
666
667 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
668 pref1.reset();
669 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
670
671 int64_t ret = pref1->GetLong(PreferencesTest::LONG_KEY);
672 EXPECT_EQ(ret, 3L);
673 ret = pref1->GetLong(PreferencesTest::KEY_TEST_LONG_ELEMENT);
674 EXPECT_EQ(ret, 3L);
675 PreferencesHelper::DeletePreferences("/data/test/test1");
676 }
677
678 /**
679 * @tc.name: NativePreferencesTest_023
680 * @tc.desc: normal testcase of GetInt without defaultValue
681 * @tc.type: FUNC
682 * @tc.require: Na
683 * @tc.author: lijuntao
684 */
685 HWTEST_F(PreferencesTest, NativePreferencesTest_023, TestSize.Level1)
686 {
687 int errCode;
688 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
689 pref1->PutInt(PreferencesTest::LONG_KEY, 3);
690 pref1->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 3);
691 pref1->Flush();
692
693 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
694 pref1.reset();
695 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
696
697 int32_t ret = pref1->GetInt(PreferencesTest::LONG_KEY);
698 EXPECT_EQ(ret, 3);
699 ret = pref1->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT);
700 EXPECT_EQ(ret, 3);
701 PreferencesHelper::DeletePreferences("/data/test/test1");
702 }
703
704 /**
705 * @tc.name: NativePreferencesTest_024
706 * @tc.desc: normal testcase of GetFloat without defaultValue
707 * @tc.type: FUNC
708 * @tc.require: Na
709 * @tc.author: lijuntao
710 */
711 HWTEST_F(PreferencesTest, NativePreferencesTest_024, TestSize.Level1)
712 {
713 int errCode;
714 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
715 pref1->PutFloat(PreferencesTest::LONG_KEY, 3.0f);
716 pref1->PutFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 3.0f);
717 pref1->Flush();
718
719 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
720 pref1.reset();
721 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
722
723 float ret = pref1->GetFloat(PreferencesTest::LONG_KEY);
724 EXPECT_EQ(ret, 3.0f);
725 ret = pref1->GetFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT);
726 EXPECT_EQ(ret, 3.0f);
727 PreferencesHelper::DeletePreferences("/data/test/test1");
728 }
729
730 /**
731 * @tc.name: NativePreferencesTest_025
732 * @tc.desc: normal testcase of GetBool without defaultValue
733 * @tc.type: FUNC
734 * @tc.require: Na
735 * @tc.author: lijuntao
736 */
737 HWTEST_F(PreferencesTest, NativePreferencesTest_025, TestSize.Level1)
738 {
739 int errCode;
740 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
741 pref1->PutBool(PreferencesTest::LONG_KEY, true);
742 pref1->PutBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, true);
743 pref1->Flush();
744
745 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
746 pref1.reset();
747 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
748
749 bool ret = pref1->GetBool(PreferencesTest::LONG_KEY);
750 EXPECT_EQ(ret, true);
751 ret = pref1->GetBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT);
752 EXPECT_EQ(ret, true);
753 PreferencesHelper::DeletePreferences("/data/test/test1");
754 }
755
756 /**
757 * @tc.name: NativePreferencesTest_026
758 * @tc.desc: normal testcase of GetArray
759 * @tc.type: FUNC
760 * @tc.require: Na
761 * @tc.author: lijuntao
762 */
763 HWTEST_F(PreferencesTest, NativePreferencesTest_026, TestSize.Level1)
764 {
765 int errCode;
766 auto pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
767 std::vector<std::string> stringArray = { "str1", "str2" };
768 std::vector<bool> boolArray = { false, true };
769 std::vector<double> doubleArray = { 0.1, 0.2 };
770 pref1->Put(PreferencesTest::KEY_TEST_STRING_ARRAY_ELEMENT, stringArray);
771 pref1->Put(PreferencesTest::KEY_TEST_BOOL_ARRAY_ELEMENT, boolArray);
772 pref1->Put(PreferencesTest::KEY_TEST_DOUBLE_ARRAY_ELEMENT, doubleArray);
773 pref1->FlushSync();
774
775 PreferencesHelper::RemovePreferencesFromCache("/data/test/test1");
776 pref1.reset();
777 pref1 = PreferencesHelper::GetPreferences("/data/test/test1", errCode);
778
779 PreferencesValue defValue(static_cast<int64_t>(0));
780 PreferencesValue stringArrayRes = pref1->Get(PreferencesTest::KEY_TEST_STRING_ARRAY_ELEMENT, defValue);
781 EXPECT_EQ(stringArrayRes.IsStringArray(), true);
782 EXPECT_EQ(static_cast<std::vector<std::string>>(stringArrayRes), stringArray);
783
784 PreferencesValue boolArrayRes = pref1->Get(PreferencesTest::KEY_TEST_BOOL_ARRAY_ELEMENT, defValue);
785 EXPECT_EQ(boolArrayRes.IsBoolArray(), true);
786 EXPECT_EQ(static_cast<std::vector<bool>>(boolArrayRes), boolArray);
787
788 PreferencesValue doubleArrayRes = pref1->Get(PreferencesTest::KEY_TEST_DOUBLE_ARRAY_ELEMENT, defValue);
789 EXPECT_EQ(doubleArrayRes.IsDoubleArray(), true);
790 EXPECT_EQ(static_cast<std::vector<double>>(doubleArrayRes), doubleArray);
791 PreferencesHelper::DeletePreferences("/data/test/test1");
792 }
793
794 /**
795 * @tc.name: OperatorTest_001
796 * @tc.desc: normal testcase of PreferencesValue Operator
797 * @tc.type: FUNC
798 * @tc.require: AR000CU2BN
799 * @tc.author: xiuhongju
800 */
801 HWTEST_F(PreferencesTest, PreferencesValueTest_001, TestSize.Level1)
802 {
803 int valueInt = 1;
804 int retInt = PreferencesValue(valueInt);
805 EXPECT_EQ(valueInt, retInt);
806
807 int64_t valueInt64 = 1;
808 int64_t retInt64 = PreferencesValue(valueInt64);
809 EXPECT_EQ(valueInt64, retInt64);
810
811 float valueFloat = 1.0;
812 float retFloat = PreferencesValue(valueFloat);
813 EXPECT_EQ(valueFloat, retFloat);
814
815 double valueDouble = 1.0;
816 double retDouble = PreferencesValue(valueDouble);
817 EXPECT_EQ(valueDouble, retDouble);
818
819 bool valueBool = true;
820 bool retBool = PreferencesValue(valueBool);
821 EXPECT_EQ(valueBool, retBool);
822
823 string valueString = "test";
824 string retString = PreferencesValue(valueString);
825 EXPECT_EQ(valueString, retString);
826
827 std::vector<bool> valueVectorBool(2, true);
828 std::vector<bool> retVectorBool = PreferencesValue(valueVectorBool);
829 EXPECT_EQ(valueVectorBool, retVectorBool);
830
831 std::vector<double> valueVectorDouble(2, 1.0);
832 std::vector<double> retVectorDouble = PreferencesValue(valueVectorDouble);
833 EXPECT_EQ(valueVectorDouble, retVectorDouble);
834
835 std::vector<string> valueVectorString(2, "test");
836 std::vector<string> retVectorString = PreferencesValue(valueVectorString);
837 EXPECT_EQ(valueVectorString, retVectorString);
838 }
839 }
840