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