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 <gtest/gtest.h>
17
18 #include "distributeddb_data_generate_unit_test.h"
19 #include "distributeddb_tools_unit_test.h"
20
21 using namespace testing::ext;
22 using namespace DistributedDB;
23 using namespace DistributedDBUnitTest;
24 using namespace std;
25
26 namespace {
27 string g_testDir;
28 const string STORE_ID = STORE_ID_LOCAL;
29
30 KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
31 KvStoreConfig g_config;
32 // define the g_kvDelegateCallback, used to get some information when open a kv store.
33 DBStatus g_kvDelegateStatusForQuery = INVALID_ARGS;
34
35 #ifndef OMIT_MULTI_VER
36 const bool LOCAL_ONLY = true;
37 KvStoreDelegate *g_kvDelegatePtrForQuery = nullptr;
38 // the type of g_kvDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
39 auto g_kvDelegateCallbackForQuery = bind(&DistributedDBToolsUnitTest::KvStoreDelegateCallback, placeholders::_1,
40 placeholders::_2, std::ref(g_kvDelegateStatusForQuery), std::ref(g_kvDelegatePtrForQuery));
41
42 // define the g_kvDelegateCallback, used to get some information when open a kv store.
43 DBStatus g_kvDelegateStatus = INVALID_ARGS;
44 KvStoreDelegate *g_kvDelegatePtr = nullptr;
45 // the type of g_kvDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
46 auto g_kvDelegateCallback = bind(&DistributedDBToolsUnitTest::KvStoreDelegateCallback, placeholders::_1,
47 placeholders::_2, std::ref(g_kvDelegateStatus), std::ref(g_kvDelegatePtr));
48
49 // define the g_snapshotDelegateCallback, used to get some information when open a kv snapshot.
50 DBStatus g_snapshotDelegateStatus = INVALID_ARGS;
51 KvStoreSnapshotDelegate *g_snapshotDelegatePtr = nullptr;
52 // the type of g_snapshotDelegateCallback is function<void(DBStatus, KvStoreSnapshotDelegate*)>
53 auto g_snapshotDelegateCallback = bind(&DistributedDBToolsUnitTest::SnapshotDelegateCallback,
54 placeholders::_1, placeholders::_2, std::ref(g_snapshotDelegateStatus), std::ref(g_snapshotDelegatePtr));
55 #endif // OMIT_MULTI_VER
56
57 KvStoreNbDelegate *g_kvNbDelegatePtrForQuery = nullptr;
58 auto g_kvNbDelegateCallbackForQuery = bind(&DistributedDBToolsUnitTest::KvStoreNbDelegateCallback,
59 placeholders::_1, placeholders::_2, std::ref(g_kvDelegateStatusForQuery), std::ref(g_kvNbDelegatePtrForQuery));
60
61 // define the g_valueCallback, used to query a value object data from the kvdb.
62 DBStatus g_valueStatus = INVALID_ARGS;
63 Value g_value;
64 // the type of g_valueCallback is function<void(DBStatus, Value)>
65 auto g_valueCallback = bind(&DistributedDBToolsUnitTest::ValueCallback,
66 placeholders::_1, placeholders::_2, std::ref(g_valueStatus), std::ref(g_value));
67
68 // define the g_entryVectorCallback, used to query a vector<Entry> object data from the kvdb.
69 DBStatus g_entryVectorStatus = INVALID_ARGS;
70 unsigned long g_matchSize = 0;
71 std::vector<Entry> g_entriesVector;
72 // the type of g_entryVectorCallback is function<void(DBStatus, vector<Entry>)>
73 auto g_entryVectorCallback = bind(&DistributedDBToolsUnitTest::EntryVectorCallback, placeholders::_1,
74 placeholders::_2, std::ref(g_entryVectorStatus), std::ref(g_matchSize), std::ref(g_entriesVector));
75
76 const string SCHEMA_STRING = "{\"SCHEMA_VERSION\":\"1.0\","
77 "\"SCHEMA_MODE\":\"STRICT\","
78 "\"SCHEMA_DEFINE\":{"
79 "\"field_name1\":\"BOOL\","
80 "\"field_name2\":\"BOOL\","
81 "\"field_name3\":\"INTEGER, NOT NULL\","
82 "\"field_name4\":\"LONG, DEFAULT 100\","
83 "\"field_name5\":\"DOUBLE, NOT NULL, DEFAULT 3.14\","
84 "\"field_name6\":\"STRING, NOT NULL, DEFAULT '3.1415'\","
85 "\"field_name7\":\"LONG, DEFAULT 100\","
86 "\"field_name8\":\"LONG, DEFAULT 100\","
87 "\"field_name9\":\"LONG, DEFAULT 100\","
88 "\"field_name10\":\"LONG, DEFAULT 100\""
89 "},"
90 "\"SCHEMA_INDEXES\":[\"$.field_name1\", \"$.field_name2\"]}";
91 #ifndef OMIT_MULTI_VER
GetSnapshotUnitTest()92 void GetSnapshotUnitTest()
93 {
94 g_kvDelegatePtr->GetKvStoreSnapshot(nullptr, g_snapshotDelegateCallback);
95 EXPECT_TRUE(g_snapshotDelegateStatus == OK);
96 ASSERT_TRUE(g_snapshotDelegatePtr != nullptr);
97 }
98
TestSnapshotCreateAndRelease()99 void TestSnapshotCreateAndRelease()
100 {
101 DBStatus status;
102 KvStoreSnapshotDelegate *snapshot = nullptr;
103 KvStoreObserver *observer = nullptr;
104 auto snapshotDelegateCallback = bind(&DistributedDBToolsUnitTest::SnapshotDelegateCallback,
105 placeholders::_1, placeholders::_2, std::ref(status), std::ref(snapshot));
106
107 /**
108 * @tc.steps: step1. Obtain the snapshot object snapshot through
109 * the GetKvStoreSnapshot interface of the delegate.
110 * @tc.expected: step1. Returns a non-empty snapshot.
111 */
112 g_kvDelegatePtr->GetKvStoreSnapshot(observer, snapshotDelegateCallback);
113
114 EXPECT_TRUE(status == OK);
115 EXPECT_NE(snapshot, nullptr);
116
117 /**
118 * @tc.steps: step2. Release the obtained snapshot through
119 * the ReleaseKvStoreSnapshot interface of the delegate.
120 * @tc.expected: step2. Release successfully.
121 */
122 EXPECT_EQ(g_kvDelegatePtr->ReleaseKvStoreSnapshot(snapshot), OK);
123 }
124 #endif // OMIT_MULTI_VER
125 #ifndef OMIT_JSON
126 const int CIRCLE_COUNT = 3;
PutValidEntries1()127 void PutValidEntries1()
128 {
129 std::string validData = "{\"field_name1\":true,";
130 validData += "\"field_name2\":true,";
131 validData += "\"field_name3\":10,";
132 validData += "\"field_name4\":20,";
133 validData += "\"field_name5\":3.14,";
134 validData += "\"field_name6\":\"3.1415\",";
135 validData += "\"field_name7\":100,";
136 validData += "\"field_name8\":100,";
137 validData += "\"field_name9\":100,";
138 validData += "\"field_name10\":100}";
139
140 Value value(validData.begin(), validData.end());
141 Key key;
142 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
143 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
144 }
PutValidEntries2()145 void PutValidEntries2()
146 {
147 std::string validData = "{\"field_name1\":true,"
148 "\"field_name2\":false,"
149 "\"field_name3\":10,"
150 "\"field_name4\":20,"
151 "\"field_name5\":3.14,"
152 "\"field_name6\":\"3.1415\","
153 "\"field_name7\":100,"
154 "\"field_name8\":100,"
155 "\"field_name9\":100,"
156 "\"field_name10\":100}";
157 Value value(validData.begin(), validData.end());
158 Key key;
159 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
160 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
161 }
PutValidEntries3()162 void PutValidEntries3()
163 {
164 std::string validData = "{\"field_name1\":true,"
165 "\"field_name2\":true,"
166 "\"field_name3\":20,"
167 "\"field_name4\":20,"
168 "\"field_name5\":3.14,"
169 "\"field_name6\":\"3.1415\","
170 "\"field_name7\":100,"
171 "\"field_name8\":100,"
172 "\"field_name9\":100,"
173 "\"field_name10\":100}";
174 Value value(validData.begin(), validData.end());
175 Key key;
176 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
177 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
178 }
PutValidEntries4()179 void PutValidEntries4()
180 {
181 std::string validData = "{\"field_name1\":true,"
182 "\"field_name2\":true,"
183 "\"field_name3\":20,"
184 "\"field_name4\":2,"
185 "\"field_name5\":3.14,"
186 "\"field_name6\":\"3.1415\","
187 "\"field_name7\":100,"
188 "\"field_name8\":100,"
189 "\"field_name9\":100,"
190 "\"field_name10\":100}";
191 Value value(validData.begin(), validData.end());
192 Key key;
193 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
194 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
195 }
PutValidEntries5()196 void PutValidEntries5()
197 {
198 std::string validData = "{\"field_name1\":true,"
199 "\"field_name2\":true,"
200 "\"field_name3\":20,"
201 "\"field_name4\":2,"
202 "\"field_name5\":3.15,"
203 "\"field_name6\":\"3.1415\","
204 "\"field_name7\":1001,"
205 "\"field_name8\":100,"
206 "\"field_name9\":100,"
207 "\"field_name10\":100}";
208 Value value(validData.begin(), validData.end());
209 Key key;
210 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
211 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
212 }
PutValidEntries6()213 void PutValidEntries6()
214 {
215 std::string validData = "{\"field_name1\":true,"
216 "\"field_name2\":true,"
217 "\"field_name3\":20,"
218 "\"field_name4\":2,"
219 "\"field_name5\":3.15,"
220 "\"field_name6\":\"4.141\","
221 "\"field_name7\":1002,"
222 "\"field_name8\":100,"
223 "\"field_name9\":100,"
224 "\"field_name10\":100}";
225 Value value(validData.begin(), validData.end());
226 Key key;
227 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
228 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
229 }
PutValidEntries7()230 void PutValidEntries7()
231 {
232 std::string validData = "{\"field_name1\":true,"
233 "\"field_name2\":true,"
234 "\"field_name3\":20,"
235 "\"field_name4\":2,"
236 "\"field_name5\":3.15,"
237 "\"field_name6\":\"4.141\","
238 "\"field_name7\":100,"
239 "\"field_name8\":200,"
240 "\"field_name9\":100,"
241 "\"field_name10\":100}";
242 Value value(validData.begin(), validData.end());
243 Key key;
244 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
245 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
246 }
PutValidEntries8()247 void PutValidEntries8()
248 {
249 std::string validData = "{\"field_name1\":true,"
250 "\"field_name2\":true,"
251 "\"field_name3\":20,"
252 "\"field_name4\":2,"
253 "\"field_name5\":3.15,"
254 "\"field_name6\":\"4.141\","
255 "\"field_name7\":1009,"
256 "\"field_name8\":200,"
257 "\"field_name9\":100,"
258 "\"field_name10\":500}";
259 Value value(validData.begin(), validData.end());
260 Key key;
261 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
262 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(key, value), OK);
263 }
264
PutValidEntries()265 void PutValidEntries()
266 {
267 for (int i = 0; i < CIRCLE_COUNT; i++) {
268 PutValidEntries1();
269 PutValidEntries2();
270 PutValidEntries3();
271 PutValidEntries4();
272 PutValidEntries5();
273 PutValidEntries6();
274 PutValidEntries7();
275 PutValidEntries8();
276 }
277 }
278
279 const std::string SCHEMA_DEFINE2 = "{\"SCHEMA_VERSION\":\"1.0\","
280 "\"SCHEMA_MODE\":\"STRICT\","
281 "\"SCHEMA_DEFINE\":{"
282 "\"field_name1\":\"INTEGER\","
283 "\"field_name2\":\"DOUBLE\""
284 "},"
285 "\"SCHEMA_INDEXES\":[\"$.field_name1\", \"$.field_name2\"]}";
286
PresetDataForPreifxAndOrderBy001()287 void PresetDataForPreifxAndOrderBy001()
288 {
289 std::string validData = "{\"field_name1\":1, \"field_name2\":1}";
290 Value value(validData.begin(), validData.end());
291 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_1, value), OK);
292 validData = "{\"field_name1\":1, \"field_name2\":2}";
293 Value value2(validData.begin(), validData.end());
294 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_2, value2), OK);
295 validData = "{\"field_name1\":2, \"field_name2\":3}";
296 Value value3(validData.begin(), validData.end());
297 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_3, value3), OK);
298 validData = "{\"field_name1\":2, \"field_name2\":4}";
299 Value value4(validData.begin(), validData.end());
300 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_4, value4), OK);
301 validData = "{\"field_name1\":3, \"field_name2\":5}";
302 Value value5(validData.begin(), validData.end());
303 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_5, value5), OK);
304 }
305
PreDataForQueryByPreFixKey()306 vector<Entry> PreDataForQueryByPreFixKey()
307 {
308 vector<Entry> res;
309 for (int i = 0; i < 5; i++) { // rand num 5 for test
310 Key key = DistributedDBToolsUnitTest::GetRandPrefixKey({'a', 'b'}, 1024); // rand num 1024 for test
311 std::string validData = "{\"field_name1\":null, \"field_name2\":" + std::to_string(rand()) + "}";
312 Value value(validData.begin(), validData.end());
313 res.push_back({key, value});
314 }
315
316 for (int i = 0; i < 5; i++) { // rand num 5 for test
317 Key key = DistributedDBToolsUnitTest::GetRandPrefixKey({'a', 'c'}, 1024); // rand num 1024 for test
318 std::string validData = "{\"field_name1\":null, \"field_name2\":" + std::to_string(rand()) + "}";
319 Value value(validData.begin(), validData.end());
320 res.push_back({key, value});
321 }
322 return res;
323 }
324
PreDataForGroupTest()325 static void PreDataForGroupTest()
326 {
327 std::string validData = "{\"field_name1\":1, \"field_name2\":1}";
328 Value value(validData.begin(), validData.end());
329 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_1, value), OK);
330 validData = "{\"field_name1\":2, \"field_name2\":2}";
331 Value value2(validData.begin(), validData.end());
332 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_2, value2), OK);
333 validData = "{\"field_name1\":3, \"field_name2\":3}";
334 Value value3(validData.begin(), validData.end());
335 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_3, value3), OK);
336 validData = "{\"field_name1\":4, \"field_name2\":4}";
337 Value value4(validData.begin(), validData.end());
338 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_4, value4), OK);
339 validData = "{\"field_name1\":5, \"field_name2\":5}";
340 Value value5(validData.begin(), validData.end());
341 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_5, value5), OK);
342 }
343 #endif
344 }
345
346 class DistributedDBInterfacesDataOperationTest : public testing::Test {
347 public:
348 static void SetUpTestCase(void);
349 static void TearDownTestCase(void);
350 void SetUp();
351 void TearDown();
352 };
353
SetUpTestCase(void)354 void DistributedDBInterfacesDataOperationTest::SetUpTestCase(void)
355 {
356 DistributedDBToolsUnitTest::TestDirInit(g_testDir);
357 g_config.dataDir = g_testDir;
358 g_mgr.SetKvStoreConfig(g_config);
359 }
360
TearDownTestCase(void)361 void DistributedDBInterfacesDataOperationTest::TearDownTestCase(void)
362 {
363 if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
364 LOGE("rm test db files error!");
365 }
366 }
367
SetUp(void)368 void DistributedDBInterfacesDataOperationTest::SetUp(void)
369 {
370 DistributedDBToolsUnitTest::PrintTestCaseInfo();
371 // init values.
372 g_valueStatus = INVALID_ARGS;
373 g_value.clear();
374 g_entryVectorStatus = INVALID_ARGS;
375 g_matchSize = 0;
376
377 /*
378 * Here, we create STORE_ID.db before test,
379 * and it will be closed in TearDown().
380 */
381 #ifndef OMIT_MULTI_VER
382 CipherPassword passwd;
383 KvStoreDelegate::Option option = {true, LOCAL_ONLY, false, CipherType::DEFAULT, passwd};
384 g_mgr.GetKvStore(STORE_ID, option, g_kvDelegateCallback);
385 EXPECT_TRUE(g_kvDelegateStatus == OK);
386 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
387 #endif // OMIT_MULTI_VER
388 }
389
TearDown(void)390 void DistributedDBInterfacesDataOperationTest::TearDown(void)
391 {
392 #ifndef OMIT_MULTI_VER
393 if (g_kvDelegatePtr != nullptr && g_snapshotDelegatePtr != nullptr) {
394 EXPECT_TRUE(g_kvDelegatePtr->ReleaseKvStoreSnapshot(g_snapshotDelegatePtr) == OK);
395 g_snapshotDelegatePtr = nullptr;
396 }
397
398 if (g_kvDelegatePtr != nullptr) {
399 EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
400 g_kvDelegatePtr = nullptr;
401 }
402 #endif // OMIT_MULTI_VER
403 }
404
405 #ifndef OMIT_MULTI_VER
406 /**
407 * @tc.name: Put001
408 * @tc.desc: Put a data(non-empty key, non-empty value) into an exist distributed db
409 * @tc.type: FUNC
410 * @tc.require: AR000CQDTM AR000CQS3Q
411 * @tc.author: huangnaigu
412 */
413 HWTEST_F(DistributedDBInterfacesDataOperationTest, Put001, TestSize.Level1)
414 {
415 /**
416 * @tc.steps: step1. Put the data(non-empty key and non-empty value) into the database.
417 * @tc.expected: step1. Put returns OK.
418 */
419 Key keyTmp;
420 keyTmp.push_back(1);
421 Value valueTmp;
422 valueTmp.push_back('7');
423 EXPECT_TRUE(g_kvDelegatePtr->Put(keyTmp, valueTmp) == OK);
424
425 /**
426 * @tc.steps: step2. Get the value according the key through the snapshot.
427 * @tc.expected: step2. Get returns OK.
428 */
429 GetSnapshotUnitTest();
430 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
431 EXPECT_TRUE(g_valueStatus == OK);
432 }
433
434 /**
435 * @tc.name: Put002
436 * @tc.desc: Put a data(empty key) into an exist distributed db
437 * @tc.type: FUNC
438 * @tc.require: AR000C6TRV AR000CQDTM
439 * @tc.author: huangnaigu
440 */
441 HWTEST_F(DistributedDBInterfacesDataOperationTest, Put002, TestSize.Level1)
442 {
443 /**
444 * @tc.steps: step1. Put the data(empty key) into the database.
445 * @tc.expected: step1. Put returns INVALID_ARGS.
446 */
447 Key keyTmp;
448 Value valueTmp;
449 valueTmp.push_back('7');
450 EXPECT_TRUE(g_kvDelegatePtr->Put(keyTmp, valueTmp) == INVALID_ARGS);
451 }
452
453 /**
454 * @tc.name: Put003
455 * @tc.desc: Put a data(non-empty key, empty value) into an exist distributed db
456 * @tc.type: FUNC
457 * @tc.require: AR000CQDTM AR000CQS3Q
458 * @tc.author: huangnaigu
459 */
460 HWTEST_F(DistributedDBInterfacesDataOperationTest, Put003, TestSize.Level1)
461 {
462 /**
463 * @tc.steps: step1. Put the data(empty value) into the database.
464 * @tc.expected: step1. Put returns OK.
465 */
466 Key keyTmp;
467 keyTmp.push_back(1);
468 Value valueTmp;
469
470 EXPECT_TRUE(g_kvDelegatePtr->Put(keyTmp, valueTmp) == OK);
471 }
472
473 /**
474 * @tc.name: Put004
475 * @tc.desc: Put data into the local database
476 * @tc.type: FUNC
477 * @tc.require: AR000CQDVD AR000CQS3Q
478 * @tc.author: huangnaigu
479 */
480 HWTEST_F(DistributedDBInterfacesDataOperationTest, Put004, TestSize.Level1)
481 {
482 /**
483 * @tc.steps: step1. clear the database.
484 */
485 EXPECT_TRUE(g_kvDelegatePtr->Clear() == OK);
486
487 Key keyTmp;
488 keyTmp.push_back(1);
489
490 Value valueTmp;
491 valueTmp.push_back('7');
492
493 /**
494 * @tc.steps: step2. Put one data into the database.
495 * @tc.expected: step2. Put returns OK.
496 */
497 Value valueTest;
498 valueTest.push_back('9');
499 EXPECT_TRUE(g_kvDelegatePtr->Put(keyTmp, valueTmp) == OK);
500
501 /**
502 * @tc.steps: step3. Get the data from the database.
503 * @tc.expected: step3. Get returns OK and the read value is equal to the value put before.
504 */
505 GetSnapshotUnitTest();
506 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
507 EXPECT_TRUE(g_valueStatus == OK);
508 EXPECT_TRUE(g_value.size() > 0);
509 if (g_value.size() > 0) {
510 EXPECT_TRUE(g_value.front() == '7');
511 }
512
513 /**
514 * @tc.steps: step4. Change the value, and Put the data into the database.
515 * @tc.expected: step4. Put returns OK.
516 */
517 EXPECT_TRUE(g_kvDelegatePtr->Put(keyTmp, valueTest) == OK);
518
519 if (g_kvDelegatePtr != nullptr && g_snapshotDelegatePtr != nullptr) {
520 EXPECT_TRUE(g_kvDelegatePtr->ReleaseKvStoreSnapshot(g_snapshotDelegatePtr) == OK);
521 g_snapshotDelegatePtr = nullptr;
522 }
523 GetSnapshotUnitTest();
524 /**
525 * @tc.steps: step5. Get the data from the database.
526 * @tc.expected: step5. Get returns OK and the read value is equal to the new put value.
527 */
528 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
529 EXPECT_TRUE(g_valueStatus == OK);
530 EXPECT_TRUE(g_value.size() > 0);
531 if (g_value.size() > 0) {
532 EXPECT_TRUE(g_value.front() == '9');
533 }
534 }
535
536 /**
537 * @tc.name: Clear001
538 * @tc.desc: Clear the data from an exist distributed db
539 * @tc.type: FUNC
540 * @tc.require: AR000C6TRV AR000CQDTM
541 * @tc.author: huangnaigu
542 */
543 HWTEST_F(DistributedDBInterfacesDataOperationTest, Clear001, TestSize.Level1)
544 {
545 /**
546 * @tc.steps: step1. Put the valid data into the database.
547 */
548 Key keyTmp;
549 DistributedDBToolsUnitTest::GetRandomKeyValue(keyTmp);
550 Value valueTmp;
551 DistributedDBToolsUnitTest::GetRandomKeyValue(valueTmp);
552 EXPECT_TRUE(g_kvDelegatePtr->Put(keyTmp, valueTmp) == OK);
553
554 /**
555 * @tc.steps: step2. Clear the database.
556 * @tc.expected: step2. Clear returns OK.
557 */
558 EXPECT_TRUE(g_kvDelegatePtr->Clear() == OK);
559
560 /**
561 * @tc.steps: step3. Get the data from the database according the inserted key before clear.
562 * @tc.expected: step3. Get returns NOT_FOUND.
563 */
564 GetSnapshotUnitTest();
565 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
566 EXPECT_EQ(g_valueStatus, NOT_FOUND);
567 }
568
569 /**
570 * @tc.name: PutBatch001
571 * @tc.desc: Putbatch data into the local database
572 * @tc.type: FUNC
573 * @tc.require: AR000BVDFE AR000CQDVC
574 * @tc.author: huangnaigu
575 */
576 HWTEST_F(DistributedDBInterfacesDataOperationTest, PutBatch001, TestSize.Level1)
577 {
578 /**
579 * @tc.steps: step1. Put the prepared data.
580 */
581 vector<Entry> entries;
582 for (int i = 1; i < 10; i++) {
583 Entry entry;
584 entry.key.push_back(i);
585 entry.value.push_back('8');
586 entries.push_back(entry);
587 }
588 /**
589 * @tc.steps: step2. PutBatch the prepared data.
590 * @tc.expected: step2. PutBatch returns OK.
591 */
592 EXPECT_TRUE(g_kvDelegatePtr->PutBatch(entries) == OK);
593
594 /**
595 * @tc.steps: step3. Get the data from the database.
596 * @tc.expected: step3. Get returns OK and the get value is equal to the inserted value before.
597 */
598 GetSnapshotUnitTest();
599 for (int i = 1; i < 10; i++) {
600 Key keyTmp;
601 keyTmp.push_back(i);
602
603 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
604 EXPECT_TRUE(g_valueStatus == OK);
605 EXPECT_TRUE(g_value.size() > 0);
606 if (g_value.size() > 0) {
607 EXPECT_TRUE(g_value.front() == '8');
608 }
609 }
610 }
611
612 /**
613 * @tc.name: PutBatch002
614 * @tc.desc: PutBatch modified data into the local database
615 * @tc.type: FUNC
616 * @tc.require: AR000BVDFE AR000CQDVC
617 * @tc.author: huangnaigu
618 */
619 HWTEST_F(DistributedDBInterfacesDataOperationTest, PutBatch002, TestSize.Level1)
620 {
621 /**
622 * @tc.steps: step1. prepare the batch data.
623 */
624 vector<Entry> entries;
625 for (int i = 1; i < 10; i++) {
626 Entry entry;
627 entry.key.push_back(i);
628 entry.value.push_back('2');
629 entries.push_back(entry);
630 }
631 /**
632 * @tc.steps: step2. PutBatch the prepared batch data.
633 * @tc.expected: step2. PutBatch returns OK.
634 */
635 EXPECT_TRUE(g_kvDelegatePtr->PutBatch(entries) == OK);
636 /**
637 * @tc.steps: step3. Get data from the database according the inserted keys.
638 * @tc.expected: step3. Get returns OK and the read value is equal to the inserted value.
639 */
640 GetSnapshotUnitTest();
641 for (int i = 1; i < 10; i++) {
642 Key keyTmp;
643 keyTmp.push_back(i);
644
645 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
646 EXPECT_TRUE(g_valueStatus == OK);
647 EXPECT_TRUE(g_value.size() > 0);
648 if (g_value.size() > 0) {
649 EXPECT_TRUE(g_value.front() == '2');
650 }
651 }
652 }
653
654 /**
655 * @tc.name: Delete001
656 * @tc.desc: Delete existed data from the local database
657 * @tc.type: FUNC
658 * @tc.require: AR000C6TRV AR000CQDTM
659 * @tc.author: huangnaigu
660 */
661 HWTEST_F(DistributedDBInterfacesDataOperationTest, Delete001, TestSize.Level1)
662 {
663 /**
664 * @tc.steps: step1. Put the prepared data.
665 */
666 Key keyTmp;
667 keyTmp.push_back(1);
668 Value valueTmp;
669 valueTmp.push_back(3);
670 EXPECT_EQ(g_kvDelegatePtr->Put(keyTmp, valueTmp), OK);
671 /**
672 * @tc.steps: step2. Delete the existed data from the database.
673 * @tc.expected: step2. Delete returns OK.
674 */
675 EXPECT_EQ(g_kvDelegatePtr->Delete(keyTmp), OK);
676 /**
677 * @tc.steps: step3. Get the deleted data from the database.
678 * @tc.expected: step3. Get returns NOT_FOUND.
679 */
680 GetSnapshotUnitTest();
681 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
682 EXPECT_TRUE(g_valueStatus == NOT_FOUND);
683 }
684
685 /**
686 * @tc.name: Delete002
687 * @tc.desc: Delete non-existed data from the local database
688 * @tc.type: FUNC
689 * @tc.require: AR000C6TRV AR000CQDTM
690 * @tc.author: huangnaigu
691 */
692 HWTEST_F(DistributedDBInterfacesDataOperationTest, Delete002, TestSize.Level1)
693 {
694 /**
695 * @tc.steps: step1. Clear the database.
696 */
697 EXPECT_TRUE(g_kvDelegatePtr->Clear() == OK);
698
699 /**
700 * @tc.steps: step2. Delete the non-existed data from the database.
701 * @tc.expected: step2. Delete returns OK.
702 */
703 Key keyTmp;
704 keyTmp.push_back(1);
705 EXPECT_TRUE(g_kvDelegatePtr->Delete(keyTmp) == OK);
706 }
707
708 /**
709 * @tc.name: DeleteBatch001
710 * @tc.desc: Delete the existed batch data from the local database
711 * @tc.type: FUNC
712 * @tc.require: AR000C6TRV AR000CQDTM
713 * @tc.author: huangnaigu
714 */
715 HWTEST_F(DistributedDBInterfacesDataOperationTest, DeleteBatch001, TestSize.Level1)
716 {
717 /**
718 * @tc.steps: step1. Put the batch data into the database.
719 */
720 vector<Entry> entries;
721 for (int i = 1; i < 4; i++) {
722 Entry entry;
723 entry.key.push_back(i);
724 entry.value.push_back('2');
725 entries.push_back(entry);
726 }
727 EXPECT_TRUE(g_kvDelegatePtr->PutBatch(entries) == OK);
728
729 /**
730 * @tc.steps: step2. Delete the batch data from the database.
731 * @tc.steps: step2. DeleteBatch returns OK.
732 */
733 vector<Key> keys;
734 for (int i = 1; i < 4; i++) {
735 Key key;
736 key.push_back(i);
737 keys.push_back(key);
738 }
739 EXPECT_TRUE(g_kvDelegatePtr->DeleteBatch(keys) == OK);
740
741 /**
742 * @tc.steps: step3. Get all the data from the database.
743 * @tc.steps: step3. GetEntries result NOT_FOUND.
744 */
745 Key keyTmp;
746 GetSnapshotUnitTest();
747 g_snapshotDelegatePtr->Get(keyTmp, g_valueCallback);
748 EXPECT_TRUE(g_valueStatus == INVALID_ARGS);
749 }
750
751 /**
752 * @tc.name: DeleteBatch002
753 * @tc.desc: Delete the non-existed batch data from the local database
754 * @tc.type: FUNC
755 * @tc.require: AR000C6TRV AR000CQDTM
756 * @tc.author: huangnaigu
757 */
758 HWTEST_F(DistributedDBInterfacesDataOperationTest, DeleteBatch002, TestSize.Level1)
759 {
760 /**
761 * @tc.steps: step1. clear the database.
762 */
763 EXPECT_TRUE(g_kvDelegatePtr->Clear() == OK);
764 /**
765 * @tc.steps: step2. Delete the batch non-existed data from the database.
766 * @tc.expected: step2. DeleteBatch returns OK
767 */
768 vector<Key> keys;
769 for (int i = 1; i < 10; i++) {
770 Key key;
771 key.push_back(i);
772 keys.push_back(key);
773 }
774 EXPECT_TRUE(g_kvDelegatePtr->DeleteBatch(keys) == OK);
775 }
776
777 /**
778 * @tc.name: GetEntries001
779 * @tc.desc: Get the batch data from the non-empty database by the prefix key.
780 * @tc.type: FUNC
781 * @tc.require: AR000C6TUQ AR000CQDV3
782 * @tc.author: huangnaigu
783 */
784 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntries001, TestSize.Level1)
785 {
786 /**
787 * @tc.steps: step1. insert batch data into the database.
788 */
789 vector<Entry> entries;
790 for (int i = 1; i <= 10; i++) {
791 Entry entry;
792 for (int j = 1; j <= i; j++) {
793 entry.key.push_back(j);
794 }
795 entry.value.push_back(i);
796 entries.push_back(entry);
797 }
798
799 EXPECT_TRUE(g_kvDelegatePtr->PutBatch(entries) == OK);
800
801 Key keyPrefix;
802 for (int j = 1; j <= 5; j++) {
803 keyPrefix.push_back(j);
804 }
805 /**
806 * @tc.steps: step2. Get batch data from the database using the prefix key.
807 * @tc.expected: step2. GetEntries results OK and the result entries size is the match size.
808 */
809 unsigned long matchSize = 6;
810 GetSnapshotUnitTest();
811 g_snapshotDelegatePtr->GetEntries(keyPrefix, g_entryVectorCallback);
812 ASSERT_TRUE(g_matchSize == matchSize);
813 EXPECT_TRUE(g_entryVectorStatus == OK);
814 }
815
816 /**
817 * @tc.name: GetEntries002
818 * @tc.desc: Get all the data(empty prefixkey) from the empty database.
819 * @tc.type: FUNC
820 * @tc.require: AR000C6TUQ AR000CQDV3
821 * @tc.author: huangnaigu
822 */
823 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntries002, TestSize.Level1)
824 {
825 /**
826 * @tc.steps: step1. Get all the data from the empty database.
827 * @tc.expected: step1. GetEntries results NOT_FOUND.
828 */
829 Key keyPrefix;
830 for (int j = 1; j <= 5; j++) {
831 keyPrefix.push_back('a');
832 }
833
834 unsigned long matchSize = 0;
835 GetSnapshotUnitTest();
836 g_snapshotDelegatePtr->GetEntries(keyPrefix, g_entryVectorCallback);
837 ASSERT_TRUE(g_matchSize == matchSize);
838 EXPECT_TRUE(g_entryVectorStatus == NOT_FOUND);
839 }
840
841 /**
842 * @tc.name: GetEntries003
843 * @tc.desc: Get all the data(empty prefixkey) from the database.
844 * @tc.type: FUNC
845 * @tc.require: AR000C6TUQ AR000CQDV3
846 * @tc.author: huangnaigu
847 */
848 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntries003, TestSize.Level1)
849 {
850 /**
851 * @tc.steps: step1. Put batch data into the database.
852 */
853 vector<Entry> entries;
854 for (int i = 1; i <= 10; i++) {
855 Entry entry;
856 for (int j = 1; j <= i; j++) {
857 entry.key.push_back(j);
858 }
859 entry.value.push_back(i);
860 entries.push_back(entry);
861 }
862
863 EXPECT_TRUE(g_kvDelegatePtr->PutBatch(entries) == OK);
864
865 /**
866 * @tc.steps: step2. Get all the data from the database using the empty prefix key.
867 * @tc.expected: step2. GetEntries results OK and the entries size is the put batch data size.
868 */
869 Key keyPrefix;
870 unsigned long matchSize = 10;
871 GetSnapshotUnitTest();
872 g_snapshotDelegatePtr->GetEntries(keyPrefix, g_entryVectorCallback);
873 ASSERT_TRUE(g_matchSize == matchSize);
874 EXPECT_TRUE(g_entryVectorStatus == OK);
875 }
876
877 /**
878 * @tc.name: GetSnapshot001
879 * @tc.desc: Get observer is empty, whether you get the snapshot.
880 * @tc.type: FUNC
881 * @tc.require: AR000BVRNF AR000CQDTI
882 * @tc.author: wangbingquan
883 */
884 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetSnapshot001, TestSize.Level1)
885 {
886 /**
887 * @tc.steps: step1.Obtain the snapshot object whose observer is null
888 * by using the GetKvStoreSnapshot interface of the delegate.
889 * @tc.expected: step1. The obtained snapshot is not empty.
890 */
891 TestSnapshotCreateAndRelease();
892 }
893
894 /**
895 * @tc.name: GetSnapshot002
896 * @tc.desc: Get observer is not empty, whether you get the snapshot.
897 * @tc.type: FUNC
898 * @tc.require: AR000BVRNF AR000CQDTI
899 * @tc.author: wangbingquan
900 */
901 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetSnapshot002, TestSize.Level1)
902 {
903 /**
904 * @tc.steps: step1.Obtain the snapshot object whose observer is null
905 * by using the GetKvStoreSnapshot interface of the delegate.
906 * @tc.expected: step1. The obtained snapshot is not empty.
907 */
908 DBStatus status;
909 KvStoreSnapshotDelegate *snapshot = nullptr;
910 KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
911 ASSERT_NE(observer, nullptr);
912 auto snapshotDelegateCallback = bind(&DistributedDBToolsUnitTest::SnapshotDelegateCallback,
913 placeholders::_1, placeholders::_2, std::ref(status), std::ref(snapshot));
914 g_kvDelegatePtr->GetKvStoreSnapshot(observer, snapshotDelegateCallback);
915
916 EXPECT_TRUE(status == OK);
917 EXPECT_NE(snapshot, nullptr);
918
919 /**
920 * @tc.steps: step2. Release the snapshot get before.
921 * @tc.expected: step2. ReleaseKvStoreSnapshot returns OK.
922 */
923 EXPECT_EQ(g_kvDelegatePtr->ReleaseKvStoreSnapshot(snapshot), OK);
924 delete observer;
925 observer = nullptr;
926 }
927
928 /**
929 * @tc.name: ReleaseSnapshot001
930 * @tc.desc: To test the function of releasing an empty snapshot.
931 * @tc.type: FUNC
932 * @tc.require: AR000BVRNF AR000CQDTI
933 * @tc.author: wangbingquan
934 */
935 HWTEST_F(DistributedDBInterfacesDataOperationTest, ReleaseSnapshot001, TestSize.Level1)
936 {
937 /**
938 * @tc.steps: step1.Release the null pointer snapshot through
939 * the ReleaseKvStoreSnapshot interface of the delegate.
940 * @tc.expected: step1. Return ERROR.
941 */
942 KvStoreSnapshotDelegate *snapshot = nullptr;
943 EXPECT_EQ(g_kvDelegatePtr->ReleaseKvStoreSnapshot(snapshot), DB_ERROR);
944 }
945
946 /**
947 * @tc.name: ReleaseSnapshot002
948 * @tc.desc: Release the obtained snapshot object that is not empty.
949 * @tc.type: FUNC
950 * @tc.require: AR000BVRNF AR000CQDTI
951 * @tc.author: wangbingquan
952 */
953 HWTEST_F(DistributedDBInterfacesDataOperationTest, ReleaseSnapshot002, TestSize.Level1)
954 {
955 TestSnapshotCreateAndRelease();
956 }
957
958 /**
959 * @tc.name: SetConflictResolutionPolicySuccessTest001
960 * @tc.desc: Verify SetConflictResolutionPolicy() return OK with valid input.
961 * @tc.type: FUNC
962 * @tc.require: AR000CQE12
963 * @tc.author: wumin
964 */
965 HWTEST_F(DistributedDBInterfacesDataOperationTest, SetConflictResolutionPolicySuccessTest001, TestSize.Level1)
966 {
967 /**
968 * @tc.steps: step1. get g_kvDelegatePtr pointer
969 * @tc.expected: step1. g_kvDelegatePtr is not nullptr
970 */
971 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
972
973 /**
974 * @tc.steps: step2. invoke SetConflictResolutionPolicy() method by g_kvDelegatePtr
975 * @tc.expected: step2. SetConflictResolutionPolicy() return OK
976 */
977 EXPECT_EQ(g_kvDelegatePtr->SetConflictResolutionPolicy(AUTO_LAST_WIN, nullptr), OK);
978 }
979
980 /**
981 * @tc.name: SetConflictResolutionPolicyFailedTest001
982 * @tc.desc: Verify SetConflictResolutionPolicy() return INVALID_ARGS with invalid input.
983 * @tc.type: FUNC
984 * @tc.require: AR000CQE12
985 * @tc.author: wumin
986 */
987 HWTEST_F(DistributedDBInterfacesDataOperationTest, SetConflictResolutionPolicyFailedTest001, TestSize.Level1)
988 {
989 /**
990 * @tc.steps: step1. get g_kvDelegatePtr pointer
991 * @tc.expected: step1. g_kvDelegatePtr is not nullptr
992 */
993 ASSERT_TRUE(g_kvDelegatePtr != nullptr);
994
995 /**
996 * @tc.steps: step2. invoke SetConflictResolutionPolicy() method by g_kvDelegatePtr
997 * @tc.expected: step2. SetConflictResolutionPolicy() return not OK
998 */
999 EXPECT_NE(g_kvDelegatePtr->SetConflictResolutionPolicy(CUSTOMER_RESOLUTION, nullptr), OK);
1000 }
1001 #endif // OMIT_MULTI_VER
1002 #ifndef OMIT_JSON
1003 /**
1004 * @tc.name: GetEntriesWithQuery001
1005 * @tc.desc: check query_format.
1006 * @tc.type: FUNC
1007 * @tc.require: AR000DR9K7
1008 * @tc.author: weifeng
1009 */
1010 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntriesWithQuery001, TestSize.Level1)
1011 {
1012 /**
1013 * @tc.steps: step1. get a non-schema store, Getentries with query
1014 * @tc.expected: step1. get store ok, Getentries return OK
1015 */
1016 KvStoreNbDelegate::Option option = {true, false, false};
1017 g_mgr.GetKvStore("GetEntriesWithQuery001_001", option, g_kvNbDelegateCallbackForQuery);
1018 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1019 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1020 Query query = Query::Select();
1021 std::vector<Entry> entries;
1022 DBStatus ret = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1023 EXPECT_EQ(ret, NOT_FOUND);
1024 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1025 EXPECT_TRUE(g_mgr.DeleteKvStore("GetEntriesWithQuery001_001") == OK);
1026 /**
1027 * @tc.steps: step2. get a schema store, Getentries with empty query
1028 * @tc.expected: step2. get store ok, Getentries return OK
1029 */
1030 option.schema = SCHEMA_STRING;
1031 g_mgr.GetKvStore("GetEntriesWithQuery001_002", option, g_kvNbDelegateCallbackForQuery);
1032 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1033 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1034 ret = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1035 EXPECT_TRUE(ret == NOT_FOUND);
1036 /**
1037 * @tc.steps: step3. Getentries by query, query undefined field
1038 * @tc.expected: step3. Getentries return INVALID_QUERY_FIELD
1039 */
1040 query = query.EqualTo("$.field_name200", 10);
1041 ret = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1042 EXPECT_EQ(ret, INVALID_QUERY_FIELD);
1043 /**
1044 * @tc.steps: step4. Getentries by query, query has invalid linker;
1045 * @tc.expected: step4. Getentries return INVALID_QUERY_FORMAT
1046 */
1047 Query invalidQuery1 = Query::Select().EqualTo("$.field_name1", true).And().Or();
1048 ret = g_kvNbDelegatePtrForQuery->GetEntries(invalidQuery1, entries);
1049 EXPECT_TRUE(ret == INVALID_QUERY_FORMAT);
1050 /**
1051 * @tc.steps: step5. Getentries by query, query has invalid linker;
1052 * @tc.expected: step5. Getentries return INVALID_QUERY_FORMAT
1053 */
1054 Query invalidQuery2 = Query::Select().And();
1055 ret = g_kvNbDelegatePtrForQuery->GetEntries(invalidQuery2, entries);
1056 EXPECT_TRUE(ret == INVALID_QUERY_FORMAT);
1057 /**
1058 * @tc.steps: step6. Getentries by query, query has invalid limit;
1059 * @tc.expected: step6. Getentries return INVALID_QUERY_FORMAT
1060 */
1061 Query invalidQuery3 = Query::Select().Limit(10, 0).EqualTo("$.field_name1", true);
1062 ret = g_kvNbDelegatePtrForQuery->GetEntries(invalidQuery3, entries);
1063 EXPECT_TRUE(ret == INVALID_QUERY_FORMAT);
1064 /**
1065 * @tc.steps: step7. Getentries by query, query has invalid orderby;
1066 * @tc.expected: step7. Getentries return INVALID_QUERY_FORMAT
1067 */
1068 Query invalidQuery4 = Query::Select().OrderBy("$.field_name1", true).EqualTo("field_name1", true);
1069 ret = g_kvNbDelegatePtrForQuery->GetEntries(invalidQuery4, entries);
1070 EXPECT_TRUE(ret == INVALID_QUERY_FORMAT);
1071 /**
1072 * @tc.steps: step8. Getentries by query, query has invalid orderby and limit;
1073 * @tc.expected: step8. Getentries return INVALID_QUERY_FORMAT
1074 */
1075 Query invalidQuery5 = Query::Select().Limit(10, 0).OrderBy("$.field_name1", true);
1076 ret = g_kvNbDelegatePtrForQuery->GetEntries(invalidQuery5, entries);
1077 EXPECT_TRUE(ret == INVALID_QUERY_FORMAT);
1078 /**
1079 * @tc.steps: step9. Getentries by query, query has invalid field type;
1080 * @tc.expected: step9. Getentries return OK
1081 */
1082 std::string queryType = "true";
1083 Query invalidQuery6 = Query::Select().EqualTo("$.field_name1", queryType);
1084 ret = g_kvNbDelegatePtrForQuery->GetEntries(invalidQuery6, entries);
1085 EXPECT_TRUE(ret == NOT_FOUND);
1086
1087 Query invalidQuery7 = Query::Select().EqualTo("$.field_name1", queryType).IsNull("$.field_name1");
1088 ret = g_kvNbDelegatePtrForQuery->GetEntries(invalidQuery7, entries);
1089 EXPECT_TRUE(ret == INVALID_QUERY_FORMAT);
1090
1091 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1092 EXPECT_TRUE(g_mgr.DeleteKvStore("GetEntriesWithQuery001_002") == OK);
1093 }
1094
1095 /**
1096 * @tc.name: GetEntriesWithQuery002
1097 * @tc.desc: GetEntries(const Query &query, std::vector<Entry> &entries) interface test.
1098 * @tc.type: FUNC
1099 * @tc.require: AR000DR9K7
1100 * @tc.author: weifeng
1101 */
1102 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntriesWithQuery002, TestSize.Level1)
1103 {
1104 KvStoreNbDelegate::Option option = {true, false, false};
1105 option.schema = SCHEMA_STRING;
1106 g_mgr.GetKvStore("GetEntriesWithQuery002_002", option, g_kvNbDelegateCallbackForQuery);
1107 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1108 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1109 PutValidEntries();
1110 /**
1111 * @tc.steps: step1. Getentries by query, query is empty;
1112 * @tc.expected: step1. Getentries return OK, entries size == totalSize;
1113 */
1114 Query query = Query::Select();
1115 std::vector<Entry> entries;
1116 int ret = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1117 EXPECT_EQ(ret, OK);
1118 EXPECT_EQ(entries.size(), 24ul);
1119 /**
1120 * @tc.steps: step2. Getentries by query, query is full-set;
1121 * @tc.expected: step2. Getentries return OK, ;
1122 */
1123 std::vector<int> inCondition = {1, 10, 100, 200};
1124 Query fullQuery = Query::Select().EqualTo("$.field_name1", true).And().NotEqualTo("$.field_name2", false).
1125 And().GreaterThanOrEqualTo("$.field_name3", 10).And().LessThan("$.field_name4", 10).And().
1126 Like("$.field_name6", "4%").And().In("$.field_name7", inCondition).OrderBy("$.field_name9").Limit(20);
1127 ret = g_kvNbDelegatePtrForQuery->GetEntries(fullQuery, entries);
1128 EXPECT_EQ(ret, OK);
1129 EXPECT_EQ(entries.size(), 3ul);
1130 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1131 EXPECT_TRUE(g_mgr.DeleteKvStore("GetEntriesWithQuery002_002") == OK);
1132 }
1133
1134 /**
1135 * @tc.name: GetEntriesWithQuery003
1136 * @tc.desc: GetEntries(const Query &query, std::vector<Entry> &entries) interface test.
1137 * @tc.type: FUNC
1138 * @tc.require: AR000DR9K7
1139 * @tc.author: weifeng
1140 */
1141 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntriesWithQuery003, TestSize.Level1)
1142 {
1143 KvStoreNbDelegate::Option option = {true, false, false};
1144 option.schema = SCHEMA_STRING;
1145 g_mgr.GetKvStore("GetEntriesWithQuery003", option, g_kvNbDelegateCallbackForQuery);
1146 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1147 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1148 PutValidEntries();
1149 /**
1150 * @tc.steps: step1. Getentries by query, query is empty;
1151 * @tc.expected: step1. Getentries return OK, entries size == totalSize;
1152 */
1153 Query query = Query::Select();
1154 int count = 0;
1155 int ret = g_kvNbDelegatePtrForQuery->GetCount(query, count);
1156 EXPECT_TRUE(ret == OK);
1157 EXPECT_TRUE(count == 24);
1158 /**
1159 * @tc.steps: step2. Getentries by query, query is full-set;
1160 * @tc.expected: step2. Getentries return OK, ;
1161 */
1162 std::vector<int> inCondition = {1, 10, 100, 200};
1163 Query fullQuery = Query::Select().EqualTo("$.field_name1", true).And().NotEqualTo("$.field_name2", false).
1164 And().GreaterThan("$.field_name3", 10).And().LessThan("$.field_name4", 10).And().Like("$.field_name6", "4%").
1165 And().In("$.field_name7", inCondition);
1166 ret = g_kvNbDelegatePtrForQuery->GetCount(fullQuery, count);
1167 EXPECT_TRUE(ret == OK);
1168 EXPECT_TRUE(count == 3);
1169 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1170 EXPECT_TRUE(g_mgr.DeleteKvStore("GetEntriesWithQuery003") == OK);
1171 }
1172
1173 /**
1174 * @tc.name: GetEntriesWithQuery004
1175 * @tc.desc: GetEntries(const Query &query, std::vector<Entry> &entries) interface test.
1176 * @tc.type: FUNC
1177 * @tc.require: AR000DR9K7
1178 * @tc.author: weifeng
1179 */
1180 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntriesWithQuery004, TestSize.Level1)
1181 {
1182 KvStoreNbDelegate::Option option = {true, false, false};
1183 option.schema = SCHEMA_STRING;
1184 g_mgr.GetKvStore("GetEntriesWithQuery004", option, g_kvNbDelegateCallbackForQuery);
1185 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1186 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1187 PutValidEntries();
1188 /**
1189 * @tc.steps: step1. Getentries by query, query is empty;
1190 * @tc.expected: step1. Getentries return OK, entries size == totalSize;
1191 */
1192 Query query = Query::Select();
1193 KvStoreResultSet *resultSet = nullptr;
1194 int ret = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1195 ASSERT_TRUE(resultSet != nullptr);
1196 EXPECT_TRUE(ret == OK);
1197 EXPECT_EQ(resultSet->GetCount(), 24);
1198 EXPECT_EQ(resultSet->GetPosition(), -1);
1199 EXPECT_TRUE(!resultSet->IsFirst());
1200 EXPECT_TRUE(resultSet->MoveToFirst());
1201 EXPECT_TRUE(resultSet->IsFirst());
1202 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1203 EXPECT_TRUE(resultSet == nullptr);
1204 /**
1205 * @tc.steps: step2. Getentries by query, query is full-set;
1206 * @tc.expected: step2. Getentries return OK, ;
1207 */
1208 std::vector<int> inCondition = {1, 10, 100, 200};
1209 Query fullQuery = Query::Select().EqualTo("$.field_name1", true).And().NotEqualTo("$.field_name2", false).
1210 And().GreaterThan("$.field_name3", 10).And().LessThan("$.field_name4", 10).And().Like("$.field_name6", "4%").
1211 And().In("$.field_name7", inCondition).OrderBy("$.field_name9").Limit(20, 1);
1212 ret = g_kvNbDelegatePtrForQuery->GetEntries(fullQuery, resultSet);
1213 ASSERT_TRUE(resultSet != nullptr);
1214 EXPECT_EQ(ret, OK);
1215 EXPECT_EQ(resultSet->GetCount(), 2);
1216 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1217 EXPECT_TRUE(resultSet == nullptr);
1218 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1219 EXPECT_TRUE(g_mgr.DeleteKvStore("GetEntriesWithQuery004") == OK);
1220 }
1221
1222 /**
1223 * @tc.name: QueryIsNotNull001
1224 * @tc.desc: IsNotNull interface normal function
1225 * @tc.type: FUNC
1226 * @tc.require: AR000EPARK
1227 * @tc.author: sunpeng
1228 */
1229 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryIsNotNull001, TestSize.Level1)
1230 {
1231 KvStoreNbDelegate::Option option = {true, false, false};
1232 option.schema = SCHEMA_DEFINE2;
1233 g_mgr.GetKvStore("QueryIsNotNull001", option, g_kvNbDelegateCallbackForQuery);
1234 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1235 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1236 std::string validData = "{\"field_name1\":null, \"field_name2\":1}";
1237 Value value(validData.begin(), validData.end());
1238 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_1, value), OK);
1239 validData = "{\"field_name1\":2, \"field_name2\":2}";
1240 Value value2(validData.begin(), validData.end());
1241 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_2, value2), OK);
1242 /**
1243 * @tc.steps: step1. Get Query object by IsNotNull
1244 */
1245 Query query = Query::Select().IsNotNull("$.field_name1");
1246 /**
1247 * @tc.steps: step2. Use GetEntries get KV
1248 * @tc.expected: step2. Getentries return OK, Get K1V1;
1249 */
1250 std::vector<Entry> entries;
1251 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1252 EXPECT_EQ(errCode, OK);
1253 EXPECT_EQ(entries.size(), 1ul);
1254 EXPECT_EQ(entries[0].key, KEY_2);
1255 EXPECT_EQ(entries[0].value, value2);
1256 /**
1257 * @tc.steps: step3. Use GetCount to get number of item
1258 * @tc.expected: step3. Get count = 1;
1259 */
1260 int count = -1;
1261 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1262 EXPECT_EQ(count, 1);
1263 /**
1264 * @tc.steps: step4. Use GetEntries to get resultSet
1265 * @tc.expected: step4. Getentries return OK, Get K1V1;
1266 */
1267 KvStoreResultSet *resultSet = nullptr;
1268 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1269 ASSERT_TRUE(resultSet != nullptr);
1270 EXPECT_EQ(errCode, OK);
1271 EXPECT_EQ(resultSet->GetCount(), 1);
1272 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1273 EXPECT_TRUE(resultSet == nullptr);
1274 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1275 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryIsNotNull001") == OK);
1276 }
1277
1278 /**
1279 * @tc.name: QueryPreFixKey001
1280 * @tc.desc: Normal function of query by prefix key
1281 * @tc.type: FUNC
1282 * @tc.require: AR000EPARK
1283 * @tc.author: sunpeng
1284 */
1285 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryPreFixKey001, TestSize.Level1)
1286 {
1287 KvStoreNbDelegate::Option option = {true, false, false};
1288 option.schema = SCHEMA_DEFINE2;
1289 g_mgr.GetKvStore("QueryPreFixKey001", option, g_kvNbDelegateCallbackForQuery);
1290 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1291 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1292
1293 vector<Entry> entries = PreDataForQueryByPreFixKey();
1294 EXPECT_EQ(g_kvNbDelegatePtrForQuery->PutBatch(entries), OK);
1295
1296 /**
1297 * @tc.steps: step1. Get Query object by PrefixKey ac
1298 */
1299 Query query = Query::Select().PrefixKey({'a', 'c'});
1300
1301 /**
1302 * @tc.steps: step2. Use GetEnties to get same key prefix ac
1303 * @tc.expected: step2. Get count = 5, Key6~10
1304 */
1305 std::vector<Entry> entriesRes;
1306 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1307 EXPECT_EQ(errCode, OK);
1308 EXPECT_EQ(entriesRes.size(), 5ul);
1309 for (size_t i = 0; i < entriesRes.size(); i++) {
1310 EXPECT_EQ(entriesRes[i].key.front(), 'a');
1311 EXPECT_EQ(entriesRes[i].key[1], 'c');
1312 }
1313 /**
1314 * @tc.steps: step3. Use GetCount to get number of item of this query object
1315 * @tc.expected: step3. Get count = 5
1316 */
1317 int count = -1;
1318 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1319 EXPECT_EQ(count, 5);
1320 /**
1321 * @tc.steps: step4. Use GetEnties to get same key prefix ac of resultSet
1322 * @tc.expected: step4. Get resultSet of key6~10
1323 */
1324 KvStoreResultSet *resultSet = nullptr;
1325 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1326 ASSERT_TRUE(resultSet != nullptr);
1327 EXPECT_EQ(errCode, OK);
1328 EXPECT_EQ(resultSet->GetCount(), 5);
1329 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1330 EXPECT_TRUE(resultSet == nullptr);
1331
1332 /**
1333 * @tc.steps: step5. Get Query object by null PrefixKey
1334 */
1335 Query query1 = Query::Select().PrefixKey({});
1336 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1337 /**
1338 * @tc.steps: step6. Use GetEnties and GetCount to null key prefix query object
1339 * @tc.expected: step6. Get all KV from database
1340 */
1341 EXPECT_EQ(errCode, OK);
1342 EXPECT_EQ(entriesRes.size(), 10ul);
1343 EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntriesEqual(entries, entriesRes, true));
1344
1345 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1346 ASSERT_TRUE(resultSet != nullptr);
1347 EXPECT_EQ(errCode, OK);
1348 EXPECT_EQ(resultSet->GetCount(), 10);
1349 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1350 EXPECT_TRUE(resultSet == nullptr);
1351
1352 Query query2 = Query::Select().PrefixKey(Key(1025, 'a')); // 1025 over max key length 1 byte
1353 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, entriesRes);
1354 EXPECT_EQ(errCode, INVALID_ARGS);
1355
1356 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1357 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryPreFixKey001") == OK);
1358 }
1359
1360 /**
1361 * @tc.name: QueryPreFixKey003
1362 * @tc.desc: For special key prefix combination condition of query
1363 * @tc.type: FUNC
1364 * @tc.require: AR000EPARK
1365 * @tc.author: sunpeng
1366 */
1367 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryPreFixKey003, TestSize.Level1)
1368 {
1369 KvStoreNbDelegate::Option option = {true, false, false};
1370 option.schema = SCHEMA_DEFINE2;
1371 g_mgr.GetKvStore("QueryPreFixKey003", option, g_kvNbDelegateCallbackForQuery);
1372 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1373 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1374
1375 vector<Entry> entries = PreDataForQueryByPreFixKey();
1376 EXPECT_EQ(g_kvNbDelegatePtrForQuery->PutBatch(entries), OK);
1377
1378 /**
1379 * @tc.steps: step1. Get Query object by double PrefixKey
1380 */
1381 Query query = Query::Select().PrefixKey({'a', 'c'}).PrefixKey({});
1382 std::vector<Entry> entriesRes;
1383 /**
1384 * @tc.steps: step2. Use GetEnties for double prefixkey query object
1385 * @tc.expected: step2. return INVALID_QUERY_FORMAT
1386 */
1387 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1388 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1389 /**
1390 * @tc.steps: step3. Use GetEnties for double prefixkey query object to get resultSet
1391 * @tc.expected: step3. return INVALID_QUERY_FORMAT
1392 */
1393 KvStoreResultSet *resultSet = nullptr;
1394 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1395 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1396 EXPECT_TRUE(resultSet == nullptr);
1397 /**
1398 * @tc.steps: step4. Get Query object by PrefixKey and orderBy
1399 */
1400 Query query1 = Query::Select().PrefixKey({'a', 'b'}).OrderBy("$.field_name1");
1401 /**
1402 * @tc.steps: step3. Use GetEnties and GetCount for this query object
1403 * @tc.expected: step3. Can get content by GetEntries, but GetCount can not use for query object include orderBy
1404 */
1405 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1406 EXPECT_EQ(entriesRes.size(), 5ul);
1407 EXPECT_EQ(errCode, OK);
1408 int count = -1;
1409 errCode = g_kvNbDelegatePtrForQuery->GetCount(query1, count);
1410 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1411
1412 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1413 ASSERT_TRUE(resultSet != nullptr);
1414 EXPECT_EQ(errCode, OK);
1415 EXPECT_EQ(resultSet->GetCount(), 5);
1416 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1417 EXPECT_TRUE(resultSet == nullptr);
1418
1419 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1420 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryPreFixKey003") == OK);
1421 }
1422
1423 /**
1424 * @tc.name: QueryPreFixKey004
1425 * @tc.desc: Query a prefix that does not exist
1426 * @tc.type: FUNC
1427 * @tc.require: AR000EPARK
1428 * @tc.author: sunpeng
1429 */
1430 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryPreFixKey004, TestSize.Level1)
1431 {
1432 KvStoreNbDelegate::Option option = {true, false, false};
1433 option.schema = SCHEMA_DEFINE2;
1434 g_mgr.GetKvStore("QueryPreFixKey004", option, g_kvNbDelegateCallbackForQuery);
1435 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1436 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1437
1438 vector<Entry> entries = PreDataForQueryByPreFixKey();
1439 EXPECT_EQ(g_kvNbDelegatePtrForQuery->PutBatch(entries), OK);
1440 /**
1441 * @tc.steps: step1. Get Query object by PrefixKey that does not exist
1442 */
1443 Query query = Query::Select().PrefixKey({'c'});
1444 /**
1445 * @tc.steps: step2. Use GetEnties and GetCount to get result
1446 * @tc.expected: step2. Return NOT_FOUND, get result OK, number of KV is 0
1447 */
1448 std::vector<Entry> entriesRes;
1449 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1450 EXPECT_EQ(errCode, NOT_FOUND);
1451
1452 int count = -1;
1453 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1454 EXPECT_EQ(count, 0);
1455
1456 KvStoreResultSet *resultSet = nullptr;
1457 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1458 ASSERT_TRUE(resultSet != nullptr);
1459 EXPECT_EQ(errCode, OK);
1460 EXPECT_EQ(resultSet->GetCount(), 0);
1461 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1462 EXPECT_TRUE(resultSet == nullptr);
1463
1464 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1465 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryPreFixKey004") == OK);
1466 }
1467
1468 /**
1469 * @tc.name: QueryGroup001
1470 * @tc.desc: Query group nomal ability to change operation priority
1471 * @tc.type: FUNC
1472 * @tc.require: AR000EPARK
1473 * @tc.author: sunpeng
1474 */
1475 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryGroup001, TestSize.Level1)
1476 {
1477 KvStoreNbDelegate::Option option = {true, false, false};
1478 option.schema = SCHEMA_DEFINE2;
1479 g_mgr.GetKvStore("QueryGroup001", option, g_kvNbDelegateCallbackForQuery);
1480 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1481 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1482
1483 PreDataForGroupTest();
1484
1485 /**
1486 * @tc.steps: step1. Get Query object：
1487 * query: <4 and =4 or >1
1488 * query1: (<4 and =4) or >1
1489 * query2: <4 and (=4 or >1)
1490 */
1491 Query query = Query::Select().LessThan("$.field_name1", 4).And().EqualTo("$.field_name1", 4).
1492 Or().GreaterThan("$.field_name1", 1);
1493 Query query1 = Query::Select().BeginGroup().LessThan("$.field_name1", 4).And().
1494 EqualTo("$.field_name1", 4).EndGroup().Or().GreaterThan("$.field_name1", 1);
1495 Query query2 = Query::Select().LessThan("$.field_name1", 4).And().BeginGroup().
1496 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1).EndGroup();
1497
1498 /**
1499 * @tc.steps: step2. Use GetEnties to get different result
1500 * @tc.expected: step2. Result:
1501 * query: count = 4
1502 * query1: count = 4
1503 * query2: count = 2
1504 */
1505 std::vector<Entry> entries;
1506 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1507 EXPECT_EQ(errCode, OK);
1508 EXPECT_EQ(entries.size(), 4ul);
1509 int count = -1;
1510 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1511 EXPECT_EQ(count, 4);
1512
1513 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, entries);
1514 EXPECT_EQ(errCode, OK);
1515
1516 EXPECT_EQ(entries.size(), 2ul);
1517 g_kvNbDelegatePtrForQuery->GetCount(query2, count);
1518 EXPECT_EQ(count, 2);
1519 KvStoreResultSet *resultSet = nullptr;
1520 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, resultSet);
1521 ASSERT_TRUE(resultSet != nullptr);
1522 EXPECT_EQ(errCode, OK);
1523 EXPECT_EQ(resultSet->GetCount(), 2);
1524 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1525 EXPECT_TRUE(resultSet == nullptr);
1526
1527 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entries);
1528 EXPECT_EQ(errCode, OK);
1529 EXPECT_EQ(entries.size(), 4ul);
1530 g_kvNbDelegatePtrForQuery->GetCount(query1, count);
1531 EXPECT_EQ(count, 4);
1532
1533 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1534 ASSERT_TRUE(resultSet != nullptr);
1535 EXPECT_EQ(errCode, OK);
1536 EXPECT_EQ(resultSet->GetCount(), 4);
1537 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1538 EXPECT_TRUE(resultSet == nullptr);
1539
1540 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1541 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryGroup001") == OK);
1542 }
1543
1544 /**
1545 * @tc.name: QueryGroup002
1546 * @tc.desc: Test for illegal Group query object
1547 * @tc.type: FUNC
1548 * @tc.require: AR000EPARK
1549 * @tc.author: sunpeng
1550 */
1551 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryGroup002, TestSize.Level1)
1552 {
1553 KvStoreNbDelegate::Option option = {true, false, false};
1554 option.schema = SCHEMA_DEFINE2;
1555 g_mgr.GetKvStore("QueryGroup002", option, g_kvNbDelegateCallbackForQuery);
1556 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1557 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1558
1559 PreDataForGroupTest();
1560
1561 /**
1562 * @tc.steps: step1. Get Query object：
1563 * query: (<4 and (=4 or） >1)
1564 * query1: (<4 and =4 or >1
1565 * query2: <4 and =4) or >1
1566 * query3: )<4 and =4( or >1
1567 * query4: <4 (and = 4 or >1)
1568 */
1569 Query query = Query::Select().BeginGroup().LessThan("$.field_name1", 4).And().BeginGroup().
1570 EqualTo("$.field_name1", 4).Or().EndGroup().GreaterThan("$.field_name1", 1).EndGroup();
1571 Query query1 = Query::Select().BeginGroup().LessThan("$.field_name1", 4).And().
1572 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1);
1573 Query query2 = Query::Select().LessThan("$.field_name1", 4).And().
1574 EqualTo("$.field_name1", 4).EndGroup().Or().GreaterThan("$.field_name1", 1);
1575 Query query3 = Query::Select().EndGroup().LessThan("$.field_name1", 4).And().
1576 EqualTo("$.field_name1", 4).BeginGroup().Or().GreaterThan("$.field_name1", 1);
1577 Query query4 = Query::Select().LessThan("$.field_name1", 4).BeginGroup().And().
1578 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1).EndGroup();
1579
1580 /**
1581 * @tc.steps: step2. Use GetEnties and GetCount to get result
1582 * @tc.expected: step2. All query object is illegal, reeturn INVALID_QUERY_FORMAT
1583 */
1584 std::vector<Entry> entries;
1585 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1586 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1587
1588 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entries);
1589 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1590 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, entries);
1591 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1592 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query3, entries);
1593 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1594 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query4, entries);
1595 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1596
1597 KvStoreResultSet *resultSet = nullptr;
1598 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1599 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1600 EXPECT_TRUE(resultSet == nullptr);
1601
1602 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1603 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1604 EXPECT_TRUE(resultSet == nullptr);
1605
1606 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, resultSet);
1607 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1608 EXPECT_TRUE(resultSet == nullptr);
1609
1610 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query3, resultSet);
1611 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1612 EXPECT_TRUE(resultSet == nullptr);
1613
1614 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query4, resultSet);
1615 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1616 EXPECT_TRUE(resultSet == nullptr);
1617
1618 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1619 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryGroup002") == OK);
1620 }
1621
1622 /**
1623 * @tc.name: QueryGroup003
1624 * @tc.desc: Query expressions containing nested parentheses
1625 * @tc.type: FUNC
1626 * @tc.require: AR000EPARK
1627 * @tc.author: sunpeng
1628 */
1629 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryGroup003, TestSize.Level1)
1630 {
1631 KvStoreNbDelegate::Option option = {true, false, false};
1632 option.schema = SCHEMA_DEFINE2;
1633 g_mgr.GetKvStore("QueryGroup003", option, g_kvNbDelegateCallbackForQuery);
1634 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1635 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1636
1637 PreDataForGroupTest();
1638
1639 /**
1640 * @tc.steps: step1. Get Query object for (<=5 and (=4 or >1) and <3)
1641 */
1642 Query query = Query::Select().BeginGroup().LessThan("$.field_name1", 5).And().BeginGroup().
1643 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1).EndGroup().And().
1644 LessThan("$.field_name1", 3).EndGroup();
1645
1646 /**
1647 * @tc.steps: step2. Use GetEnties and GetCount to get result
1648 * @tc.expected: step2. reeturn OK, count = 1
1649 */
1650 std::vector<Entry> entries;
1651 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1652 EXPECT_EQ(errCode, OK);
1653 EXPECT_EQ(entries.size(), 1ul);
1654 int count = -1;
1655 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1656 EXPECT_EQ(count, 1);
1657
1658 KvStoreResultSet *resultSet = nullptr;
1659 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1660 ASSERT_TRUE(resultSet != nullptr);
1661 EXPECT_EQ(errCode, OK);
1662 EXPECT_EQ(resultSet->GetCount(), 1);
1663 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1664 EXPECT_TRUE(resultSet == nullptr);
1665
1666 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1667 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryGroup003") == OK);
1668 }
1669
1670 /**
1671 * @tc.name: multiOrderBy001
1672 * @tc.desc: Test multiple orderby conditions together to query
1673 * @tc.type: FUNC
1674 * @tc.require: AR000DR9K7
1675 * @tc.author: sunpeng
1676 */
1677 HWTEST_F(DistributedDBInterfacesDataOperationTest, multiOrderBy001, TestSize.Level1)
1678 {
1679 KvStoreNbDelegate::Option option = {true, false, false};
1680 option.schema = SCHEMA_DEFINE2;
1681 g_mgr.GetKvStore("multiOrderBy001", option, g_kvNbDelegateCallbackForQuery);
1682 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1683 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1684
1685 PreDataForGroupTest();
1686
1687 Query query = Query::Select().PrefixKey({}).OrderBy("$.field_name1").OrderBy("$.field_name1");
1688 std::vector<Entry> entries;
1689 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1690 EXPECT_EQ(errCode, OK);
1691
1692 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query.Limit(2, 2), entries);
1693 EXPECT_EQ(errCode, OK);
1694
1695 Query query1 = Query::Select().PrefixKey({}).Limit(2, 2).OrderBy("$.field_name1").OrderBy("$.field_name1");
1696 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entries);
1697 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1698
1699 Query query2 = Query::Select().PrefixKey({}).OrderBy("$.field_name1").Limit(2, 2).OrderBy("$.field_name1");
1700 KvStoreResultSet *resultSet = nullptr;
1701 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, resultSet);
1702 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1703
1704 Query query3 = Query::Select().PrefixKey({}).OrderBy("$.field_name1").
1705 OrderBy("$.field_name1").OrderBy("$.field_name1");
1706 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query3, resultSet);
1707 EXPECT_EQ(errCode, OK);
1708 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1709 EXPECT_TRUE(resultSet == nullptr);
1710
1711 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1712 EXPECT_TRUE(g_mgr.DeleteKvStore("multiOrderBy001") == OK);
1713 }
1714
1715 /**
1716 * @tc.name: multiOrderBy001
1717 * @tc.desc: For multiple order query.
1718 * @tc.type: FUNC
1719 * @tc.require: AR000EPARK
1720 * @tc.author: sunpeng
1721 */
1722 HWTEST_F(DistributedDBInterfacesDataOperationTest, PreifxAndOrderBy001, TestSize.Level1)
1723 {
1724 KvStoreNbDelegate::Option option = {true, false, false};
1725 option.schema = SCHEMA_DEFINE2;
1726 g_mgr.GetKvStore("PreifxAndOrderBy001", option, g_kvNbDelegateCallbackForQuery);
1727 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1728 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1729
1730 PresetDataForPreifxAndOrderBy001();
1731
1732 Query query = Query::Select().PrefixKey({}).OrderBy("$.field_name1", false);
1733 std::vector<Entry> entriesRes;
1734 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1735 EXPECT_EQ(errCode, OK);
1736 ASSERT_EQ(entriesRes.size(), 5ul);
1737 EXPECT_EQ(entriesRes[0].key, KEY_5);
1738 EXPECT_EQ(entriesRes[1].key, KEY_3);
1739 EXPECT_EQ(entriesRes[2].key, KEY_4);
1740 EXPECT_EQ(entriesRes[3].key, KEY_1);
1741 EXPECT_EQ(entriesRes[4].key, KEY_2);
1742
1743 Query query1 = Query::Select().OrderBy("$.field_name1", false);
1744 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1745 EXPECT_EQ(errCode, OK);
1746 ASSERT_EQ(entriesRes.size(), 5ul);
1747 EXPECT_EQ(entriesRes[0].key, KEY_5);
1748 EXPECT_EQ(entriesRes[1].key, KEY_4);
1749 EXPECT_EQ(entriesRes[2].key, KEY_3);
1750 EXPECT_EQ(entriesRes[3].key, KEY_2);
1751 EXPECT_EQ(entriesRes[4].key, KEY_1);
1752
1753 Query query2 = Query::Select().PrefixKey({}).OrderBy("$.field_name1", false).OrderBy("$.field_name2", false);
1754 (void) g_kvNbDelegatePtrForQuery->GetEntries(query2, entriesRes);
1755 ASSERT_EQ(entriesRes.size(), 5ul);
1756 EXPECT_EQ(entriesRes[0].key, KEY_5);
1757 EXPECT_EQ(entriesRes[1].key, KEY_4);
1758 EXPECT_EQ(entriesRes[2].key, KEY_3);
1759 EXPECT_EQ(entriesRes[3].key, KEY_2);
1760 EXPECT_EQ(entriesRes[4].key, KEY_1);
1761
1762 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1763 EXPECT_TRUE(g_mgr.DeleteKvStore("PreifxAndOrderBy001") == OK);
1764 }
1765
1766 /**
1767 * @tc.name: PrefixAndOther001
1768 * @tc.desc: Combination of prefix query and logical filtering
1769 * @tc.type: FUNC
1770 * @tc.require: AR000EPARK
1771 * @tc.author: sunpeng
1772 */
1773 HWTEST_F(DistributedDBInterfacesDataOperationTest, PrefixAndOther001, TestSize.Level1)
1774 {
1775 KvStoreNbDelegate::Option option = {true, false, false};
1776 option.schema = SCHEMA_DEFINE2;
1777 g_mgr.GetKvStore("PrefixAndOther001", option, g_kvNbDelegateCallbackForQuery);
1778 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1779 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1780
1781 PresetDataForPreifxAndOrderBy001();
1782
1783 std::vector<Entry> entriesRes;
1784 Query query1 = Query::Select().EqualTo("$.field_name1", 1).PrefixKey({});
1785 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1786 EXPECT_EQ(errCode, OK);
1787 query1 = Query::Select().PrefixKey({}).EqualTo("$.field_name1", 1);
1788 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1789 EXPECT_EQ(errCode, OK);
1790
1791 query1 = Query::Select().EqualTo("$.field_name1", 1).PrefixKey({}).And().EqualTo("$.field_name1", 1);
1792 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1793 EXPECT_EQ(errCode, OK);
1794
1795 query1 = Query::Select().EqualTo("$.field_name1", 1).PrefixKey({}).And().EqualTo("$.field_name1", 2);
1796 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1797 EXPECT_EQ(errCode, NOT_FOUND);
1798
1799 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1800 EXPECT_TRUE(g_mgr.DeleteKvStore("PrefixAndOther001") == OK);
1801 }
1802
1803 /**
1804 * @tc.name: InKeys001
1805 * @tc.desc: InKeys query base function
1806 * @tc.type: FUNC
1807 * @tc.require: AR000GOH06
1808 * @tc.author: xushaohua
1809 */
1810 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeys001, TestSize.Level1)
1811 {
1812 /**
1813 * @tc.steps: step1. Create a database And Preset Data
1814 */
1815 KvStoreNbDelegate::Option option = {true, false, false};
1816 g_mgr.GetKvStore("InKeys001", option, g_kvNbDelegateCallbackForQuery);
1817 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1818 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
1819
1820 Key key = {'1'};
1821 DBStatus status = g_kvNbDelegatePtrForQuery->Put(key, VALUE_1);
1822 ASSERT_EQ(status, OK);
1823 const int dataSize = 10; // 10 data for test
1824 std::set<Key> keys;
1825 for (uint8_t i = 0; i < dataSize; i++) {
1826 key.push_back(i);
1827 status = g_kvNbDelegatePtrForQuery->Put(key, VALUE_1);
1828 ASSERT_EQ(status, OK);
1829 keys.emplace(key);
1830 key.pop_back();
1831 }
1832
1833 /**
1834 * @tc.steps: step2. Call GetEntries With Query, set all keys at Inkeys.
1835 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
1836 * all data are equals the preset data
1837 */
1838 KvStoreResultSet *resultSet = nullptr;
1839 g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys), resultSet);
1840 ASSERT_NE(resultSet, nullptr);
1841 ASSERT_EQ(resultSet->GetCount(), dataSize);
1842 for (int i = 0; i < dataSize; i++) {
1843 resultSet->MoveToPosition(i);
1844 Entry entry;
1845 resultSet->GetEntry(entry);
1846 key.push_back(i);
1847 EXPECT_EQ(key, entry.key);
1848 EXPECT_EQ(entry.value, VALUE_1);
1849 key.pop_back();
1850 }
1851 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
1852
1853 /**
1854 * @tc.steps: step3. Call GetEntries With Query, set one other key at Inkeys.
1855 * @tc.expected: step3. Returns KvStoreResultSet, the count is 0,
1856 */
1857 g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys({KEY_7}), resultSet);
1858 ASSERT_NE(resultSet, nullptr);
1859 ASSERT_EQ(resultSet->GetCount(), 0);
1860 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
1861 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1862 EXPECT_EQ(g_mgr.DeleteKvStore("InKeys001"), OK);
1863 }
1864
1865 /**
1866 * @tc.name: InKeysLimit001
1867 * @tc.desc: InKeys query limit verification
1868 * @tc.type: FUNC
1869 * @tc.require: AR000GOH06
1870 * @tc.author: xushaohua
1871 */
1872 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeysLimit001, TestSize.Level1)
1873 {
1874 /**
1875 * @tc.steps: step1. Create a database
1876 */
1877 KvStoreNbDelegate::Option option = {true, false, false};
1878 g_mgr.GetKvStore("InKeysLimit001", option, g_kvNbDelegateCallbackForQuery);
1879 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1880 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
1881
1882 /**
1883 * @tc.steps: step2. Construct a key set, and the key size over MAX_BATCH_SIZE
1884 */
1885 std::set<Key> keys;
1886 for (uint8_t i = 0; i < DBConstant::MAX_BATCH_SIZE + 1; i++) {
1887 Key key = { i };
1888 keys.emplace(key);
1889 }
1890
1891 /**
1892 * @tc.steps: step3. Call GetEntries With Query, set keys at Inkeys.
1893 * @tc.expected: step3. Returns OVER_MAX_LIMITS, the resultSet is nullptr,
1894 */
1895 KvStoreResultSet *resultSet = nullptr;
1896 DBStatus status = g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys), resultSet);
1897 EXPECT_EQ(status, OVER_MAX_LIMITS);
1898 EXPECT_EQ(resultSet, nullptr);
1899
1900 /**
1901 * @tc.steps: step4. Call GetEntries With Query, set keys empty.
1902 * @tc.expected: step4. Returns INVALID_ARGS, the resultSet is nullptr,
1903 */
1904 status = g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys({}), resultSet);
1905 EXPECT_EQ(status, INVALID_ARGS);
1906 EXPECT_EQ(resultSet, nullptr);
1907
1908 /**
1909 * @tc.steps: step4. Call GetEntries With Query, set a invalid key.
1910 * @tc.expected: step4. Returns INVALID_ARGS, the resultSet is nullptr,
1911 */
1912 status = g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys({{}}), resultSet);
1913 EXPECT_EQ(status, INVALID_ARGS);
1914 EXPECT_EQ(resultSet, nullptr);
1915
1916 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1917 EXPECT_EQ(g_mgr.DeleteKvStore("InKeysLimit001"), OK);
1918 }
1919
1920 /**
1921 * @tc.name: InKeysAndOther001
1922 * @tc.desc: Combination of InKeys query and logical filtering
1923 * @tc.type: FUNC
1924 * @tc.require: AR000GOH06
1925 * @tc.author: xushaohua
1926 */
1927 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeysAndOther001, TestSize.Level1)
1928 {
1929 /**
1930 * @tc.steps: step1. Create a database And Preset Data
1931 */
1932 KvStoreNbDelegate::Option option = {true, false, false};
1933 option.schema = SCHEMA_DEFINE2;
1934 g_mgr.GetKvStore("InKeysAndOther001", option, g_kvNbDelegateCallbackForQuery);
1935 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1936 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
1937
1938 PresetDataForPreifxAndOrderBy001();
1939
1940 std::set<Key> keys = { KEY_1, KEY_2, KEY_4 };
1941 std::vector<Entry> entriesRes;
1942
1943 /**
1944 * @tc.steps: step2. Call GetEntries With Query, use EqualTo and InKeys
1945 * @tc.expected: step2. Returns OK
1946 */
1947 Query query1 = Query::Select().EqualTo("$.field_name1", 1).InKeys(keys);
1948 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1949 EXPECT_EQ(errCode, OK);
1950
1951 /**
1952 * @tc.steps: step3. Call GetEntries With Query, use InKeys and EqualTo
1953 * @tc.expected: step3. Returns OK
1954 */
1955 query1 = Query::Select().InKeys(keys).EqualTo("$.field_name1", 1);
1956 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1957 EXPECT_EQ(errCode, OK);
1958
1959 /**
1960 * @tc.steps: step4. Call GetEntries With Query, use EqualTo, InKeys and EqualTo, all valid
1961 * @tc.expected: step4. Returns OK
1962 */
1963 query1 = Query::Select().EqualTo("$.field_name1", 1).InKeys(keys).And().EqualTo("$.field_name2", 2);
1964 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1965 EXPECT_EQ(errCode, OK);
1966
1967 /**
1968 * @tc.steps: step4. Call GetEntries With Query, use EqualTo, InKeys and EqualTo, has invalid
1969 * @tc.expected: step4. Returns NOT_FOUND
1970 */
1971 query1 = Query::Select().EqualTo("$.field_name1", 1).InKeys(keys).And().EqualTo("$.field_name1", 2);
1972 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1973 EXPECT_EQ(errCode, NOT_FOUND);
1974
1975 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1976 EXPECT_EQ(g_mgr.DeleteKvStore("InKeysAndOther001"), OK);
1977 }
1978
1979 /**
1980 * @tc.name: InKeysAndOther002
1981 * @tc.desc: Combination of InKeys query and logical filtering
1982 * @tc.type: FUNC
1983 * @tc.require: AR000GOH06
1984 * @tc.author: lianhuix
1985 */
1986 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeysAndOther002, TestSize.Level1)
1987 {
1988 KvStoreNbDelegate::Option option = {true, false, false};
1989 option.schema = SCHEMA_DEFINE2;
1990 g_mgr.GetKvStore("InKeysAndOther001", option, g_kvNbDelegateCallbackForQuery);
1991 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1992 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
1993
1994 std::set<Key> keys = { KEY_1, KEY_2, KEY_4 };
1995 std::vector<Query> queries = {
1996 Query::Select().PrefixKey({}).InKeys(keys).Or().EqualTo("$.field_name1", 2),
1997 Query::Select().PrefixKey({}).InKeys(keys).And().EqualTo("$.field_name1", 2),
1998 Query::Select().InKeys(keys).Or().EqualTo("$.field_name1", 2),
1999 Query::Select().InKeys(keys).And().EqualTo("$.field_name1", 2),
2000 Query::Select().PrefixKey({}).Or().EqualTo("$.field_name1", 2),
2001 Query::Select().PrefixKey({}).And().EqualTo("$.field_name1", 2),
2002 Query::Select().PrefixKey({}).And().InKeys(keys).EqualTo("$.field_name1", 2),
2003 Query::Select().And().InKeys(keys).EqualTo("$.field_name1", 2),
2004 Query::Select().Or().PrefixKey({}).EqualTo("$.field_name1", 2),
2005 Query::Select().BeginGroup().PrefixKey({}).Or().EqualTo("$.field_name1", 2).EndGroup(),
2006 Query::Select().EqualTo("$.field_name1", 2).Or().InKeys(keys),
2007 Query::Select().EqualTo("$.field_name1", 2).Or().PrefixKey({}),
2008 };
2009
2010 for (const auto &query : queries) {
2011 std::vector<Entry> entriesRes;
2012 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
2013 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
2014 }
2015
2016 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2017 EXPECT_EQ(g_mgr.DeleteKvStore("InKeysAndOther001"), OK);
2018 }
2019
2020 /**
2021 * @tc.name: WriteTimeSort001
2022 * @tc.desc: For prefixKey query with orderBy writeTime asc
2023 * @tc.type: FUNC
2024 * @tc.require: SR000H5U55
2025 * @tc.author: zhuwentao
2026 */
2027 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort001, TestSize.Level0)
2028 {
2029 /**
2030 * @tc.steps: step1. Create a database And Preset Data
2031 */
2032 KvStoreNbDelegate::Option option = {true, false, false};
2033 g_mgr.GetKvStore("WriteTimeSort001", option, g_kvNbDelegateCallbackForQuery);
2034 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2035 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2036 /**
2037 * @tc.steps: step2. put some data
2038 * @tc.expected: step2. Returns OK
2039 */
2040 Key key = {'x'};
2041 Key key2 = {'y'};
2042 const int dataSize = 100; // 100 data for test
2043 std::vector<Key> expectedKeys;
2044 std::vector<uint8_t> keySuffix;
2045 for (uint8_t i = 0; i < dataSize; i++) {
2046 keySuffix.push_back(rand () % 100);
2047 }
2048 for (uint8_t i = 0; i < dataSize; i++) {
2049 Key tmpKey = {key[0], keySuffix[i], i};
2050 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2051 expectedKeys.push_back(tmpKey);
2052 }
2053 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2054
2055 /**
2056 * @tc.steps: step2. Call GetEntries With prefix Query
2057 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2058 * all data are equals the preset data
2059 */
2060 KvStoreResultSet *resultSet = nullptr;
2061 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(true), resultSet),
2062 OK);
2063 ASSERT_NE(resultSet, nullptr);
2064 ASSERT_EQ(resultSet->GetCount(), dataSize);
2065 for (int i = 0; i < dataSize; i++) {
2066 resultSet->MoveToPosition(i);
2067 Entry entry;
2068 resultSet->GetEntry(entry);
2069 EXPECT_EQ(expectedKeys[i], entry.key);
2070 EXPECT_EQ(entry.value, VALUE_1);
2071 }
2072 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2073 /**
2074 * @tc.steps: step3. Call GetEntries With prefix Query limit
2075 * @tc.expected: step3. Returns KvStoreResultSet, the count is dataSize,
2076 * all data are equals the preset data
2077 */
2078 KvStoreResultSet *resultSet2 = nullptr;
2079 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2080 Query::Select().PrefixKey(key).OrderByWriteTime(true).Limit(dataSize / 2, 0), resultSet2), OK);
2081 ASSERT_NE(resultSet2, nullptr);
2082 ASSERT_EQ(resultSet2->GetCount(), dataSize / 2);
2083 for (int i = 0; i < dataSize / 2; i++) {
2084 resultSet2->MoveToPosition(i);
2085 Entry entry;
2086 resultSet2->GetEntry(entry);
2087 EXPECT_EQ(expectedKeys[i], entry.key);
2088 EXPECT_EQ(entry.value, VALUE_1);
2089 }
2090 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet2);
2091 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2092 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort001"), OK);
2093 }
2094
2095 /**
2096 * @tc.name: WriteTimeSort002
2097 * @tc.desc: For prefixKey query with orderBy writeTime asc
2098 * @tc.type: FUNC
2099 * @tc.require: SR000H5U55
2100 * @tc.author: zhuwentao
2101 */
2102 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort002, TestSize.Level0)
2103 {
2104 /**
2105 * @tc.steps: step1. Create a database And Preset Data
2106 */
2107 KvStoreNbDelegate::Option option = {true, false, false};
2108 g_mgr.GetKvStore("WriteTimeSort002", option, g_kvNbDelegateCallbackForQuery);
2109 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2110 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2111 /**
2112 * @tc.steps: step2. put some data
2113 * @tc.expected: step2. Returns OK
2114 */
2115 Key key = {'x'};
2116 Key key2 = {'y'};
2117 const int dataSize = 100; // 100 data for test
2118 std::vector<Key> expectedKeys;
2119 std::vector<uint8_t> keySuffix;
2120 for (uint8_t i = 0; i < dataSize; i++) {
2121 keySuffix.push_back(rand () % 100);
2122 }
2123 for (uint8_t i = 0; i < dataSize; i++) {
2124 Key tmpKey = {key[0], keySuffix[i], i};
2125 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2126 expectedKeys.push_back(tmpKey);
2127 }
2128 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2129
2130 /**
2131 * @tc.steps: step2. Call GetEntries With prefix Query
2132 * @tc.expected: step2. Returns entries
2133 * all data are equals the preset data
2134 */
2135 std::vector<Entry> entries;
2136 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(true), entries),
2137 OK);
2138 ASSERT_EQ(entries.size(), static_cast<long unsigned int>(dataSize));
2139 for (int i = 0; i < dataSize; i++) {
2140 EXPECT_EQ(expectedKeys[i], entries[i].key);
2141 EXPECT_EQ(entries[i].value, VALUE_1);
2142 }
2143 /**
2144 * @tc.steps: step3. Call GetEntries With prefix Query limit
2145 * @tc.expected: step3. Returns entries
2146 * all data are equals the preset data
2147 */
2148 std::vector<Entry> entries2;
2149 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2150 Query::Select().PrefixKey(key).OrderByWriteTime(true).Limit(dataSize / 2, 0), entries2), OK);
2151 ASSERT_EQ(entries2.size(), static_cast<long unsigned int>(dataSize / 2));
2152 for (int i = 0; i < dataSize / 2; i++) {
2153 EXPECT_EQ(expectedKeys[i], entries2[i].key);
2154 EXPECT_EQ(entries2[i].value, VALUE_1);
2155 }
2156 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2157 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort002"), OK);
2158 }
2159
2160 /**
2161 * @tc.name: WriteTimeSort003
2162 * @tc.desc: For prefixKey query with orderBy writeTime desc
2163 * @tc.type: FUNC
2164 * @tc.require: SR000H5U55
2165 * @tc.author: zhuwentao
2166 */
2167 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort003, TestSize.Level0)
2168 {
2169 /**
2170 * @tc.steps: step1. Create a database And Preset Data
2171 */
2172 KvStoreNbDelegate::Option option = {true, false, false};
2173 g_mgr.GetKvStore("WriteTimeSort003", option, g_kvNbDelegateCallbackForQuery);
2174 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2175 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2176 /**
2177 * @tc.steps: step2. put some data
2178 * @tc.expected: step2. Returns OK
2179 */
2180 Key key = {'x'};
2181 Key key2 = {'y'};
2182 const int dataSize = 100; // 100 data for test
2183 std::vector<Key> expectedKeys;
2184 std::vector<uint8_t> keySuffix;
2185 for (uint8_t i = 0; i < dataSize; i++) {
2186 keySuffix.push_back(rand () % 100);
2187 }
2188 for (uint8_t i = 0; i < dataSize; i++) {
2189 Key tmpKey = {key[0], keySuffix[i], i};
2190 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2191 expectedKeys.push_back(tmpKey);
2192 }
2193 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2194
2195 /**
2196 * @tc.steps: step2. Call GetEntries With prefix Query
2197 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2198 * all data are equals the preset data
2199 */
2200 KvStoreResultSet *resultSet = nullptr;
2201 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(false), resultSet),
2202 OK);
2203 ASSERT_NE(resultSet, nullptr);
2204 ASSERT_EQ(resultSet->GetCount(), dataSize);
2205 for (int i = 0; i < dataSize; i++) {
2206 resultSet->MoveToPosition(i);
2207 Entry entry;
2208 resultSet->GetEntry(entry);
2209 EXPECT_EQ(expectedKeys[dataSize - i - 1], entry.key);
2210 EXPECT_EQ(entry.value, VALUE_1);
2211 }
2212 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2213 /**
2214 * @tc.steps: step3. Call GetEntries With prefix Query limit
2215 * @tc.expected: step3. Returns KvStoreResultSet, the count is dataSize,
2216 * all data are equals the preset data
2217 */
2218 KvStoreResultSet *resultSet2 = nullptr;
2219 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2220 Query::Select().PrefixKey(key).OrderByWriteTime(false).Limit(dataSize / 2, 0), resultSet2), OK);
2221 ASSERT_NE(resultSet2, nullptr);
2222 ASSERT_EQ(resultSet2->GetCount(), dataSize / 2);
2223 for (int i = 0; i < dataSize / 2; i++) {
2224 resultSet2->MoveToPosition(i);
2225 Entry entry;
2226 resultSet2->GetEntry(entry);
2227 EXPECT_EQ(expectedKeys[dataSize - i - 1], entry.key);
2228 EXPECT_EQ(entry.value, VALUE_1);
2229 }
2230 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet2);
2231 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2232 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort003"), OK);
2233 }
2234
2235 /**
2236 * @tc.name: WriteTimeSort004
2237 * @tc.desc: For prefixKey query with orderBy writeTime asc
2238 * @tc.type: FUNC
2239 * @tc.require: SR000H5U55
2240 * @tc.author: zhuwentao
2241 */
2242 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort004, TestSize.Level0)
2243 {
2244 /**
2245 * @tc.steps: step1. Create a database And Preset Data
2246 */
2247 KvStoreNbDelegate::Option option = {true, false, false};
2248 g_mgr.GetKvStore("WriteTimeSort004", option, g_kvNbDelegateCallbackForQuery);
2249 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2250 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2251 /**
2252 * @tc.steps: step2. put some data
2253 * @tc.expected: step2. Returns OK
2254 */
2255 Key key = {'x'};
2256 Key key2 = {'y'};
2257 const int dataSize = 100; // 100 data for test
2258 std::vector<Key> expectedKeys;
2259 std::vector<uint8_t> keySuffix;
2260 for (uint8_t i = 0; i < dataSize; i++) {
2261 keySuffix.push_back(rand () % 100);
2262 }
2263 for (uint8_t i = 0; i < dataSize; i++) {
2264 Key tmpKey = {key[0], keySuffix[i], i};
2265 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2266 expectedKeys.push_back(tmpKey);
2267 }
2268 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2269
2270 /**
2271 * @tc.steps: step2. Call GetEntries With prefix Query
2272 * @tc.expected: step2. Returns entries
2273 * all data are equals the preset data
2274 */
2275 std::vector<Entry> entries;
2276 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(false), entries),
2277 OK);
2278 ASSERT_EQ(entries.size(), static_cast<long unsigned int>(dataSize));
2279 for (int i = 0; i < dataSize; i++) {
2280 EXPECT_EQ(expectedKeys[dataSize - i - 1], entries[i].key);
2281 EXPECT_EQ(entries[i].value, VALUE_1);
2282 }
2283 /**
2284 * @tc.steps: step3. Call GetEntries With prefix Query limit
2285 * @tc.expected: step3. Returns entries
2286 * all data are equals the preset data
2287 */
2288 std::vector<Entry> entries2;
2289 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2290 Query::Select().PrefixKey(key).OrderByWriteTime(false).Limit(dataSize / 2, 0), entries2), OK);
2291 ASSERT_EQ(entries2.size(), static_cast<long unsigned int>(dataSize / 2));
2292 for (int i = 0; i < dataSize / 2; i++) {
2293 EXPECT_EQ(expectedKeys[dataSize - i - 1], entries2[i].key);
2294 EXPECT_EQ(entries2[i].value, VALUE_1);
2295 }
2296 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2297 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort004"), OK);
2298 }
2299
2300 namespace {
CheckResultSize(KvStoreResultSet * resultSet,const std::vector<Key> & expectedKeys,int expectedSize)2301 void CheckResultSize(KvStoreResultSet *resultSet, const std::vector<Key> &expectedKeys, int expectedSize)
2302 {
2303 for (int i = 0; i < expectedSize; i++) {
2304 resultSet->MoveToPosition(i);
2305 Entry entry;
2306 resultSet->GetEntry(entry);
2307 EXPECT_EQ(expectedKeys[i], entry.key);
2308 }
2309 }
2310 }
2311
2312 /**
2313 * @tc.name: WriteTimeSort005
2314 * @tc.desc: For inkeys query with orderBy writeTime asc
2315 * @tc.type: FUNC
2316 * @tc.require: SR000H5U55
2317 * @tc.author: zhuwentao
2318 */
2319 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort005, TestSize.Level0)
2320 {
2321 /**
2322 * @tc.steps: step1. Create a database And Preset Data
2323 */
2324 KvStoreNbDelegate::Option option = {true, false, false};
2325 g_mgr.GetKvStore("WriteTimeSort005", option, g_kvNbDelegateCallbackForQuery);
2326 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2327 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2328 /**
2329 * @tc.steps: step2. put some data
2330 * @tc.expected: step2. Returns OK
2331 */
2332 Key key = {'x'};
2333 Key key2 = {'y'};
2334 const int dataSize = 100; // 100 data for test
2335 std::vector<Key> expectedKeys;
2336 std::vector<uint8_t> keySuffix;
2337 for (uint8_t i = 0; i < dataSize; i++) {
2338 keySuffix.push_back(rand () % 100);
2339 }
2340 for (uint8_t i = 0; i < dataSize; i++) {
2341 Key tmpKey = {key[0], keySuffix[i], i};
2342 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2343 if (rand() % 2) {
2344 expectedKeys.push_back(tmpKey);
2345 }
2346 }
2347 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2348 /**
2349 * @tc.steps: step2. Call GetEntries With prefix Query
2350 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2351 * all data are equals the preset data
2352 */
2353 KvStoreResultSet *resultSet = nullptr;
2354 std::set<Key> keys(expectedKeys.begin(), expectedKeys.end());
2355 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys).OrderByWriteTime(true), resultSet),
2356 OK);
2357 ASSERT_NE(resultSet, nullptr);
2358 ASSERT_EQ(resultSet->GetCount(), static_cast<int>(keys.size()));
2359 for (uint32_t i = 0; i < keys.size(); i++) {
2360 resultSet->MoveToPosition(i);
2361 Entry entry;
2362 resultSet->GetEntry(entry);
2363 EXPECT_EQ(expectedKeys[i], entry.key);
2364 EXPECT_EQ(entry.value, VALUE_1);
2365 }
2366 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2367 /**
2368 * @tc.steps: step3. Call GetEntries With prefix Query limit
2369 * @tc.expected: step3. Returns KvStoreResultSet, the count is dataSize,
2370 * all data are equals the preset data
2371 */
2372 KvStoreResultSet *resultSet2 = nullptr;
2373 long unsigned int limitNum = 40;
2374 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2375 Query::Select().InKeys(keys).OrderByWriteTime(true).Limit(limitNum, 0), resultSet2), OK);
2376 ASSERT_NE(resultSet2, nullptr);
2377 int expectedSize = (keys.size() >= limitNum) ? limitNum : keys.size();
2378 ASSERT_EQ(resultSet2->GetCount(), static_cast<int>(expectedSize));
2379 CheckResultSize(resultSet2, expectedKeys, expectedSize);
2380 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet2);
2381 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2382 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort005"), OK);
2383 }
2384
2385 /**
2386 * @tc.name: WriteTimeSort006
2387 * @tc.desc: For inkeys query with orderBy writeTime desc
2388 * @tc.type: FUNC
2389 * @tc.require: SR000H5U55
2390 * @tc.author: zhuwentao
2391 */
2392 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort006, TestSize.Level0)
2393 {
2394 /**
2395 * @tc.steps: step1. Create a database And Preset Data
2396 */
2397 KvStoreNbDelegate::Option option = {true, false, false};
2398 g_mgr.GetKvStore("WriteTimeSort006", option, g_kvNbDelegateCallbackForQuery);
2399 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2400 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2401 /**
2402 * @tc.steps: step2. put some data
2403 * @tc.expected: step2. Returns OK
2404 */
2405 Key key = {'x'};
2406 Key key2 = {'y'};
2407 const int dataSize = 100; // 100 data for test
2408 std::vector<Key> expectedKeys;
2409 std::vector<uint8_t> keySuffix;
2410 for (uint8_t i = 0; i < dataSize; i++) {
2411 keySuffix.push_back(rand () % 100);
2412 }
2413 for (uint8_t i = 0; i < dataSize; i++) {
2414 Key tmpKey = {key[0], keySuffix[i], i};
2415 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2416 if (rand() % 2) {
2417 expectedKeys.push_back(tmpKey);
2418 }
2419 }
2420 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2421 /**
2422 * @tc.steps: step2. Call GetEntries With prefix Query
2423 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2424 * all data are equals the preset data
2425 */
2426 KvStoreResultSet *resultSet = nullptr;
2427 std::set<Key> keys(expectedKeys.begin(), expectedKeys.end());
2428 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys).OrderByWriteTime(false), resultSet),
2429 OK);
2430 ASSERT_NE(resultSet, nullptr);
2431 ASSERT_EQ(resultSet->GetCount(), static_cast<int>(keys.size()));
2432 for (uint32_t i = 0; i < keys.size(); i++) {
2433 resultSet->MoveToPosition(i);
2434 Entry entry;
2435 resultSet->GetEntry(entry);
2436 EXPECT_EQ(expectedKeys[keys.size() - i - 1], entry.key);
2437 EXPECT_EQ(entry.value, VALUE_1);
2438 }
2439 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2440 /**
2441 * @tc.steps: step3. Call GetEntries With prefix Query limit
2442 * @tc.expected: step3. Returns entries
2443 * all data are equals the preset data
2444 */
2445
2446 std::vector<Entry> entries2;
2447 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2448 Query::Select().InKeys(keys).OrderByWriteTime(false).Limit(keys.size() / 2, 0), entries2), OK);
2449 ASSERT_EQ(entries2.size(), static_cast<long unsigned int>(expectedKeys.size() / 2));
2450 for (uint32_t i = 0; i < keys.size() / 2; i++) {
2451 EXPECT_EQ(expectedKeys[keys.size() - i - 1], entries2[i].key);
2452 EXPECT_EQ(entries2[i].value, VALUE_1);
2453 }
2454 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2455 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort006"), OK);
2456 }
2457
2458 /**
2459 * @tc.name: WriteTimeSort007
2460 * @tc.desc: For unsupport query when getEntries
2461 * @tc.type: FUNC
2462 * @tc.require: SR000H5U55
2463 * @tc.author: zhuwentao
2464 */
2465 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort007, TestSize.Level0)
2466 {
2467 /**
2468 * @tc.steps: step1. Create a database And Preset Data
2469 */
2470 KvStoreNbDelegate::Option option = {true, false, false};
2471 g_mgr.GetKvStore("WriteTimeSort007", option, g_kvNbDelegateCallbackForQuery);
2472 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2473 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2474 /**
2475 * @tc.steps: step2. Call GetEntries With unsupport Query
2476 * @tc.expected: step2. Returns NOT_SUPPORT
2477 */
2478 Query query = Query::Select().BeginGroup().LessThan("$.field_name1", 5).OrderByWriteTime(false);
2479 KvStoreResultSet *resultSet = nullptr;
2480 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet), NOT_SUPPORT);
2481 std::vector<Entry> entries2;
2482 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(query, entries2), NOT_SUPPORT);
2483 int count = 0;
2484 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetCount(query, count), NOT_SUPPORT);
2485 Key key = {'x'};
2486 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key, VALUE_1), OK);
2487 Query query1 = Query::Select().PrefixKey(key).OrderByWriteTime(false);
2488 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetCount(query1, count), OK);
2489 EXPECT_EQ(count, 1);
2490 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2491 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort007"), OK);
2492 }
2493 #endif // OMIT_JSON
2494