1 /*
2 * Copyright (c) 2020-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 <stdio.h>
17 #include "gtest/gtest.h"
18 #include <securec.h>
19
20 #include "utils_config.h"
21 #include "kv_store.h"
22 #include "kvstore_env.h"
23
24 using namespace std;
25 using namespace testing::ext;
26
27 const int MAX_KEY_LEN_TEST = 32; // Key length specifications
28 const int MAX_VALUE_LEN_TEST = 128; // Value length specifications
29 const int MAX_KEY_NUM_TEST = 50; // Maximum number of keys
30 const int MAX_CACHE_NUM_TEST = 10; // Minimum number of cache
31 const int INVALID_PARAMETER = -9; // Invalid parameter.
32
33 class KvStoreTest : public testing::Test {
34 protected:
35 // SetUpTestCase：测试套预置动作，在第一个TestCase之前执行
SetUpTestCase(void)36 static void SetUpTestCase(void)
37 {
38 printf("----------test case with KvStoreTest start-------------\n");
39 int ret = mkdir("/storage/com.openharmony.kv", S_IRUSR | S_IWUSR);
40 printf("/storage/com.openharmony.kv ret = %d\n", ret);
41 ret = UtilsSetEnv("/storage/com.openharmony.kv");
42 EXPECT_EQ(ret, 0);
43 }
44 // TearDownTestCase：测试套清理动作，在最后一个TestCase之后执行
TearDownTestCase(void)45 static void TearDownTestCase(void)
46 {
47 int ret = rmdir("/storage/com.openharmony.kv/kvstore");
48 printf("/storage/com.openharmony.kv/kvstore ret = %d\n", ret);
49 ret = rmdir("/storage/com.openharmony.kv");
50 printf("/storage/com.openharmony.kv ret = %d\n", ret);
51 printf("----------test case with KvStoreTest end-------------\n");
52 }
53 // 用例的预置动作
SetUp()54 virtual void SetUp() {}
55 // 用例的清理动作
TearDown()56 virtual void TearDown() {}
57 bool TouchKVFiles (int num, const char* key, const char* value) const;
58 bool DeleteKVFiles (int num, const char* key) const;
59 bool ReadKVFiles (int num, const char* key, const char* value) const;
60 };
61
62 /* Create files in batches. */
TouchKVFiles(int num,const char * key,const char * value) const63 bool KvStoreTest::TouchKVFiles (int num, const char* key, const char* value) const
64 {
65 int size = 0;
66 int ret = 0;
67 char keytemp[MAX_KEY_LEN_TEST] = {0};
68 char valuetemp[MAX_VALUE_LEN_TEST] = {0};
69 char temp[MAX_VALUE_LEN_TEST] = {0};
70 if (num <= 0) {
71 return false;
72 }
73 for (int i = 1; i <= num; i++) {
74 size = sprintf_s(keytemp, MAX_KEY_LEN_TEST, "%s_%d", key, i);
75 if (size < 0) {
76 return false;
77 }
78 size = sprintf_s(valuetemp, MAX_VALUE_LEN_TEST, "%s_%d", value, i);
79 if (size < 0) {
80 return false;
81 }
82 ret = UtilsSetValue(keytemp, valuetemp);
83 if (i <= MAX_KEY_NUM_TEST) {
84 EXPECT_EQ(ret, 0);
85 } else {
86 EXPECT_EQ(ret, -1);
87 }
88 ret = UtilsGetValue(keytemp, temp, MAX_VALUE_LEN_TEST);
89 if (i <= MAX_KEY_NUM_TEST) {
90 EXPECT_EQ(ret, 0);
91 EXPECT_STREQ(valuetemp, temp);
92 } else {
93 EXPECT_EQ(ret, -1);
94 }
95 memset_s(keytemp, MAX_KEY_LEN_TEST, 0, MAX_KEY_LEN_TEST);
96 memset_s(temp, MAX_VALUE_LEN_TEST, 0, MAX_VALUE_LEN_TEST);
97 memset_s(valuetemp, MAX_VALUE_LEN_TEST, 0, MAX_VALUE_LEN_TEST);
98 }
99 return true;
100 }
101
102 /* Create files in batches. */
ReadKVFiles(int num,const char * key,const char * value) const103 bool KvStoreTest::ReadKVFiles (int num, const char* key, const char* value) const
104 {
105 int size = 0;
106 int ret = 0;
107 int i = 1;
108 char keytemp[MAX_KEY_LEN_TEST] = {0};
109 char valuetemp[MAX_VALUE_LEN_TEST] = {0};
110 char temp[MAX_VALUE_LEN_TEST] = {0};
111 if (num <= 0) {
112 return false;
113 }
114 for (; num > 0; num--) {
115 size = sprintf_s(keytemp, MAX_KEY_LEN_TEST, "%s_%d", key, num);
116 if (size < 0) {
117 return false;
118 }
119 size = sprintf_s(valuetemp, MAX_VALUE_LEN_TEST, "%s_%d", value, num);
120 if (size < 0) {
121 return false;
122 }
123 ret = UtilsGetValue(keytemp, temp, MAX_VALUE_LEN_TEST);
124 if (num <= MAX_KEY_NUM_TEST) {
125 if (i <= MAX_CACHE_NUM_TEST) {
126 EXPECT_EQ(ret, 0);
127 } else {
128 EXPECT_GT(ret, 0);
129 }
130 EXPECT_STREQ(valuetemp, temp);
131 i++;
132 } else {
133 EXPECT_EQ(ret, -1);
134 }
135 memset_s(keytemp, MAX_KEY_LEN_TEST, 0, MAX_KEY_LEN_TEST);
136 memset_s(temp, MAX_VALUE_LEN_TEST, 0, MAX_VALUE_LEN_TEST);
137 memset_s(valuetemp, MAX_VALUE_LEN_TEST, 0, MAX_VALUE_LEN_TEST);
138 }
139 return true;
140 }
141
142 /* Delete files in batches. */
DeleteKVFiles(int num,const char * key) const143 bool KvStoreTest::DeleteKVFiles (int num, const char* key) const
144 {
145 int size = 0;
146 int ret = 0;
147 char keytemp[MAX_KEY_LEN_TEST] = {0};
148
149 if (num <= 0) {
150 return false;
151 }
152 for (int i = 1; i <= num; i++) {
153 size = sprintf_s(keytemp, MAX_KEY_LEN_TEST, "%s_%d", key, i);
154 if (size < 0) {
155 return false;
156 }
157 ret = UtilsDeleteValue(keytemp);
158 if (i <= MAX_KEY_NUM_TEST) {
159 EXPECT_EQ(ret, 0);
160 } else {
161 EXPECT_EQ(ret, -1);
162 }
163 memset_s(keytemp, MAX_KEY_LEN_TEST, 0, MAX_KEY_LEN_TEST);
164 }
165 return true;
166 }
167
168 /**
169 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0100
170 * @tc.name : UtilsSetValue parameter legal test Lowercase alphanumeric, dot
171 * @tc.desc : [C- SOFTWARE -0200]
172 */
173 HWTEST_F(KvStoreTest, testUtilsSetValue001, Function | MediumTest | Level0)
174 {
175 char key[] = "rw.sys.version";
176 char value[] = "Hello world !";
177 int ret = UtilsSetValue(key, value);
178 EXPECT_EQ(ret, 0);
179
180 ret = UtilsDeleteValue(key);
181 EXPECT_EQ(ret, 0);
182 }
183
184 /**
185 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0200
186 * @tc.name : UtilsSetValue parameter legal test Lowercase alphanumeric, underscore, dot
187 * @tc.desc : [C- SOFTWARE -0200]
188 */
189 HWTEST_F(KvStoreTest, testUtilsSetValue002, Function | MediumTest | Level1)
190 {
191 char key[] = "rw.sys.version_100";
192 char value[] = "Hello world !";
193 int ret = UtilsSetValue(key, value);
194 EXPECT_EQ(ret, 0);
195
196 ret = UtilsDeleteValue(key);
197 EXPECT_EQ(ret, 0);
198 }
199
200 /**
201 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0300
202 * @tc.name : UtilsSetValue parameter legal test Lowercase alphanumeric
203 * @tc.desc : [C- SOFTWARE -0200]
204 */
205 HWTEST_F(KvStoreTest, testUtilsSetValue003, Function | MediumTest | Level1)
206 {
207 char key[] = "100";
208 char value[] = "Hello world !";
209 int ret = UtilsSetValue(key, value);
210 EXPECT_EQ(ret, 0);
211
212 ret = UtilsDeleteValue(key);
213 EXPECT_EQ(ret, 0);
214 }
215
216 /**
217 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0400
218 * @tc.name : UtilsSetValue parameter legal test key length is 31 Byte
219 * @tc.desc : [C- SOFTWARE -0200]
220 */
221 HWTEST_F(KvStoreTest, testUtilsSetValue004, Function | MediumTest | Level2)
222 {
223 char key[] = "rw.sys.version.utilskvparameter";
224 char value[] = "Hello world !";
225 int ret = UtilsSetValue(key, value);
226 EXPECT_EQ(ret, 0);
227
228 ret = UtilsDeleteValue(key);
229 EXPECT_EQ(ret, 0);
230 }
231
232 /**
233 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0500
234 * @tc.name : UtilsSetValue parameter Illegal test key length is 32 Byte
235 * @tc.desc : [C- SOFTWARE -0200]
236 */
237 HWTEST_F(KvStoreTest, testUtilsSetValue005, Function | MediumTest | Level2)
238 {
239 char key[] = "rw.sys.version.utilskvparameter1";
240 char value[] = "Hello world !";
241 int ret = UtilsSetValue(key, value);
242 EXPECT_EQ(ret, INVALID_PARAMETER);
243 }
244
245 /**
246 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0600
247 * @tc.name : UtilsSetValue parameter Illegal test key length is 33 Byte
248 * @tc.desc : [C- SOFTWARE -0200]
249 */
250 HWTEST_F(KvStoreTest, testUtilsSetValue006, Function | MediumTest | Level2)
251 {
252 char key[] = "rw.sys.version.utilskvparameter12";
253 char value[] = "Hello world !";
254 int ret = UtilsSetValue(key, value);
255 EXPECT_EQ(ret, INVALID_PARAMETER);
256 }
257
258 /**
259 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0700
260 * @tc.name : UtilsSetValue parameter Illegal test key length is 41 Byte
261 * @tc.desc : [C- SOFTWARE -0200]
262 */
263 HWTEST_F(KvStoreTest, testUtilsSetValue007, Function | MediumTest | Level2)
264 {
265 char key[] = "rw.sys.version.utilskvparameterforillegal";
266 char value[] = "Hello world !";
267 int ret = UtilsSetValue(key, value);
268 EXPECT_EQ(ret, INVALID_PARAMETER);
269 }
270
271 /**
272 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0800
273 * @tc.name : UtilsSetValue parameter Illegal test key is an invalid character
274 * @tc.desc : [C- SOFTWARE -0200]
275 */
276 HWTEST_F(KvStoreTest, testUtilsSetValue008, Function | MediumTest | Level2)
277 {
278 char key[] = "Rw.sys.version";
279 char value[] = "Hello world !";
280 int ret = UtilsSetValue(key, value);
281 EXPECT_EQ(ret, INVALID_PARAMETER);
282 }
283
284 /**
285 * @tc.number : SUB_UTILS_KV_STORE_POSIX_0900
286 * @tc.name : UtilsSetValue parameter Illegal test key is an invalid character with minus
287 * @tc.desc : [C- SOFTWARE -0200]
288 */
289 HWTEST_F(KvStoreTest, testUtilsSetValue009, Function | MediumTest | Level2)
290 {
291 char key[] = "rw.sys.version-r3";
292 char value[] = "Hello world !";
293 int ret = UtilsSetValue(key, value);
294 EXPECT_EQ(ret, INVALID_PARAMETER);
295 }
296
297 /**
298 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1000
299 * @tc.name : UtilsSetValue parameter Illegal test key is an invalid character with plus
300 * @tc.desc : [C- SOFTWARE -0200]
301 */
302 HWTEST_F(KvStoreTest, testUtilsSetValue010, Function | MediumTest | Level2)
303 {
304 char key[] = "RE+R3";
305 char value[] = "Hello world !";
306 int ret = UtilsSetValue(key, value);
307 EXPECT_EQ(ret, INVALID_PARAMETER);
308 }
309
310 /**
311 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1100
312 * @tc.name : UtilsSetValue parameter Illegal test key is an invalid character with multiplication
313 * @tc.desc : [C- SOFTWARE -0200]
314 */
315 HWTEST_F(KvStoreTest, testUtilsSetValue0011, Function | MediumTest | Level2)
316 {
317 char key[] = "rw.sys.version*r3";
318 char value[] = "Hello world !";
319 int ret = UtilsSetValue(key, value);
320 EXPECT_EQ(ret, INVALID_PARAMETER);
321 }
322
323 /**
324 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1200
325 * @tc.name : UtilsSetValue parameter legal test Value is equal to 121 characters
326 * @tc.desc : [C- SOFTWARE -0200]
327 */
328 HWTEST_F(KvStoreTest, testUtilsSetValue012, Function | MediumTest | Level0)
329 {
330 char key[] = "rw.sys.version";
331 char value[] = "Two tigers Two tigers two tiger running so fast \
332 running so fast one has no ears one has no tail How strange How strange ";
333 int ret = UtilsSetValue(key, value);
334 EXPECT_EQ(ret, 0);
335
336 ret = UtilsDeleteValue(key);
337 EXPECT_EQ(ret, 0);
338 }
339
340 /**
341 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1300
342 * @tc.name : UtilsSetValue parameter legal test Value is equal to 126 characters
343 * @tc.desc : [C- SOFTWARE -0200]
344 */
345 HWTEST_F(KvStoreTest, testUtilsSetValue013, Function | MediumTest | Level1)
346 {
347 char key[] = "rw.sys.version";
348 char value[] = "Two tigers Two tigers two tiger running so fast \
349 running so fast one has no ears one has no tail How strange Howstrangesleeping";
350 int ret = UtilsSetValue(key, value);
351 EXPECT_EQ(ret, 0);
352
353 ret = UtilsDeleteValue(key);
354 EXPECT_EQ(ret, 0);
355 }
356
357 /**
358 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1400
359 * @tc.name : UtilsSetValue parameter legal test Value is equal to 127 characters
360 * @tc.desc : [C- SOFTWARE -0200]
361 */
362 HWTEST_F(KvStoreTest, testUtilsSetValue014, Function | MediumTest | Level1)
363 {
364 char key[] = "rw.sys.version";
365 char value[] = "Two tigers Two tigers two tiger running so fast \
366 running so fast one has no ears one has no tail How strange How strangesleeping";
367 int ret = UtilsSetValue(key, value);
368 EXPECT_EQ(ret, 0);
369
370 ret = UtilsDeleteValue(key);
371 EXPECT_EQ(ret, 0);
372 }
373
374 /**
375 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1500
376 * @tc.name : UtilsSetValue parameter Illegal test Value is equal to 128 characters
377 * @tc.desc : [C- SOFTWARE -0200]
378 */
379 HWTEST_F(KvStoreTest, testUtilsSetValue015, Function | MediumTest | Level1)
380 {
381 char key[] = "rw.sys.version";
382 char value[] = "Two tigers Two tigers two tiger running so fast \
383 running so fast one has no ears one has no tail How strange How strange sleeping";
384 int ret = UtilsSetValue(key, value);
385 EXPECT_EQ(ret, INVALID_PARAMETER);
386 }
387
388 /**
389 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1600
390 * @tc.name : UtilsSetValue parameter Illegal test Value greater than 128 characters
391 * @tc.desc : [C- SOFTWARE -0200]
392 */
393 HWTEST_F(KvStoreTest, testUtilsSetValue016, Function | MediumTest | Level2)
394 {
395 char key[] = "rw.sys.version";
396 char value[] = "Two tigers Two tigers two tiger running so fast \
397 running so fast one has no ears one has no tail How strange How strange Are you sleeping";
398 int ret = UtilsSetValue(key, value);
399 EXPECT_EQ(ret, INVALID_PARAMETER);
400 }
401
402 /**
403 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1700
404 * @tc.name : Value greater than 128 characters and key is an invalid character
405 * @tc.desc : [C- SOFTWARE -0200]
406 */
407 HWTEST_F(KvStoreTest, testUtilsSetValue017, Function | MediumTest | Level2)
408 {
409 char key[] = "Rw.sys.version";
410 char value[] = "Two tigers Two tigers two tiger running so fast \
411 running so fast one has no ears one has no tail How strange How strange Are you sleeping";
412 int ret = UtilsSetValue(key, value);
413 EXPECT_EQ(ret, INVALID_PARAMETER);
414 }
415
416 /**
417 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1800
418 * @tc.name : Use the interface UtilsGetValue to get the kv value cache with key is alpha and dot
419 * @tc.desc : [C- SOFTWARE -0200]
420 */
421 HWTEST_F(KvStoreTest, testUtilsGetValue001, Function | MediumTest | Level0)
422 {
423 char key[] = "rw.sys.version";
424 char value[] = "It is never too old to learn";
425 char temp[MAX_VALUE_LEN_TEST] = {0};
426 int ret = UtilsSetValue(key, value);
427 EXPECT_EQ(ret, 0);
428
429 ret = UtilsGetValue(key, temp, MAX_VALUE_LEN_TEST);
430 EXPECT_EQ(ret, 0);
431 EXPECT_STREQ(value, temp);
432 ret = UtilsDeleteValue(key);
433 EXPECT_EQ(ret, 0);
434 }
435
436 /**
437 * @tc.number : SUB_UTILS_KV_STORE_POSIX_1900
438 * @tc.name : Use the interface UtilsGetValue to get the kv value cache with key is digit
439 * @tc.desc : [C- SOFTWARE -0200]
440 */
441 HWTEST_F(KvStoreTest, testUtilsGetValue002, Function | MediumTest | Level1)
442 {
443 char key[] = "100";
444 char value[] = "！@#￥%……&*（）——+~《》？，。、“‘；：、12345767890";
445 char temp[MAX_VALUE_LEN_TEST] = {0};
446 int ret = UtilsSetValue(key, value);
447 EXPECT_EQ(ret, 0);
448
449 ret = UtilsGetValue(key, temp, MAX_VALUE_LEN_TEST);
450 EXPECT_EQ(ret, 0);
451 EXPECT_STREQ(value, temp);
452 ret = UtilsDeleteValue(key);
453 EXPECT_EQ(ret, 0);
454 }
455
456 /**
457 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2000
458 * @tc.name : Use the interface UtilsGetValue to get the kv value cache with key is dot and alpha
459 * @tc.desc : [C- SOFTWARE -0200]
460 */
461 HWTEST_F(KvStoreTest, testUtilsGetValue003, Function | MediumTest | Level1)
462 {
463 char key[] = "rw.sys.version";
464 char temp[MAX_VALUE_LEN_TEST] = {0};
465 // Update the value of key
466 char value1[] = "Two tigers,Two tigers,two tiger,running so fast";
467 int ret = UtilsSetValue(key, value1);
468 EXPECT_EQ(ret, 0);
469
470 ret = UtilsGetValue(key, temp, MAX_VALUE_LEN_TEST);
471 EXPECT_EQ(ret, 0);
472 EXPECT_STREQ(value1, temp);
473 ret = UtilsDeleteValue(key);
474 EXPECT_EQ(ret, 0);
475 }
476
477 #ifdef FEATURE_KV_CACHE
478 /**
479 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2100
480 * @tc.name : Use the interface ClearKVCache to clear cache with key is alpha and dot
481 * @tc.desc : [C- SOFTWARE -0200]
482 */
483 HWTEST_F(KvStoreTest, testClearKVCache001, Function | MediumTest | Level0)
484 {
485 char key[] = "rw.sys.version";
486 char value[] = "It is never too old to learn";
487 char temp[MAX_VALUE_LEN_TEST] = {0};
488 int ret = UtilsSetValue(key, value);
489 EXPECT_EQ(ret, 0);
490 // Get the value of key
491 ret = UtilsGetValue(key, temp, MAX_VALUE_LEN_TEST);
492 EXPECT_EQ(ret, 0);
493 EXPECT_STREQ(value, temp);
494 // Clear cache
495 ret = ClearKVCache();
496 EXPECT_EQ(ret, 0);
497 // Get the value of key
498 memset_s(temp, MAX_VALUE_LEN_TEST, 0, MAX_VALUE_LEN_TEST);
499 ret = UtilsGetValue(key, temp, MAX_VALUE_LEN_TEST);
500 EXPECT_GT(ret, 0);
501 EXPECT_STREQ(value, temp);
502 // Clear key
503 ret = UtilsDeleteValue(key);
504 EXPECT_EQ(ret, 0);
505 }
506
507 /**
508 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2200
509 * @tc.name : Use the interface ClearKVCache to clear cache with key is dot and alpha
510 * @tc.desc : [C- SOFTWARE -0200]
511 */
512 HWTEST_F(KvStoreTest, testClearKVCache002, Function | MediumTest | Level1)
513 {
514 char key[] = "rw.sys.version";
515 char temp[MAX_VALUE_LEN_TEST] = {0};
516 // Update the value of key
517 char value1[] = "Two tigers,Two tigers,two tiger,running so fast";
518 int ret = UtilsSetValue(key, value1);
519 EXPECT_EQ(ret, 0);
520 // Get the value of key
521 ret = UtilsGetValue(key, temp, MAX_VALUE_LEN_TEST);
522 EXPECT_EQ(ret, 0);
523 EXPECT_STREQ(value1, temp);
524 // Clear cache
525 ret = ClearKVCache();
526 EXPECT_EQ(ret, 0);
527 // Get the value of key
528 memset_s(temp, MAX_VALUE_LEN_TEST, 0, MAX_VALUE_LEN_TEST);
529 ret = UtilsGetValue(key, temp, MAX_VALUE_LEN_TEST);
530 EXPECT_GT(ret, 0);
531 EXPECT_STREQ(value1, temp);
532 // Clear key
533 ret = UtilsDeleteValue(key);
534 EXPECT_EQ(ret, 0);
535 }
536 #endif
537
538 /**
539 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2300
540 * @tc.name : Specification test with cache num is less than max
541 * @tc.desc : [C- SOFTWARE -0200]
542 */
543 HWTEST_F(KvStoreTest, testKVCacheCacheSize001, Function | MediumTest | Level1)
544 {
545 char key[] = "rw.sys.version";
546 char value[] = "It is never too old to learn";
547 bool ret = false;
548
549 ret = TouchKVFiles(MAX_CACHE_NUM_TEST-1, key, value);
550 if (ret == true)
551 {
552 SUCCEED();
553 }else
554 {
555 ADD_FAILURE();
556 }
557 ret = ReadKVFiles(MAX_CACHE_NUM_TEST-1, key, value);
558 if (ret == true)
559 {
560 SUCCEED();
561 }else
562 {
563 ADD_FAILURE();
564 }
565 ret = DeleteKVFiles(MAX_CACHE_NUM_TEST-1, key);
566 if (ret == true)
567 {
568 SUCCEED();
569 }else
570 {
571 ADD_FAILURE();
572 }
573 }
574
575 /**
576 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2400
577 * @tc.name : Specification test with cache num is equal to max
578 * @tc.desc : [C- SOFTWARE -0200]
579 */
580 HWTEST_F(KvStoreTest, testKVCacheCacheSize002, Function | MediumTest | Level1)
581 {
582 char key[] = "rw.sys.version";
583 char value[] = "It is never too old to learn";
584 bool ret = false;
585
586 ret = TouchKVFiles(MAX_CACHE_NUM_TEST, key, value);
587 if (ret == true)
588 {
589 SUCCEED();
590 }else
591 {
592 ADD_FAILURE();
593 }
594 ret = ReadKVFiles(MAX_CACHE_NUM_TEST, key, value);
595 if (ret == true)
596 {
597 SUCCEED();
598 }else
599 {
600 ADD_FAILURE();
601 }
602 ret = DeleteKVFiles(MAX_CACHE_NUM_TEST, key);
603 if (ret == true)
604 {
605 SUCCEED();
606 }else
607 {
608 ADD_FAILURE();
609 }
610 }
611
612 /**
613 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2500
614 * @tc.name : Specification test with cache num is greater than max
615 * @tc.desc : [C- SOFTWARE -0200]
616 */
617 HWTEST_F(KvStoreTest, testKVCacheCacheSize003, Function | MediumTest | Level1)
618 {
619 char key[] = "rw.sys.version";
620 char value[] = "It is never too old to learn";
621 bool ret = false;
622
623 ret = TouchKVFiles(MAX_CACHE_NUM_TEST+1, key, value);
624 if (ret == true)
625 {
626 SUCCEED();
627 }else
628 {
629 ADD_FAILURE();
630 }
631 ret = ReadKVFiles(MAX_CACHE_NUM_TEST+1, key, value);
632 if (ret == true)
633 {
634 SUCCEED();
635 }else
636 {
637 ADD_FAILURE();
638 }
639 ret = DeleteKVFiles(MAX_CACHE_NUM_TEST+1, key);
640 if (ret == true)
641 {
642 SUCCEED();
643 }else
644 {
645 ADD_FAILURE();
646 }
647 }
648
649 /**
650 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2600
651 * @tc.name : Specification test with key num is less than max
652 * @tc.desc : [C- SOFTWARE -0200]
653 */
654 HWTEST_F(KvStoreTest, testKVStoreSize001, Function | MediumTest | Level1)
655 {
656 char key[] = "rw.sys.version";
657 char value[] = "It is never too old to learn";
658 bool ret = false;
659
660 ret = TouchKVFiles(MAX_KEY_NUM_TEST-1, key, value);
661 if (ret == true)
662 {
663 SUCCEED();
664 }else
665 {
666 ADD_FAILURE();
667 }
668 ret = ReadKVFiles(MAX_KEY_NUM_TEST-1, key, value);
669 if (ret == true)
670 {
671 SUCCEED();
672 }else
673 {
674 ADD_FAILURE();
675 }
676 ret = DeleteKVFiles(MAX_KEY_NUM_TEST-1, key);
677 if (ret == true)
678 {
679 SUCCEED();
680 }else
681 {
682 ADD_FAILURE();
683 }
684 }
685
686 /**
687 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2700
688 * @tc.name : Specification test with key num is equal to max
689 * @tc.desc : [C- SOFTWARE -0200]
690 */
691 HWTEST_F(KvStoreTest, testKVStoreSize002, Function | MediumTest | Level1)
692 {
693 char key[] = "rw.sys.version";
694 char value[] = "It is never too old to learn";
695 bool ret = false;
696
697 ret = TouchKVFiles(MAX_KEY_NUM_TEST, key, value);
698 if (ret == true)
699 {
700 SUCCEED();
701 }else
702 {
703 ADD_FAILURE();
704 }
705 ret = ReadKVFiles(MAX_KEY_NUM_TEST, key, value);
706 if (ret == true)
707 {
708 SUCCEED();
709 }else
710 {
711 ADD_FAILURE();
712 }
713 ret = DeleteKVFiles(MAX_KEY_NUM_TEST, key);
714 if (ret == true)
715 {
716 SUCCEED();
717 }else
718 {
719 ADD_FAILURE();
720 }
721 }
722
723 /**
724 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2800
725 * @tc.name : Specification test with key num is greater than max
726 * @tc.desc : [C- SOFTWARE -0200]
727 */
728 HWTEST_F(KvStoreTest, testKVStoreSize003, Function | MediumTest | Level1)
729 {
730 char key[] = "rw.sys.version";
731 char value[] = "It is never too old to learn";
732 bool ret = false;
733
734 ret = TouchKVFiles(MAX_KEY_NUM_TEST+1, key, value);
735 if (ret == true)
736 {
737 SUCCEED();
738 }else
739 {
740 ADD_FAILURE();
741 }
742 ret = ReadKVFiles(MAX_KEY_NUM_TEST+1, key, value);
743 if (ret == true)
744 {
745 SUCCEED();
746 }else
747 {
748 ADD_FAILURE();
749 }
750 ret = DeleteKVFiles(MAX_KEY_NUM_TEST+1, key);
751 if (ret == true)
752 {
753 SUCCEED();
754 }else
755 {
756 ADD_FAILURE();
757 }
758 }
759
760 /**
761 * @tc.number : SUB_UTILS_KV_STORE_POSIX_2900
762 * @tc.name : Specification test with value num is equal to max
763 * @tc.desc : [C- SOFTWARE -0200]
764 */
765 HWTEST_F(KvStoreTest, testKVStoreSize004, Function | MediumTest | Level1)
766 {
767 char key[] = "rw.sys.version";
768 char value[] = "It is never too old to learn";
769 bool ret = false;
770
771 ret = TouchKVFiles(MAX_VALUE_LEN_TEST, key, value);
772 if (ret == true)
773 {
774 SUCCEED();
775 }else
776 {
777 ADD_FAILURE();
778 }
779 ret = ReadKVFiles(MAX_VALUE_LEN_TEST, key, value);
780 if (ret == true)
781 {
782 SUCCEED();
783 }else
784 {
785 ADD_FAILURE();
786 }
787 ret = DeleteKVFiles(MAX_VALUE_LEN_TEST, key);
788 if (ret == true)
789 {
790 SUCCEED();
791 }else
792 {
793 ADD_FAILURE();
794 }
795 }
796
797