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