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 "logger.h"
25 #include "preferences_errno.h"
26 #include "preferences_helper.h"
27 #include "preferences_observer.h"
28
29 using namespace testing::ext;
30 using namespace OHOS::NativePreferences;
31
32 class PreferencesTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38
39 static std::shared_ptr<Preferences> pref;
40
41 static const std::string LONG_KEY;
42
43 static const std::string KEY_TEST_INT_ELEMENT;
44 static const std::string KEY_TEST_LONG_ELEMENT;
45 static const std::string KEY_TEST_FLOAT_ELEMENT;
46 static const std::string KEY_TEST_DOUBLE_ELEMENT;
47 static const std::string KEY_TEST_BOOL_ELEMENT;
48 static const std::string KEY_TEST_STRING_ELEMENT;
49 };
50
51 std::shared_ptr<Preferences> PreferencesTest::pref = nullptr;
52
53 const std::string PreferencesTest::LONG_KEY = std::string(Preferences::MAX_KEY_LENGTH, std::toupper('a'));
54 ;
55
56 const std::string PreferencesTest::KEY_TEST_INT_ELEMENT = "key_test_int";
57 const std::string PreferencesTest::KEY_TEST_LONG_ELEMENT = "key_test_long";
58 const std::string PreferencesTest::KEY_TEST_FLOAT_ELEMENT = "key_test_float";
59 const std::string PreferencesTest::KEY_TEST_DOUBLE_ELEMENT = "key_test_double";
60 const std::string PreferencesTest::KEY_TEST_BOOL_ELEMENT = "key_test_bool";
61 const std::string PreferencesTest::KEY_TEST_STRING_ELEMENT = "key_test_string";
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->Flush();
87 }
88 }
89
90 class PreferencesObserverCounter : public PreferencesObserver {
91 public:
92 virtual ~PreferencesObserverCounter();
93 void OnChange(Preferences &preferences, const std::string &key) override;
94
95 std::atomic_int notifyTimes;
96 static const std::vector<std::string> NOTIFY_KEYS_VECTOR;
97 };
98
~PreferencesObserverCounter()99 PreferencesObserverCounter::~PreferencesObserverCounter()
100 {
101 }
102
OnChange(Preferences & preferences,const std::string & key)103 void PreferencesObserverCounter::OnChange(Preferences &preferences, const std::string &key)
104 {
105 for (auto it = NOTIFY_KEYS_VECTOR.cbegin(); it != NOTIFY_KEYS_VECTOR.cend(); it++) {
106 if (key.compare(*it)) {
107 notifyTimes++;
108 break;
109 }
110 }
111 }
112
113 const std::vector<std::string> PreferencesObserverCounter::NOTIFY_KEYS_VECTOR = { PreferencesTest::KEY_TEST_INT_ELEMENT,
114 PreferencesTest::KEY_TEST_LONG_ELEMENT, PreferencesTest::KEY_TEST_FLOAT_ELEMENT,
115 PreferencesTest::KEY_TEST_BOOL_ELEMENT, PreferencesTest::KEY_TEST_STRING_ELEMENT };
116
117 /**
118 * @tc.name: NativePreferencesTest_001
119 * @tc.desc: normal testcase of FlushSync
120 * @tc.type: FUNC
121 * @tc.require: AR000CU2BN
122 * @tc.author: xiuhongju
123 */
124 HWTEST_F(PreferencesTest, NativePreferencesTest_001, TestSize.Level1)
125 {
126 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 2);
127 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
128 pref->FlushSync();
129
130 int ret1 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 6);
131 EXPECT_EQ(ret1, 2);
132 std::string ret2 = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test1");
133 EXPECT_EQ(ret2, "test");
134 }
135
136 /**
137 * @tc.name: NativePreferencesTest_002
138 * @tc.desc: normal testcase of HasKey
139 * @tc.type: FUNC
140 * @tc.require: AR000CU2BN
141 * @tc.author: xiuhongju
142 */
143 HWTEST_F(PreferencesTest, NativePreferencesTest_002, TestSize.Level1)
144 {
145 bool ret = pref->HasKey(LONG_KEY + 'x');
146 EXPECT_EQ(ret, false);
147
148 ret = pref->HasKey(std::string());
149 EXPECT_EQ(ret, false);
150
151 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
152 ret = pref->HasKey(KEY_TEST_STRING_ELEMENT);
153 EXPECT_EQ(ret, true);
154
155 pref->Flush();
156 ret = pref->HasKey(KEY_TEST_STRING_ELEMENT);
157 EXPECT_EQ(ret, true);
158 }
159
160 /**
161 * @tc.name: NativePreferencesTest_003
162 * @tc.desc: normal testcase of pref
163 * @tc.type: FUNC
164 * @tc.require: AR000CU2BN
165 * @tc.author: xiuhongju
166 */
167 HWTEST_F(PreferencesTest, NativePreferencesTest_003, TestSize.Level1)
168 {
169 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test1");
170
171 std::string ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
172 EXPECT_EQ(ret, "test1");
173
174 pref->Flush();
175 ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
176 EXPECT_EQ(ret, "test1");
177 }
178
179 /**
180 * @tc.name: NativePreferencesTest_004
181 * @tc.desc: normal testcase of GetBool
182 * @tc.type: FUNC
183 * @tc.require: AR000CU2BN
184 * @tc.author: xiuhongju
185 */
186 HWTEST_F(PreferencesTest, NativePreferencesTest_004, TestSize.Level1)
187 {
188 bool ret = pref->GetBool(PreferencesTest::LONG_KEY + 'x', true);
189 EXPECT_EQ(ret, true);
190
191 ret = pref->GetBool("", true);
192 EXPECT_EQ(ret, true);
193
194 pref->PutBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, false);
195 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "false");
196 pref->Flush();
197
198 ret = pref->GetBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, true);
199 EXPECT_EQ(ret, false);
200
201 ret = pref->GetBool(PreferencesTest::KEY_TEST_STRING_ELEMENT, true);
202 EXPECT_EQ(ret, true);
203 }
204
205 /**
206 * @tc.name: NativePreferencesTest_005
207 * @tc.desc: normal testcase of GetFloat
208 * @tc.type: FUNC
209 * @tc.require: AR000CU2BN
210 * @tc.author: xiuhongju
211 */
212 HWTEST_F(PreferencesTest, NativePreferencesTest_005, TestSize.Level1)
213 {
214 float ret = pref->GetFloat(PreferencesTest::LONG_KEY + 'x', 3.0f);
215 EXPECT_EQ(ret, 3.0f);
216
217 ret = pref->GetFloat("", 3.0f);
218 EXPECT_EQ(ret, 3.0f);
219
220 pref->PutFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 5.0f);
221 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "5.0");
222 pref->Flush();
223
224 ret = pref->GetFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, true);
225 EXPECT_EQ(ret, 5.0f);
226
227 ret = pref->GetFloat(PreferencesTest::KEY_TEST_STRING_ELEMENT, 3.0f);
228 EXPECT_EQ(ret, 3.0f);
229 }
230
231 /**
232 * @tc.name: NativePreferencesTest_006
233 * @tc.desc: normal testcase of GetInt
234 * @tc.type: FUNC
235 * @tc.require: AR000CU2BN
236 * @tc.author: xiuhongju
237 */
238 HWTEST_F(PreferencesTest, NativePreferencesTest_006, TestSize.Level1)
239 {
240 int ret = pref->GetInt(PreferencesTest::LONG_KEY + 'x', 35);
241 EXPECT_EQ(ret, 35);
242
243 ret = pref->GetInt("", 35);
244 EXPECT_EQ(ret, 35);
245
246 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 5);
247 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "5");
248 pref->Flush();
249
250 ret = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 3);
251 EXPECT_EQ(ret, 5);
252
253 ret = pref->GetInt(PreferencesTest::KEY_TEST_STRING_ELEMENT, 3);
254 EXPECT_EQ(ret, 3);
255 }
256
257 /**
258 * @tc.name: NativePreferencesTest_007
259 * @tc.desc: normal testcase of GetLong
260 * @tc.type: FUNC
261 * @tc.require: AR000CU2BN
262 * @tc.author: xiuhongju
263 */
264 HWTEST_F(PreferencesTest, NativePreferencesTest_007, TestSize.Level1)
265 {
266 int64_t ret = pref->GetLong(PreferencesTest::LONG_KEY + 'x', 35L);
267 EXPECT_EQ(ret, 35L);
268
269 ret = pref->GetLong("", 35L);
270 EXPECT_EQ(ret, 35L);
271
272 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 5);
273 pref->PutLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 5L);
274 pref->Flush();
275
276 ret = pref->GetLong(PreferencesTest::KEY_TEST_INT_ELEMENT, 3L);
277 EXPECT_EQ(ret, 3L);
278
279 ret = pref->GetLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 3L);
280 EXPECT_EQ(ret, 5L);
281 }
282
283 /**
284 * @tc.name: NativePreferencesTest_008
285 * @tc.desc: normal testcase of GetString
286 * @tc.type: FUNC
287 * @tc.require: AR000CU2BN
288 * @tc.author: xiuhongju
289 */
290 HWTEST_F(PreferencesTest, NativePreferencesTest_008, TestSize.Level1)
291 {
292 std::string ret = pref->GetString(PreferencesTest::LONG_KEY + 'x', "test");
293 EXPECT_EQ(ret, "test");
294
295 ret = pref->GetString("", "test");
296 EXPECT_EQ(ret, "test");
297
298 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 5);
299 pref->PutString(PreferencesTest::KEY_TEST_LONG_ELEMENT, "test");
300 pref->Flush();
301
302 ret = pref->GetString(PreferencesTest::KEY_TEST_INT_ELEMENT, "defaultvalue");
303 EXPECT_EQ(ret, "defaultvalue");
304
305 ret = pref->GetString(PreferencesTest::KEY_TEST_LONG_ELEMENT, "defaultvalue");
306 EXPECT_EQ(ret, "test");
307 }
308
309 /**
310 * @tc.name: NativePreferencesTest_009
311 * @tc.desc: normal testcase of GetDefValue
312 * @tc.type: FUNC
313 * @tc.require: AR000CU2BN
314 * @tc.author: xiuhongju
315 */
316 HWTEST_F(PreferencesTest, NativePreferencesTest_009, TestSize.Level1)
317 {
318 int ret0 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, -1);
319 EXPECT_EQ(ret0, -1);
320
321 float ret1 = pref->GetFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 1.0f);
322 EXPECT_EQ(ret1, 1.0f);
323
324 int64_t ret2 = pref->GetLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 10000L);
325 EXPECT_EQ(ret2, 10000L);
326
327 bool ret3 = pref->GetBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, true);
328 EXPECT_EQ(ret3, true);
329
330 std::string ret4 = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
331 EXPECT_EQ(ret4, "test");
332 }
333
334 /**
335 * @tc.name: NativePreferencesTest_010
336 * @tc.desc: normal testcase of PutBool
337 * @tc.type: FUNC
338 * @tc.require: AR000CU2BN
339 * @tc.author: xiuhongju
340 */
341 HWTEST_F(PreferencesTest, NativePreferencesTest_010, TestSize.Level1)
342 {
343 pref->PutBool(PreferencesTest::LONG_KEY + 'x', true);
344 pref->PutBool("", true);
345 pref->Flush();
346
347 bool ret = pref->GetBool(PreferencesTest::LONG_KEY + 'x', false);
348 EXPECT_EQ(ret, false);
349 ret = pref->GetBool("", false);
350 EXPECT_EQ(ret, false);
351
352 pref->PutBool(PreferencesTest::LONG_KEY, true);
353 pref->PutBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, true);
354 pref->Flush();
355
356 ret = pref->GetBool(PreferencesTest::LONG_KEY, false);
357 EXPECT_EQ(ret, true);
358 ret = pref->GetBool(PreferencesTest::KEY_TEST_BOOL_ELEMENT, false);
359 EXPECT_EQ(ret, true);
360 }
361
362 /**
363 * @tc.name: NativePreferencesTest_011
364 * @tc.desc: normal testcase of PutFloat
365 * @tc.type: FUNC
366 * @tc.require: AR000CU2BN
367 * @tc.author: xiuhongju
368 */
369 HWTEST_F(PreferencesTest, NativePreferencesTest_011, TestSize.Level1)
370 {
371 pref->PutFloat(PreferencesTest::LONG_KEY + 'x', 3.0f);
372 pref->PutFloat("", 3.0f);
373 pref->Flush();
374
375 float ret = pref->GetFloat(PreferencesTest::LONG_KEY + 'x', 1.0f);
376 EXPECT_EQ(ret, 1.0f);
377 ret = pref->GetFloat("", 1.0f);
378 EXPECT_EQ(ret, 1.0f);
379
380 pref->PutFloat(PreferencesTest::LONG_KEY, 3.0f);
381 pref->PutFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 3.0f);
382 pref->Flush();
383
384 ret = pref->GetFloat(PreferencesTest::LONG_KEY, 1.0f);
385 EXPECT_EQ(ret, 3.0f);
386 ret = pref->GetFloat(PreferencesTest::KEY_TEST_FLOAT_ELEMENT, 1.0f);
387 EXPECT_EQ(ret, 3.0f);
388 }
389
390 /**
391 * @tc.name: NativePreferencesTest_012
392 * @tc.desc: normal testcase of PutInt
393 * @tc.type: FUNC
394 * @tc.require: AR000CU2BN
395 * @tc.author: xiuhongju
396 */
397 HWTEST_F(PreferencesTest, NativePreferencesTest_012, TestSize.Level1)
398 {
399 pref->PutInt(PreferencesTest::LONG_KEY + 'x', 3);
400 pref->PutInt("", 3);
401 pref->Flush();
402
403 int ret = pref->GetInt(PreferencesTest::LONG_KEY + 'x', 1);
404 EXPECT_EQ(ret, 1);
405 ret = pref->GetInt("", 1);
406 EXPECT_EQ(ret, 1);
407
408 pref->PutInt(PreferencesTest::LONG_KEY, 3);
409 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 3);
410 pref->Flush();
411
412 ret = pref->GetInt(PreferencesTest::LONG_KEY, 1);
413 EXPECT_EQ(ret, 3);
414 ret = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 1);
415 EXPECT_EQ(ret, 3);
416 }
417
418 /**
419 * @tc.name: NativePreferencesTest_013
420 * @tc.desc: normal testcase of PutLong
421 * @tc.type: FUNC
422 * @tc.require: AR000CU2BN
423 * @tc.author: xiuhongju
424 */
425 HWTEST_F(PreferencesTest, NativePreferencesTest_013, TestSize.Level1)
426 {
427 pref->PutLong(PreferencesTest::LONG_KEY + 'x', 3L);
428 pref->PutLong("", 3L);
429 pref->Flush();
430
431 int64_t ret = pref->GetLong(PreferencesTest::LONG_KEY + 'x', 1L);
432 EXPECT_EQ(ret, 1L);
433 ret = pref->GetLong("", 1L);
434 EXPECT_EQ(ret, 1L);
435
436 pref->PutLong(PreferencesTest::LONG_KEY, 3L);
437 pref->PutLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 3L);
438 pref->Flush();
439
440 ret = pref->GetLong(PreferencesTest::LONG_KEY, 1L);
441 EXPECT_EQ(ret, 3L);
442 ret = pref->GetLong(PreferencesTest::KEY_TEST_LONG_ELEMENT, 1L);
443 EXPECT_EQ(ret, 3L);
444 }
445
446 /**
447 * @tc.name: NativePreferencesTest_014
448 * @tc.desc: normal testcase of PutString
449 * @tc.type: FUNC
450 * @tc.require: AR000CU2BN
451 * @tc.author: xiuhongju
452 */
453 HWTEST_F(PreferencesTest, NativePreferencesTest_014, TestSize.Level1)
454 {
455 pref->PutString(PreferencesTest::LONG_KEY + 'x', "test");
456 pref->PutString("", "test");
457 pref->Flush();
458
459 std::string ret = pref->GetString(PreferencesTest::LONG_KEY + 'x', "defaultValue");
460 EXPECT_EQ(ret, "defaultValue");
461 ret = pref->GetString("", "defaultValue");
462 EXPECT_EQ(ret, "defaultValue");
463
464 pref->PutString(PreferencesTest::LONG_KEY, "test");
465 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
466 pref->Flush();
467
468 ret = pref->GetString(PreferencesTest::LONG_KEY, "defaultValue");
469 EXPECT_EQ(ret, "test");
470 ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultValue");
471 EXPECT_EQ(ret, "test");
472 }
473
474 /**
475 * @tc.name: NativePreferencesTest_015
476 * @tc.desc: normal testcase of Delete
477 * @tc.type: FUNC
478 * @tc.require: AR000CU2BN
479 * @tc.author: xiuhongju
480 */
481 HWTEST_F(PreferencesTest, NativePreferencesTest_015, TestSize.Level1)
482 {
483 pref->PutString("test", "remove");
484 pref->Flush();
485
486 std::string ret = pref->GetString("test", "defaultValue");
487 EXPECT_EQ(ret, "remove");
488
489 pref->Delete("test");
490 pref->Flush();
491 ret = pref->GetString("test", "defaultValue");
492 EXPECT_EQ(ret, "defaultValue");
493 }
494
495 /**
496 * @tc.name: NativePreferencesTest_016
497 * @tc.desc: normal testcase of RegisterPreferencesObserver
498 * @tc.type: FUNC
499 * @tc.require: AR000CU2BN
500 * @tc.author: xiuhongju
501 */
502 HWTEST_F(PreferencesTest, NativePreferencesTest_016, TestSize.Level1)
503 {
504 std::shared_ptr<PreferencesObserver> counter =
505 std::shared_ptr<PreferencesObserver>(new PreferencesObserverCounter());
506 pref->RegisterObserver(counter);
507
508 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
509 pref->Flush();
510 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 1);
511
512 /* same value */
513 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 2);
514 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
515 pref->Flush();
516 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
517
518 pref->UnRegisterObserver(counter);
519 }
520
521 /**
522 * @tc.name: NativePreferencesTest_017
523 * @tc.desc: normal testcase of UnRegisterPreferencesObserver
524 * @tc.type: FUNC
525 * @tc.require: AR000CU2BN
526 * @tc.author: xiuhongju
527 */
528 HWTEST_F(PreferencesTest, NativePreferencesTest_017, TestSize.Level1)
529 {
530 std::shared_ptr<PreferencesObserver> counter =
531 std::shared_ptr<PreferencesObserver>(new PreferencesObserverCounter());
532 pref->RegisterObserver(counter);
533
534 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 2);
535 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
536 pref->Flush();
537 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
538
539 pref->UnRegisterObserver(counter);
540
541 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 6);
542 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test1");
543 pref->Flush();
544 EXPECT_EQ(static_cast<PreferencesObserverCounter *>(counter.get())->notifyTimes, 2);
545 }
546
547 /**
548 * @tc.name: NativePreferencesTest_018
549 * @tc.desc: normal testcase of Clear
550 * @tc.type: FUNC
551 * @tc.require: AR000CU2BN
552 * @tc.author: xiuhongju
553 */
554 HWTEST_F(PreferencesTest, NativePreferencesTest_018, TestSize.Level1)
555 {
556 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "test");
557 pref->PutInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 3);
558 pref->Flush();
559
560 pref->Clear();
561 std::string ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
562 EXPECT_EQ(ret, "defaultvalue");
563 int ret1 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 0);
564 EXPECT_EQ(ret1, 0);
565
566 pref->Flush();
567 ret = pref->GetString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "defaultvalue");
568 EXPECT_EQ(ret, "defaultvalue");
569 ret1 = pref->GetInt(PreferencesTest::KEY_TEST_INT_ELEMENT, 0);
570 EXPECT_EQ(ret1, 0);
571 }
572
573 /**
574 * @tc.name: NativePreferencesTest_019
575 * @tc.desc: normal testcase of GetDouble
576 * @tc.type: FUNC
577 * @tc.require: Na
578 * @tc.author: mang tsang
579 */
580 HWTEST_F(PreferencesTest, NativePreferencesTest_019, TestSize.Level1)
581 {
582 double ret = pref->GetDouble(PreferencesTest::LONG_KEY + 'x', 35.99999);
583 EXPECT_EQ(ret, 35.99999);
584
585 ret = pref->GetDouble("", 35.99999);
586 EXPECT_EQ(ret, 35.99999);
587
588 pref->PutDouble(PreferencesTest::KEY_TEST_DOUBLE_ELEMENT, (std::numeric_limits<double>::max)());
589 pref->PutString(PreferencesTest::KEY_TEST_STRING_ELEMENT, "5.99");
590 pref->Flush();
591
592 ret = pref->GetDouble(PreferencesTest::KEY_TEST_DOUBLE_ELEMENT, 3.99);
593 EXPECT_EQ(ret, (std::numeric_limits<double>::max)());
594
595 ret = pref->GetDouble(PreferencesTest::KEY_TEST_STRING_ELEMENT, 3.99);
596 EXPECT_EQ(ret, 3.99);
597 }
598