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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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 QueryExpression expression;
1134 EXPECT_TRUE(expression.GetErrFlag());
1135 expression.SetErrFlag(false);
1136 EXPECT_FALSE(expression.GetErrFlag());
1137 expression.Reset();
1138 EXPECT_TRUE(expression.GetErrFlag());
1139 }
1140
1141 /**
1142 * @tc.name: GetEntriesWithQuery003
1143 * @tc.desc: GetEntries(const Query &query, std::vector<Entry> &entries) interface test.
1144 * @tc.type: FUNC
1145 * @tc.require:
1146 * @tc.author: weifeng
1147 */
1148 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntriesWithQuery003, TestSize.Level1)
1149 {
1150 KvStoreNbDelegate::Option option = {true, false, false};
1151 option.schema = SCHEMA_STRING;
1152 g_mgr.GetKvStore("GetEntriesWithQuery003", option, g_kvNbDelegateCallbackForQuery);
1153 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1154 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1155 PutValidEntries();
1156 /**
1157 * @tc.steps: step1. Getentries by query, query is empty;
1158 * @tc.expected: step1. Getentries return OK, entries size == totalSize;
1159 */
1160 Query query = Query::Select();
1161 int count = 0;
1162 int ret = g_kvNbDelegatePtrForQuery->GetCount(query, count);
1163 EXPECT_TRUE(ret == OK);
1164 EXPECT_TRUE(count == 24);
1165 /**
1166 * @tc.steps: step2. Getentries by query, query is full-set;
1167 * @tc.expected: step2. Getentries return OK, ;
1168 */
1169 std::vector<int> inCondition = {1, 10, 100, 200};
1170 Query fullQuery = Query::Select().EqualTo("$.field_name1", true).And().NotEqualTo("$.field_name2", false).
1171 And().GreaterThan("$.field_name3", 10).And().LessThan("$.field_name4", 10).And().Like("$.field_name6", "4%").
1172 And().In("$.field_name7", inCondition);
1173 ret = g_kvNbDelegatePtrForQuery->GetCount(fullQuery, count);
1174 EXPECT_TRUE(ret == OK);
1175 EXPECT_TRUE(count == 3);
1176 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1177 EXPECT_TRUE(g_mgr.DeleteKvStore("GetEntriesWithQuery003") == OK);
1178 }
1179
1180 /**
1181 * @tc.name: GetEntriesWithQuery004
1182 * @tc.desc: GetEntries(const Query &query, std::vector<Entry> &entries) interface test.
1183 * @tc.type: FUNC
1184 * @tc.require:
1185 * @tc.author: weifeng
1186 */
1187 HWTEST_F(DistributedDBInterfacesDataOperationTest, GetEntriesWithQuery004, TestSize.Level1)
1188 {
1189 KvStoreNbDelegate::Option option = {true, false, false};
1190 option.schema = SCHEMA_STRING;
1191 g_mgr.GetKvStore("GetEntriesWithQuery004", option, g_kvNbDelegateCallbackForQuery);
1192 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1193 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1194 PutValidEntries();
1195 /**
1196 * @tc.steps: step1. Getentries by query, query is empty;
1197 * @tc.expected: step1. Getentries return OK, entries size == totalSize;
1198 */
1199 Query query = Query::Select();
1200 KvStoreResultSet *resultSet = nullptr;
1201 int ret = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1202 ASSERT_TRUE(resultSet != nullptr);
1203 EXPECT_TRUE(ret == OK);
1204 EXPECT_EQ(resultSet->GetCount(), 24);
1205 EXPECT_EQ(resultSet->GetPosition(), -1);
1206 EXPECT_TRUE(!resultSet->IsFirst());
1207 EXPECT_TRUE(resultSet->MoveToFirst());
1208 EXPECT_TRUE(resultSet->IsFirst());
1209 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1210 EXPECT_TRUE(resultSet == nullptr);
1211 /**
1212 * @tc.steps: step2. Getentries by query, query is full-set;
1213 * @tc.expected: step2. Getentries return OK, ;
1214 */
1215 std::vector<int> inCondition = {1, 10, 100, 200};
1216 Query fullQuery = Query::Select().EqualTo("$.field_name1", true).And().NotEqualTo("$.field_name2", false).
1217 And().GreaterThan("$.field_name3", 10).And().LessThan("$.field_name4", 10).And().Like("$.field_name6", "4%").
1218 And().In("$.field_name7", inCondition).OrderBy("$.field_name9").Limit(20, 1);
1219 ret = g_kvNbDelegatePtrForQuery->GetEntries(fullQuery, resultSet);
1220 ASSERT_TRUE(resultSet != nullptr);
1221 EXPECT_EQ(ret, OK);
1222 EXPECT_EQ(resultSet->GetCount(), 2);
1223 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1224 EXPECT_TRUE(resultSet == nullptr);
1225 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1226 EXPECT_TRUE(g_mgr.DeleteKvStore("GetEntriesWithQuery004") == OK);
1227 }
1228
1229 /**
1230 * @tc.name: QueryIsNotNull001
1231 * @tc.desc: IsNotNull interface normal function
1232 * @tc.type: FUNC
1233 * @tc.require:
1234 * @tc.author: sunpeng
1235 */
1236 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryIsNotNull001, TestSize.Level1)
1237 {
1238 KvStoreNbDelegate::Option option = {true, false, false};
1239 option.schema = SCHEMA_DEFINE2;
1240 g_mgr.GetKvStore("QueryIsNotNull001", option, g_kvNbDelegateCallbackForQuery);
1241 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1242 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1243 std::string validData = "{\"field_name1\":null, \"field_name2\":1}";
1244 Value value(validData.begin(), validData.end());
1245 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_1, value), OK);
1246 validData = "{\"field_name1\":2, \"field_name2\":2}";
1247 Value value2(validData.begin(), validData.end());
1248 EXPECT_EQ(g_kvNbDelegatePtrForQuery->Put(KEY_2, value2), OK);
1249 /**
1250 * @tc.steps: step1. Get Query object by IsNotNull
1251 */
1252 Query query = Query::Select().IsNotNull("$.field_name1");
1253 /**
1254 * @tc.steps: step2. Use GetEntries get KV
1255 * @tc.expected: step2. Getentries return OK, Get K1V1;
1256 */
1257 std::vector<Entry> entries;
1258 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1259 EXPECT_EQ(errCode, OK);
1260 EXPECT_EQ(entries.size(), 1ul);
1261 EXPECT_EQ(entries[0].key, KEY_2);
1262 EXPECT_EQ(entries[0].value, value2);
1263 /**
1264 * @tc.steps: step3. Use GetCount to get number of item
1265 * @tc.expected: step3. Get count = 1;
1266 */
1267 int count = -1;
1268 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1269 EXPECT_EQ(count, 1);
1270 /**
1271 * @tc.steps: step4. Use GetEntries to get resultSet
1272 * @tc.expected: step4. Getentries return OK, Get K1V1;
1273 */
1274 KvStoreResultSet *resultSet = nullptr;
1275 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1276 ASSERT_TRUE(resultSet != nullptr);
1277 EXPECT_EQ(errCode, OK);
1278 EXPECT_EQ(resultSet->GetCount(), 1);
1279 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1280 EXPECT_TRUE(resultSet == nullptr);
1281 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1282 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryIsNotNull001") == OK);
1283 }
1284
1285 /**
1286 * @tc.name: QueryPreFixKey001
1287 * @tc.desc: Normal function of query by prefix key
1288 * @tc.type: FUNC
1289 * @tc.require:
1290 * @tc.author: sunpeng
1291 */
1292 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryPreFixKey001, TestSize.Level1)
1293 {
1294 KvStoreNbDelegate::Option option = {true, false, false};
1295 option.schema = SCHEMA_DEFINE2;
1296 g_mgr.GetKvStore("QueryPreFixKey001", option, g_kvNbDelegateCallbackForQuery);
1297 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1298 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1299
1300 vector<Entry> entries = PreDataForQueryByPreFixKey();
1301 EXPECT_EQ(g_kvNbDelegatePtrForQuery->PutBatch(entries), OK);
1302
1303 /**
1304 * @tc.steps: step1. Get Query object by PrefixKey ac
1305 */
1306 Query query = Query::Select().PrefixKey({'a', 'c'});
1307
1308 /**
1309 * @tc.steps: step2. Use GetEnties to get same key prefix ac
1310 * @tc.expected: step2. Get count = 5, Key6~10
1311 */
1312 std::vector<Entry> entriesRes;
1313 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1314 EXPECT_EQ(errCode, OK);
1315 EXPECT_EQ(entriesRes.size(), 5ul);
1316 for (size_t i = 0; i < entriesRes.size(); i++) {
1317 EXPECT_EQ(entriesRes[i].key.front(), 'a');
1318 EXPECT_EQ(entriesRes[i].key[1], 'c');
1319 }
1320 /**
1321 * @tc.steps: step3. Use GetCount to get number of item of this query object
1322 * @tc.expected: step3. Get count = 5
1323 */
1324 int count = -1;
1325 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1326 EXPECT_EQ(count, 5);
1327 /**
1328 * @tc.steps: step4. Use GetEnties to get same key prefix ac of resultSet
1329 * @tc.expected: step4. Get resultSet of key6~10
1330 */
1331 KvStoreResultSet *resultSet = nullptr;
1332 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1333 ASSERT_TRUE(resultSet != nullptr);
1334 EXPECT_EQ(errCode, OK);
1335 EXPECT_EQ(resultSet->GetCount(), 5);
1336 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1337 EXPECT_TRUE(resultSet == nullptr);
1338
1339 /**
1340 * @tc.steps: step5. Get Query object by null PrefixKey
1341 */
1342 Query query1 = Query::Select().PrefixKey({});
1343 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1344 /**
1345 * @tc.steps: step6. Use GetEnties and GetCount to null key prefix query object
1346 * @tc.expected: step6. Get all KV from database
1347 */
1348 EXPECT_EQ(errCode, OK);
1349 EXPECT_EQ(entriesRes.size(), 10ul);
1350 EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntriesEqual(entries, entriesRes, true));
1351
1352 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1353 ASSERT_TRUE(resultSet != nullptr);
1354 EXPECT_EQ(errCode, OK);
1355 EXPECT_EQ(resultSet->GetCount(), 10);
1356 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1357 EXPECT_TRUE(resultSet == nullptr);
1358
1359 Query query2 = Query::Select().PrefixKey(Key(1025, 'a')); // 1025 over max key length 1 byte
1360 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, entriesRes);
1361 EXPECT_EQ(errCode, INVALID_ARGS);
1362
1363 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1364 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryPreFixKey001") == OK);
1365 }
1366
1367 /**
1368 * @tc.name: QueryPreFixKey003
1369 * @tc.desc: For special key prefix combination condition of query
1370 * @tc.type: FUNC
1371 * @tc.require:
1372 * @tc.author: sunpeng
1373 */
1374 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryPreFixKey003, TestSize.Level1)
1375 {
1376 KvStoreNbDelegate::Option option = {true, false, false};
1377 option.schema = SCHEMA_DEFINE2;
1378 g_mgr.GetKvStore("QueryPreFixKey003", option, g_kvNbDelegateCallbackForQuery);
1379 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1380 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1381
1382 vector<Entry> entries = PreDataForQueryByPreFixKey();
1383 EXPECT_EQ(g_kvNbDelegatePtrForQuery->PutBatch(entries), OK);
1384
1385 /**
1386 * @tc.steps: step1. Get Query object by double PrefixKey
1387 */
1388 Query query = Query::Select().PrefixKey({'a', 'c'}).PrefixKey({});
1389 std::vector<Entry> entriesRes;
1390 /**
1391 * @tc.steps: step2. Use GetEnties for double prefixkey query object
1392 * @tc.expected: step2. return INVALID_QUERY_FORMAT
1393 */
1394 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1395 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1396 /**
1397 * @tc.steps: step3. Use GetEnties for double prefixkey query object to get resultSet
1398 * @tc.expected: step3. return INVALID_QUERY_FORMAT
1399 */
1400 KvStoreResultSet *resultSet = nullptr;
1401 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1402 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1403 EXPECT_TRUE(resultSet == nullptr);
1404 /**
1405 * @tc.steps: step4. Get Query object by PrefixKey and orderBy
1406 */
1407 Query query1 = Query::Select().PrefixKey({'a', 'b'}).OrderBy("$.field_name1");
1408 /**
1409 * @tc.steps: step3. Use GetEnties and GetCount for this query object
1410 * @tc.expected: step3. Can get content by GetEntries, but GetCount can not use for query object include orderBy
1411 */
1412 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1413 EXPECT_EQ(entriesRes.size(), 5ul);
1414 EXPECT_EQ(errCode, OK);
1415 int count = -1;
1416 errCode = g_kvNbDelegatePtrForQuery->GetCount(query1, count);
1417 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1418
1419 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1420 ASSERT_TRUE(resultSet != nullptr);
1421 EXPECT_EQ(errCode, OK);
1422 EXPECT_EQ(resultSet->GetCount(), 5);
1423 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1424 EXPECT_TRUE(resultSet == nullptr);
1425
1426 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1427 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryPreFixKey003") == OK);
1428 }
1429
1430 /**
1431 * @tc.name: QueryPreFixKey004
1432 * @tc.desc: Query a prefix that does not exist
1433 * @tc.type: FUNC
1434 * @tc.require:
1435 * @tc.author: sunpeng
1436 */
1437 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryPreFixKey004, TestSize.Level1)
1438 {
1439 KvStoreNbDelegate::Option option = {true, false, false};
1440 option.schema = SCHEMA_DEFINE2;
1441 g_mgr.GetKvStore("QueryPreFixKey004", option, g_kvNbDelegateCallbackForQuery);
1442 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1443 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1444
1445 vector<Entry> entries = PreDataForQueryByPreFixKey();
1446 EXPECT_EQ(g_kvNbDelegatePtrForQuery->PutBatch(entries), OK);
1447 /**
1448 * @tc.steps: step1. Get Query object by PrefixKey that does not exist
1449 */
1450 Query query = Query::Select().PrefixKey({'c'});
1451 /**
1452 * @tc.steps: step2. Use GetEnties and GetCount to get result
1453 * @tc.expected: step2. Return NOT_FOUND, get result OK, number of KV is 0
1454 */
1455 std::vector<Entry> entriesRes;
1456 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1457 EXPECT_EQ(errCode, NOT_FOUND);
1458
1459 int count = -1;
1460 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1461 EXPECT_EQ(count, 0);
1462
1463 KvStoreResultSet *resultSet = nullptr;
1464 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1465 ASSERT_TRUE(resultSet != nullptr);
1466 EXPECT_EQ(errCode, OK);
1467 EXPECT_EQ(resultSet->GetCount(), 0);
1468 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1469 EXPECT_TRUE(resultSet == nullptr);
1470
1471 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1472 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryPreFixKey004") == OK);
1473 }
1474
1475 /**
1476 * @tc.name: QueryGroup001
1477 * @tc.desc: Query group nomal ability to change operation priority
1478 * @tc.type: FUNC
1479 * @tc.require:
1480 * @tc.author: sunpeng
1481 */
1482 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryGroup001, TestSize.Level1)
1483 {
1484 KvStoreNbDelegate::Option option = {true, false, false};
1485 option.schema = SCHEMA_DEFINE2;
1486 g_mgr.GetKvStore("QueryGroup001", option, g_kvNbDelegateCallbackForQuery);
1487 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1488 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1489
1490 PreDataForGroupTest();
1491
1492 /**
1493 * @tc.steps: step1. Get Query object：
1494 * query: <4 and =4 or >1
1495 * query1: (<4 and =4) or >1
1496 * query2: <4 and (=4 or >1)
1497 */
1498 Query query = Query::Select().LessThan("$.field_name1", 4).And().EqualTo("$.field_name1", 4).
1499 Or().GreaterThan("$.field_name1", 1);
1500 Query query1 = Query::Select().BeginGroup().LessThan("$.field_name1", 4).And().
1501 EqualTo("$.field_name1", 4).EndGroup().Or().GreaterThan("$.field_name1", 1);
1502 Query query2 = Query::Select().LessThan("$.field_name1", 4).And().BeginGroup().
1503 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1).EndGroup();
1504
1505 /**
1506 * @tc.steps: step2. Use GetEnties to get different result
1507 * @tc.expected: step2. Result:
1508 * query: count = 4
1509 * query1: count = 4
1510 * query2: count = 2
1511 */
1512 std::vector<Entry> entries;
1513 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1514 EXPECT_EQ(errCode, OK);
1515 EXPECT_EQ(entries.size(), 4ul);
1516 int count = -1;
1517 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1518 EXPECT_EQ(count, 4);
1519
1520 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, entries);
1521 EXPECT_EQ(errCode, OK);
1522
1523 EXPECT_EQ(entries.size(), 2ul);
1524 g_kvNbDelegatePtrForQuery->GetCount(query2, count);
1525 EXPECT_EQ(count, 2);
1526 KvStoreResultSet *resultSet = nullptr;
1527 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, resultSet);
1528 ASSERT_TRUE(resultSet != nullptr);
1529 EXPECT_EQ(errCode, OK);
1530 EXPECT_EQ(resultSet->GetCount(), 2);
1531 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1532 EXPECT_TRUE(resultSet == nullptr);
1533
1534 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entries);
1535 EXPECT_EQ(errCode, OK);
1536 EXPECT_EQ(entries.size(), 4ul);
1537 g_kvNbDelegatePtrForQuery->GetCount(query1, count);
1538 EXPECT_EQ(count, 4);
1539
1540 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1541 ASSERT_TRUE(resultSet != nullptr);
1542 EXPECT_EQ(errCode, OK);
1543 EXPECT_EQ(resultSet->GetCount(), 4);
1544 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1545 EXPECT_TRUE(resultSet == nullptr);
1546
1547 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1548 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryGroup001") == OK);
1549 }
1550
1551 /**
1552 * @tc.name: QueryGroup002
1553 * @tc.desc: Test for illegal Group query object
1554 * @tc.type: FUNC
1555 * @tc.require:
1556 * @tc.author: sunpeng
1557 */
1558 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryGroup002, TestSize.Level1)
1559 {
1560 KvStoreNbDelegate::Option option = {true, false, false};
1561 option.schema = SCHEMA_DEFINE2;
1562 g_mgr.GetKvStore("QueryGroup002", option, g_kvNbDelegateCallbackForQuery);
1563 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1564 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1565
1566 PreDataForGroupTest();
1567
1568 /**
1569 * @tc.steps: step1. Get Query object：
1570 * query: (<4 and (=4 or） >1)
1571 * query1: (<4 and =4 or >1
1572 * query2: <4 and =4) or >1
1573 * query3: )<4 and =4( or >1
1574 * query4: <4 (and = 4 or >1)
1575 */
1576 Query query = Query::Select().BeginGroup().LessThan("$.field_name1", 4).And().BeginGroup().
1577 EqualTo("$.field_name1", 4).Or().EndGroup().GreaterThan("$.field_name1", 1).EndGroup();
1578 Query query1 = Query::Select().BeginGroup().LessThan("$.field_name1", 4).And().
1579 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1);
1580 Query query2 = Query::Select().LessThan("$.field_name1", 4).And().
1581 EqualTo("$.field_name1", 4).EndGroup().Or().GreaterThan("$.field_name1", 1);
1582 Query query3 = Query::Select().EndGroup().LessThan("$.field_name1", 4).And().
1583 EqualTo("$.field_name1", 4).BeginGroup().Or().GreaterThan("$.field_name1", 1);
1584 Query query4 = Query::Select().LessThan("$.field_name1", 4).BeginGroup().And().
1585 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1).EndGroup();
1586
1587 /**
1588 * @tc.steps: step2. Use GetEnties and GetCount to get result
1589 * @tc.expected: step2. All query object is illegal, reeturn INVALID_QUERY_FORMAT
1590 */
1591 std::vector<Entry> entries;
1592 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1593 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1594
1595 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entries);
1596 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1597 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, entries);
1598 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1599 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query3, entries);
1600 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1601 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query4, entries);
1602 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1603
1604 KvStoreResultSet *resultSet = nullptr;
1605 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1606 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1607 EXPECT_TRUE(resultSet == nullptr);
1608
1609 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, resultSet);
1610 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1611 EXPECT_TRUE(resultSet == nullptr);
1612
1613 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, resultSet);
1614 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1615 EXPECT_TRUE(resultSet == nullptr);
1616
1617 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query3, resultSet);
1618 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1619 EXPECT_TRUE(resultSet == nullptr);
1620
1621 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query4, resultSet);
1622 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1623 EXPECT_TRUE(resultSet == nullptr);
1624
1625 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1626 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryGroup002") == OK);
1627 }
1628
1629 /**
1630 * @tc.name: QueryGroup003
1631 * @tc.desc: Query expressions containing nested parentheses
1632 * @tc.type: FUNC
1633 * @tc.require:
1634 * @tc.author: sunpeng
1635 */
1636 HWTEST_F(DistributedDBInterfacesDataOperationTest, QueryGroup003, TestSize.Level1)
1637 {
1638 KvStoreNbDelegate::Option option = {true, false, false};
1639 option.schema = SCHEMA_DEFINE2;
1640 g_mgr.GetKvStore("QueryGroup003", option, g_kvNbDelegateCallbackForQuery);
1641 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1642 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1643
1644 PreDataForGroupTest();
1645
1646 /**
1647 * @tc.steps: step1. Get Query object for (<=5 and (=4 or >1) and <3)
1648 */
1649 Query query = Query::Select().BeginGroup().LessThan("$.field_name1", 5).And().BeginGroup().
1650 EqualTo("$.field_name1", 4).Or().GreaterThan("$.field_name1", 1).EndGroup().And().
1651 LessThan("$.field_name1", 3).EndGroup();
1652
1653 /**
1654 * @tc.steps: step2. Use GetEnties and GetCount to get result
1655 * @tc.expected: step2. reeturn OK, count = 1
1656 */
1657 std::vector<Entry> entries;
1658 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1659 EXPECT_EQ(errCode, OK);
1660 EXPECT_EQ(entries.size(), 1ul);
1661 int count = -1;
1662 g_kvNbDelegatePtrForQuery->GetCount(query, count);
1663 EXPECT_EQ(count, 1);
1664
1665 KvStoreResultSet *resultSet = nullptr;
1666 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet);
1667 ASSERT_TRUE(resultSet != nullptr);
1668 EXPECT_EQ(errCode, OK);
1669 EXPECT_EQ(resultSet->GetCount(), 1);
1670 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1671 EXPECT_TRUE(resultSet == nullptr);
1672
1673 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1674 EXPECT_TRUE(g_mgr.DeleteKvStore("QueryGroup003") == OK);
1675 }
1676
1677 /**
1678 * @tc.name: multiOrderBy001
1679 * @tc.desc: Test multiple orderby conditions together to query
1680 * @tc.type: FUNC
1681 * @tc.require:
1682 * @tc.author: sunpeng
1683 */
1684 HWTEST_F(DistributedDBInterfacesDataOperationTest, multiOrderBy001, TestSize.Level1)
1685 {
1686 KvStoreNbDelegate::Option option = {true, false, false};
1687 option.schema = SCHEMA_DEFINE2;
1688 g_mgr.GetKvStore("multiOrderBy001", option, g_kvNbDelegateCallbackForQuery);
1689 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1690 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1691
1692 PreDataForGroupTest();
1693
1694 Query query = Query::Select().PrefixKey({}).OrderBy("$.field_name1").OrderBy("$.field_name1");
1695 std::vector<Entry> entries;
1696 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entries);
1697 EXPECT_EQ(errCode, OK);
1698
1699 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query.Limit(2, 2), entries);
1700 EXPECT_EQ(errCode, OK);
1701
1702 Query query1 = Query::Select().PrefixKey({}).Limit(2, 2).OrderBy("$.field_name1").OrderBy("$.field_name1");
1703 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entries);
1704 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1705
1706 Query query2 = Query::Select().PrefixKey({}).OrderBy("$.field_name1").Limit(2, 2).OrderBy("$.field_name1");
1707 KvStoreResultSet *resultSet = nullptr;
1708 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query2, resultSet);
1709 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
1710
1711 Query query3 = Query::Select().PrefixKey({}).OrderBy("$.field_name1").
1712 OrderBy("$.field_name1").OrderBy("$.field_name1");
1713 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query3, resultSet);
1714 EXPECT_EQ(errCode, OK);
1715 EXPECT_EQ(g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet), OK);
1716 EXPECT_TRUE(resultSet == nullptr);
1717
1718 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1719 EXPECT_TRUE(g_mgr.DeleteKvStore("multiOrderBy001") == OK);
1720 }
1721
1722 /**
1723 * @tc.name: multiOrderBy001
1724 * @tc.desc: For multiple order query.
1725 * @tc.type: FUNC
1726 * @tc.require:
1727 * @tc.author: sunpeng
1728 */
1729 HWTEST_F(DistributedDBInterfacesDataOperationTest, PreifxAndOrderBy001, TestSize.Level1)
1730 {
1731 KvStoreNbDelegate::Option option = {true, false, false};
1732 option.schema = SCHEMA_DEFINE2;
1733 g_mgr.GetKvStore("PreifxAndOrderBy001", option, g_kvNbDelegateCallbackForQuery);
1734 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1735 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1736
1737 PresetDataForPreifxAndOrderBy001();
1738
1739 Query query = Query::Select().PrefixKey({}).OrderBy("$.field_name1", false);
1740 std::vector<Entry> entriesRes;
1741 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
1742 EXPECT_EQ(errCode, OK);
1743 ASSERT_EQ(entriesRes.size(), 5ul);
1744 EXPECT_EQ(entriesRes[0].key, KEY_5);
1745 EXPECT_EQ(entriesRes[1].key, KEY_3);
1746 EXPECT_EQ(entriesRes[2].key, KEY_4);
1747 EXPECT_EQ(entriesRes[3].key, KEY_1);
1748 EXPECT_EQ(entriesRes[4].key, KEY_2);
1749
1750 Query query1 = Query::Select().OrderBy("$.field_name1", false);
1751 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1752 EXPECT_EQ(errCode, OK);
1753 ASSERT_EQ(entriesRes.size(), 5ul);
1754 EXPECT_EQ(entriesRes[0].key, KEY_5);
1755 EXPECT_EQ(entriesRes[1].key, KEY_4);
1756 EXPECT_EQ(entriesRes[2].key, KEY_3);
1757 EXPECT_EQ(entriesRes[3].key, KEY_2);
1758 EXPECT_EQ(entriesRes[4].key, KEY_1);
1759
1760 Query query2 = Query::Select().PrefixKey({}).OrderBy("$.field_name1", false).OrderBy("$.field_name2", false);
1761 (void) g_kvNbDelegatePtrForQuery->GetEntries(query2, entriesRes);
1762 ASSERT_EQ(entriesRes.size(), 5ul);
1763 EXPECT_EQ(entriesRes[0].key, KEY_5);
1764 EXPECT_EQ(entriesRes[1].key, KEY_4);
1765 EXPECT_EQ(entriesRes[2].key, KEY_3);
1766 EXPECT_EQ(entriesRes[3].key, KEY_2);
1767 EXPECT_EQ(entriesRes[4].key, KEY_1);
1768
1769 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1770 EXPECT_TRUE(g_mgr.DeleteKvStore("PreifxAndOrderBy001") == OK);
1771 }
1772
1773 /**
1774 * @tc.name: PrefixAndOther001
1775 * @tc.desc: Combination of prefix query and logical filtering
1776 * @tc.type: FUNC
1777 * @tc.require:
1778 * @tc.author: sunpeng
1779 */
1780 HWTEST_F(DistributedDBInterfacesDataOperationTest, PrefixAndOther001, TestSize.Level1)
1781 {
1782 KvStoreNbDelegate::Option option = {true, false, false};
1783 option.schema = SCHEMA_DEFINE2;
1784 g_mgr.GetKvStore("PrefixAndOther001", option, g_kvNbDelegateCallbackForQuery);
1785 ASSERT_TRUE(g_kvNbDelegatePtrForQuery != nullptr);
1786 EXPECT_TRUE(g_kvDelegateStatusForQuery == OK);
1787
1788 PresetDataForPreifxAndOrderBy001();
1789
1790 std::vector<Entry> entriesRes;
1791 Query query1 = Query::Select().EqualTo("$.field_name1", 1).PrefixKey({});
1792 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1793 EXPECT_EQ(errCode, OK);
1794 query1 = Query::Select().PrefixKey({}).EqualTo("$.field_name1", 1);
1795 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1796 EXPECT_EQ(errCode, OK);
1797
1798 query1 = Query::Select().EqualTo("$.field_name1", 1).PrefixKey({}).And().EqualTo("$.field_name1", 1);
1799 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1800 EXPECT_EQ(errCode, OK);
1801
1802 query1 = Query::Select().EqualTo("$.field_name1", 1).PrefixKey({}).And().EqualTo("$.field_name1", 2);
1803 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1804 EXPECT_EQ(errCode, NOT_FOUND);
1805
1806 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1807 EXPECT_TRUE(g_mgr.DeleteKvStore("PrefixAndOther001") == OK);
1808 }
1809
1810 /**
1811 * @tc.name: InKeys001
1812 * @tc.desc: InKeys query base function
1813 * @tc.type: FUNC
1814 * @tc.require:
1815 * @tc.author: xushaohua
1816 */
1817 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeys001, TestSize.Level1)
1818 {
1819 /**
1820 * @tc.steps: step1. Create a database And Preset Data
1821 */
1822 KvStoreNbDelegate::Option option = {true, false, false};
1823 g_mgr.GetKvStore("InKeys001", option, g_kvNbDelegateCallbackForQuery);
1824 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1825 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
1826
1827 Key key = {'1'};
1828 DBStatus status = g_kvNbDelegatePtrForQuery->Put(key, VALUE_1);
1829 ASSERT_EQ(status, OK);
1830 const int dataSize = 10; // 10 data for test
1831 std::set<Key> keys;
1832 for (uint8_t i = 0; i < dataSize; i++) {
1833 key.push_back(i);
1834 status = g_kvNbDelegatePtrForQuery->Put(key, VALUE_1);
1835 ASSERT_EQ(status, OK);
1836 keys.emplace(key);
1837 key.pop_back();
1838 }
1839
1840 /**
1841 * @tc.steps: step2. Call GetEntries With Query, set all keys at Inkeys.
1842 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
1843 * all data are equals the preset data
1844 */
1845 KvStoreResultSet *resultSet = nullptr;
1846 g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys), resultSet);
1847 ASSERT_NE(resultSet, nullptr);
1848 ASSERT_EQ(resultSet->GetCount(), dataSize);
1849 for (int i = 0; i < dataSize; i++) {
1850 resultSet->MoveToPosition(i);
1851 Entry entry;
1852 resultSet->GetEntry(entry);
1853 key.push_back(i);
1854 EXPECT_EQ(key, entry.key);
1855 EXPECT_EQ(entry.value, VALUE_1);
1856 key.pop_back();
1857 }
1858 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
1859
1860 /**
1861 * @tc.steps: step3. Call GetEntries With Query, set one other key at Inkeys.
1862 * @tc.expected: step3. Returns KvStoreResultSet, the count is 0,
1863 */
1864 g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys({KEY_7}), resultSet);
1865 ASSERT_NE(resultSet, nullptr);
1866 ASSERT_EQ(resultSet->GetCount(), 0);
1867 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
1868 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1869 EXPECT_EQ(g_mgr.DeleteKvStore("InKeys001"), OK);
1870 }
1871
1872 /**
1873 * @tc.name: InKeysLimit001
1874 * @tc.desc: InKeys query limit verification
1875 * @tc.type: FUNC
1876 * @tc.require:
1877 * @tc.author: xushaohua
1878 */
1879 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeysLimit001, TestSize.Level1)
1880 {
1881 /**
1882 * @tc.steps: step1. Create a database
1883 */
1884 KvStoreNbDelegate::Option option = {true, false, false};
1885 g_mgr.GetKvStore("InKeysLimit001", option, g_kvNbDelegateCallbackForQuery);
1886 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1887 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
1888
1889 /**
1890 * @tc.steps: step2. Construct a key set, and the key size over MAX_BATCH_SIZE
1891 */
1892 std::set<Key> keys;
1893 for (uint8_t i = 0; i < DBConstant::MAX_BATCH_SIZE + 1; i++) {
1894 Key key = { i };
1895 keys.emplace(key);
1896 }
1897
1898 /**
1899 * @tc.steps: step3. Call GetEntries With Query, set keys at Inkeys.
1900 * @tc.expected: step3. Returns OVER_MAX_LIMITS, the resultSet is nullptr,
1901 */
1902 KvStoreResultSet *resultSet = nullptr;
1903 DBStatus status = g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys), resultSet);
1904 EXPECT_EQ(status, OVER_MAX_LIMITS);
1905 EXPECT_EQ(resultSet, nullptr);
1906
1907 /**
1908 * @tc.steps: step4. Call GetEntries With Query, set keys empty.
1909 * @tc.expected: step4. Returns INVALID_ARGS, the resultSet is nullptr,
1910 */
1911 status = g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys({}), resultSet);
1912 EXPECT_EQ(status, INVALID_ARGS);
1913 EXPECT_EQ(resultSet, nullptr);
1914
1915 /**
1916 * @tc.steps: step4. Call GetEntries With Query, set a invalid key.
1917 * @tc.expected: step4. Returns INVALID_ARGS, the resultSet is nullptr,
1918 */
1919 status = g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys({{}}), resultSet);
1920 EXPECT_EQ(status, INVALID_ARGS);
1921 EXPECT_EQ(resultSet, nullptr);
1922
1923 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1924 EXPECT_EQ(g_mgr.DeleteKvStore("InKeysLimit001"), OK);
1925 }
1926
1927 /**
1928 * @tc.name: InKeysAndOther001
1929 * @tc.desc: Combination of InKeys query and logical filtering
1930 * @tc.type: FUNC
1931 * @tc.require:
1932 * @tc.author: xushaohua
1933 */
1934 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeysAndOther001, TestSize.Level1)
1935 {
1936 /**
1937 * @tc.steps: step1. Create a database And Preset Data
1938 */
1939 KvStoreNbDelegate::Option option = {true, false, false};
1940 option.schema = SCHEMA_DEFINE2;
1941 g_mgr.GetKvStore("InKeysAndOther001", option, g_kvNbDelegateCallbackForQuery);
1942 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1943 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
1944
1945 PresetDataForPreifxAndOrderBy001();
1946
1947 std::set<Key> keys = { KEY_1, KEY_2, KEY_4 };
1948 std::vector<Entry> entriesRes;
1949
1950 /**
1951 * @tc.steps: step2. Call GetEntries With Query, use EqualTo and InKeys
1952 * @tc.expected: step2. Returns OK
1953 */
1954 Query query1 = Query::Select().EqualTo("$.field_name1", 1).InKeys(keys);
1955 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1956 EXPECT_EQ(errCode, OK);
1957
1958 /**
1959 * @tc.steps: step3. Call GetEntries With Query, use InKeys and EqualTo
1960 * @tc.expected: step3. Returns OK
1961 */
1962 query1 = Query::Select().InKeys(keys).EqualTo("$.field_name1", 1);
1963 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1964 EXPECT_EQ(errCode, OK);
1965
1966 /**
1967 * @tc.steps: step4. Call GetEntries With Query, use EqualTo, InKeys and EqualTo, all valid
1968 * @tc.expected: step4. Returns OK
1969 */
1970 query1 = Query::Select().EqualTo("$.field_name1", 1).InKeys(keys).And().EqualTo("$.field_name2", 2);
1971 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1972 EXPECT_EQ(errCode, OK);
1973
1974 /**
1975 * @tc.steps: step4. Call GetEntries With Query, use EqualTo, InKeys and EqualTo, has invalid
1976 * @tc.expected: step4. Returns NOT_FOUND
1977 */
1978 query1 = Query::Select().EqualTo("$.field_name1", 1).InKeys(keys).And().EqualTo("$.field_name1", 2);
1979 errCode = g_kvNbDelegatePtrForQuery->GetEntries(query1, entriesRes);
1980 EXPECT_EQ(errCode, NOT_FOUND);
1981
1982 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
1983 EXPECT_EQ(g_mgr.DeleteKvStore("InKeysAndOther001"), OK);
1984 }
1985
1986 /**
1987 * @tc.name: InKeysAndOther002
1988 * @tc.desc: Combination of InKeys query and logical filtering
1989 * @tc.type: FUNC
1990 * @tc.require:
1991 * @tc.author: lianhuix
1992 */
1993 HWTEST_F(DistributedDBInterfacesDataOperationTest, InKeysAndOther002, TestSize.Level1)
1994 {
1995 KvStoreNbDelegate::Option option = {true, false, false};
1996 option.schema = SCHEMA_DEFINE2;
1997 g_mgr.GetKvStore("InKeysAndOther001", option, g_kvNbDelegateCallbackForQuery);
1998 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
1999 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2000
2001 std::set<Key> keys = { KEY_1, KEY_2, KEY_4 };
2002 std::vector<Query> queries = {
2003 Query::Select().PrefixKey({}).InKeys(keys).Or().EqualTo("$.field_name1", 2),
2004 Query::Select().PrefixKey({}).InKeys(keys).And().EqualTo("$.field_name1", 2),
2005 Query::Select().InKeys(keys).Or().EqualTo("$.field_name1", 2),
2006 Query::Select().InKeys(keys).And().EqualTo("$.field_name1", 2),
2007 Query::Select().PrefixKey({}).Or().EqualTo("$.field_name1", 2),
2008 Query::Select().PrefixKey({}).And().EqualTo("$.field_name1", 2),
2009 Query::Select().PrefixKey({}).And().InKeys(keys).EqualTo("$.field_name1", 2),
2010 Query::Select().And().InKeys(keys).EqualTo("$.field_name1", 2),
2011 Query::Select().Or().PrefixKey({}).EqualTo("$.field_name1", 2),
2012 Query::Select().BeginGroup().PrefixKey({}).Or().EqualTo("$.field_name1", 2).EndGroup(),
2013 Query::Select().EqualTo("$.field_name1", 2).Or().InKeys(keys),
2014 Query::Select().EqualTo("$.field_name1", 2).Or().PrefixKey({}),
2015 };
2016
2017 for (const auto &query : queries) {
2018 std::vector<Entry> entriesRes;
2019 int errCode = g_kvNbDelegatePtrForQuery->GetEntries(query, entriesRes);
2020 EXPECT_EQ(errCode, INVALID_QUERY_FORMAT);
2021 }
2022
2023 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2024 EXPECT_EQ(g_mgr.DeleteKvStore("InKeysAndOther001"), OK);
2025 }
2026
2027 /**
2028 * @tc.name: WriteTimeSort001
2029 * @tc.desc: For prefixKey query with orderBy writeTime asc
2030 * @tc.type: FUNC
2031 * @tc.require:
2032 * @tc.author: zhuwentao
2033 */
2034 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort001, TestSize.Level1)
2035 {
2036 /**
2037 * @tc.steps: step1. Create a database And Preset Data
2038 */
2039 KvStoreNbDelegate::Option option = {true, false, false};
2040 g_mgr.GetKvStore("WriteTimeSort001", option, g_kvNbDelegateCallbackForQuery);
2041 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2042 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2043 /**
2044 * @tc.steps: step2. put some data
2045 * @tc.expected: step2. Returns OK
2046 */
2047 Key key = {'x'};
2048 Key key2 = {'y'};
2049 const int dataSize = 100; // 100 data for test
2050 std::vector<Key> expectedKeys;
2051 std::vector<uint8_t> keySuffix;
2052 for (uint8_t i = 0; i < dataSize; i++) {
2053 keySuffix.push_back(rand () % 100);
2054 }
2055 for (uint8_t i = 0; i < dataSize; i++) {
2056 Key tmpKey = {key[0], keySuffix[i], i};
2057 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2058 expectedKeys.push_back(tmpKey);
2059 }
2060 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2061
2062 /**
2063 * @tc.steps: step2. Call GetEntries With prefix Query
2064 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2065 * all data are equals the preset data
2066 */
2067 KvStoreResultSet *resultSet = nullptr;
2068 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(true), resultSet),
2069 OK);
2070 ASSERT_NE(resultSet, nullptr);
2071 ASSERT_EQ(resultSet->GetCount(), dataSize);
2072 for (int i = 0; i < dataSize; i++) {
2073 resultSet->MoveToPosition(i);
2074 Entry entry;
2075 resultSet->GetEntry(entry);
2076 EXPECT_EQ(expectedKeys[i], entry.key);
2077 EXPECT_EQ(entry.value, VALUE_1);
2078 }
2079 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2080 /**
2081 * @tc.steps: step3. Call GetEntries With prefix Query limit
2082 * @tc.expected: step3. Returns KvStoreResultSet, the count is dataSize,
2083 * all data are equals the preset data
2084 */
2085 KvStoreResultSet *resultSet2 = nullptr;
2086 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2087 Query::Select().PrefixKey(key).OrderByWriteTime(true).Limit(dataSize / 2, 0), resultSet2), OK);
2088 ASSERT_NE(resultSet2, nullptr);
2089 ASSERT_EQ(resultSet2->GetCount(), dataSize / 2);
2090 for (int i = 0; i < dataSize / 2; i++) {
2091 resultSet2->MoveToPosition(i);
2092 Entry entry;
2093 resultSet2->GetEntry(entry);
2094 EXPECT_EQ(expectedKeys[i], entry.key);
2095 EXPECT_EQ(entry.value, VALUE_1);
2096 }
2097 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet2);
2098 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2099 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort001"), OK);
2100 }
2101
2102 /**
2103 * @tc.name: WriteTimeSort002
2104 * @tc.desc: For prefixKey query with orderBy writeTime asc
2105 * @tc.type: FUNC
2106 * @tc.require:
2107 * @tc.author: zhuwentao
2108 */
2109 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort002, TestSize.Level1)
2110 {
2111 /**
2112 * @tc.steps: step1. Create a database And Preset Data
2113 */
2114 KvStoreNbDelegate::Option option = {true, false, false};
2115 g_mgr.GetKvStore("WriteTimeSort002", option, g_kvNbDelegateCallbackForQuery);
2116 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2117 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2118 /**
2119 * @tc.steps: step2. put some data
2120 * @tc.expected: step2. Returns OK
2121 */
2122 Key key = {'x'};
2123 Key key2 = {'y'};
2124 const int dataSize = 100; // 100 data for test
2125 std::vector<Key> expectedKeys;
2126 std::vector<uint8_t> keySuffix;
2127 for (uint8_t i = 0; i < dataSize; i++) {
2128 keySuffix.push_back(rand () % 100);
2129 }
2130 for (uint8_t i = 0; i < dataSize; i++) {
2131 Key tmpKey = {key[0], keySuffix[i], i};
2132 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2133 expectedKeys.push_back(tmpKey);
2134 }
2135 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2136
2137 /**
2138 * @tc.steps: step2. Call GetEntries With prefix Query
2139 * @tc.expected: step2. Returns entries
2140 * all data are equals the preset data
2141 */
2142 std::vector<Entry> entries;
2143 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(true), entries),
2144 OK);
2145 ASSERT_EQ(entries.size(), static_cast<long unsigned int>(dataSize));
2146 for (int i = 0; i < dataSize; i++) {
2147 EXPECT_EQ(expectedKeys[i], entries[i].key);
2148 EXPECT_EQ(entries[i].value, VALUE_1);
2149 }
2150 /**
2151 * @tc.steps: step3. Call GetEntries With prefix Query limit
2152 * @tc.expected: step3. Returns entries
2153 * all data are equals the preset data
2154 */
2155 std::vector<Entry> entries2;
2156 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2157 Query::Select().PrefixKey(key).OrderByWriteTime(true).Limit(dataSize / 2, 0), entries2), OK);
2158 ASSERT_EQ(entries2.size(), static_cast<long unsigned int>(dataSize / 2));
2159 for (int i = 0; i < dataSize / 2; i++) {
2160 EXPECT_EQ(expectedKeys[i], entries2[i].key);
2161 EXPECT_EQ(entries2[i].value, VALUE_1);
2162 }
2163 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2164 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort002"), OK);
2165 }
2166
2167 /**
2168 * @tc.name: WriteTimeSort003
2169 * @tc.desc: For prefixKey query with orderBy writeTime desc
2170 * @tc.type: FUNC
2171 * @tc.require:
2172 * @tc.author: zhuwentao
2173 */
2174 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort003, TestSize.Level1)
2175 {
2176 /**
2177 * @tc.steps: step1. Create a database And Preset Data
2178 */
2179 KvStoreNbDelegate::Option option = {true, false, false};
2180 g_mgr.GetKvStore("WriteTimeSort003", option, g_kvNbDelegateCallbackForQuery);
2181 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2182 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2183 /**
2184 * @tc.steps: step2. put some data
2185 * @tc.expected: step2. Returns OK
2186 */
2187 Key key = {'x'};
2188 Key key2 = {'y'};
2189 const int dataSize = 100; // 100 data for test
2190 std::vector<Key> expectedKeys;
2191 std::vector<uint8_t> keySuffix;
2192 for (uint8_t i = 0; i < dataSize; i++) {
2193 keySuffix.push_back(rand () % 100);
2194 }
2195 for (uint8_t i = 0; i < dataSize; i++) {
2196 Key tmpKey = {key[0], keySuffix[i], i};
2197 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2198 expectedKeys.push_back(tmpKey);
2199 }
2200 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2201
2202 /**
2203 * @tc.steps: step2. Call GetEntries With prefix Query
2204 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2205 * all data are equals the preset data
2206 */
2207 KvStoreResultSet *resultSet = nullptr;
2208 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(false), resultSet),
2209 OK);
2210 ASSERT_NE(resultSet, nullptr);
2211 ASSERT_EQ(resultSet->GetCount(), dataSize);
2212 for (int i = 0; i < dataSize; i++) {
2213 resultSet->MoveToPosition(i);
2214 Entry entry;
2215 resultSet->GetEntry(entry);
2216 EXPECT_EQ(expectedKeys[dataSize - i - 1], entry.key);
2217 EXPECT_EQ(entry.value, VALUE_1);
2218 }
2219 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2220 /**
2221 * @tc.steps: step3. Call GetEntries With prefix Query limit
2222 * @tc.expected: step3. Returns KvStoreResultSet, the count is dataSize,
2223 * all data are equals the preset data
2224 */
2225 KvStoreResultSet *resultSet2 = nullptr;
2226 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2227 Query::Select().PrefixKey(key).OrderByWriteTime(false).Limit(dataSize / 2, 0), resultSet2), OK);
2228 ASSERT_NE(resultSet2, nullptr);
2229 ASSERT_EQ(resultSet2->GetCount(), dataSize / 2);
2230 for (int i = 0; i < dataSize / 2; i++) {
2231 resultSet2->MoveToPosition(i);
2232 Entry entry;
2233 resultSet2->GetEntry(entry);
2234 EXPECT_EQ(expectedKeys[dataSize - i - 1], entry.key);
2235 EXPECT_EQ(entry.value, VALUE_1);
2236 }
2237 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet2);
2238 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2239 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort003"), OK);
2240 }
2241
2242 /**
2243 * @tc.name: WriteTimeSort004
2244 * @tc.desc: For prefixKey query with orderBy writeTime asc
2245 * @tc.type: FUNC
2246 * @tc.require:
2247 * @tc.author: zhuwentao
2248 */
2249 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort004, TestSize.Level1)
2250 {
2251 /**
2252 * @tc.steps: step1. Create a database And Preset Data
2253 */
2254 KvStoreNbDelegate::Option option = {true, false, false};
2255 g_mgr.GetKvStore("WriteTimeSort004", option, g_kvNbDelegateCallbackForQuery);
2256 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2257 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2258 /**
2259 * @tc.steps: step2. put some data
2260 * @tc.expected: step2. Returns OK
2261 */
2262 Key key = {'x'};
2263 Key key2 = {'y'};
2264 const int dataSize = 100; // 100 data for test
2265 std::vector<Key> expectedKeys;
2266 std::vector<uint8_t> keySuffix;
2267 for (uint8_t i = 0; i < dataSize; i++) {
2268 keySuffix.push_back(rand () % 100);
2269 }
2270 for (uint8_t i = 0; i < dataSize; i++) {
2271 Key tmpKey = {key[0], keySuffix[i], i};
2272 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2273 expectedKeys.push_back(tmpKey);
2274 }
2275 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2276
2277 /**
2278 * @tc.steps: step2. Call GetEntries With prefix Query
2279 * @tc.expected: step2. Returns entries
2280 * all data are equals the preset data
2281 */
2282 std::vector<Entry> entries;
2283 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().PrefixKey(key).OrderByWriteTime(false), entries),
2284 OK);
2285 ASSERT_EQ(entries.size(), static_cast<long unsigned int>(dataSize));
2286 for (int i = 0; i < dataSize; i++) {
2287 EXPECT_EQ(expectedKeys[dataSize - i - 1], entries[i].key);
2288 EXPECT_EQ(entries[i].value, VALUE_1);
2289 }
2290 /**
2291 * @tc.steps: step3. Call GetEntries With prefix Query limit
2292 * @tc.expected: step3. Returns entries
2293 * all data are equals the preset data
2294 */
2295 std::vector<Entry> entries2;
2296 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2297 Query::Select().PrefixKey(key).OrderByWriteTime(false).Limit(dataSize / 2, 0), entries2), OK);
2298 ASSERT_EQ(entries2.size(), static_cast<long unsigned int>(dataSize / 2));
2299 for (int i = 0; i < dataSize / 2; i++) {
2300 EXPECT_EQ(expectedKeys[dataSize - i - 1], entries2[i].key);
2301 EXPECT_EQ(entries2[i].value, VALUE_1);
2302 }
2303 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2304 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort004"), OK);
2305 }
2306
2307 namespace {
CheckResultSize(KvStoreResultSet * resultSet,const std::vector<Key> & expectedKeys,int expectedSize)2308 void CheckResultSize(KvStoreResultSet *resultSet, const std::vector<Key> &expectedKeys, int expectedSize)
2309 {
2310 for (int i = 0; i < expectedSize; i++) {
2311 resultSet->MoveToPosition(i);
2312 Entry entry;
2313 resultSet->GetEntry(entry);
2314 EXPECT_EQ(expectedKeys[i], entry.key);
2315 }
2316 }
2317 }
2318
2319 /**
2320 * @tc.name: WriteTimeSort005
2321 * @tc.desc: For inkeys query with orderBy writeTime asc
2322 * @tc.type: FUNC
2323 * @tc.require:
2324 * @tc.author: zhuwentao
2325 */
2326 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort005, TestSize.Level1)
2327 {
2328 /**
2329 * @tc.steps: step1. Create a database And Preset Data
2330 */
2331 KvStoreNbDelegate::Option option = {true, false, false};
2332 g_mgr.GetKvStore("WriteTimeSort005", option, g_kvNbDelegateCallbackForQuery);
2333 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2334 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2335 /**
2336 * @tc.steps: step2. put some data
2337 * @tc.expected: step2. Returns OK
2338 */
2339 Key key = {'x'};
2340 Key key2 = {'y'};
2341 const int dataSize = 100; // 100 data for test
2342 std::vector<Key> expectedKeys;
2343 std::vector<uint8_t> keySuffix;
2344 for (uint8_t i = 0; i < dataSize; i++) {
2345 keySuffix.push_back(rand () % 100);
2346 }
2347 for (uint8_t i = 0; i < dataSize; i++) {
2348 Key tmpKey = {key[0], keySuffix[i], i};
2349 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2350 if (rand() % 2) {
2351 expectedKeys.push_back(tmpKey);
2352 }
2353 }
2354 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2355 /**
2356 * @tc.steps: step2. Call GetEntries With prefix Query
2357 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2358 * all data are equals the preset data
2359 */
2360 KvStoreResultSet *resultSet = nullptr;
2361 std::set<Key> keys(expectedKeys.begin(), expectedKeys.end());
2362 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys).OrderByWriteTime(true), resultSet),
2363 OK);
2364 ASSERT_NE(resultSet, nullptr);
2365 ASSERT_EQ(resultSet->GetCount(), static_cast<int>(keys.size()));
2366 for (uint32_t i = 0; i < keys.size(); i++) {
2367 resultSet->MoveToPosition(i);
2368 Entry entry;
2369 resultSet->GetEntry(entry);
2370 EXPECT_EQ(expectedKeys[i], entry.key);
2371 EXPECT_EQ(entry.value, VALUE_1);
2372 }
2373 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2374 /**
2375 * @tc.steps: step3. Call GetEntries With prefix Query limit
2376 * @tc.expected: step3. Returns KvStoreResultSet, the count is dataSize,
2377 * all data are equals the preset data
2378 */
2379 KvStoreResultSet *resultSet2 = nullptr;
2380 long unsigned int limitNum = 40;
2381 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2382 Query::Select().InKeys(keys).OrderByWriteTime(true).Limit(limitNum, 0), resultSet2), OK);
2383 ASSERT_NE(resultSet2, nullptr);
2384 int expectedSize = (keys.size() >= limitNum) ? static_cast<int>(limitNum) : static_cast<int>(keys.size());
2385 ASSERT_EQ(resultSet2->GetCount(), static_cast<int>(expectedSize));
2386 CheckResultSize(resultSet2, expectedKeys, expectedSize);
2387 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet2);
2388 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2389 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort005"), OK);
2390 }
2391
2392 /**
2393 * @tc.name: WriteTimeSort006
2394 * @tc.desc: For inkeys query with orderBy writeTime desc
2395 * @tc.type: FUNC
2396 * @tc.require:
2397 * @tc.author: zhuwentao
2398 */
2399 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort006, TestSize.Level1)
2400 {
2401 /**
2402 * @tc.steps: step1. Create a database And Preset Data
2403 */
2404 KvStoreNbDelegate::Option option = {true, false, false};
2405 g_mgr.GetKvStore("WriteTimeSort006", option, g_kvNbDelegateCallbackForQuery);
2406 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2407 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2408 /**
2409 * @tc.steps: step2. put some data
2410 * @tc.expected: step2. Returns OK
2411 */
2412 Key key = {'x'};
2413 Key key2 = {'y'};
2414 const int dataSize = 100; // 100 data for test
2415 std::vector<Key> expectedKeys;
2416 std::vector<uint8_t> keySuffix;
2417 for (uint8_t i = 0; i < dataSize; i++) {
2418 keySuffix.push_back(rand () % 100);
2419 }
2420 for (uint8_t i = 0; i < dataSize; i++) {
2421 Key tmpKey = {key[0], keySuffix[i], i};
2422 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(tmpKey, VALUE_1), OK);
2423 if (rand() % 2) {
2424 expectedKeys.push_back(tmpKey);
2425 }
2426 }
2427 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key2, VALUE_1), OK);
2428 /**
2429 * @tc.steps: step2. Call GetEntries With prefix Query
2430 * @tc.expected: step2. Returns KvStoreResultSet, the count is dataSize,
2431 * all data are equals the preset data
2432 */
2433 KvStoreResultSet *resultSet = nullptr;
2434 std::set<Key> keys(expectedKeys.begin(), expectedKeys.end());
2435 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(Query::Select().InKeys(keys).OrderByWriteTime(false), resultSet),
2436 OK);
2437 ASSERT_NE(resultSet, nullptr);
2438 ASSERT_EQ(resultSet->GetCount(), static_cast<int>(keys.size()));
2439 for (uint32_t i = 0; i < keys.size(); i++) {
2440 resultSet->MoveToPosition(i);
2441 Entry entry;
2442 resultSet->GetEntry(entry);
2443 EXPECT_EQ(expectedKeys[keys.size() - i - 1], entry.key);
2444 EXPECT_EQ(entry.value, VALUE_1);
2445 }
2446 g_kvNbDelegatePtrForQuery->CloseResultSet(resultSet);
2447 /**
2448 * @tc.steps: step3. Call GetEntries With prefix Query limit
2449 * @tc.expected: step3. Returns entries
2450 * all data are equals the preset data
2451 */
2452
2453 std::vector<Entry> entries2;
2454 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(
2455 Query::Select().InKeys(keys).OrderByWriteTime(false).Limit(keys.size() / 2, 0), entries2), OK);
2456 ASSERT_EQ(entries2.size(), static_cast<long unsigned int>(expectedKeys.size() / 2));
2457 for (uint32_t i = 0; i < keys.size() / 2; i++) {
2458 EXPECT_EQ(expectedKeys[keys.size() - i - 1], entries2[i].key);
2459 EXPECT_EQ(entries2[i].value, VALUE_1);
2460 }
2461 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2462 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort006"), OK);
2463 }
2464
2465 /**
2466 * @tc.name: WriteTimeSort007
2467 * @tc.desc: For unsupport query when getEntries
2468 * @tc.type: FUNC
2469 * @tc.require:
2470 * @tc.author: zhuwentao
2471 */
2472 HWTEST_F(DistributedDBInterfacesDataOperationTest, WriteTimeSort007, TestSize.Level0)
2473 {
2474 /**
2475 * @tc.steps: step1. Create a database And Preset Data
2476 */
2477 KvStoreNbDelegate::Option option = {true, false, false};
2478 g_mgr.GetKvStore("WriteTimeSort007", option, g_kvNbDelegateCallbackForQuery);
2479 ASSERT_NE(g_kvNbDelegatePtrForQuery, nullptr);
2480 EXPECT_EQ(g_kvDelegateStatusForQuery, OK);
2481 /**
2482 * @tc.steps: step2. Call GetEntries With unsupport Query
2483 * @tc.expected: step2. Returns NOT_SUPPORT
2484 */
2485 Query query = Query::Select().BeginGroup().LessThan("$.field_name1", 5).OrderByWriteTime(false);
2486 KvStoreResultSet *resultSet = nullptr;
2487 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(query, resultSet), NOT_SUPPORT);
2488 std::vector<Entry> entries2;
2489 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetEntries(query, entries2), NOT_SUPPORT);
2490 int count = 0;
2491 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetCount(query, count), NOT_SUPPORT);
2492 Key key = {'x'};
2493 ASSERT_EQ(g_kvNbDelegatePtrForQuery->Put(key, VALUE_1), OK);
2494 Query query1 = Query::Select().PrefixKey(key).OrderByWriteTime(false);
2495 EXPECT_EQ(g_kvNbDelegatePtrForQuery->GetCount(query1, count), OK);
2496 EXPECT_EQ(count, 1);
2497 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtrForQuery), OK);
2498 EXPECT_EQ(g_mgr.DeleteKvStore("WriteTimeSort007"), OK);
2499 }
2500 #endif // OMIT_JSON
2501