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