1 /*
2 * Copyright (c) 2022 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 <endian.h>
17 #include <vector>
18 #include <map>
19 #include "datashare_predicates.h"
20 #include "datashare_values_bucket.h"
21 #include "distributed_kv_data_manager.h"
22 #include "gtest/gtest.h"
23 #include "kv_utils.h"
24 #include "kvstore_datashare_bridge.h"
25 #include "kvstore_result_set.h"
26 #include "result_set_bridge.h"
27 #include "store_errno.h"
28 #include "types.h"
29
30 namespace {
31 using namespace testing::ext;
32 using namespace OHOS::DistributedKv;
33 using namespace OHOS::DataShare;
34 using var_t = std::variant<std::monostate, int64_t, double, std::string, bool, std::vector<uint8_t>>;
35 class KvUtilTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
SetUp()39 void SetUp() {}
TearDown()40 void TearDown() {}
41
42 protected:
43 static DistributedKvDataManager manager;
44 static std::shared_ptr<SingleKvStore> singleKvStore;
45 static constexpr const char *KEY = "key";
46 static constexpr const char *VALUE = "value";
47 static constexpr const char *VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\","
48 "\"SCHEMA_MODE\":\"STRICT\","
49 "\"SCHEMA_SKIPSIZE\":0,"
50 "\"SCHEMA_DEFINE\":"
51 "{"
52 "\"age\":\"INTEGER, NOT NULL\""
53 "},"
54 "\"SCHEMA_INDEXES\":[\"$.age\"]}";
55 static std::string Entry2Str(const Entry &entry);
56 static void ClearEntry(Entry &entry);
57 static Blob VariantValue2Blob(const var_t &value);
58 static Blob VariantKey2Blob(const var_t &value);
59 };
60 std::shared_ptr<SingleKvStore> KvUtilTest::singleKvStore = nullptr;
61 DistributedKvDataManager KvUtilTest::manager;
62
Entry2Str(const Entry & entry)63 std::string KvUtilTest::Entry2Str(const Entry &entry)
64 {
65 return entry.key.ToString() + entry.value.ToString();
66 }
67
ClearEntry(Entry & entry)68 void KvUtilTest::ClearEntry(Entry &entry)
69 {
70 entry.key.Clear();
71 entry.value.Clear();
72 }
73
VariantKey2Blob(const var_t & value)74 Blob KvUtilTest::VariantKey2Blob(const var_t &value)
75 {
76 std::vector<uint8_t> uData;
77 if (auto *val = std::get_if<std::string>(&value)) {
78 std::string data = *val;
79 uData.insert(uData.end(), data.begin(), data.end());
80 }
81 return Blob(uData);
82 }
83
VariantValue2Blob(const var_t & value)84 Blob KvUtilTest::VariantValue2Blob(const var_t &value)
85 {
86 std::vector<uint8_t> data;
87 auto strValue = std::get_if<std::string>(&value);
88 if (strValue != nullptr) {
89 data.push_back(KvUtils::STRING);
90 data.insert(data.end(), (*strValue).begin(), (*strValue).end());
91 }
92 auto boolValue = std::get_if<bool>(&value);
93 if (boolValue != nullptr) {
94 data.push_back(KvUtils::BOOLEAN);
95 data.push_back(static_cast<uint8_t>(*boolValue));
96 }
97 uint8_t *tmp = nullptr;
98 auto dblValue = std::get_if<double>(&value);
99 if (dblValue != nullptr) {
100 double tmp4dbl = *dblValue;
101 uint64_t tmp64 = htobe64(*reinterpret_cast<uint64_t*>(&tmp4dbl));
102 tmp = reinterpret_cast<uint8_t*>(&tmp64);
103 data.push_back(KvUtils::DOUBLE);
104 data.insert(data.end(), tmp, tmp + sizeof(double) / sizeof(uint8_t));
105 }
106 auto intValue = std::get_if<int64_t>(&value);
107 if (intValue != nullptr) {
108 int64_t tmp4int = *intValue;
109 uint64_t tmp64 = htobe64(*reinterpret_cast<uint64_t*>(&tmp4int));
110 tmp = reinterpret_cast<uint8_t*>(&tmp64);
111 data.push_back(KvUtils::INTEGER);
112 data.insert(data.end(), tmp, tmp + sizeof(int64_t) / sizeof(uint8_t));
113 }
114 auto u8ArrayValue = std::get_if<std::vector<uint8_t>>(&value);
115 if (u8ArrayValue != nullptr) {
116 data.push_back(KvUtils::BYTE_ARRAY);
117 data.insert(data.end(), (*u8ArrayValue).begin(), (*u8ArrayValue).end());
118 }
119 return Blob(data);
120 }
121
SetUpTestCase(void)122 void KvUtilTest::SetUpTestCase(void)
123 {
124 Options options = {.createIfMissing = true, .encrypt = false, .autoSync = false,
125 .kvStoreType = KvStoreType::SINGLE_VERSION, .schema = VALID_SCHEMA_STRICT_DEFINE};
126 options.area = EL1;
127 options.baseDir = std::string("/data/service/el1/public/database/kvUtilTest");
128 AppId appId = { "kvUtilTest" };
129 StoreId storeId = { "test_single" };
130 mkdir(options.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
131 manager.DeleteKvStore(appId, storeId, options.baseDir);
132 manager.GetSingleKvStore(options, appId, storeId, singleKvStore);
133 EXPECT_NE(singleKvStore, nullptr);
134 singleKvStore->Put("test_key_1", "{\"age\":1}");
135 singleKvStore->Put("test_key_2", "{\"age\":2}");
136 singleKvStore->Put("test_key_3", "{\"age\":3}");
137 singleKvStore->Put("kv_utils", "{\"age\":4}");
138 }
139
TearDownTestCase(void)140 void KvUtilTest::TearDownTestCase(void)
141 {
142 manager.DeleteKvStore(
143 {"kvUtilTest"}, {"test_single"}, "/data/service/el1/public/database/kvUtilTest");
144 (void) remove("/data/service/el1/public/database/kvUtilTest/key");
145 (void) remove("/data/service/el1/public/database/kvUtilTest/kvdb");
146 (void) remove("/data/service/el1/public/database/kvUtilTest");
147 }
148
149 /**
150 * @tc.name: KvStoreResultSetToResultSetBridge
151 * @tc.desc: kvStore resultSet to resultSet bridge, the former is nullptr
152 * @tc.type: FUNC
153 * @tc.require:
154 * @tc.author: zuojiangjiang
155 */
156 HWTEST_F(KvUtilTest, KvStoreResultSetToResultSetBridgeAbnormal, TestSize.Level0)
157 {
158 std::shared_ptr<KvStoreResultSet> resultSet = nullptr;
159 auto bridge = KvUtils::ToResultSetBridge(resultSet);
160 EXPECT_EQ(bridge, nullptr);
161 }
162
163 /**
164 * @tc.name: KvStoreResultSetToResultSetBridge
165 * @tc.desc: kvStore resultSet to resultSet bridge
166 * @tc.type: FUNC
167 * @tc.require:
168 * @tc.author: zuojiangjiang
169 */
170 HWTEST_F(KvUtilTest, KvStoreResultSetToResultSetBridge, TestSize.Level0)
171 {
172 DataSharePredicates predicates;
173 predicates.KeyPrefix("test");
174 DataQuery query;
175 auto status = KvUtils::ToQuery(predicates, query);
176 EXPECT_EQ(status, Status::SUCCESS);
177 std::shared_ptr<KvStoreResultSet> resultSet = nullptr;
178 status = singleKvStore->GetResultSet(query, resultSet);
179 EXPECT_EQ(status, Status::SUCCESS);
180 EXPECT_NE(resultSet, nullptr);
181 EXPECT_EQ(resultSet->GetCount(), 3);
182 auto bridge = KvUtils::ToResultSetBridge(resultSet);
183 EXPECT_NE(bridge, nullptr);
184 }
185
186 /**
187 * @tc.name: PredicatesToQuery
188 * @tc.desc: to query equalTo
189 * @tc.type: FUNC
190 * @tc.require:
191 * @tc.author: zuojiangjiang
192 */
193 HWTEST_F(KvUtilTest, PredicatesToQueryEqualTo, TestSize.Level0)
194 {
195 DataSharePredicates predicates;
196 predicates.EqualTo("$.age", 1);
197 DataQuery query;
198 auto status = KvUtils::ToQuery(predicates, query);
199 EXPECT_EQ(status, Status::SUCCESS);
200 DataQuery trgQuery;
201 trgQuery.EqualTo("$.age", 1);
202 EXPECT_EQ(query.ToString(), trgQuery.ToString());
203 }
204
205 /**
206 * @tc.name: PredicatesToQuery
207 * @tc.desc: to query not equalTo
208 * @tc.type: FUNC
209 * @tc.require:
210 * @tc.author: zuojiangjiang
211 */
212 HWTEST_F(KvUtilTest, PredicatesToQueryNotEqualTo, TestSize.Level0)
213 {
214 DataSharePredicates predicates;
215 predicates.NotEqualTo("$.age", 1);
216 DataQuery query;
217 auto status = KvUtils::ToQuery(predicates, query);
218 EXPECT_EQ(status, Status::SUCCESS);
219 DataQuery trgQuery;
220 trgQuery.NotEqualTo("$.age", 1);
221 EXPECT_EQ(query.ToString(), trgQuery.ToString());
222 }
223
224 /**
225 * @tc.name: PredicatesToQuery
226 * @tc.desc: to query greater than
227 * @tc.type: FUNC
228 * @tc.require:
229 * @tc.author: zuojiangjiang
230 */
231 HWTEST_F(KvUtilTest, PredicatesToQueryGreaterThan, TestSize.Level0)
232 {
233 DataSharePredicates predicates;
234 predicates.GreaterThan("$.age", 1);
235 DataQuery query;
236 auto status = KvUtils::ToQuery(predicates, query);
237 EXPECT_EQ(status, Status::SUCCESS);
238 DataQuery trgQuery;
239 trgQuery.GreaterThan("$.age", 1);
240 EXPECT_EQ(query.ToString(), trgQuery.ToString());
241 }
242
243 /**
244 * @tc.name: PredicatesToQuery
245 * @tc.desc: to query less than
246 * @tc.type: FUNC
247 * @tc.require:
248 * @tc.author: zuojiangjiang
249 */
250 HWTEST_F(KvUtilTest, PredicatesToQueryLessThan, TestSize.Level0)
251 {
252 DataSharePredicates predicates;
253 predicates.LessThan("$.age", 3);
254 DataQuery query;
255 auto status = KvUtils::ToQuery(predicates, query);
256 EXPECT_EQ(status, Status::SUCCESS);
257 DataQuery trgQuery;
258 trgQuery.LessThan("$.age", 3);
259 EXPECT_EQ(query.ToString(), trgQuery.ToString());
260 }
261
262 /**
263 * @tc.name: PredicatesToQuery
264 * @tc.desc: to query greater than or equalTo
265 * @tc.type: FUNC
266 * @tc.require:
267 * @tc.author: zuojiangjiang
268 */
269 HWTEST_F(KvUtilTest, PredicatesToQueryGreaterThanOrEqualTo, TestSize.Level0)
270 {
271 DataSharePredicates predicates;
272 predicates.GreaterThanOrEqualTo("$.age", 1);
273 DataQuery query;
274 auto status = KvUtils::ToQuery(predicates, query);
275 EXPECT_EQ(status, Status::SUCCESS);
276 DataQuery trgQuery;
277 trgQuery.GreaterThanOrEqualTo("$.age", 1);
278 EXPECT_EQ(query.ToString(), trgQuery.ToString());
279 }
280
281 /**
282 * @tc.name: PredicatesToQuery
283 * @tc.desc: to query less than or equalTo
284 * @tc.type: FUNC
285 * @tc.require:
286 * @tc.author: zuojiangjiang
287 */
288 HWTEST_F(KvUtilTest, PredicatesToQueryLessThanOrEqualTo, TestSize.Level0)
289 {
290 DataSharePredicates predicates;
291 predicates.LessThanOrEqualTo("$.age", 3);
292 DataQuery query;
293 auto status = KvUtils::ToQuery(predicates, query);
294 EXPECT_EQ(status, Status::SUCCESS);
295 DataQuery trgQuery;
296 trgQuery.LessThanOrEqualTo("$.age", 3);
297 EXPECT_EQ(query.ToString(), trgQuery.ToString());
298 }
299
300 /**
301 * @tc.name: PredicatesToQuery
302 * @tc.desc: to query in
303 * @tc.type: FUNC
304 * @tc.require:
305 * @tc.author: zuojiangjiang
306 */
307 HWTEST_F(KvUtilTest, PredicatesToQueryIn, TestSize.Level0)
308 {
309 std::vector<int> vectInt{ 1, 2 };
310 DataSharePredicates predicates;
311 predicates.In("$.age", vectInt);
312 DataQuery query;
313 auto status = KvUtils::ToQuery(predicates, query);
314 EXPECT_EQ(status, Status::SUCCESS);
315 DataQuery trgQuery;
316 trgQuery.In("$.age", vectInt);
317 EXPECT_EQ(query.ToString(), trgQuery.ToString());
318 }
319
320 /**
321 * @tc.name: PredicatesToQuery
322 * @tc.desc: to query not in
323 * @tc.type: FUNC
324 * @tc.require:
325 * @tc.author: zuojiangjiang
326 */
327 HWTEST_F(KvUtilTest, PredicatesToQueryNotIn, TestSize.Level0)
328 {
329 std::vector<int> vectInt{ 1, 2 };
330 DataSharePredicates predicates;
331 predicates.NotIn("$.age", vectInt);
332 DataQuery query;
333 auto status = KvUtils::ToQuery(predicates, query);
334 EXPECT_EQ(status, Status::SUCCESS);
335 DataQuery trgQuery;
336 trgQuery.NotIn("$.age", vectInt);
337 EXPECT_EQ(query.ToString(), trgQuery.ToString());
338 }
339
340 /**
341 * @tc.name: PredicatesToQuery
342 * @tc.desc: to query or, like
343 * @tc.type: FUNC
344 * @tc.require:
345 * @tc.author: zuojiangjiang
346 */
347 HWTEST_F(KvUtilTest, PredicatesToQueryLike, TestSize.Level0)
348 {
349 DataSharePredicates predicates;
350 predicates.Like("$.age", "1");
351 predicates.Or();
352 predicates.Like("$.age", "3");
353 DataQuery query;
354 auto status = KvUtils::ToQuery(predicates, query);
355 EXPECT_EQ(status, Status::SUCCESS);
356 DataQuery trgQuery;
357 trgQuery.Like("$.age", "1");
358 trgQuery.Or();
359 trgQuery.Like("$.age", "3");
360 EXPECT_EQ(query.ToString(), trgQuery.ToString());
361 }
362
363 /**
364 * @tc.name: PredicatesToQuery
365 * @tc.desc: to query and, unlike
366 * @tc.type: FUNC
367 * @tc.require:
368 * @tc.author: zuojiangjiang
369 */
370 HWTEST_F(KvUtilTest, PredicatesToQueryUnlike, TestSize.Level0)
371 {
372 DataSharePredicates predicates;
373 predicates.Unlike("$.age", "1");
374 predicates.And();
375 predicates.Unlike("$.age", "3");
376 DataQuery query;
377 auto status = KvUtils::ToQuery(predicates, query);
378 EXPECT_EQ(status, Status::SUCCESS);
379 DataQuery trgQuery;
380 trgQuery.Unlike("$.age", "1");
381 trgQuery.And();
382 trgQuery.Unlike("$.age", "3");
383 EXPECT_EQ(query.ToString(), trgQuery.ToString());
384 }
385
386 /**
387 * @tc.name: PredicatesToQuery
388 * @tc.desc: to query is null
389 * @tc.type: FUNC
390 * @tc.require:
391 * @tc.author: zuojiangjiang
392 */
393 HWTEST_F(KvUtilTest, PredicatesToQueryIsNull, TestSize.Level0)
394 {
395 DataSharePredicates predicates;
396 predicates.IsNull("$.age");
397 DataQuery query;
398 auto status = KvUtils::ToQuery(predicates, query);
399 EXPECT_EQ(status, Status::SUCCESS);
400 DataQuery trgQuery;
401 trgQuery.IsNull("$.age");
402 EXPECT_EQ(query.ToString(), trgQuery.ToString());
403 }
404
405 /**
406 * @tc.name: PredicatesToQuery
407 * @tc.desc: to query is not null
408 * @tc.type: FUNC
409 * @tc.require:
410 * @tc.author: zuojiangjiang
411 */
412 HWTEST_F(KvUtilTest, PredicatesToQueryIsNotNull, TestSize.Level0)
413 {
414 DataSharePredicates predicates;
415 predicates.IsNotNull("$.age");
416 DataQuery query;
417 auto status = KvUtils::ToQuery(predicates, query);
418 EXPECT_EQ(status, Status::SUCCESS);
419 DataQuery trgQuery;
420 trgQuery.IsNotNull("$.age");
421 EXPECT_EQ(query.ToString(), trgQuery.ToString());
422 }
423
424 /**
425 * @tc.name: PredicatesToQuery
426 * @tc.desc: to query is order by asc
427 * @tc.type: FUNC
428 * @tc.require:
429 * @tc.author: zuojiangjiang
430 */
431 HWTEST_F(KvUtilTest, PredicatesToQueryOrderByAsc, TestSize.Level0)
432 {
433 DataSharePredicates predicates;
434 predicates.OrderByAsc("$.age");
435 DataQuery query;
436 auto status = KvUtils::ToQuery(predicates, query);
437 EXPECT_EQ(status, Status::SUCCESS);
438 DataQuery trgQuery;
439 trgQuery.OrderByAsc("$.age");
440 EXPECT_EQ(query.ToString(), trgQuery.ToString());
441 }
442
443 /**
444 * @tc.name: PredicatesToQuery
445 * @tc.desc: to query is order by desc
446 * @tc.type: FUNC
447 * @tc.require:
448 * @tc.author: zuojiangjiang
449 */
450 HWTEST_F(KvUtilTest, PredicatesToQueryOrderByDesc, TestSize.Level0)
451 {
452 DataSharePredicates predicates;
453 predicates.OrderByDesc("$.age");
454 DataQuery query;
455 auto status = KvUtils::ToQuery(predicates, query);
456 EXPECT_EQ(status, Status::SUCCESS);
457 DataQuery trgQuery;
458 trgQuery.OrderByDesc("$.age");
459 EXPECT_EQ(query.ToString(), trgQuery.ToString());
460 }
461
462 /**
463 * @tc.name: PredicatesToQuery
464 * @tc.desc: to query is limit
465 * @tc.type: FUNC
466 * @tc.require:
467 * @tc.author: zuojiangjiang
468 */
469 HWTEST_F(KvUtilTest, PredicatesToQueryLimit, TestSize.Level0)
470 {
471 DataSharePredicates predicates;
472 predicates.Limit(0, 9);
473 DataQuery query;
474 auto status = KvUtils::ToQuery(predicates, query);
475 EXPECT_EQ(status, Status::SUCCESS);
476 DataQuery trgQuery;
477 trgQuery.Limit(0, 9);
478 EXPECT_EQ(query.ToString(), trgQuery.ToString());
479 }
480
481 /**
482 * @tc.name: PredicatesToQuery
483 * @tc.desc: to query is in keys
484 * @tc.type: FUNC
485 * @tc.require:
486 * @tc.author: zuojiangjiang
487 */
488 HWTEST_F(KvUtilTest, PredicatesToQueryInKeys, TestSize.Level0)
489 {
490 std::vector<std::string> keys { "test_field", "", "^test_field", "^", "test_field_name" };
491 DataSharePredicates predicates;
492 predicates.InKeys(keys);
493 DataQuery query;
494 auto status = KvUtils::ToQuery(predicates, query);
495 EXPECT_EQ(status, Status::SUCCESS);
496 DataQuery trgQuery;
497 trgQuery.InKeys(keys);
498 EXPECT_EQ(query.ToString(), trgQuery.ToString());
499 }
500
501 /**
502 * @tc.name: ToEntry
503 * @tc.desc: dataShare values bucket to entry, the bucket is invalid
504 * @tc.type: FUNC
505 * @tc.require:
506 * @tc.author: zuojiangjiang
507 */
508 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryAbnormal, TestSize.Level0)
509 {
510 DataShareValuesBucket bucket {};
511 Entry trgEntry {};
512 auto entry = KvUtils::ToEntry(bucket);
513 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
514 bucket.Put("invalid key", "value");
515 EXPECT_FALSE(bucket.IsEmpty());
516 entry = KvUtils::ToEntry(bucket);
517 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
518 bucket.Put(KEY, "value");
519 entry = KvUtils::ToEntry(bucket);
520 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
521 }
522
523 /**
524 * @tc.name: ToEntry
525 * @tc.desc: dataShare values bucket to entry, the bucket value is null
526 * @tc.type: FUNC
527 * @tc.require:
528 * @tc.author: zuojiangjiang
529 */
530 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryNull, TestSize.Level0)
531 {
532 DataShareValuesBucket bucket {};
533 bucket.Put(KEY, {});
534 bucket.Put(VALUE, {});
535 auto entry = KvUtils::ToEntry(bucket);
536 Entry trgEntry;
537 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
538 }
539
540 /**
541 * @tc.name: ToEntry
542 * @tc.desc: dataShare values bucket to entry, the bucket value type is int64_t
543 * @tc.type: FUNC
544 * @tc.require:
545 * @tc.author: zuojiangjiang
546 */
547 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryInt64_t, TestSize.Level0)
548 {
549 DataShareValuesBucket bucket {};
550 Entry trgEntry;
551 var_t varValue;
552 varValue.emplace<1>(314);
553 var_t varKey;
554 varKey.emplace<3>("314");
555 bucket.Put(KEY, varKey);
556 bucket.Put(VALUE, varValue);
557 auto entry = KvUtils::ToEntry(bucket);
558 trgEntry.key = VariantKey2Blob(varKey);
559 trgEntry.value = VariantValue2Blob(varValue);
560 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
561 }
562
563 /**
564 * @tc.name: ToEntry
565 * @tc.desc: dataShare values bucket to entry, the bucket value type is double
566 * @tc.type: FUNC
567 * @tc.require:
568 * @tc.author: zuojiangjiang
569 */
570 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryDouble, TestSize.Level0)
571 {
572 DataShareValuesBucket bucket {};
573 Entry trgEntry;
574 var_t varValue;
575 varValue.emplace<2>(3.14);
576 var_t varKey;
577 varKey.emplace<3>("314");
578 bucket.Put(KEY, varKey);
579 bucket.Put(VALUE, varValue);
580 auto entry = KvUtils::ToEntry(bucket);
581 trgEntry.key = VariantKey2Blob(varKey);
582 trgEntry.value = VariantValue2Blob(varValue);
583 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
584 }
585
586 /**
587 * @tc.name: ToEntry
588 * @tc.desc: dataShare values bucket to entry, the bucket value type is string
589 * @tc.type: FUNC
590 * @tc.require:
591 * @tc.author: zuojiangjiang
592 */
593 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryString, TestSize.Level0)
594 {
595 DataShareValuesBucket bucket {};
596 Entry trgEntry;
597 var_t varValue;
598 varValue.emplace<3>("3.14");
599 var_t varKey;
600 varKey.emplace<3>("314");
601 bucket.Put(KEY, varKey);
602 bucket.Put(VALUE, varValue);
603 auto entry = KvUtils::ToEntry(bucket);
604 trgEntry.key = VariantKey2Blob(varKey);
605 trgEntry.value = VariantValue2Blob(varValue);
606 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
607 }
608
609 /**
610 * @tc.name: ToEntry
611 * @tc.desc: dataShare values bucket to entry, the bucket value type is bool
612 * @tc.type: FUNC
613 * @tc.require:
614 * @tc.author: zuojiangjiang
615 */
616 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryBool, TestSize.Level0)
617 {
618 DataShareValuesBucket bucket {};
619 Entry trgEntry;
620 var_t varValue;
621 varValue.emplace<4>(true);
622 var_t varKey;
623 varKey.emplace<3>("314");
624 bucket.Put(KEY, varKey);
625 bucket.Put(VALUE, varValue);
626 auto entry = KvUtils::ToEntry(bucket);
627 trgEntry.key = VariantKey2Blob(varKey);
628 trgEntry.value = VariantValue2Blob(varValue);
629 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
630 }
631
632 /**
633 * @tc.name: ToEntry
634 * @tc.desc: dataShare values bucket to entry, the bucket value type is uint8array
635 * @tc.type: FUNC
636 * @tc.require:
637 * @tc.author: zuojiangjiang
638 */
639 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryUint8Array, TestSize.Level0)
640 {
641 DataShareValuesBucket bucket {};
642 Entry trgEntry;
643 var_t varValue;
644 std::vector<uint8_t> vecUint8 { 3, 14 };
645 varValue.emplace<5>(vecUint8);
646 var_t varKey;
647 varKey.emplace<3>("314");
648 bucket.Put(KEY, varKey);
649 bucket.Put(VALUE, varValue);
650 auto entry = KvUtils::ToEntry(bucket);
651 trgEntry.key = VariantKey2Blob(varKey);
652 trgEntry.value = VariantValue2Blob(varValue);
653 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
654 }
655
656 /**
657 * @tc.name: ToEntry
658 * @tc.desc: dataShare values bucket to entry, the bucket key type is not string
659 * @tc.type: FUNC
660 * @tc.require:
661 * @tc.author: zuojiangjiang
662 */
663 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryInvalidKey, TestSize.Level0)
664 {
665 DataShareValuesBucket bucket {};
666 Entry trgEntry;
667 var_t varValue;
668 std::vector<uint8_t> vecUint8 { 3, 14 };
669 varValue.emplace<5>(vecUint8);
670 var_t varKey;
671 varKey.emplace<1>(314);
672 bucket.Put(KEY, varKey);
673 bucket.Put(VALUE, varValue);
674 auto entry = KvUtils::ToEntry(bucket);
675 trgEntry.key = VariantKey2Blob(varKey);
676 EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry));
677 }
678
679 /**
680 * @tc.name: ToEntry
681 * @tc.desc: dataShare values bucket to entries, the buckets is invalid
682 * @tc.type: FUNC
683 * @tc.require:
684 * @tc.author: zuojiangjiang
685 */
686 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntriesAbnormal, TestSize.Level0)
687 {
688 std::vector<DataShareValuesBucket> buckets {};
689 auto entries = KvUtils::ToEntries(buckets);
690 EXPECT_TRUE(entries.empty());
691 }
692
693 /**
694 * @tc.name: ToEntry
695 * @tc.desc: dataShare values bucket to entries, the buckets has valid value
696 * @tc.type: FUNC
697 * @tc.require:
698 * @tc.author: zuojiangjiang
699 */
700 HWTEST_F(KvUtilTest, DataShareValuesBucketToEntriesNormal, TestSize.Level0)
701 {
702 std::vector<DataShareValuesBucket> buckets {};
703 DataShareValuesBucket bucket;
704 Entry trgEntryFirst;
705 Entry trgEntrySecond;
706 var_t varValue;
707 varValue.emplace<1>(314);
708 var_t varKey;
709 varKey.emplace<3>("314");
710 bucket.Put(KEY, varKey);
711 bucket.Put(VALUE, varValue);
712 buckets.emplace_back(bucket);
713 trgEntryFirst.key = VariantKey2Blob(varKey);
714 trgEntryFirst.value = VariantValue2Blob(varValue);
715 bucket.Clear();
716 varValue.emplace<2>(3.14);
717 varKey.emplace<3>("3.14");
718 bucket.Put(KEY, varKey);
719 bucket.Put(VALUE, varValue);
720 buckets.emplace_back(bucket);
721 trgEntrySecond.key = VariantKey2Blob(varKey);
722 trgEntrySecond.value = VariantValue2Blob(varValue);
723 auto entries = KvUtils::ToEntries(buckets);
724 EXPECT_EQ(entries.size(), 2);
725 EXPECT_EQ(Entry2Str(entries[0]), Entry2Str(trgEntryFirst));
726 EXPECT_EQ(Entry2Str(entries[1]), Entry2Str(trgEntrySecond));
727 }
728
729 /**
730 * @tc.name: GetKeys
731 * @tc.desc: get keys from data share predicates, the predicates is invalid
732 * @tc.type: FUNC
733 * @tc.require:
734 * @tc.author: zuojiangjiang
735 */
736 HWTEST_F(KvUtilTest, GetKeysFromDataSharePredicatesAbnormal, TestSize.Level0)
737 {
738 DataSharePredicates predicates;
739 std::vector<Key> kvKeys;
740 auto status = KvUtils::GetKeys(predicates, kvKeys);
741 EXPECT_EQ(status, Status::ERROR);
742 predicates.EqualTo("$.age", 1);
743 status = KvUtils::GetKeys(predicates, kvKeys);
744 EXPECT_EQ(status, Status::NOT_SUPPORT);
745 }
746
747 /**
748 * @tc.name: GetKeys
749 * @tc.desc: get keys from data share predicates, the predicates has valid value
750 * @tc.type: FUNC
751 * @tc.require:
752 * @tc.author: zuojiangjiang
753 */
754 HWTEST_F(KvUtilTest, GetKeysFromDataSharePredicatesNormal, TestSize.Level0)
755 {
756 std::vector<std::string> keys { "test_field", "", "^test_field", "^", "test_field_name" };
757 DataSharePredicates predicates;
758 predicates.InKeys(keys);
759 std::vector<Key> kvKeys;
760 auto status = KvUtils::GetKeys(predicates, kvKeys);
761 EXPECT_EQ(status, Status::SUCCESS);
762 EXPECT_EQ(keys.size(), kvKeys.size());
763 for (size_t i = 0; i < keys.size(); i++) {
764 EXPECT_EQ(keys[i], kvKeys[i].ToString());
765 }
766 }
767 } // namespace