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 #ifndef OMIT_MULTI_VER
16 #include <gtest/gtest.h>
17 #include <ctime>
18 #include <cmath>
19 #include <random>
20 #include <chrono>
21 #include <string>
22
23 #include "distributeddb_data_generator.h"
24 #include "distributed_test_tools.h"
25 #include "kv_store_delegate.h"
26 #include "kv_store_delegate_manager.h"
27
28 using namespace std;
29 using namespace chrono;
30 using namespace testing;
31 #if defined TESTCASES_USING_GTEST_EXT
32 using namespace testing::ext;
33 #endif
34 using namespace DistributedDB;
35 using namespace DistributedDBDataGenerator;
36
37 namespace DistributeddbKvCrud {
38 class DistributeddbKvCrudTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 private:
45 };
46
47 const bool IS_LOCAL = GetRandBool();
48 KvStoreDelegate *g_kvStoreDelegate = nullptr; // the delegate used in this suit.
49 KvStoreDelegateManager *g_manager = nullptr;
SetUpTestCase(void)50 void DistributeddbKvCrudTest::SetUpTestCase(void)
51 {
52 }
53
TearDownTestCase(void)54 void DistributeddbKvCrudTest::TearDownTestCase(void)
55 {
56 }
57
SetUp(void)58 void DistributeddbKvCrudTest::SetUp(void)
59 {
60 MST_LOG("SetUp TestCase before every case local[%d].", IS_LOCAL);
61 RemoveDir(DIRECTOR);
62
63 UnitTest *test = UnitTest::GetInstance();
64 ASSERT_NE(test, nullptr);
65 const TestInfo *testinfo = test->current_test_info();
66 ASSERT_NE(testinfo, nullptr);
67 string testCaseName = string(testinfo->name());
68 MST_LOG("[SetUp] test case %s is start to run", testCaseName.c_str());
69
70 KvOption option = g_kvOption;
71 option.localOnly = IS_LOCAL;
72 g_kvStoreDelegate = DistributedTestTools::GetDelegateSuccess(g_manager, g_kvdbParameter1, option);
73 ASSERT_TRUE(g_manager != nullptr && g_kvStoreDelegate != nullptr);
74 }
75
TearDown(void)76 void DistributeddbKvCrudTest::TearDown(void)
77 {
78 MST_LOG("TearDownTestCase after all cases.");
79 EXPECT_TRUE(g_manager->CloseKvStore(g_kvStoreDelegate) == OK);
80 g_kvStoreDelegate = nullptr;
81 DBStatus status = g_manager->DeleteKvStore(STORE_ID_1);
82 EXPECT_TRUE(status == DistributedDB::DBStatus::OK) << "fail to delete exist kvdb";
83 delete g_manager;
84 g_manager = nullptr;
85 RemoveDir(DIRECTOR);
86 }
87
88 /*
89 * @tc.name: SimpleDataTest 001
90 * @tc.desc: Verify that can put value to db and get successfully.
91 * @tc.type: FUNC
92 * @tc.require: SR000BUH3J
93 * @tc.author: luqianfu
94 */
95 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest001, TestSize.Level1)
96 {
97 /**
98 * @tc.steps: step1. create kv db and put (k1,v1) then get the value of k1 from db.
99 * @tc.expected: step1. put successfully and get the value of k1 is v1.
100 */
101 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_1);
102 ASSERT_TRUE(status == DBStatus::OK);
103 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
104 EXPECT_TRUE(valueResult.size() != 0);
105 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
106
107 /**
108 * @tc.steps: step2. create kv db and put (k2,v2) then get the value of k2 from db.
109 * @tc.expected: step2. put successfully and get the value of k2 is v2.
110 */
111 status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_2, VALUE_2);
112 ASSERT_TRUE(status == DBStatus::OK);
113 Value valueResult2 = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_2);
114 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult2, VALUE_2));
115 }
116
117 /*
118 * @tc.name: SimpleDataTest 002
119 * @tc.desc: Verify that can delete value and get successfully.
120 * @tc.type: FUNC
121 * @tc.require: SR000BUH3J
122 * @tc.author: luqianfu
123 */
124 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest002, TestSize.Level1)
125 {
126 /**
127 * @tc.steps: step1. create kv db and put (k1,v1) then get the value of k1 from db.
128 * @tc.expected: step1. put successfully and get the value of k1 is v1.
129 */
130 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_1);
131 ASSERT_TRUE(status == DBStatus::OK);
132 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
133 EXPECT_TRUE(valueResult.size() != 0);
134
135 /**
136 * @tc.steps: step2. delete k1 from db.
137 * @tc.expected: step2. delete successfully.
138 */
139 status = DistributedTestTools::Delete(*g_kvStoreDelegate, KEY_1);
140 ASSERT_TRUE(status == DBStatus::OK);
141
142 /**
143 * @tc.steps: step3. get k1 from db.
144 * @tc.expected: step3. get successfully but value is null.
145 */
146 Value valueResult2 = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
147 EXPECT_TRUE(valueResult2.size() == 0);
148 }
149
150 /*
151 * @tc.name: SimpleDataTest 003
152 * @tc.desc: Verify that can put the same key with different value and get successfully.
153 * @tc.type: FUNC
154 * @tc.require: SR000BUH3J
155 * @tc.author: luqianfu
156 */
157 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest003, TestSize.Level1)
158 {
159 /**
160 * @tc.steps: step1. create kv db and put (k1,v1) then get the value of k1 from db.
161 * @tc.expected: step1. put successfully and get the value of k1 is v1.
162 */
163 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_1);
164 ASSERT_TRUE(status == DBStatus::OK);
165 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
166 EXPECT_TRUE(valueResult.size() != 0);
167 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
168
169 /**
170 * @tc.steps: step2. create kv db and put (k1,v2) then get the value of k1 from db.
171 * @tc.expected: step2. put successfully and get the value of k1 is v2.
172 */
173 status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_2);
174 ASSERT_TRUE(status == DBStatus::OK);
175 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
176 EXPECT_TRUE(valueResult.size() != 0);
177 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_2));
178
179 /**
180 * @tc.steps: step3. create kv db and put (k1,v1) then get the value of k1 from db.
181 * @tc.expected: step3. put successfully and get the value of k1 is v1.
182 */
183 status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_1);
184 ASSERT_TRUE(status == DBStatus::OK);
185 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
186 EXPECT_TRUE(valueResult.size() != 0);
187 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
188 }
189
190 /*
191 * @tc.name: SimpleDataTest 004
192 * @tc.desc: Verify that put a null value to db will get nothing.
193 * @tc.type: FUNC
194 * @tc.require: SR000BUH3J
195 * @tc.author: luqianfu
196 */
197 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest004, TestSize.Level1)
198 {
199 DBStatus status = DistributedTestTools::Delete(*g_kvStoreDelegate, KEY_1);
200 ASSERT_EQ(status, DBStatus::OK);
201
202 /**
203 * @tc.steps: step1. create kv db and put (k1,null).
204 * @tc.expected: step1. put ok.
205 */
206 status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_EMPTY);
207 ASSERT_EQ(status, DBStatus::OK);
208 /**
209 * @tc.steps: step2. get the value of k1 from db.
210 * @tc.expected: step2. get successfully and get the value of k1 is null.
211 */
212 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
213 EXPECT_TRUE(valueResult.size() == 0);
214 }
215
216 /*
217 * @tc.name: SimpleDataTest 005
218 * @tc.desc: Verify that can not put a null key to db.
219 * @tc.type: FUNC
220 * @tc.require: SR000BUH3J
221 * @tc.author: luqianfu
222 */
223 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest005, TestSize.Level1)
224 {
225 /**
226 * @tc.steps: step1. create kv db and put (null,v1).
227 * @tc.expected: step1. put failed.
228 */
229 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_EMPTY, VALUE_1);
230 ASSERT_TRUE(status == DBStatus::INVALID_ARGS);
231 /**
232 * @tc.steps: step2. get k=null from db.
233 * @tc.expected: step2. get value of k is null.
234 */
235 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_EMPTY);
236 EXPECT_TRUE(valueResult.size() == 0);
237 }
238
239 /*
240 * @tc.name: SimpleDataTest 006
241 * @tc.desc: Verify that can delete the entry that not exist.
242 * @tc.type: FUNC
243 * @tc.require: SR000BUH3J
244 * @tc.author: luqianfu
245 */
246 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest006, TestSize.Level1)
247 {
248 /**
249 * @tc.steps: step1. delete k1 from db.
250 * @tc.expected: step1. Construct that no k1 exist in db.
251 */
252 DBStatus status = DistributedTestTools::Delete(*g_kvStoreDelegate, KEY_1);
253 ASSERT_TRUE(status == DBStatus::OK);
254
255 /**
256 * @tc.steps: step2. get k1 from db.
257 * @tc.expected: step2. get the value of k1 is null.
258 */
259 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
260 EXPECT_TRUE(valueResult.size() == 0);
261 }
262
263 /*
264 * @tc.name: SimpleDataTest 007
265 * @tc.desc: Verify that delete absent key return OK.
266 * @tc.type: FUNC
267 * @tc.require: SR000BUH3J
268 * @tc.author: luqianfu
269 */
270 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest007, TestSize.Level1)
271 {
272 /**
273 * @tc.steps: step1. delete k1 from db.
274 * @tc.expected: step1. Construct that no k1 exist in db.
275 */
276 DBStatus status = DistributedTestTools::Delete(*g_kvStoreDelegate, KEY_1);
277 ASSERT_TRUE(status == DBStatus::OK);
278
279 /**
280 * @tc.steps: step2. delete nonexistent k1 from db.
281 * @tc.expected: step2. delete failed but return OK.
282 */
283 status = DistributedTestTools::Delete(*g_kvStoreDelegate, KEY_1);
284 ASSERT_TRUE(status == DBStatus::OK);
285 }
286
287 /*
288 * @tc.name: SimpleDataTest 008
289 * @tc.desc: Verify that can the Clear interface can delete all the records one time.
290 * @tc.type: FUNC
291 * @tc.require: SR000BUH3J
292 * @tc.author: luqianfu
293 */
294 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest008, TestSize.Level1)
295 {
296 /**
297 * @tc.steps: step1. create kv db and put (k1,v1)(k1,v2).
298 * @tc.expected: step1. put successfully.cd ..
299 */
300 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_1);
301 ASSERT_TRUE(status == DBStatus::OK);
302 status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_2, VALUE_2);
303 ASSERT_TRUE(status == DBStatus::OK);
304
305 /**
306 * @tc.steps: step2. delete all k from db then get k1 from db.
307 * @tc.expected: step2. delete successfully and get the value of k1 if null.
308 */
309 status = DistributedTestTools::Clear(*g_kvStoreDelegate);
310 ASSERT_TRUE(status == DBStatus::OK);
311 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
312 EXPECT_TRUE(valueResult.size() == 0);
313 }
314
315 /*
316 * @tc.name: SimpleDataTest 009
317 * @tc.desc: Verify that can crud the same key continuously.
318 * @tc.type: FUNC
319 * @tc.require: SR000BUH3J
320 * @tc.author: luqianfu
321 */
322 HWTEST_F(DistributeddbKvCrudTest, SimpleDataTest009, TestSize.Level1)
323 {
324 for (int cnt = 0; cnt < FIVE_TIMES; cnt++) {
325 /**
326 * @tc.steps: step1. create kv db and put (k1,v1) and check the records.
327 * @tc.expected: step1. put successfully and the value of the k1 in db is v1.
328 */
329 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_1);
330 ASSERT_TRUE(status == DBStatus::OK);
331 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
332 EXPECT_TRUE(valueResult.size() != 0);
333 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
334 /**
335 * @tc.steps: step2. put (k1,v2) to db and get.
336 * @tc.expected: step2. put successfully and get the value of k1 is v2.
337 */
338 status = DistributedTestTools::Put(*g_kvStoreDelegate, KEY_1, VALUE_2);
339 ASSERT_TRUE(status == DBStatus::OK);
340 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
341 EXPECT_TRUE(valueResult.size() != 0);
342 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_2));
343 /**
344 * @tc.steps: step3. delete k1 from db and get.
345 * @tc.expected: step3. delete successfully and get the value of k1 is null.
346 */
347 status = DistributedTestTools::Delete(*g_kvStoreDelegate, KEY_1);
348 ASSERT_TRUE(status == DBStatus::OK);
349 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, KEY_1);
350 EXPECT_TRUE(valueResult.size() == 0);
351 }
352 }
353
354 /*
355 * @tc.name: ComplexDataTest 001
356 * @tc.desc: Verify that can operate a long string key and key's length can not bigger than 1K.
357 * @tc.type: FUNC
358 * @tc.require: SR000BUH3J
359 * @tc.author: luqianfu
360 */
361 HWTEST_F(DistributeddbKvCrudTest, ComplexDataTest001, TestSize.Level1)
362 {
363 DistributedDB::Key longKey1, longKey2;
364 longKey1.assign(ONE_K_LONG_STRING, (uint8_t)'a');
365 longKey2.assign(ONE_K_LONG_STRING + 1, (uint8_t)'b'); // 1 Byte bigger than 1024Byte
366 /**
367 * @tc.steps: step1. create kv db and put (longKey1,null) which the length of longKey1 is 1k and get.
368 * @tc.expected: step1. put successfully and get the value of longKey1 is null.
369 */
370 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, longKey1, VALUE_EMPTY);
371 ASSERT_TRUE(status == DBStatus::OK);
372 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, longKey1);
373 EXPECT_TRUE(valueResult.size() == 0);
374 /**
375 * @tc.steps: step2. create kv db and put (longKey2,null) which the length of longKey2 is 1k+1 and get.
376 * @tc.expected: step2. put successfully and get the value of longKey2 is null.
377 */
378 status = DistributedTestTools::Put(*g_kvStoreDelegate, longKey2, VALUE_EMPTY);
379 ASSERT_TRUE(status != DBStatus::OK);
380 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, longKey2);
381 EXPECT_TRUE(valueResult.size() == 0);
382
383 /**
384 * @tc.steps: step3. create kv db and put (longKey1,ok_v1) which the length of longKey1 is 1k and get.
385 * @tc.expected: step3. put successfully and get the size of longKey1.value is 1k.
386 */
387 status = DistributedTestTools::Put(*g_kvStoreDelegate, longKey1, OK_VALUE_1);
388 ASSERT_TRUE(status == DBStatus::OK);
389 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, longKey1);
390 EXPECT_TRUE(valueResult.size() == OK_VALUE_1.size());
391 /**
392 * @tc.steps: step4. create kv db and put (longKey2,ok_v1) which the length of longKey2 is 1k+1 and get.
393 * @tc.expected: step4. put failed and get the value of longKey2 is null.
394 */
395 status = DistributedTestTools::Put(*g_kvStoreDelegate, longKey2, OK_VALUE_1);
396 ASSERT_TRUE(status != DBStatus::OK);
397 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, longKey2);
398 EXPECT_TRUE(valueResult.size() == 0);
399
400 /**
401 * @tc.steps: step5. delete longKey1 from db and get.
402 * @tc.expected: step5. delete successfully and get the value of longKey1 is null.
403 */
404 status = DistributedTestTools::Delete(*g_kvStoreDelegate, longKey1);
405 ASSERT_EQ(status, DBStatus::OK);
406 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, longKey1);
407 EXPECT_TRUE(valueResult.size() == 0);
408 /**
409 * @tc.steps: step6. delete longKey2 from db and get.
410 * @tc.expected: step6. delete failed and get the value of longKey2 is null.
411 */
412 status = DistributedTestTools::Delete(*g_kvStoreDelegate, longKey2);
413 ASSERT_NE(status, DBStatus::OK);
414 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, longKey2);
415 EXPECT_TRUE(valueResult.size() == 0);
416 }
417
418 /*
419 * @tc.name: ComplexDataTest 002
420 * @tc.desc: Verify that can operate a long string value and value's length can not bigger than 4M.
421 * @tc.type: FUNC
422 * @tc.require: SR000BUH3J
423 * @tc.author: luqianfu
424 */
425 HWTEST_F(DistributeddbKvCrudTest, ComplexDataTest002, TestSize.Level1)
426 {
427 DistributedDB::Value longValue1, longValue2;
428 longValue1.assign(FOUR_M_LONG_STRING, (uint8_t)'a');
429 longValue2.assign(FOUR_M_LONG_STRING + 1, (uint8_t)'b');
430
431 /**
432 * @tc.steps: step1. create kv db and put (OK_K1,longValue1) which the length of longValue1 is 4M and get.
433 * @tc.expected: step1. put successfully and get the value of OK_K1 is longValue1.
434 */
435 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, OK_KEY_1, longValue1);
436 ASSERT_TRUE(status == DBStatus::OK);
437 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
438 EXPECT_TRUE(valueResult.size() == FOUR_M_LONG_STRING);
439 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, longValue1));
440
441 /**
442 * @tc.steps: step2. create kv db and put (OK_K1,longValue2) which the length of longValue2 is 4M+1 and get.
443 * @tc.expected: step2. put failed and get the size of longValue2 is 4M.
444 */
445 status = DistributedTestTools::Put(*g_kvStoreDelegate, OK_KEY_1, longValue2);
446 ASSERT_TRUE(status != DBStatus::OK);
447 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
448 EXPECT_TRUE(valueResult.size() == FOUR_M_LONG_STRING);
449
450 /**
451 * @tc.steps: step3. delete OK_KEY_1 and get.
452 * @tc.expected: step3. delete successfully and get the value of OK_KEY_1 is null.
453 */
454 status = DistributedTestTools::Delete(*g_kvStoreDelegate, OK_KEY_1);
455 ASSERT_TRUE(status == DBStatus::OK);
456 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
457 EXPECT_TRUE(valueResult.size() == 0);
458 }
459
460 /*
461 * @tc.name: ComplexDataTest 003
462 * @tc.desc: Verify that can operate an alphanum string key.
463 * @tc.type: FUNC
464 * @tc.require: SR000BUH3J
465 * @tc.author: luqianfu
466 */
467 HWTEST_F(DistributeddbKvCrudTest, ComplexDataTest003, TestSize.Level1)
468 {
469 DistributedDB::Key alphanumKey1;
470 char chr;
471 for (chr = 'a'; chr <= 'z'; ++chr) {
472 alphanumKey1.push_back(chr);
473 }
474 for (chr = 'A'; chr <= 'Z'; ++chr) {
475 alphanumKey1.push_back(chr);
476 }
477 for (chr = '0'; chr <= '9'; ++chr) {
478 alphanumKey1.push_back(chr);
479 }
480
481 /**
482 * @tc.steps: step1. create kv db and put (alphanumKey1,null) that alphanumKey1=[a-zA-Z0-9].
483 * @tc.expected: step1. put successfully and get the value of alphanumKey1 is null.
484 */
485 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, alphanumKey1, VALUE_EMPTY);
486 ASSERT_TRUE(status == DBStatus::OK);
487 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, alphanumKey1);
488 EXPECT_TRUE(valueResult.size() == 0);
489 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_EMPTY));
490
491 /**
492 * @tc.steps: step2. create kv db and put (alphanumKey1,OK_VALUE_1) that alphanumKey1=[a-zA-Z0-9].
493 * @tc.expected: step2. put successfully and get the value of alphanumKey1 is OK_VALUE_1.
494 */
495 status = DistributedTestTools::Put(*g_kvStoreDelegate, alphanumKey1, OK_VALUE_1);
496 ASSERT_TRUE(status == DBStatus::OK);
497 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, alphanumKey1);
498 EXPECT_TRUE(valueResult.size() == OK_VALUE_1.size());
499 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, OK_VALUE_1));
500
501 /**
502 * @tc.steps: step3. delete alphanumKey1 from db and get.
503 * @tc.expected: step3. delete successfully and get the value of alphanumKey1 is null.
504 */
505 status = DistributedTestTools::Delete(*g_kvStoreDelegate, alphanumKey1);
506 ASSERT_TRUE(status == DBStatus::OK);
507 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, alphanumKey1);
508 EXPECT_TRUE(valueResult.size() == 0);
509 }
510
511 /*
512 * @tc.name: ComplexDataTest 004
513 * @tc.desc: Verify that can operate a alphanum string value.
514 * @tc.type: FUNC
515 * @tc.require: SR000BUH3J
516 * @tc.author: luqianfu
517 */
518 HWTEST_F(DistributeddbKvCrudTest, ComplexDataTest004, TestSize.Level1)
519 {
520 DistributedDB::Value alphanumValue1, alphanumValue2;
521 int chr;
522 for (chr = 'a'; chr <= 'z'; ++chr) {
523 alphanumValue1.push_back(chr);
524 alphanumValue2.push_back('a' + 'z' - chr);
525 }
526 for (chr = 'A'; chr <= 'Z'; ++chr) {
527 alphanumValue1.push_back(chr);
528 alphanumValue2.push_back('A' + 'Z' - chr);
529 }
530 for (chr = '0'; chr <= '9'; ++chr) {
531 alphanumValue1.push_back(chr);
532 alphanumValue2.push_back('0' + '9' - chr);
533 }
534
535 /**
536 * @tc.steps: step1. create kv db and put (OK_KEY_1,alphanumValue1) that alphanumValue1=[a-zA-Z0-9].
537 * @tc.expected: step1. put successfully and get the value of OK_KEY_1 is alphanumValue1.
538 */
539 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, OK_KEY_1, alphanumValue1);
540 ASSERT_TRUE(status == DBStatus::OK);
541 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
542 EXPECT_TRUE(valueResult.size() == alphanumValue1.size());
543 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, alphanumValue1));
544
545 /**
546 * @tc.steps: step2. create kv db and put (OK_KEY_1,alphanumValue2) that alphanumValue1=[z-aZ-A9-0].
547 * @tc.expected: step2. put successfully and get the value of OK_KEY_1 is alphanumValue2.
548 */
549 status = DistributedTestTools::Put(*g_kvStoreDelegate, OK_KEY_1, alphanumValue2);
550 ASSERT_TRUE(status == DBStatus::OK);
551 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
552 EXPECT_TRUE(valueResult.size() == alphanumValue2.size());
553 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, alphanumValue2));
554
555 /**
556 * @tc.steps: step3. delete OK_KEY_1 from db and get.
557 * @tc.expected: step3. delete successfully and get the value of OK_KEY_1 is null.
558 */
559 status = DistributedTestTools::Delete(*g_kvStoreDelegate, OK_KEY_1);
560 ASSERT_TRUE(status == DBStatus::OK);
561 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
562 EXPECT_TRUE(valueResult.size() == 0);
563 }
564
565 /*
566 * @tc.name: ComplexDataTest 005
567 * @tc.desc: Verify that can operate a full ASCII set string key.
568 * @tc.type: FUNC
569 * @tc.require: SR000BUH3J
570 * @tc.author: luqianfu
571 */
572 HWTEST_F(DistributeddbKvCrudTest, ComplexDataTest005, TestSize.Level1)
573 {
574 DistributedDB::Key fullAsciiKey1;
575 for (int cVal = 0; cVal <= 255; ++cVal) {
576 fullAsciiKey1.push_back(cVal);
577 }
578
579 /**
580 * @tc.steps: step1. create kv db and put (fullAsciiKey1,null) that fullAsciiKey1=[\0-\255].
581 * @tc.expected: step1. put successfully and get the value of fullAsciiKey1 is null.
582 */
583 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, fullAsciiKey1, VALUE_EMPTY);
584 ASSERT_TRUE(status == DBStatus::OK);
585 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, fullAsciiKey1);
586 EXPECT_TRUE(valueResult.size() == 0);
587 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_EMPTY));
588
589 /**
590 * @tc.steps: step2. create kv db and put (fullAsciiKey1,OK_VALUE_1) that fullAsciiKey1=[\0-\255].
591 * @tc.expected: step2. put successfully and get the value of fullAsciiKey1 is OK_VALUE_1.
592 */
593 status = DistributedTestTools::Put(*g_kvStoreDelegate, fullAsciiKey1, OK_VALUE_1);
594 ASSERT_TRUE(status == DBStatus::OK);
595 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, fullAsciiKey1);
596 EXPECT_TRUE(valueResult.size() == OK_VALUE_1.size());
597 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, OK_VALUE_1));
598
599 /**
600 * @tc.steps: step3. delete fullAsciiKey1 from db and get.
601 * @tc.expected: step3. delete successfully and get the value of fullAsciiKey1 is null.
602 */
603 status = DistributedTestTools::Delete(*g_kvStoreDelegate, fullAsciiKey1);
604 ASSERT_TRUE(status == DBStatus::OK);
605 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, fullAsciiKey1);
606 EXPECT_TRUE(valueResult.size() == 0);
607 }
608
609 /*
610 * @tc.name: ComplexDataTest 006
611 * @tc.desc: Verify that can operate a full ASCII set string value.
612 * @tc.type: FUNC
613 * @tc.require: SR000BUH3J
614 * @tc.author: luqianfu
615 */
616 HWTEST_F(DistributeddbKvCrudTest, ComplexDataTest006, TestSize.Level1)
617 {
618 DistributedDB::Value fullAsciiValue1, fullAsciiValue2;
619 for (int cVal = 0; cVal <= 255; ++cVal) {
620 fullAsciiValue1.push_back(cVal);
621 fullAsciiValue2.push_back(255 - cVal);
622 }
623
624 /**
625 * @tc.steps: step1. create kv db and put (OK_KEY_1,fullAsciiValue1) that fullAsciiValue1=[\0-\255].
626 * @tc.expected: step1. put successfully and get the value of OK_KEY_1 is fullAsciiValue1.
627 */
628 DBStatus status = DistributedTestTools::Put(*g_kvStoreDelegate, OK_KEY_1, fullAsciiValue1);
629 ASSERT_TRUE(status == DBStatus::OK);
630 Value valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
631 EXPECT_TRUE(valueResult.size() == fullAsciiValue1.size());
632 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, fullAsciiValue1));
633
634 /**
635 * @tc.steps: step2. create kv db and put (OK_KEY_1,fullAsciiValue2) that fullAsciiValue2=[\255-\0].
636 * @tc.expected: step2. put successfully and get the value of OK_KEY_1 is fullAsciiValue2.
637 */
638 status = DistributedTestTools::Put(*g_kvStoreDelegate, OK_KEY_1, fullAsciiValue2);
639 ASSERT_TRUE(status == DBStatus::OK);
640 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
641 EXPECT_TRUE(valueResult.size() == fullAsciiValue2.size());
642 EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, fullAsciiValue2));
643
644 /**
645 * @tc.steps: step3. delete OK_KEY_1 from db and get.
646 * @tc.expected: step3. delete successfully and get the value of OK_KEY_1 is null.
647 */
648 status = DistributedTestTools::Delete(*g_kvStoreDelegate, OK_KEY_1);
649 ASSERT_TRUE(status == DBStatus::OK);
650 valueResult = DistributedTestTools::Get(*g_kvStoreDelegate, OK_KEY_1);
651 EXPECT_TRUE(valueResult.size() == 0);
652 }
653
654 /*
655 * @tc.name: ReadWritePerformance 001
656 * @tc.desc: calculate the time of put-get in 16b-100b/16b-100kb, 1k times' random-put&get.
657 * @tc.type: Performance
658 * @tc.require: SR000BUH3J
659 * @tc.author: luqianfu
660 */
661 HWTEST_F(DistributeddbKvCrudTest, ReadWritePerformance001, TestSize.Level3)
662 {
663 const int PERFORMANCE_SIZE = 6;
664 PerformanceData performanceData[PERFORMANCE_SIZE] = {
665 /**
666 * @tc.steps: step1. put/get 16B key,100B value with random model.
667 * @tc.expected: step1. Performance of put&get is normal.
668 */
669 { 1, 16, 100, false, false, false, false, IS_LOCAL },
670 /**
671 * @tc.steps: step2. put/get 16B key,100KB value with random model.
672 * @tc.expected: step2. Performance of put&get is normal.
673 */
674 { 1, 16, 100 * 1000, false, false, false, false, IS_LOCAL },
675 /**
676 * @tc.steps: step3. put/get 16B key,100B value with random model.
677 * @tc.expected: step3. Performance of put&get is normal.
678 */
679 { 50, 16, 100, false, false, false, false, IS_LOCAL },
680 /**
681 * @tc.steps: step4. put/get 16B key,100KB value with random model.
682 * @tc.expected: step4. Performance of put&get is normal.
683 */
684 { 50, 16, 100 * 1000, false, false, false, false, IS_LOCAL },
685 /**
686 * @tc.steps: step5. put/get 16B key,100B value with random model.
687 * @tc.expected: step5. Performance of put&get is normal.
688 */
689 { 100, 16, 100, false, false, false, false, IS_LOCAL },
690 /**
691 * @tc.steps: step6. put/get 16B key,100B value with random model.
692 * @tc.expected: step6. Performance of put&get is normal.
693 */
694 { 100, 16, 100 * 1000, false, false, false, false, IS_LOCAL }
695 };
696
697 for (int ps = 0; ps < PERFORMANCE_SIZE; ++ps) {
698 EXPECT_TRUE(DistributedTestTools::CalculateOpenPerformance(performanceData[ps]));
699 EXPECT_TRUE(DistributedTestTools::CalculateInsertPerformance(performanceData[ps]));
700 EXPECT_TRUE(DistributedTestTools::CalculateGetPutPerformance(performanceData[ps]));
701 EXPECT_TRUE(DistributedTestTools::CalculateUpdatePerformance(performanceData[ps]));
702 EXPECT_TRUE(DistributedTestTools::CalculateGetUpdatePerformance(performanceData[ps]));
703 EXPECT_TRUE(DistributedTestTools::CalculateUseClearPerformance(performanceData[ps]));
704 }
705 }
706 }
707 #endif // OMIT_MULTI_VER