1 /*
2 * Copyright (c) 2024 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 #include "log_print.h"
18 #include "accesstoken_kit.h"
19 #include "auth_delegate.h"
20 #include "bootstrap.h"
21 #include "crypto_manager.h"
22 #include "device_manager_adapter.h"
23 #include "directory/directory_manager.h"
24 #include "metadata/meta_data_manager.h"
25 #include "metadata/secret_key_meta_data.h"
26 #include "metadata/store_meta_data.h"
27 #include "metadata/store_meta_data_local.h"
28 #include "query_helper.h"
29 #include "upgrade.h"
30 #include "user_delegate.h"
31 #include "kvdb_general_store.h"
32 #include "kvdb_watcher.h"
33 #include "kvdb_notifier_proxy.h"
34 #include "kvstore_sync_manager.h"
35 #include "kvstore_meta_manager.h"
36 
37 using namespace testing::ext;
38 using namespace DistributedDB;
39 using namespace OHOS::DistributedData;
40 using StoreMetaData = OHOS::DistributedData::StoreMetaData;
41 using DBPassword = DistributedDB::CipherPassword;
42 using DBStatus = DistributedDB::DBStatus;
43 using Status = OHOS::DistributedKv::Status;
44 using KVDBWatcher = OHOS::DistributedKv::KVDBWatcher;
45 using KVDBNotifierProxy = OHOS::DistributedKv::KVDBNotifierProxy;
46 using QueryHelper = OHOS::DistributedKv::QueryHelper;
47 namespace OHOS::Test {
48 namespace DistributedDataTest {
49 class UpgradeTest : public testing::Test {
50 public:
SetUpTestCase(void)51     static void SetUpTestCase(void){};
TearDownTestCase(void)52     static void TearDownTestCase(void){};
53     void SetUp();
TearDown()54     void TearDown(){};
55 protected:
56     static constexpr const char *bundleName = "test_upgrade";
57     static constexpr const char *storeName = "test_upgrade_meta";
58     void InitMetaData();
59     StoreMetaData metaData_;
60 };
61 
InitMetaData()62 void UpgradeTest::InitMetaData()
63 {
64     metaData_.bundleName = bundleName;
65     metaData_.appId = bundleName;
66     metaData_.user = "0";
67     metaData_.area = OHOS::DistributedKv::EL1;
68     metaData_.instanceId = 0;
69     metaData_.isAutoSync = true;
70     metaData_.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
71     metaData_.storeId = storeName;
72     metaData_.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade";
73     metaData_.securityLevel = DistributedKv::SecurityLevel::S2;
74 }
75 
SetUp()76 void UpgradeTest::SetUp()
77 {
78     Bootstrap::GetInstance().LoadDirectory();
79     InitMetaData();
80 }
81 
82 class KvStoreSyncManagerTest : public testing::Test {
83 public:
SetUpTestCase(void)84     static void SetUpTestCase(void){};
TearDownTestCase(void)85     static void TearDownTestCase(void){};
SetUp()86     void SetUp(){};
TearDown()87     void TearDown(){};
88 protected:
89 };
90 
91 class KVDBWatcherTest : public testing::Test {
92 public:
SetUpTestCase(void)93     static void SetUpTestCase(void){};
TearDownTestCase(void)94     static void TearDownTestCase(void){};
SetUp()95     void SetUp(){};
TearDown()96     void TearDown(){};
97 protected:
98 };
99 
100 class UserDelegateTest : public testing::Test {
101 public:
SetUpTestCase(void)102     static void SetUpTestCase(void){};
TearDownTestCase(void)103     static void TearDownTestCase(void){};
SetUp()104     void SetUp(){};
TearDown()105     void TearDown(){};
106 protected:
107 };
108 
109 class QueryHelperTest : public testing::Test {
110 public:
SetUpTestCase(void)111     static void SetUpTestCase(void){};
TearDownTestCase(void)112     static void TearDownTestCase(void){};
SetUp()113     void SetUp(){};
TearDown()114     void TearDown(){};
115 protected:
116 };
117 
118 class AuthHandlerTest : public testing::Test {
119 public:
SetUpTestCase(void)120     static void SetUpTestCase(void){};
TearDownTestCase(void)121     static void TearDownTestCase(void){};
SetUp()122     void SetUp(){};
TearDown()123     void TearDown(){};
124 protected:
125 };
126 
127 /**
128 * @tc.name: UpdateStore
129 * @tc.desc: UpdateStore test the return result of input with different values.
130 * @tc.type: FUNC
131 * @tc.author: SQL
132 */
133 HWTEST_F(UpgradeTest, UpdateStore, TestSize.Level0)
134 {
135     DistributedKv::Upgrade upgrade;
136     StoreMetaData oldMeta = metaData_;
137     oldMeta.version = 1;
138     oldMeta.storeType = DistributedKv::KvStoreType::DEVICE_COLLABORATION;
139     oldMeta.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade/old";
140     std::vector<uint8_t> password = {0x01, 0x02, 0x03};
141     auto dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
142     EXPECT_EQ(dbStatus, DBStatus::DB_ERROR);
143 
144     oldMeta.version = StoreMetaData::CURRENT_VERSION;
145     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
146     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
147 
148     oldMeta.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
__anon5631c79e0102(const StoreMetaData &, DBPassword &) 149     DistributedKv::Upgrade::Exporter exporter = [](const StoreMetaData &, DBPassword &) {
150         return "testexporter";
151     };
152     upgrade.exporter_ = exporter;
153     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
154     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
155 
156     oldMeta.version = 1;
__anon5631c79e0202(const StoreMetaData &meta) 157     DistributedKv::Upgrade::Cleaner cleaner = [](const StoreMetaData &meta) -> DistributedKv::Status {
158         return DistributedKv::Status::SUCCESS;
159     };
160     upgrade.cleaner_ = cleaner;
161     upgrade.exporter_ = nullptr;
162     upgrade.UpdatePassword(metaData_, password);
163     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
164     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
165 
166     metaData_.isEncrypt = true;
167     upgrade.UpdatePassword(metaData_, password);
168     EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, exporter));
169     EXPECT_TRUE(upgrade.RegisterCleaner(oldMeta.version, cleaner));
170     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
171     EXPECT_EQ(dbStatus, DBStatus::DB_ERROR);
172 
173     StoreMetaData oldMetas = metaData_;
174     dbStatus = upgrade.UpdateStore(oldMetas, metaData_, password);
175     EXPECT_EQ(dbStatus, DBStatus::OK);
176 }
177 
178 /**
179 * @tc.name: ExportStore
180 * @tc.desc: ExportStore test the return result of input with different values.
181 * @tc.type: FUNC
182 * @tc.author: SQL
183 */
184 HWTEST_F(UpgradeTest, ExportStore, TestSize.Level0)
185 {
186     DistributedKv::Upgrade upgrade;
187     StoreMetaData oldMeta = metaData_;
188     auto dbStatus = upgrade.ExportStore(oldMeta, metaData_);
189     EXPECT_EQ(dbStatus, DBStatus::OK);
190 
191     oldMeta.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade/old";
192     dbStatus = upgrade.ExportStore(oldMeta, metaData_);
193     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
194 
__anon5631c79e0302(const StoreMetaData &, DBPassword &) 195     DistributedKv::Upgrade::Exporter exporter = [](const StoreMetaData &, DBPassword &) {
196         return "testexporter";
197     };
198     EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, exporter));
199     dbStatus = upgrade.ExportStore(oldMeta, metaData_);
200     EXPECT_EQ(dbStatus, DBStatus::OK);
201 
__anon5631c79e0402(const StoreMetaData &, DBPassword &) 202     DistributedKv::Upgrade::Exporter test = [](const StoreMetaData &, DBPassword &) {
203         return "";
204     };
205     EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, test));
206     dbStatus = upgrade.ExportStore(oldMeta, metaData_);
207     EXPECT_EQ(dbStatus, DBStatus::NOT_FOUND);
208 }
209 
210 /**
211 * @tc.name: GetEncryptedUuidByMeta
212 * @tc.desc: GetEncryptedUuidByMeta test the return result of input with different values.
213 * @tc.type: FUNC
214 * @tc.author: SQL
215 */
216 HWTEST_F(UpgradeTest, GetEncryptedUuidByMeta, TestSize.Level0)
217 {
218     DistributedKv::Upgrade upgrade;
219     auto dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
220     EXPECT_EQ(dbStatus, metaData_.deviceId);
221     metaData_.appId = "";
222     dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
223     EXPECT_EQ(dbStatus, metaData_.appId);
224 }
225 
226 /**
227 * @tc.name: AddSyncOperation
228 * @tc.desc: AddSyncOperation test the return result of input with different values.
229 * @tc.type: FUNC
230 * @tc.author: SQL
231 */
232 HWTEST_F(KvStoreSyncManagerTest, AddSyncOperation, TestSize.Level0)
233 {
234     DistributedKv::KvStoreSyncManager syncManager;
235     uintptr_t syncId = 0;
236     DistributedKv::KvStoreSyncManager::SyncFunc syncFunc = nullptr;
237     DistributedKv::KvStoreSyncManager::SyncEnd syncEnd = nullptr;
238     auto kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
239     EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
240     syncId = 1;
241     kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
242     EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
__anon5631c79e0502(const DistributedKv::KvStoreSyncManager::SyncEnd &callback) 243     syncFunc = [](const DistributedKv::KvStoreSyncManager::SyncEnd &callback) -> Status {
244         std::map<std::string, DBStatus> status_map =
245             {{"key1", DBStatus::OK}, {"key2", DBStatus::DB_ERROR}};
246         callback(status_map);
247         return Status::SUCCESS;
248     };
249     kvStatus = syncManager.AddSyncOperation(0, 0, syncFunc, syncEnd);
250     EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
251 }
252 
253 /**
254 * @tc.name: RemoveSyncOperation
255 * @tc.desc: RemoveSyncOperation test the return result of input with different values.
256 * @tc.type: FUNC
257 * @tc.author: SQL
258 */
259 HWTEST_F(KvStoreSyncManagerTest, RemoveSyncOperation, TestSize.Level0)
260 {
261     DistributedKv::KvStoreSyncManager syncManager;
262     uintptr_t syncId = 0;
263     auto kvStatus = syncManager.RemoveSyncOperation(syncId);
264     EXPECT_EQ(kvStatus, Status::ERROR);
265 }
266 
267 /**
268 * @tc.name: DoRemoveSyncingOp
269 * @tc.desc: DoRemoveSyncingOp test the return result of input with different values.
270 * @tc.type: FUNC
271 * @tc.author: SQL
272 */
273 HWTEST_F(KvStoreSyncManagerTest, GetTimeoutSyncOps, TestSize.Level0)
274 {
275     DistributedKv::KvStoreSyncManager syncManager;
276     DistributedKv::KvStoreSyncManager::TimePoint currentTime = std::chrono::steady_clock::now();
277     DistributedKv::KvStoreSyncManager::KvSyncOperation syncOp;
278     syncOp.syncId = 1;
279     syncOp.beginTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(1);
280     std::list<DistributedKv::KvStoreSyncManager::KvSyncOperation> syncOps;
281 
282     EXPECT_TRUE(syncManager.realtimeSyncingOps_.empty());
283     EXPECT_TRUE(syncManager.scheduleSyncOps_.empty());
284     auto kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
285     EXPECT_EQ(kvStatus, false);
286     syncManager.realtimeSyncingOps_.push_back(syncOp);
287     kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
288     EXPECT_EQ(kvStatus, false);
289     syncManager.realtimeSyncingOps_ = syncOps;
290     syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
291     kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
292     EXPECT_EQ(kvStatus, false);
293 
294     syncManager.realtimeSyncingOps_.push_back(syncOp);
295     syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
296     EXPECT_TRUE(!syncManager.realtimeSyncingOps_.empty());
297     EXPECT_TRUE(!syncManager.scheduleSyncOps_.empty());
298     kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
299     EXPECT_EQ(kvStatus, true);
300 }
301 
302 /**
303 * @tc.name: KVDBWatcher
304 * @tc.desc: KVDBWatcher test the return result of input with different values.
305 * @tc.type: FUNC
306 * @tc.author: SQL
307 */
308 HWTEST_F(KVDBWatcherTest, KVDBWatcher, TestSize.Level0)
309 {
310     GeneralWatcher::Origin origin;
311     GeneralWatcher::PRIFields primaryFields = {{"primaryFields1", "primaryFields2"}};
312     GeneralWatcher::ChangeInfo values;
313     std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
314     sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
315     watcher->SetObserver(observer);
316     EXPECT_EQ(watcher->observer_, nullptr);
317     auto result = watcher->OnChange(origin, primaryFields, std::move(values));
318     EXPECT_EQ(result, GeneralError::E_OK);
319     GeneralWatcher::Fields fields;
320     GeneralWatcher::ChangeData data;
321     result = watcher->OnChange(origin, fields, std::move(data));
322     EXPECT_EQ(result, GeneralError::E_OK);
323 }
324 
325 /**
326 * @tc.name: ConvertToEntries
327 * @tc.desc: ConvertToEntries test the return result of input with different values.
328 * @tc.type: FUNC
329 * @tc.author: SQL
330 */
331 HWTEST_F(KVDBWatcherTest, ConvertToEntries, TestSize.Level0)
332 {
333     std::vector<Values> values;
334     Values info1;
335     info1.emplace_back(Bytes({1, 2, 3}));
336     info1.emplace_back(Bytes({4, 5, 6}));
337     values.emplace_back(info1);
338     Values info2;
339     info2.emplace_back(Bytes({7, 8, 9}));
340     info2.emplace_back(Bytes({10, 11, 12}));
341     values.emplace_back(info2);
342     Values info3;
343     info3.emplace_back(Bytes({16, 17, 18}));
344     info3.emplace_back(int64_t(1));
345     values.emplace_back(info3);
346     Values info4;
347     info4.emplace_back(int64_t(1));
348     info4.emplace_back(Bytes({19, 20, 21}));
349     values.emplace_back(info4);
350     Values info5;
351     info5.emplace_back(int64_t(1));
352     info5.emplace_back(int64_t(1));
353     values.emplace_back(info5);
354     std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
355     auto result = watcher->ConvertToEntries(values);
356     EXPECT_EQ(result.size(), 2);
357     EXPECT_EQ(result[0].key, Bytes({1, 2, 3}));
358     EXPECT_EQ(result[0].value, Bytes({4, 5, 6}));
359     EXPECT_EQ(result[1].key, Bytes({7, 8, 9}));
360     EXPECT_EQ(result[1].value, Bytes({10, 11, 12}));
361 }
362 
363 /**
364 * @tc.name: ConvertToKeys
365 * @tc.desc: ConvertToKeys test the return result of input with different values.
366 * @tc.type: FUNC
367 * @tc.author: SQL
368 */
369 HWTEST_F(KVDBWatcherTest, ConvertToKeys, TestSize.Level0)
370 {
371     std::vector<GeneralWatcher::PRIValue> values = { "key1", 123, "key3", 456, "key5" };
372     std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
373     auto result = watcher->ConvertToKeys(values);
374     EXPECT_EQ(result.size(), 3);
375     EXPECT_EQ(result[0], "key1");
376     EXPECT_EQ(result[1], "key3");
377     EXPECT_EQ(result[2], "key5");
378 }
379 
380 /**
381 * @tc.name: UserDelegate
382 * @tc.desc: UserDelegate test the return result of input with different values.
383 * @tc.type: FUNC
384 * @tc.author: SQL
385 */
386 HWTEST_F(UserDelegateTest, UserDelegate, TestSize.Level0)
387 {
388     std::shared_ptr<UserDelegate> userDelegate = std::make_shared<UserDelegate>();
389     auto result = userDelegate->GetLocalUserStatus();
390     EXPECT_EQ(result.size(), 0);
391     std::string deviceId = "";
392     result = userDelegate->GetRemoteUserStatus(deviceId);
393     EXPECT_TRUE(deviceId.empty());
394     EXPECT_TRUE(result.empty());
395     deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
396     result = userDelegate->GetRemoteUserStatus(deviceId);
397     EXPECT_EQ(result.size(), 0);
398 }
399 
400 /**
401 * @tc.name: StringToDbQuery
402 * @tc.desc: StringToDbQuery test the return result of input with different values.
403 * @tc.type: FUNC
404 * @tc.author: SQL
405 */
406 HWTEST_F(QueryHelperTest, StringToDbQuery, TestSize.Level0)
407 {
408     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
409     bool isSuccess = false;
410     std::string query = "";
411     auto result = queryHelper->StringToDbQuery(query, isSuccess);
412     EXPECT_TRUE(isSuccess);
413     std::string querys(5 * 1024, 'a');
414     query = "querys" + querys;
415     result = queryHelper->StringToDbQuery(query, isSuccess);
416     EXPECT_FALSE(isSuccess);
417     query = "query";
418     result = queryHelper->StringToDbQuery(query, isSuccess);
419     EXPECT_FALSE(isSuccess);
420 }
421 
422 /**
423 * @tc.name: Handle001
424 * @tc.desc: Handle test the return result of input with different values.
425 * @tc.type: FUNC
426 * @tc.author: SQL
427 */
428 HWTEST_F(QueryHelperTest, Handle001, TestSize.Level0)
429 {
430     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
431     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
432     int pointer = 0;
433     int end = 1;
434     int ends = 4;
435     DistributedDB::Query dbQuery;
436     EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
437     EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
438     EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
439     EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
440     EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
441     EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
442     EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
443     EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
444     EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
445     EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
446     EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
447     EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
448     EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
449 
450     pointer = 0;
451     words = {"INTEGER", "LONG", "DOUBLE", "STRING"};
452     EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
453     EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
454     EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
455     EXPECT_TRUE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
456     EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
457     pointer = 0;
458     EXPECT_TRUE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
459     EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
460     pointer = 0;
461     EXPECT_TRUE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
462     EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
463     pointer = 0;
464     EXPECT_TRUE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
465     EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
466     pointer = 0;
467     EXPECT_TRUE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
468     EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
469 }
470 
471 /**
472 * @tc.name: Handle002
473 * @tc.desc: Handle test the return result of input with different values.
474 * @tc.type: FUNC
475 * @tc.author: SQL
476 */
477 HWTEST_F(QueryHelperTest, Handle002, TestSize.Level0)
478 {
479     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
480     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
481     int pointer = 1;
482     int end = 1;
483     int ends = 4;
484     DistributedDB::Query dbQuery;
485     EXPECT_TRUE(queryHelper->HandleIsNull(words, pointer, ends, dbQuery));
486     EXPECT_FALSE(queryHelper->HandleIsNull(words, pointer, end, dbQuery));
487     pointer = 0;
488     EXPECT_TRUE(queryHelper->HandleIsNotNull(words, pointer, ends, dbQuery));
489     EXPECT_FALSE(queryHelper->HandleIsNotNull(words, pointer, end, dbQuery));
490     pointer = 0;
491     EXPECT_TRUE(queryHelper->HandleLike(words, pointer, ends, dbQuery));
492     EXPECT_FALSE(queryHelper->HandleLike(words, pointer, end, dbQuery));
493     pointer = 0;
494     EXPECT_TRUE(queryHelper->HandleNotLike(words, pointer, ends, dbQuery));
495     EXPECT_FALSE(queryHelper->HandleNotLike(words, pointer, end, dbQuery));
496     pointer = 0;
497     EXPECT_TRUE(queryHelper->HandleOrderByAsc(words, pointer, ends, dbQuery));
498     EXPECT_FALSE(queryHelper->HandleOrderByAsc(words, pointer, end, dbQuery));
499     pointer = 0;
500     EXPECT_TRUE(queryHelper->HandleOrderByDesc(words, pointer, ends, dbQuery));
501     EXPECT_FALSE(queryHelper->HandleOrderByDesc(words, pointer, end, dbQuery));
502     pointer = 0;
503     EXPECT_TRUE(queryHelper->HandleOrderByWriteTime(words, pointer, ends, dbQuery));
504     EXPECT_FALSE(queryHelper->HandleOrderByWriteTime(words, pointer, end, dbQuery));
505     pointer = 0;
506     EXPECT_TRUE(queryHelper->HandleLimit(words, pointer, ends, dbQuery));
507     EXPECT_FALSE(queryHelper->HandleLimit(words, pointer, end, dbQuery));
508     pointer = 0;
509     EXPECT_TRUE(queryHelper->HandleKeyPrefix(words, pointer, ends, dbQuery));
510     EXPECT_FALSE(queryHelper->HandleKeyPrefix(words, pointer, end, dbQuery));
511 }
512 
513 /**
514 * @tc.name: Handle003
515 * @tc.desc: Handle test the return result of input with different values.
516 * @tc.type: FUNC
517 * @tc.author: SQL
518 */
519 HWTEST_F(QueryHelperTest, Handle003, TestSize.Level0)
520 {
521     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
522     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
523     std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
524     int pointer = 0;
525     int end = 1;
526     int ends = 5;
527     DistributedDB::Query dbQuery;
528     EXPECT_FALSE(queryHelper->HandleIn(words, pointer, ends, dbQuery));
529     EXPECT_FALSE(queryHelper->HandleIn(words, pointer, end, dbQuery));
530     EXPECT_FALSE(queryHelper->HandleIn(wordss, pointer, end, dbQuery));
531     EXPECT_TRUE(queryHelper->HandleIn(wordss, pointer, ends, dbQuery));
532     pointer = 0;
533     EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, ends, dbQuery));
534     EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, end, dbQuery));
535     EXPECT_FALSE(queryHelper->HandleNotIn(wordss, pointer, end, dbQuery));
536     EXPECT_TRUE(queryHelper->HandleNotIn(wordss, pointer, ends, dbQuery));
537 }
538 
539 /**
540 * @tc.name: Handle004
541 * @tc.desc: Handle test the return result of input with different values.
542 * @tc.type: FUNC
543 * @tc.author: SQL
544 */
545 HWTEST_F(QueryHelperTest, Handle004, TestSize.Level0)
546 {
547     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
548     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
549     std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
550     int pointer = 2;
551     int end = 3;
552     int ends = 5;
553     DistributedDB::Query dbQuery;
554     EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, ends, dbQuery));
555     EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, end, dbQuery));
556     EXPECT_FALSE(queryHelper->HandleInKeys(wordss, pointer, end, dbQuery));
557     EXPECT_TRUE(queryHelper->HandleInKeys(wordss, pointer, ends, dbQuery));
558     pointer = 3;
559     EXPECT_FALSE(queryHelper->HandleSetSuggestIndex(wordss, pointer, end, dbQuery));
560     EXPECT_TRUE(queryHelper->HandleSetSuggestIndex(wordss, pointer, ends, dbQuery));
561     pointer = 3;
562     EXPECT_FALSE(queryHelper->HandleDeviceId(wordss, pointer, end, dbQuery));
563     EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
564     queryHelper->hasPrefixKey_ = true;
565     pointer = 3;
566     EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
567 }
568 
569 /**
570 * @tc.name: StringTo
571 * @tc.desc: StringTo test the return result of input with different values.
572 * @tc.type: FUNC
573 * @tc.author: SQL
574 */
575 HWTEST_F(QueryHelperTest, StringTo, TestSize.Level0)
576 {
577     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
578     std::string word = "true";
579     EXPECT_TRUE(queryHelper->StringToBoolean(word));
580     word = "false";
581     EXPECT_FALSE(queryHelper->StringToBoolean(word));
582     word = "BOOL";
583     EXPECT_FALSE(queryHelper->StringToBoolean(word));
584 
585     word = "^EMPTY_STRING";
586     auto result = queryHelper->StringToString(word);
587     EXPECT_EQ(result, "");
588     word = "START";
589     result = queryHelper->StringToString(word);
590     EXPECT_EQ(result, "START");
591     word = "START^^START";
592     result = queryHelper->StringToString(word);
593     EXPECT_EQ(result, "START START");
594     word = "START(^)START";
595     result = queryHelper->StringToString(word);
596     EXPECT_EQ(result, "START^START");
597 }
598 
599 /**
600 * @tc.name: Get
601 * @tc.desc: Get test the return result of input with different values.
602 * @tc.type: FUNC
603 * @tc.author: SQL
604 */
605 HWTEST_F(QueryHelperTest, Get, TestSize.Level0)
606 {
607     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
608     std::vector<std::string> words = {"1", "2", "3", "4", "5", "^END"};
609     int elementPointer = 0;
610     int end = 5;
611     std::vector<int> ret = {1, 2, 3, 4, 5};
612     auto result = queryHelper->GetIntegerList(words, elementPointer, end);
613     EXPECT_EQ(result, ret);
614     elementPointer = 6;
615     ret = {};
616     result = queryHelper->GetIntegerList(words, elementPointer, end);
617     EXPECT_EQ(result, ret);
618 
619     elementPointer = 0;
620     std::vector<int64_t> ret1 = {1, 2, 3, 4, 5};
621     auto result1 = queryHelper->GetLongList(words, elementPointer, end);
622     EXPECT_EQ(result1, ret1);
623     elementPointer = 6;
624     ret1 = {};
625     result1 = queryHelper->GetLongList(words, elementPointer, end);
626     EXPECT_EQ(result1, ret1);
627 
628     elementPointer = 0;
629     std::vector<double> ret2 = {1, 2, 3, 4, 5};
630     auto result2 = queryHelper->GetDoubleList(words, elementPointer, end);
631     EXPECT_EQ(result2, ret2);
632     elementPointer = 6;
633     ret2 = {};
634     result2 = queryHelper->GetDoubleList(words, elementPointer, end);
635     EXPECT_EQ(result2, ret2);
636 
637     std::vector<std::string> words1 = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
638     elementPointer = 0;
639     std::vector<std::string> ret3 = { "^NOT_IN", "INTEGER", "LONG", "^START", "STRING" };
640     auto result3 = queryHelper->GetStringList(words1, elementPointer, end);
641     EXPECT_EQ(result3, ret3);
642     elementPointer = 6;
643     ret3 = {};
644     result3 = queryHelper->GetStringList(words1, elementPointer, end);
645     EXPECT_EQ(result3, ret3);
646 }
647 
648 /**
649 * @tc.name: AuthHandler
650 * @tc.desc: AuthHandler test the return result of input with different values.
651 * @tc.type: FUNC
652 * @tc.author: SQL
653 */
654 HWTEST_F(AuthHandlerTest, AuthHandler, TestSize.Level0)
655 {
656     int localUserId = 0;
657     int peerUserId = 0;
658     std::string peerDeviceId = "";
659     int32_t authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
660     bool isSend = false;
661     auto result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
662     EXPECT_FALSE(result);
663     authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
664     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
665     EXPECT_TRUE(result);
666 
667     authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
668     peerDeviceId = "peerDeviceId";
669     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
670     EXPECT_FALSE(result);
671 
672     authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
673     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
674     EXPECT_TRUE(result);
675 
676     localUserId = 1;
677     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
678     EXPECT_FALSE(result);
679 
680     peerUserId = 1;
681     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
682     EXPECT_FALSE(result);
683 }
684 } // namespace DistributedDataTest
685 } // namespace OHOS::Test