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 <securec.h>
17 #include "hctest.h"
18
19 #include "dbm_errno.h"
20 #include "dbm_kv_store.h"
21 #include "dbm_config.h"
22
23 #define MAX_KEY_LEN_TEST 32
24 #define MAX_VALUE_LEN_TEST 512
25 #define MAX_KEY_NUM_TEST 45
26 #define INVALID_KEY_NUM 55
27
28 #define STORE_FULL_PATH ""
29 static KVStoreHandle g_KVStoreHandle = NULL;
30
31 /**
32 * @tc.desc : register a test suite, this suite is used to test basic flow and interface dependency
33 * @param : subsystem name is utils
34 * @param : module name is kvStore
35 * @param : test suit name is DBMKvStoreFuncTestSuite
36 */
37 LITE_TEST_SUIT(utils, kvStore, DBMKvStoreFuncTestSuite);
38
39 /**
40 * @tc.setup : setup for all testcases
41 * @return : setup result, TRUE is success, FALSE is fail
42 */
DBMKvStoreFuncTestSuiteSetUp(void)43 static BOOL DBMKvStoreFuncTestSuiteSetUp(void)
44 {
45 printf("+-begin----------------------------------------+\n");
46 int status = DBM_GetKVStore(STORE_FULL_PATH, &g_KVStoreHandle);
47 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
48
49 status = DBM_CloseKVStore(g_KVStoreHandle);
50 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
51
52 status = DBM_DeleteKVStore(STORE_FULL_PATH);
53 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
54
55 int tickCount1 = osKernelGetTickCount();
56 status = DBM_GetKVStore(STORE_FULL_PATH, &g_KVStoreHandle);
57 int tickCount2 = osKernelGetTickCount();
58 printf("GetKVStore: begin[%d] finish[%d] use[%d]\n", tickCount1, tickCount2, tickCount2 - tickCount1);
59 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
60
61 return TRUE;
62 }
63
64 /**
65 * @tc.teardown : teardown for all testcases
66 * @return : teardown result, TRUE is success, FALSE is fail
67 */
DBMKvStoreFuncTestSuiteTearDown(void)68 static BOOL DBMKvStoreFuncTestSuiteTearDown(void)
69 {
70 printf("+-finish--------------------------------------+\n");
71
72 int tickCount1 = osKernelGetTickCount();
73 int status = DBM_CloseKVStore(g_KVStoreHandle);
74 int tickCount2 = osKernelGetTickCount();
75 printf("CloseKVStore: begin[%d] finish[%d] use[%d]\n", tickCount1, tickCount2, tickCount2 - tickCount1);
76 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
77
78 tickCount1 = osKernelGetTickCount();
79 status = DBM_DeleteKVStore(STORE_FULL_PATH);
80 tickCount2 = osKernelGetTickCount();
81 printf("DeleteKVStore: begin[%d] finish[%d] use[%d]\n", tickCount1, tickCount2, tickCount2 - tickCount1);
82
83 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
84 return TRUE;
85 }
86
87 /* Create files in batches. */
PutKVs(int num,const char * key,const char * content)88 static BOOL PutKVs(int num, const char* key, const char* content)
89 {
90 int size;
91 int status;
92 char keytemp[MAX_KEY_LEN_TEST] = {0};
93 struct {
94 int num;
95 char content[200];
96 } value, value1;
97
98 if (num <= 0) {
99 return FALSE;
100 }
101 for (int i = 1; i <= num; i++) {
102 size = sprintf_s(keytemp, MAX_KEY_LEN_TEST, "%s_%d", key, i);
103 if (size < 0) {
104 return FALSE;
105 }
106
107 memset_s(&value, sizeof(value), 0, sizeof(value));
108 value.num = i;
109
110 int ret = strcpy_s(value.content, sizeof(value.content), content);
111 TEST_ASSERT_EQUAL_INT(0, ret);
112
113 status = DBM_Put(g_KVStoreHandle, keytemp, (void*)&value, sizeof(value));
114 if (i <= MAX_KEY_NUM_TEST) {
115 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
116 } else {
117 TEST_ASSERT_EQUAL_INT(DBM_OVER_MAX_LIMITS, status);
118 }
119
120 memset_s(&value1, sizeof(value1), 0, sizeof(value1));
121 unsigned int realValLen = 0;
122 status = DBM_Get(g_KVStoreHandle, keytemp, &value1, sizeof(value1), &realValLen);
123 if (i <= MAX_KEY_NUM_TEST) {
124 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
125 TEST_ASSERT_EQUAL_INT(sizeof(value1), realValLen);
126 TEST_ASSERT_EQUAL_INT(value1.num, value.num);
127 TEST_ASSERT_EQUAL_STRING(value1.content, value.content);
128 TEST_ASSERT_EQUAL_MEMORY(&value1, &value, sizeof(value));
129 } else {
130 TEST_ASSERT_EQUAL_INT(DBM_NOT_FOUND, status);
131 }
132
133 memset_s(keytemp, MAX_KEY_LEN_TEST, 0, MAX_KEY_LEN_TEST);
134 IoTWatchDogKick();
135 }
136 IoTWatchDogKick();
137 return TRUE;
138 }
139
140 /* Read files in batches. */
GetKVs(int num,const char * key,const char * content)141 static BOOL GetKVs(int num, const char* key, const char* content)
142 {
143 int size;
144 int status;
145 char keytemp[MAX_KEY_LEN_TEST] = {0};
146 struct {
147 int num;
148 char content[200];
149 } value, value1;
150
151 if (num <= 0) {
152 return FALSE;
153 }
154 for (int loop = num; loop > 0; loop--) {
155 size = sprintf_s(keytemp, MAX_KEY_LEN_TEST, "%s_%d", key, loop);
156 if (size < 0) {
157 return FALSE;
158 }
159
160 memset_s(&value, sizeof(value), 0, sizeof(value));
161 value.num = loop;
162
163 int ret = strcpy_s(value.content, sizeof(value.content), content);
164 TEST_ASSERT_EQUAL_INT(0, ret);
165
166 memset_s(&value1, sizeof(value1), 0, sizeof(value1));
167 unsigned int realValLen = 0;
168 status = DBM_Get(g_KVStoreHandle, keytemp, &value1, sizeof(value1), &realValLen);
169 if (loop <= MAX_KEY_NUM_TEST) {
170 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
171 TEST_ASSERT_EQUAL_INT(sizeof(value1), realValLen);
172 TEST_ASSERT_EQUAL_INT(value1.num, value.num);
173 TEST_ASSERT_EQUAL_STRING(value1.content, value.content);
174 TEST_ASSERT_EQUAL_MEMORY(&value1, &value, sizeof(value));
175 } else {
176 TEST_ASSERT_EQUAL_INT(DBM_NOT_FOUND, status);
177 }
178
179 memset_s(keytemp, MAX_KEY_LEN_TEST, 0, MAX_KEY_LEN_TEST);
180 IoTWatchDogKick();
181 }
182 IoTWatchDogKick();
183 return TRUE;
184 }
185
186 /* Delete files in batches. */
DeleteKVs(int num,const char * key)187 static BOOL DeleteKVs(int num, const char* key)
188 {
189 int size;
190 int status;
191 char keytemp[MAX_KEY_LEN_TEST] = {0};
192
193 if (num <= 0) {
194 return FALSE;
195 }
196 for (int i = 1; i <= num; i++) {
197 size = sprintf_s(keytemp, MAX_KEY_LEN_TEST, "%s_%d", key, i);
198 if (size < 0) {
199 return FALSE;
200 }
201
202 status = DBM_Delete(g_KVStoreHandle, keytemp);
203 TEST_ASSERT_EQUAL_INT(DBM_OK, status); // same as > L2, if key not existed, still return OK
204
205 memset_s(keytemp, MAX_KEY_LEN_TEST, 0, MAX_KEY_LEN_TEST);
206 IoTWatchDogKick();
207 }
208 IoTWatchDogKick();
209 return TRUE;
210 }
211
212 /**
213 * @tc.number : SUB_UTILS_KV_STORE_0100
214 * @tc.name : DBM_Put parameter legal test
215 * @tc.desc : [C- SOFTWARE -0200]
216 */
217 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue001, Function | MediumTest | Level1)
218 {
219 int status;
220 char key[] = "rw.sys.version";
221 struct {
222 int num;
223 char content[200];
224 } value;
225 memset_s(&value, sizeof(value), 0, sizeof(value));
226 value.num = 1;
227 strcpy_s(value.content, sizeof(value.content), "Hello world !");
228
229 int tickCount1 = osKernelGetTickCount();
230 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
231 int tickCount2 = osKernelGetTickCount();
232 printf("Insert One: begin[%d] finish[%d] use[%d]\n", tickCount1, tickCount2, tickCount2 - tickCount1);
233 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
234
235
236 tickCount1 = osKernelGetTickCount();
237 status = DBM_Delete(g_KVStoreHandle, key);
238 tickCount2 = osKernelGetTickCount();
239 printf("Delete One: begin[%d] finish[%d] use[%d]\n", tickCount1, tickCount2, tickCount2 - tickCount1);
240
241 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
242 };
243
244 /**
245 * @tc.number : SUB_UTILS_KV_STORE_0200
246 * @tc.name : DBM_Put parameter legal test using key with underline
247 * @tc.desc : [C- SOFTWARE -0200]
248 */
249 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue002, Function | MediumTest | Level1)
250 {
251 int status;
252 char key[] = "rw.sys.version_100";
253 struct {
254 int num;
255 char content[200];
256 } value;
257 memset_s(&value, sizeof(value), 0, sizeof(value));
258 value.num = 1;
259 strcpy_s(value.content, sizeof(value.content), "Hello world !");
260
261 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
262 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
263
264 status = DBM_Delete(g_KVStoreHandle, key);
265 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
266 };
267
268 /**
269 * @tc.number : SUB_UTILS_KV_STORE_0300
270 * @tc.name : DBM_Put parameter legal test when key contains only number
271 * @tc.desc : [C- SOFTWARE -0200]
272 */
273 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue003, Function | MediumTest | Level1)
274 {
275 int status;
276 char key[] = "100";
277 struct {
278 int num;
279 char content[200];
280 } value;
281 memset_s(&value, sizeof(value), 0, sizeof(value));
282 value.num = 1;
283 strcpy_s(value.content, sizeof(value.content), "Hello world !");
284
285 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
286 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
287
288 status = DBM_Delete(g_KVStoreHandle, key);
289 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
290 };
291
292 /**
293 * @tc.number : SUB_UTILS_KV_STORE_0400
294 * @tc.name : DBM_Put parameter legal test when key is equal to 31 Byte
295 * @tc.desc : [C- SOFTWARE -0200]
296 */
297 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue004, Function | MediumTest | Level1)
298 {
299 int status;
300 char key[] = "rw.sys.version.utilskvparameter";
301 struct {
302 int num;
303 char content[200];
304 } value;
305 memset_s(&value, sizeof(value), 0, sizeof(value));
306 value.num = 1;
307 strcpy_s(value.content, sizeof(value.content), "Hello world !");
308
309 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
310 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
311
312 status = DBM_Delete(g_KVStoreHandle, key);
313 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
314 };
315
316 /**
317 * @tc.number : SUB_UTILS_KV_STORE_0500
318 * @tc.name : DBM_Put parameter Illegal test when key is equal to 32 Byte
319 * @tc.desc : [C- SOFTWARE -0200]
320 */
321 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue005, Function | MediumTest | Level1)
322 {
323 int status;
324 char key[] = "rw.sys.version.utilskvparameter1";
325 struct {
326 int num;
327 char content[200];
328 } value;
329 memset_s(&value, sizeof(value), 0, sizeof(value));
330 value.num = 1;
331 strcpy_s(value.content, sizeof(value.content), "Hello world !");
332
333 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
334 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
335 };
336
337 /**
338 * @tc.number : SUB_UTILS_KV_STORE_0600
339 * @tc.name : DBM_Put parameter Illegal test when key is gteater than 32 Byte
340 * @tc.desc : [C- SOFTWARE -0200]
341 */
342 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue006, Function | MediumTest | Level1)
343 {
344 int status;
345 char key[] = "rw.sys.version.utilskvparameterforillegal";
346 struct {
347 int num;
348 char content[200];
349 } value;
350 memset_s(&value, sizeof(value), 0, sizeof(value));
351 value.num = 1;
352 strcpy_s(value.content, sizeof(value.content), "Hello world !");
353
354 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
355 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
356 };
357
358 /**
359 * @tc.number : SUB_UTILS_KV_STORE_0700
360 * @tc.name : DBM_Put parameter Illegal test when key contains uppercase
361 * @tc.desc : [C- SOFTWARE -0200]
362 */
363 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue007, Function | MediumTest | Level1)
364 {
365 int status;
366 char key[] = "Rw.sys.version";
367 struct {
368 int num;
369 char content[200];
370 } value;
371 memset_s(&value, sizeof(value), 0, sizeof(value));
372 value.num = 1;
373 strcpy_s(value.content, sizeof(value.content), "Hello world !");
374
375 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
376 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
377 };
378
379 /**
380 * @tc.number : SUB_UTILS_KV_STORE_0800
381 * @tc.name : DBM_Put parameter Illegal test when key contains horizontal line
382 * @tc.desc : [C- SOFTWARE -0200]
383 */
384 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue008, Function | MediumTest | Level1)
385 {
386 int status;
387 char key[] = "rw.sys.version-r3";
388 struct {
389 int num;
390 char content[200];
391 } value;
392 memset_s(&value, sizeof(value), 0, sizeof(value));
393 value.num = 1;
394 strcpy_s(value.content, sizeof(value.content), "Hello world !");
395
396 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
397 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
398 };
399
400 /**
401 * @tc.number : SUB_UTILS_KV_STORE_0900
402 * @tc.name : DBM_Put parameter Illegal test when key contains plus sign
403 * @tc.desc : [C- SOFTWARE -0200]
404 */
405 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue009, Function | MediumTest | Level1)
406 {
407 int status;
408 char key[] = "re+r3";
409 struct {
410 int num;
411 char content[200];
412 } value;
413 memset_s(&value, sizeof(value), 0, sizeof(value));
414 value.num = 1;
415 strcpy_s(value.content, sizeof(value.content), "Hello world !");
416
417 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
418 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
419 };
420
421 /**
422 * @tc.number : SUB_UTILS_KV_STORE_1000
423 * @tc.name : DBM_Put parameter Illegal test when key contains asterisk
424 * @tc.desc : [C- SOFTWARE -0200]
425 */
426 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue010, Function | MediumTest | Level1)
427 {
428 int status;
429 char key[] = "rw.sys.version*r3";
430 struct {
431 int num;
432 char content[200];
433 } value;
434 memset_s(&value, sizeof(value), 0, sizeof(value));
435 value.num = 1;
436 strcpy_s(value.content, sizeof(value.content), "Hello world !");
437
438 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
439 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
440 };
441
442 /**
443 * @tc.number : SUB_UTILS_KV_STORE_1100
444 * @tc.name : DBM_Put parameter legal test when Value is equal to 512 characters
445 * @tc.desc : [C- SOFTWARE -0200]
446 */
447 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue011, Function | MediumTest | Level1)
448 {
449 int status;
450 char key[] = "rw.sys.version";
451 struct {
452 int num;
453 char content[507];
454 } value;
455 memset_s(&value, sizeof(value), 0, sizeof(value));
456 value.num = 1;
457 strcpy_s(value.content, sizeof(value.content), "Hello world !");
458
459 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
460 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
461
462 status = DBM_Delete(g_KVStoreHandle, key);
463 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
464 };
465
466 /**
467 * @tc.number : SUB_UTILS_KV_STORE_1200
468 * @tc.name : DBM_Put parameter Illegal test when Value is equal to 513 characters
469 * @tc.desc : [C- SOFTWARE -0200]
470 */
471 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue012, Function | MediumTest | Level1)
472 {
473 int status;
474 char key[] = "rw.sys.version";
475 struct {
476 int num;
477 char content[509];
478 } value;
479 memset_s(&value, sizeof(value), 0, sizeof(value));
480 value.num = 1;
481 strcpy_s(value.content, sizeof(value.content), "Hello world !");
482
483 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
484 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
485 };
486
487 /**
488 * @tc.number : SUB_UTILS_KV_STORE_1300
489 * @tc.name : DBM_Put parameter Illegal test when Value greater than 512 characters
490 * @tc.desc : [C- SOFTWARE -0200]
491 */
492 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue013, Function | MediumTest | Level1)
493 {
494 int status;
495 char key[] = "rw.sys.version";
496 struct {
497 int num;
498 char content[512];
499 } value;
500 memset_s(&value, sizeof(value), 0, sizeof(value));
501 value.num = 1;
502 strcpy_s(value.content, sizeof(value.content), "Hello world !");
503
504 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
505 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
506 };
507
508 /**
509 * @tc.number : SUB_UTILS_KV_STORE_1400
510 * @tc.name : Value greater than 512 characters and key is an invalid character
511 * @tc.desc : [C- SOFTWARE -0200]
512 */
513 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue014, Function | MediumTest | Level1)
514 {
515 int status;
516 char key[] = "Rw.sys.version";
517 struct {
518 int num;
519 char content[512];
520 } value;
521 memset_s(&value, sizeof(value), 0, sizeof(value));
522 value.num = 1;
523 strcpy_s(value.content, sizeof(value.content), "Hello world !");
524
525 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
526 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
527 };
528
529 /**
530 * @tc.number : SUB_UTILS_KV_STORE_1500
531 * @tc.name : DBM_Put parameter legal test with Special characters
532 * @tc.desc : [C- SOFTWARE -0200]
533 */
534 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue015, Function | MediumTest | Level1)
535 {
536 int status;
537 char key[] = "_._..__...___";
538 struct {
539 int num;
540 char content[508];
541 } value;
542 memset_s(&value, sizeof(value), 0, sizeof(value));
543 value.num = 1;
544 strcpy_s(value.content, sizeof(value.content), "！@#￥%……&*（）——+~《》？，。、“‘；：、12345767890");
545
546 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
547 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
548
549 status = DBM_Delete(g_KVStoreHandle, key);
550 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
551 };
552
553 /**
554 * @tc.number : SUB_UTILS_KV_STORE_1600
555 * @tc.name : DBM_Put parameter Illegal test when key contains blank
556 * @tc.desc : [C- SOFTWARE -0200]
557 */
558 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue016, Function | MediumTest | Level1)
559 {
560 int status;
561 char key[] = "rw.sys.version space test";
562 struct {
563 int num;
564 char content[200];
565 } value;
566 memset_s(&value, sizeof(value), 0, sizeof(value));
567 value.num = 1;
568 strcpy_s(value.content, sizeof(value.content), "Hello world !");
569
570 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
571 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
572 };
573
574 /**
575 * @tc.number : SUB_UTILS_KV_STORE_1700
576 * @tc.name : DBM_Put parameter legal test when value contains only blank
577 * @tc.desc : [C- SOFTWARE -0200]
578 */
579 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreSetValue017, Function | MediumTest | Level1)
580 {
581 int status;
582 char key[] = "rw.sys.version";
583 struct {
584 int num;
585 char content[200];
586 } value;
587 memset_s(&value, sizeof(value), 0, sizeof(value));
588 value.num = 1;
589 strcpy_s(value.content, sizeof(value.content), " ");
590
591 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
592 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
593
594 status = DBM_Delete(g_KVStoreHandle, key);
595 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
596 };
597
598 /**
599 * @tc.number : SUB_UTILS_KV_STORE_1800
600 * @tc.name : Use the interface to get the kv value
601 * @tc.desc : [C- SOFTWARE -0200]
602 */
603 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreGetValue001, Function | MediumTest | Level1)
604 {
605 int status;
606 char key[] = "rw.sys.version";
607 struct {
608 int num;
609 char content[200];
610 } value, value1;
611 memset_s(&value, sizeof(value), 0, sizeof(value));
612 value.num = 1;
613 strcpy_s(value.content, sizeof(value.content), "It is never too old to learn");
614
615 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
616 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
617
618 memset_s(&value1, sizeof(value1), 0, sizeof(value1));
619 unsigned int realValLen = 0;
620 status = DBM_Get(g_KVStoreHandle, key, &value1, sizeof(value1), &realValLen);
621 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
622 TEST_ASSERT_EQUAL_INT(sizeof(value1), realValLen);
623 TEST_ASSERT_EQUAL_INT(value1.num, value.num);
624 TEST_ASSERT_EQUAL_STRING(value1.content, value.content);
625 TEST_ASSERT_EQUAL_MEMORY(&value1, &value, sizeof(value));
626
627 status = DBM_Delete(g_KVStoreHandle, key);
628 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
629 };
630
631 /**
632 * @tc.number : SUB_UTILS_KV_STORE_1900
633 * @tc.name : Use the interface to get the kv value when key contains only number
634 * @tc.desc : [C- SOFTWARE -0200]
635 */
636 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreGetValue002, Function | MediumTest | Level1)
637 {
638 int status;
639 char key[] = "100";
640 struct {
641 int num;
642 char content[200];
643 } value, value1;
644 memset_s(&value, sizeof(value), 0, sizeof(value));
645 value.num = 1;
646 strcpy_s(value.content, sizeof(value.content), "！@#￥%……&*（）——+~《》？，。、“‘；：、12345767890");
647
648 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
649 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
650
651 memset_s(&value1, sizeof(value1), 0, sizeof(value1));
652 unsigned int realValLen = 0;
653 status = DBM_Get(g_KVStoreHandle, key, &value1, sizeof(value1), &realValLen);
654 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
655 TEST_ASSERT_EQUAL_INT(sizeof(value1), realValLen);
656 TEST_ASSERT_EQUAL_INT(value1.num, value.num);
657 TEST_ASSERT_EQUAL_STRING(value1.content, value.content);
658 TEST_ASSERT_EQUAL_MEMORY(&value1, &value, sizeof(value));
659
660 status = DBM_Delete(g_KVStoreHandle, key);
661 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
662 };
663
664 /**
665 * @tc.number : SUB_UTILS_KV_STORE_2000
666 * @tc.name : Use the interface to get the kv value after value is updated
667 * @tc.desc : [C- SOFTWARE -0200]
668 */
669 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreGetValue003, Function | MediumTest | Level1)
670 {
671 int status;
672 char key[] = "rw.sys.version.utils";
673 struct {
674 int num;
675 char content[200];
676 } value, value1, value2;
677 memset_s(&value, sizeof(value), 0, sizeof(value));
678 value.num = 1;
679 strcpy_s(value.content, sizeof(value.content), "It is never too old to learn");
680
681 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
682 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
683
684 // Update the value of key
685 memset_s(&value1, sizeof(value1), 0, sizeof(value1));
686 value1.num = 1;
687 strcpy_s(value1.content, sizeof(value1.content), "Two tigers Two tigers two tiger running so fast");
688
689 int tickCount1 = osKernelGetTickCount();
690 status = DBM_Put(g_KVStoreHandle, key, (void*)&value1, sizeof(value1));
691 int tickCount2 = osKernelGetTickCount();
692 printf("Update One: begin[%d] finish[%d] use[%d]\n", tickCount1, tickCount2, tickCount2 - tickCount1);
693 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
694
695 memset_s(&value2, sizeof(value2), 0, sizeof(value2));
696 unsigned int realValLen = 0;
697 status = DBM_Get(g_KVStoreHandle, key, &value2, sizeof(value2), &realValLen);
698 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
699 TEST_ASSERT_EQUAL_INT(sizeof(value2), realValLen);
700 TEST_ASSERT_EQUAL_INT(value2.num, value1.num);
701 TEST_ASSERT_EQUAL_STRING(value2.content, value1.content);
702 TEST_ASSERT_EQUAL_MEMORY(&value2, &value1, sizeof(value1));
703
704 status = DBM_Delete(g_KVStoreHandle, key);
705 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
706 };
707
708 /**
709 * @tc.number : SUB_UTILS_KV_STORE_2100
710 * @tc.name : DBM_Get parameter Illegal test
711 * @tc.desc : [C- SOFTWARE -0200]
712 */
713 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreGetValue004, Function | MediumTest | Level1)
714 {
715 int status;
716 char key[] = "Rw.sys.version";
717 struct {
718 int num;
719 char content[200];
720 } value;
721 memset_s(&value, sizeof(value), 0, sizeof(value));
722
723 unsigned int realValLen = 0;
724 status = DBM_Get(g_KVStoreHandle, key, &value, sizeof(value), &realValLen);
725 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
726 };
727
728 /**
729 * @tc.number : SUB_UTILS_KV_STORE_2200
730 * @tc.name : Get the kv value when key contains only special characters and value contains only blank
731 * @tc.desc : [C- SOFTWARE -0200]
732 */
733 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreGetValue005, Function | MediumTest | Level1)
734 {
735 int status;
736 char key[] = "_._..__...___";
737 struct {
738 int num;
739 char content[200];
740 } value, value1;
741 memset_s(&value, sizeof(value), 0, sizeof(value));
742 value.num = 1;
743 strcpy_s(value.content, sizeof(value.content), " ");
744
745 status = DBM_Put(g_KVStoreHandle, key, (void*)&value, sizeof(value));
746 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
747
748 memset_s(&value1, sizeof(value1), 0, sizeof(value1));
749 unsigned int realValLen = 0;
750 status = DBM_Get(g_KVStoreHandle, key, &value1, sizeof(value1), &realValLen);
751 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
752 TEST_ASSERT_EQUAL_INT(sizeof(value1), realValLen);
753 TEST_ASSERT_EQUAL_INT(value1.num, value.num);
754 TEST_ASSERT_EQUAL_STRING(value1.content, value.content);
755 TEST_ASSERT_EQUAL_MEMORY(&value1, &value, sizeof(value));
756
757 status = DBM_Delete(g_KVStoreHandle, key);
758 TEST_ASSERT_EQUAL_INT(DBM_OK, status);
759 };
760
761 /**
762 * @tc.number : SUB_UTILS_KV_STORE_2300
763 * @tc.name : DBM_Delete parameter Illegal test
764 * @tc.desc : [C- SOFTWARE -0200]
765 */
766 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreDeleteValue, Function | MediumTest | Level1)
767 {
768 int status;
769 char key[] = "Rw.sys.version";
770
771 status = DBM_Delete(g_KVStoreHandle, key);
772 TEST_ASSERT_EQUAL_INT(DBM_INVALID_ARGS, status);
773 };
774
775 /**
776 * @tc.number : SUB_UTILS_KV_STORE_2900
777 * @tc.name : Specification test when MaxKeyNum
778 * @tc.desc : [C- SOFTWARE -0200]
779 */
780 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreMaxSize001, Function | MediumTest | Level1)
781 {
782 char key[] = "rw.sys.version";
783 char value[] = "It is never too old to learn";
784 BOOL ret = FALSE;
785
786 ret = PutKVs(MAX_KEY_NUM_TEST-1, key, value);
787 if (ret != TRUE)
788 {
789 TEST_FAIL();
790 }
791
792 ret = GetKVs(MAX_KEY_NUM_TEST-1, key, value);
793 if (ret != TRUE)
794 {
795 TEST_FAIL();
796 }
797 ret = DeleteKVs(MAX_KEY_NUM_TEST-1, key);
798 if (ret != TRUE)
799 {
800 TEST_FAIL();
801 }
802 };
803
804 /**
805 * @tc.number : SUB_UTILS_KV_STORE_3000
806 * @tc.name : Specification test when MaxKeyNum is 200
807 * @tc.desc : [C- SOFTWARE -0200]
808 */
809 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreMaxSize002, Function | MediumTest | Level1)
810 {
811 char key[] = "rw.sys.version";
812 char value[] = "It is never too old to learn";
813 BOOL ret = FALSE;
814
815 ret = PutKVs(MAX_KEY_NUM_TEST, key, value);
816 if (ret != TRUE)
817 {
818 TEST_FAIL();
819 }
820 ret = GetKVs(MAX_KEY_NUM_TEST, key, value);
821 if (ret != TRUE)
822 {
823 TEST_FAIL();
824 }
825 ret = DeleteKVs(MAX_KEY_NUM_TEST, key);
826 if (ret != TRUE)
827 {
828 TEST_FAIL();
829 }
830 };
831
832 /**
833 * @tc.number : SUB_UTILS_KV_STORE_3100
834 * @tc.name : Specification test when MaxKeyNum
835 * @tc.desc : [C- SOFTWARE -0200]
836 */
837 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreMaxSize003, Function | MediumTest | Level1)
838 {
839 char key[] = "rw.sys.version";
840 char value[] = "It is never too old to learn";
841 BOOL ret = FALSE;
842
843 ret = PutKVs(MAX_KEY_NUM_TEST+1, key, value);
844 if (ret != TRUE)
845 {
846 TEST_FAIL();
847 }
848 ret = GetKVs(MAX_KEY_NUM_TEST+1, key, value);
849 if (ret != TRUE)
850 {
851 TEST_FAIL();
852 }
853
854 ret = DeleteKVs(MAX_KEY_NUM_TEST+1, key);
855 if (ret != TRUE)
856 {
857 TEST_FAIL();
858 }
859 };
860
861 /**
862 * @tc.number : SUB_UTILS_KV_STORE_3200
863 * @tc.name : Specification test using InvalidKeyNum
864 * @tc.desc : [C- SOFTWARE -0200]
865 */
866 LITE_TEST_CASE(DBMKvStoreFuncTestSuite, testKvStoreMaxSize004, Function | MediumTest | Level1)
867 {
868 char key[] = "rw.sys.version";
869 char value[] = "It is never too old to learn";
870 char value1[] = "Two tigers Two tigers two tiger running so fast \
871 running so fast one has no ears one has no tail How strange How strange";
872 BOOL ret = FALSE;
873
874 ret = PutKVs(INVALID_KEY_NUM, key, value);
875 if (ret != TRUE)
876 {
877 TEST_FAIL();
878 }
879 // Update operation
880 ret = PutKVs(INVALID_KEY_NUM, key, value1);
881 if (ret != TRUE)
882 {
883 TEST_FAIL();
884 }
885 ret = GetKVs(INVALID_KEY_NUM, key, value1);
886 if (ret != TRUE)
887 {
888 TEST_FAIL();
889 }
890 ret = DeleteKVs(INVALID_KEY_NUM, key);
891 if (ret != TRUE)
892 {
893 TEST_FAIL();
894 }
895 };
896
897 RUN_TEST_SUITE(DBMKvStoreFuncTestSuite);
898