diff --git a/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h b/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h index 726800b5885359e90ec7bf625c7b1a979c6d8dbd..e549a1c32220265420f64ebbcdef62c804134ee2 100644 --- a/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h +++ b/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h @@ -43,6 +43,8 @@ public: uint32_t SetStatusNotifier(std::shared_ptr watcher) override; uint32_t SyncAllData(const std::string &sessionId, const std::vector &deviceIds, const std::function &)> &onComplete); + void OnComplete(const std::string &key, const std::map &devices, + std::shared_ptr statusWatcher); bool isOpened_ = false; void NotifyStatus(const std::string &sessionId, const std::string &deviceId, const std::string &status); void NotifyChange(const std::string &sessionId, const std::map> &changedData); diff --git a/data_object/frameworks/innerkitsimpl/include/communicator/visibility.h b/data_object/frameworks/innerkitsimpl/include/communicator/visibility.h index a9dec0b96f880805ea79195585726be2356c37c4..3c5f92532b1e11c796f2c9936d8784b455cfebbe 100644 --- a/data_object/frameworks/innerkitsimpl/include/communicator/visibility.h +++ b/data_object/frameworks/innerkitsimpl/include/communicator/visibility.h @@ -21,4 +21,4 @@ #endif #ifndef KVSTORE_API #define KVSTORE_API API_EXPORT -#endif \ No newline at end of file +#endif diff --git a/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp b/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp index ae72c69e6281d78f65d7606f59e5d24511386971..510778234fa75fd96a7309adcf0479e0da17e9c2 100644 --- a/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp +++ b/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp @@ -67,6 +67,12 @@ DistributedObject *DistributedObjectStoreImpl::CreateObject(const std::string &s LOG_ERROR("DistributedObjectStoreImpl::CreateObject store not opened!"); return nullptr; } + + if (sessionId.empty()) { + LOG_ERROR("DistributedObjectStoreImpl::CreateObject Invalid sessionId"); + return nullptr; + } + uint32_t status = flatObjectStore_->CreateObject(sessionId); if (status != SUCCESS) { LOG_ERROR("DistributedObjectStoreImpl::CreateObject CreateTable err %{public}d", status); @@ -83,6 +89,13 @@ DistributedObject *DistributedObjectStoreImpl::CreateObject(const std::string &s status = ERR_NULL_OBJECTSTORE; return nullptr; } + + if (sessionId.empty()) { + LOG_ERROR("DistributedObjectStoreImpl::CreateObject Invalid sessionId"); + status = ERR_INVALID_ARGS; + return nullptr; + } + status = flatObjectStore_->CreateObject(sessionId); if (status != SUCCESS) { LOG_ERROR("DistributedObjectStoreImpl::CreateObject CreateTable err %{public}d", status); diff --git a/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp b/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp index cb9bd9fe389ece3e5947c7a61d417af391ef613b..401d3c19f2c48a2802a69c9b4052a9fbaf3b4f95 100644 --- a/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp +++ b/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp @@ -74,6 +74,18 @@ uint32_t FlatObjectStorageEngine::Close() return SUCCESS; } +void FlatObjectStorageEngine::OnComplete(const std::string &key, + const std::map &devices, std::shared_ptr statusWatcher) +{ + LOG_INFO("complete"); + if (statusWatcher != nullptr) { + for (auto item : devices) { + statusWatcher->OnChanged(key, SoftBusAdapter::GetInstance()->ToNodeID(item.first), + item.second == DistributedDB::OK ? "online" : "offline"); + } + } +} + uint32_t FlatObjectStorageEngine::CreateTable(const std::string &key) { if (!isOpened_) { @@ -97,12 +109,16 @@ uint32_t FlatObjectStorageEngine::CreateTable(const std::string &key) kvStore = kvStoreNbDelegate; LOG_INFO("create table result %{public}d", status); }); + if (status != DistributedDB::DBStatus::OK || kvStore == nullptr) { + LOG_ERROR("FlatObjectStorageEngine::CreateTable %{public}s getkvstore fail[%{public}d]", key.c_str(), status); + return ERR_DB_GETKV_FAIL; + } bool autoSync = true; DistributedDB::PragmaData data = static_cast(&autoSync); LOG_INFO("start Pragma"); status = kvStore->Pragma(DistributedDB::AUTO_SYNC, data); if (status != DistributedDB::DBStatus::OK) { - LOG_ERROR("FlatObjectStorageEngine::CreateTable %{public}s getkvstore fail[%{public}d]", key.c_str(), status); + LOG_ERROR("FlatObjectStorageEngine::CreateTable %{public}s Pragma fail[%{public}d]", key.c_str(), status); return ERR_DB_GETKV_FAIL; } LOG_INFO("create table %{public}s success", key.c_str()); @@ -112,17 +128,7 @@ uint32_t FlatObjectStorageEngine::CreateTable(const std::string &key) } auto onComplete = [key, this](const std::map &devices) { - LOG_INFO("complete"); - for (auto item : devices) { - LOG_INFO("%{public}s pull data result %{public}d in device %{public}s", key.c_str(), item.second, - SoftBusAdapter::GetInstance()->ToNodeID(item.first).c_str()); - } - if (statusWatcher_ != nullptr) { - for (auto item : devices) { - statusWatcher_->OnChanged(key, SoftBusAdapter::GetInstance()->ToNodeID(item.first), - item.second == DistributedDB::OK ? "online" : "offline"); - } - } + OnComplete(key, devices, statusWatcher_); }; std::vector devices = SoftBusAdapter::GetInstance()->GetDeviceList(); std::vector deviceIds; @@ -148,7 +154,8 @@ uint32_t FlatObjectStorageEngine::GetTable(const std::string &key, std::mapGetEntries(emptyKey, resultSet); + auto delegate = delegates_.at(key); + DistributedDB::DBStatus status = delegate->GetEntries(emptyKey, resultSet); if (status != DistributedDB::DBStatus::OK || resultSet == nullptr) { LOG_INFO("FlatObjectStorageEngine::GetTable %{public}s GetEntries fail", key.c_str()); return ERR_DB_GET_FAIL; @@ -158,12 +165,22 @@ uint32_t FlatObjectStorageEngine::GetTable(const std::string &key, std::mapGetEntry(entry); if (status != DistributedDB::DBStatus::OK) { - LOG_INFO("FlatObjectStorageEngine::GetTable GetEntry fail"); + LOG_INFO("FlatObjectStorageEngine::GetTable GetEntry fail, errcode = %{public}d", status); + status = delegate->CloseResultSet(resultSet); + if (status != DistributedDB::DBStatus::OK) { + LOG_INFO("KvStoreNbDelegate::CloseResultSet fail, errcode = %{public}d", status); + return ERR_RESULTSET; + } return ERR_DB_ENTRY_FAIL; } result.insert_or_assign(StringUtils::BytesToStr(entry.key), entry.value); resultSet->MoveToNext(); } + status = delegate->CloseResultSet(resultSet); + if (status != DistributedDB::DBStatus::OK) { + LOG_INFO("KvStoreNbDelegate::CloseResultSet fail, errcode = %{public}d", status); + return ERR_RESULTSET; + } return SUCCESS; } diff --git a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn index 69bcbecebf79042b81d62a81efd7aa1de1c7d162..aa5a45253f026a1f33ff6cedeed1d8de1fddda74 100644 --- a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn +++ b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn @@ -17,7 +17,10 @@ import("//build/test.gni") config("module_private_config") { visibility = [ ":*" ] - include_dirs = [] + include_dirs = [ + "../../../../../frameworks/innerkitsimpl/include/adaptor", + "../../../../../frameworks/innerkitsimpl/include/common", + ] } ##############################fuzztest########################################## @@ -29,6 +32,9 @@ ohos_fuzztest("ObjectStoreFuzzTest") { sources = [ "objectstore_fuzzer.cpp" ] configs = [ ":module_private_config" ] + deps = [ + "../../../../../../kv_store/frameworks/libs/distributeddb:distributeddb", + ] external_deps = [ "data_object:distributeddataobject_impl", diff --git a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.cpp b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.cpp index 0c4db0eca0516b09fb2e68cce779e8b213c3bf08..8a1a5fec90a58bdf6adbb93cfc1076d06bf60b68 100644 --- a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.cpp +++ b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.cpp @@ -13,10 +13,13 @@ * limitations under the License. */ +#include "objectstore_fuzzer.h" + #include #include #include "distributed_object.h" #include "distributed_objectstore.h" +#include "flat_object_storage_engine.h" #include "objectstore_errors.h" using namespace OHOS::ObjectStore; @@ -24,6 +27,15 @@ namespace OHOS { static DistributedObject *object_ = nullptr; static DistributedObjectStore *objectStore_ = nullptr; constexpr const char *SESSIONID = "123456"; +constexpr const char *TABLESESSIONID = "654321"; +class TableWatcherImpl : public TableWatcher { +public: + explicit TableWatcherImpl(const std::string &sessionId) : TableWatcher(sessionId) {} + void OnChanged(const std::string &sessionid, const std::vector &changedData) override; + virtual ~TableWatcherImpl(); +}; +TableWatcherImpl::~TableWatcherImpl() {} +void TableWatcherImpl::OnChanged(const std::string &sessionid, const std::vector &changedData) {} uint32_t SetUpTestCase() { @@ -142,7 +154,7 @@ bool GetBooleanFuzz(const uint8_t *data, size_t size) return false; } std::string skey(data, data + size); - if (SUCCESS == object_->PutBoolean(skey, true)) { + if (SUCCESS == object_->PutBoolean(skey, true)) { uint32_t ret = object_->GetBoolean(skey, val); if (!ret) { result = true; @@ -161,7 +173,7 @@ bool GetStringFuzz(const uint8_t *data, size_t size) std::string skey(data, data + size); std::string sval(data, data + size); std::string val; - if (SUCCESS == object_->PutString(skey, sval)) { + if (SUCCESS == object_->PutString(skey, sval)) { uint32_t ret = object_->GetString(skey, val); if (!ret) { result = true; @@ -194,7 +206,6 @@ bool GetComplexFuzz(const uint8_t *data, size_t size) return result; } - bool GetTypeFuzz(const uint8_t *data, size_t size) { bool result = false; @@ -226,11 +237,133 @@ bool SaveFuzz(const uint8_t *data, size_t size) return result; } +bool SaveAndRevokeSaveFuzz(const uint8_t *data, size_t size) +{ + bool result = false; + if (SUCCESS != SetUpTestCase()) { + return false; + } + std::string skey(data, data + size); + if (SUCCESS == object_->PutDouble(skey, static_cast(size))) { + uint32_t ret = object_->Save(skey); + if (!ret) { + result = false; + } + + if (object_->RevokeSave()) { + return false; + } + result = true; + } + objectStore_->DeleteObject(SESSIONID); + return result; +} + +bool CreateObjectV9Fuzz(const uint8_t *data, size_t size) +{ + bool result = false; + std::string bundleName = "com.example.myapplication"; + DistributedObject *object = nullptr; + objectStore_ = DistributedObjectStore::GetInstance(bundleName); + uint32_t status = 0; + std::string skey(data, data + size); + if (objectStore_ == nullptr) { + return false; + } + object = objectStore_->CreateObject(skey, status); + if (object == nullptr || status != SUCCESS) { + return false; + } + double val = static_cast(size); + if (SUCCESS == object->PutDouble(skey, val)) { + double getResult; + if (object->GetDouble(skey, getResult)) { + result = true; + } + } + objectStore_->DeleteObject(skey); + return result; +} +bool GetFuzz(const uint8_t *data, size_t size) +{ + std::string bundleName = "default1"; + objectStore_ = DistributedObjectStore::GetInstance(bundleName); + if (objectStore_ == nullptr) { + return false; + } + uint32_t status = 0; + DistributedObject *object = objectStore_->CreateObject(SESSIONID, status); + if (object == nullptr) { + return false; + } + + DistributedObject *object2 = nullptr; + std::string skey(data, data + size); + if (!objectStore_->Get(skey, &object2)) { + return false; + } + + if (object != object2) { + return false; + } + objectStore_->DeleteObject(SESSIONID); + return true; +} + +bool GetTableFuzz(const uint8_t *data, size_t size) +{ + bool result = false; + std::string skey(data, data + size); + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open("com.myapplication"); + storageEngine->CreateTable(TABLESESSIONID); + std::map tableResult; + uint32_t ret = storageEngine->GetTable(skey, tableResult); + if (ret != SUCCESS) { + result = false; + } + storageEngine->DeleteTable(TABLESESSIONID); + return result; +} + +bool NotifyStatusAndNotifyChangeFuzz(const uint8_t *data, size_t size) +{ + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open("com.example.myapplication"); + uint32_t ret = storageEngine->CreateTable(TABLESESSIONID); + if (ret != SUCCESS) { + return false; + } + std::map> filteredData; + std::string skey(data, data + size); + storageEngine->NotifyChange(skey, filteredData); + storageEngine->NotifyStatus(skey, skey, skey); + storageEngine->DeleteTable(TABLESESSIONID); + return true; +} + +bool RegisterObserverAndUnRegisterObserverFuzz(const uint8_t *data, size_t size) +{ + bool result = true; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open("com.example.myapplication"); + std::string skey(data, data + size); + auto tableWatcherPtr = std::make_shared(SESSIONID); + uint32_t ret = storageEngine->RegisterObserver(skey, tableWatcherPtr); + if (ret != SUCCESS) { + result = false; + } + ret = storageEngine->UnRegisterObserver(skey); + if (ret != SUCCESS) { + result = false; + } + return result; +} } /* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { OHOS::PutDoubleFuzz(data, size); OHOS::PutBooleanFuzz(data, size); @@ -242,6 +375,12 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) OHOS::GetComplexFuzz(data, size); OHOS::GetTypeFuzz(data, size); OHOS::SaveFuzz(data, size); + OHOS::SaveAndRevokeSaveFuzz(data, size); + OHOS::CreateObjectV9Fuzz(data, size); + OHOS::GetFuzz(data, size); + OHOS::GetTableFuzz(data, size); + OHOS::NotifyStatusAndNotifyChangeFuzz(data, size); + OHOS::RegisterObserverAndUnRegisterObserverFuzz(data, size); /* Run your code on data */ return 0; } \ No newline at end of file diff --git a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.h b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.h index 3431adfecd542b98f09dd654f2a145a0ca12b3d3..9400fb6fc7053c2ec2fdd79c03b5a509dc8ce74c 100644 --- a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.h +++ b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/objectstore_fuzzer.h @@ -15,8 +15,5 @@ #ifndef OBJECTSTORE_FUZZER_H #define OBJECTSTORE_FUZZER_H - -#define OBJECTSTORE_FUZZER_H "objectstore_fuzzer" - #endif // OBJECTSTORE_FUZZER_H diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/BUILD.gn b/data_object/frameworks/innerkitsimpl/test/unittest/BUILD.gn index 521846dc68e17198c900644d47eda07c319b246a..b598fc79a095927c36039d8dc3593aa966b6cb75 100644 --- a/data_object/frameworks/innerkitsimpl/test/unittest/BUILD.gn +++ b/data_object/frameworks/innerkitsimpl/test/unittest/BUILD.gn @@ -15,25 +15,52 @@ import("//build/test.gni") module_output_path = "data_object/impl" +data_object_base_path = "//foundation/distributeddatamgr/data_object" + +data_object_innerkits_path = "${data_object_base_path}/frameworks/innerkitsimpl" + +kv_store_include_path = + "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb" + config("module_private_config") { visibility = [ ":*" ] - include_dirs = [] + include_dirs = [ + "./mock/include", + "${data_object_innerkits_path}/include/adaptor", + "${data_object_innerkits_path}/include/common", + "${data_object_innerkits_path}/include/communicator", + "${kv_store_include_path}/include", + "${kv_store_include_path}/interfaces/include/", + "${kv_store_include_path}/interfaces/include/relational", + ] } ohos_unittest("NativeObjectStoreTest") { module_out_path = module_output_path - sources = [ "object_store_test.cpp" ] + sources = [ + "mock/src/mock_soft_bus.cpp", + "src/app_pipe_mgr_test.cpp", + "src/communicator_test.cpp", + "src/object_store_test.cpp", + "src/process_communicator_impl_test.cpp", + ] configs = [ ":module_private_config" ] external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", "data_object:distributeddataobject_impl", "hilog_native:libhilog", ] - deps = [ "//third_party/googletest:gtest_main" ] + deps = [ + "//base/security/access_token/interfaces/innerkits/token_setproc:libtoken_setproc", + "//third_party/googletest:gmock", + "//third_party/googletest:gtest_main", + ] } group("unittest") { diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/mock/include/mock_app_data_change_listener.h b/data_object/frameworks/innerkitsimpl/test/unittest/mock/include/mock_app_data_change_listener.h new file mode 100644 index 0000000000000000000000000000000000000000..4e5342f5b6755f0b4e12ebad40454443fdb700ca --- /dev/null +++ b/data_object/frameworks/innerkitsimpl/test/unittest/mock/include/mock_app_data_change_listener.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef DATA_OBJECT_MOCK_APP_DATA_CHANGE_LISTENER_H +#define DATA_OBJECT_MOCK_APP_DATA_CHANGE_LISTENER_H + +#include +#include "app_data_change_listener.h" + +namespace OHOS { +namespace ObjectStore { +class MockAppDataChangeListener : public AppDataChangeListener { + MOCK_CONST_METHOD4(OnMessage, + void(const DeviceInfo &info, const uint8_t *ptr, const int size, const PipeInfo &pipeInfo)); +}; +} // namespace ObjectStore +} // namespace OHOS + +#endif // DATA_OBJECT_MOCK_APP_DATA_CHANGE_LISTENER_H diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/mock/include/mock_app_device_change_listener.h b/data_object/frameworks/innerkitsimpl/test/unittest/mock/include/mock_app_device_change_listener.h new file mode 100644 index 0000000000000000000000000000000000000000..6460a436b95cd373235abf09725ee6ff8ca6bce8 --- /dev/null +++ b/data_object/frameworks/innerkitsimpl/test/unittest/mock/include/mock_app_device_change_listener.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef DATA_OBJECT_MOCK_APP_DEVICE_CHANGE_LISTENER_H +#define DATA_OBJECT_MOCK_APP_DEVICE_CHANGE_LISTENER_H + +#include +#include "app_device_status_change_listener.h" + +namespace OHOS { +namespace ObjectStore { +class MockAppDeviceStatusChangeListener : public AppDeviceStatusChangeListener { + MOCK_CONST_METHOD2(OnDeviceChanged, void(const DeviceInfo &info, const DeviceChangeType &type)); +}; +} // namespace ObjectStore +} // namespace OHOS + +#endif // DATA_OBJECT_MOCK_APP_DEVICE_CHANGE_LISTENER_H diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/mock/src/mock_soft_bus.cpp b/data_object/frameworks/innerkitsimpl/test/unittest/mock/src/mock_soft_bus.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5ee21e5155138100013378158b44e80efdfe929b --- /dev/null +++ b/data_object/frameworks/innerkitsimpl/test/unittest/mock/src/mock_soft_bus.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "softbus_bus_center.h" + +static std::map> sessionListeners; +static std::map callbacks_; + +int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerDeviceId, const char *groupId, + const SessionAttribute *attr) +{ + return -1; +} + +int SendBytes(int sessionId, const void *data, unsigned int len) +{ + return -1; +} + +int RemoveSessionServer(const char *pkgName, const char *sessionName) +{ + const char *invalidSessionName = "INVALID_SESSION_NAME"; + const char *closeFailedSessionName = "REMOVE_FAILED_SESSION_NAME"; + if (!strcmp(sessionName, invalidSessionName)) { + return -1; + } + if (!strcmp(sessionName, closeFailedSessionName)) { + return -1; + } + return 0; +} +int GetMySessionName(int sessionId, char *sessionName, unsigned int len) +{ + return -1; +} +int GetPeerSessionName(int sessionId, char *sessionName, unsigned int len) +{ + return 0; +} +int GetPeerDeviceId(int sessionId, char *devId, unsigned int len) +{ + return 0; +} +void CloseSession(int sessionId){}; +int GetSessionSide(int sessionId) +{ + return 1; +}; + +int32_t GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info) +{ + return -1; +} + +int32_t GetAllNodeDeviceInfo(const char *pkgName, NodeBasicInfo **info, int32_t *infoNum) +{ + return -1; +} + +int32_t GetNodeKeyInfo(const char *pkgName, const char *networkId, NodeDeviceInfoKey key, uint8_t *info, + int32_t infoLen) +{ + return -1; +} + +int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener) +{ + const char *invalidSessionName = "INVALID_SESSION_NAME"; + if (!strcmp(sessionName, invalidSessionName)) { + return -1; + } + return 0; +} \ No newline at end of file diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/src/app_pipe_mgr_test.cpp b/data_object/frameworks/innerkitsimpl/test/unittest/src/app_pipe_mgr_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..59ea357c7b88d828cd75bf4f27a9a8fa30310be9 --- /dev/null +++ b/data_object/frameworks/innerkitsimpl/test/unittest/src/app_pipe_mgr_test.cpp @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include "app_pipe_mgr.h" +#include "app_types.h" +#include "auto_launch_export.h" +#include "ipc_skeleton.h" +#include "objectstore_errors.h" +#include "mock_app_data_change_listener.h" + +namespace { +using namespace testing::ext; +using namespace OHOS::ObjectStore; + +class NativeAppPipeMgrTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void NativeAppPipeMgrTest::SetUpTestCase(void) +{ + // input testsuit setup step，setup invoked before all testcases +} + +void NativeAppPipeMgrTest::TearDownTestCase(void) +{ + // input testsuit teardown step，teardown invoked after all testcases +} + +void NativeAppPipeMgrTest::SetUp(void) +{ + // input testcase setup step，setup invoked before each testcases +} + +void NativeAppPipeMgrTest::TearDown(void) +{ + // input testcase teardown step，teardown invoked after each testcases +} + +/** + * @tc.name: NativeAppPipeMgrTest_StartWatchDataChange_001 + * @tc.desc: test NativeAppPipeMgrTest StartWatchDataChange. argument invalid + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_StartWatchDataChange_001, TestSize.Level1) +{ + PipeInfo pipeInfo = {""}; + AppDataChangeListener *observer = new MockAppDataChangeListener(); + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->StartWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::INVALID_ARGUMENT, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_StartWatchDataChange_002 + * @tc.desc: test NativeAppPipeMgrTest StartWatchDataChange. pipId not found. + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_StartWatchDataChange_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipId01" }; + AppDataChangeListener *observer = new MockAppDataChangeListener(); + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->StartWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_StopWatchDataChange_001 + * @tc.desc: test NativeAppPipeMgrTest StopWatchDataChange. argument invalid + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_StopWatchDataChange_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipId01" }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->StopWatchDataChange(nullptr, pipeInfo); + EXPECT_EQ(Status::INVALID_ARGUMENT, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_StopWatchDataChange_002 + * @tc.desc: test NativeAppPipeMgrTest StopWatchDataChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_StopWatchDataChange_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipId01" }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + AppDataChangeListener *observer = new MockAppDataChangeListener(); + auto ret = appPipeMgr->StopWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_StopWatchDataChange_003 + * @tc.desc: test NativeAppPipeMgrTest StopWatchDataChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_StopWatchDataChange_003, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipId01" }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + AppDataChangeListener *observer = new MockAppDataChangeListener(); + auto ret = appPipeMgr->StopWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_Start_001 + * @tc.desc: test NativeAppPipeMgrTest Start. pipInfo is empty + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_Start_001, TestSize.Level1) +{ + PipeInfo pipeInfo = {}; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->Start(pipeInfo); + EXPECT_EQ(Status::INVALID_ARGUMENT, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_Start_002 + * @tc.desc: test NativeAppPipeMgrTest Start. invalid pipInfo + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_Start_002, TestSize.Level1) +{ + PipeInfo pipeInfo = {"INVALID_SESSION_NAME"}; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->Start(pipeInfo); + EXPECT_EQ(Status::ILLEGAL_STATE, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_Start_003 + * @tc.desc: test NativeAppPipeMgrTest Start. + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_Start_003, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo01" }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->Start(pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + ret = appPipeMgr->Stop(pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_Start_004 + * @tc.desc: test NativeAppPipeMgrTest Start. repeat start + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_Start_004, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo01" }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->Start(pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + ret = appPipeMgr->Start(pipeInfo); + EXPECT_EQ(Status::REPEATED_REGISTER, ret); + ret = appPipeMgr->Stop(pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_Stop_001 + * @tc.desc: test NativeAppPipeMgrTest Stop. pipInfo not found. + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_Stop_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo01" }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->Stop(pipeInfo); + EXPECT_EQ(Status::KEY_NOT_FOUND, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_Stop_002 + * @tc.desc: test NativeAppPipeMgrTest Stop. RemoveSessionServer failed + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_Stop_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "REMOVE_FAILED_SESSION_NAME" }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->Start(pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + ret = appPipeMgr->Stop(pipeInfo); + EXPECT_EQ(Status::ERROR, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_SendData_001 + * @tc.desc: test NativeAppPipeMgrTest SendData. input is invalid + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_SendData_001, TestSize.Level1) +{ + PipeInfo pipeInfo = {}; + DeviceId deviceId = {"devideId01"}; + int size = 1; + uint8_t tmpNum = 1; + uint8_t *ptr = &tmpNum; + MessageInfo messageInfo = {MessageType::DEFAULT}; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->SendData(pipeInfo, deviceId, ptr, size, messageInfo); + EXPECT_EQ(Status::ERROR, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_SendData_002 + * @tc.desc: test NativeAppPipeMgrTest SendData. pipInfo not found + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_SendData_002, TestSize.Level1) +{ + PipeInfo pipeInfo = {"pipInfo02"}; + DeviceId deviceId = {"devideId02"}; + int size = 1; + uint8_t tmpNum = 1; + uint8_t *ptr = &tmpNum; + MessageInfo messageInfo = { MessageType::DEFAULT }; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->SendData(pipeInfo, deviceId, ptr, size, messageInfo); + EXPECT_EQ(Status::KEY_NOT_FOUND, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_IsSameStartedOnPeer_001 + * @tc.desc: test NativeAppPipeMgrTest IsSameStartedOnPeer. pipInfo or deviceId is empty + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_IsSameStartedOnPeer_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo01" }; + DeviceId deviceId = {}; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->IsSameStartedOnPeer(pipeInfo, deviceId); + EXPECT_EQ(false, ret); +} + +/** + * @tc.name: NativeAppPipeMgrTest_IsSameStartedOnPeer_002 + * @tc.desc: test NativeAppPipeMgrTest IsSameStartedOnPeer. pipInfo not found + * @tc.type: FUNC + */ +HWTEST_F(NativeAppPipeMgrTest, NativeAppPipeMgrTest_IsSameStartedOnPeer_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo02" }; + DeviceId deviceId = {"deviceId02"}; + AppPipeMgr *appPipeMgr = new AppPipeMgr(); + auto ret = appPipeMgr->IsSameStartedOnPeer(pipeInfo, deviceId); + EXPECT_EQ(false, ret); +} + +} diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/src/communicator_test.cpp b/data_object/frameworks/innerkitsimpl/test/unittest/src/communicator_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..06d5d41f137d9b08ea0544c0f24e7291d633f038 --- /dev/null +++ b/data_object/frameworks/innerkitsimpl/test/unittest/src/communicator_test.cpp @@ -0,0 +1,506 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "auto_launch_export.h" +#include "objectstore_errors.h" +#include "ipc_skeleton.h" +#include "accesstoken_kit.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" +#include "app_types.h" +#include "softbus_adapter.h" +#include "app_device_status_change_listener.h" +#include "app_data_change_listener.h" +#include "mock_app_device_change_listener.h" +#include "mock_app_data_change_listener.h" + +using namespace testing::ext; +using namespace OHOS::Security::AccessToken; +using namespace OHOS::ObjectStore; + +namespace { +constexpr int32_t HEAD_SIZE = 3; +constexpr const char *REPLACE_CHAIN = "***"; +constexpr const char *DEFAULT_ANONYMOUS = "******"; + +class NativeCommunicatorTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void NativeCommunicatorTest::SetUpTestCase(void) +{ + // input testsuit setup step，setup invoked before all testcases +} + +void NativeCommunicatorTest::TearDownTestCase(void) +{ + // input testsuit teardown step，teardown invoked after all testcases +} + +void NativeCommunicatorTest::SetUp(void) +{ + // input testcase setup step，setup invoked before each testcases +} + +void NativeCommunicatorTest::TearDown(void) +{ + // input testcase teardown step，teardown invoked after each testcases +} + +/** + * @tc.name: SoftBusAdapter_StartWatchDeviceChange_001 + * @tc.desc: test SoftBusAdapter NotifyAll. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, StartWatchDeviceChange_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo001" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + MockAppDeviceStatusChangeListener *mockAppDeviceStatusChangeListener = new MockAppDeviceStatusChangeListener(); + auto ret = softBusAdapter->StartWatchDeviceChange(mockAppDeviceStatusChangeListener, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + delete softBusAdapter; + delete mockAppDeviceStatusChangeListener; +} + +/** + * @tc.name: SoftBusAdapter_StartWatchDeviceChange_002 + * @tc.desc: test SoftBusAdapter NotifyAll. input parameter of observer is null + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StartWatchDeviceChange_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo002" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + MockAppDeviceStatusChangeListener *mockAppDeviceStatusChangeListener = nullptr; + auto ret = softBusAdapter->StartWatchDeviceChange(mockAppDeviceStatusChangeListener, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_StartWatchDeviceChange_003 + * @tc.desc: test SoftBusAdapter StartWatchDeviceChange. insert the same observer + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StartWatchDeviceChange_003, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo003" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + MockAppDeviceStatusChangeListener *mockAppDeviceStatusChangeListener = new MockAppDeviceStatusChangeListener(); + auto ret = softBusAdapter->StartWatchDeviceChange(mockAppDeviceStatusChangeListener, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + ret = softBusAdapter->StartWatchDeviceChange(mockAppDeviceStatusChangeListener, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); + delete softBusAdapter; + delete mockAppDeviceStatusChangeListener; +} + +/** + * @tc.name: SoftBusAdapter_StopWatchDeviceChange_001 + * @tc.desc: test SoftBusAdapter StopWatchDeviceChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StopWatchDeviceChange_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo001" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + MockAppDeviceStatusChangeListener *mockAppDeviceStatusChangeListener = new MockAppDeviceStatusChangeListener(); + auto ret = softBusAdapter->StartWatchDeviceChange(mockAppDeviceStatusChangeListener, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + ret = softBusAdapter->StopWatchDeviceChange(mockAppDeviceStatusChangeListener, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + delete softBusAdapter; + delete mockAppDeviceStatusChangeListener; +} + +/** + * @tc.name: SoftBusAdapter_StopWatchDeviceChange_002 + * @tc.desc: test SoftBusAdapter StopWatchDeviceChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StopWatchDeviceChange_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo002" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + MockAppDeviceStatusChangeListener *mockAppDeviceStatusChangeListener = new MockAppDeviceStatusChangeListener(); + auto ret = softBusAdapter->StartWatchDeviceChange(mockAppDeviceStatusChangeListener, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + ret = softBusAdapter->StopWatchDeviceChange(nullptr, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); + delete softBusAdapter; + delete mockAppDeviceStatusChangeListener; +} + +/** + * @tc.name: SoftBusAdapter_StopWatchDeviceChange_003 + * @tc.desc: test SoftBusAdapter StopWatchDeviceChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StopWatchDeviceChange_003, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo003" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + MockAppDeviceStatusChangeListener *mockAppDeviceStatusChangeListener1 = new MockAppDeviceStatusChangeListener(); + MockAppDeviceStatusChangeListener *mockAppDeviceStatusChangeListener2 = new MockAppDeviceStatusChangeListener(); + auto ret = softBusAdapter->StartWatchDeviceChange(mockAppDeviceStatusChangeListener1, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + ret = softBusAdapter->StopWatchDeviceChange(mockAppDeviceStatusChangeListener2, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); + delete softBusAdapter; + delete mockAppDeviceStatusChangeListener1; + delete mockAppDeviceStatusChangeListener2; +} + +/** + * @tc.name: SoftBusAdapter_IsSameStartedOnPeer_001 + * @tc.desc: test SoftBusAdapter NotifyAll. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_IsSameStartedOnPeer_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo001" }; + DeviceId deviceId = { "deviceId01" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->IsSameStartedOnPeer(pipeInfo, deviceId); + EXPECT_EQ(false, ret); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_IsSameStartedOnPeer_002 + * @tc.desc: test SoftBusAdapter IsSameStartedOnPeer. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_IsSameStartedOnPeer_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo002" }; + DeviceId deviceId = { "deviceId02" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + std::string sessionName = "pipInfo002deviceId02"; + softBusAdapter->InsertSession(sessionName); + auto ret = softBusAdapter->IsSameStartedOnPeer(pipeInfo, deviceId); + EXPECT_EQ(true, ret); + softBusAdapter->DeleteSession(sessionName); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_SendData_001 + * @tc.desc: test SoftBusAdapter SendData. OpenSession error + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_SendData_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo001" }; + DeviceId deviceId = { "deviceId01" }; + uint8_t ptr = 1; + int size = 1; + MessageInfo info = { MessageType::DEFAULT }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->SendData(pipeInfo, deviceId, &ptr, size, info); + EXPECT_EQ(Status::CREATE_SESSION_ERROR, ret); + delete softBusAdapter; +} + + +/** + * @tc.name: SoftBusAdapter_StartWatchDataChange_001 + * @tc.desc: test SoftBusAdapter StartWatchDataChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StartWatchDataChange_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo001" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + AppDataChangeListener *observer = new MockAppDataChangeListener(); + auto ret = softBusAdapter->StartWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + delete softBusAdapter; + delete observer; +} + +/** + * @tc.name: SoftBusAdapter_StartWatchDataChange_002 + * @tc.desc: test SoftBusAdapter StartWatchDataChange. insert the same observer + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StartWatchDataChange_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo002" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + AppDataChangeListener *observer = new MockAppDataChangeListener(); + auto ret = softBusAdapter->StartWatchDataChange(observer, pipeInfo); + ret = softBusAdapter->StartWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); + delete softBusAdapter; + delete observer; +} + +/** + * @tc.name: SoftBusAdapter_StartWatchDataChange_003 + * @tc.desc: test SoftBusAdapter StartWatchDataChange. observer is nullptr + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StartWatchDataChange_003, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo002" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->StartWatchDataChange(nullptr, pipeInfo); + EXPECT_EQ(Status::INVALID_ARGUMENT, ret); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_StopWatchDataChange_001 + * @tc.desc: test SoftBusAdapter StartWatchDataChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StopWatchDataChange_001, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo001" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + AppDataChangeListener *observer = new MockAppDataChangeListener(); + auto ret = softBusAdapter->StartWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + softBusAdapter->StopWatchDataChange(observer, pipeInfo); + EXPECT_EQ(Status::SUCCESS, ret); + delete softBusAdapter; + delete observer; +} + +/** + * @tc.name: SoftBusAdapter_StopWatchDataChange_002 + * @tc.desc: test SoftBusAdapter StartWatchDataChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_StopWatchDataChange_002, TestSize.Level1) +{ + PipeInfo pipeInfo = { "pipInfo001" }; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->StopWatchDataChange(nullptr, pipeInfo); + EXPECT_EQ(Status::ERROR, ret); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_ToBeAnonymous_001 + * @tc.desc: test SoftBusAdapter ToBeAnonymous. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_ToBeAnonymous_001, TestSize.Level1) +{ + std::string name = "na"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->ToBeAnonymous(name); + EXPECT_EQ(DEFAULT_ANONYMOUS, ret); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_ToBeAnonymous_002 + * @tc.desc: test SoftBusAdapter ToBeAnonymous. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_ToBeAnonymous_002, TestSize.Level1) +{ + std::string name = "name"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->ToBeAnonymous(name); + EXPECT_EQ(name.substr(0, HEAD_SIZE) + REPLACE_CHAIN, ret); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_GetLocalBasicInfo_001 + * @tc.desc: test SoftBusAdapter GetLocalBasicInfo. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_GetLocalBasicInfo_001, TestSize.Level1) +{ + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->GetLocalBasicInfo(); + EXPECT_EQ(true, ret.deviceId.empty()); + EXPECT_EQ(true, ret.deviceName.empty()); + EXPECT_EQ(true, ret.deviceType.empty()); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_GetRemoteNodesBasicInfo_002 + * @tc.desc: test SoftBusAdapter GetRemoteNodesBasicInfo. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_GetLocalBasicInfo_002, TestSize.Level1) +{ + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->GetRemoteNodesBasicInfo(); + EXPECT_EQ(true, ret.empty()); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_UpdateRelationship_001 + * @tc.desc: test SoftBusAdapter UpdateRelationship. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_UpdateRelationship_001, TestSize.Level1) +{ + std::string networdId01 = "networdId01"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_ONLINE); + auto ret = softBusAdapter->ToNodeID(""); + EXPECT_EQ(networdId01, ret); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_OFFLINE); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_UpdateRelationship_002 + * @tc.desc: test SoftBusAdapter UpdateRelationship. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_UpdateRelationship_002, TestSize.Level1) +{ + std::string networdId01 = "networdId01"; + std::string networdId02 = "networdId02"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_ONLINE); + softBusAdapter->UpdateRelationship(networdId02, DeviceChangeType::DEVICE_ONLINE); + softBusAdapter->UpdateRelationship(networdId02, DeviceChangeType::DEVICE_OFFLINE); + auto ret = softBusAdapter->ToNodeID(""); + EXPECT_EQ(networdId01, ret); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_OFFLINE); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_UpdateRelationship_003 + * @tc.desc: test SoftBusAdapter UpdateRelationship. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_UpdateRelationship_003, TestSize.Level1) +{ + std::string networdId01 = "networdId01"; + std::string networdId02 = "networdId02"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_ONLINE); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_ONLINE); + auto ret = softBusAdapter->ToNodeID(""); + EXPECT_EQ(networdId01, ret); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_OFFLINE); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_UpdateRelationship_004 + * @tc.desc: test SoftBusAdapter UpdateRelationship. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_UpdateRelationship_004, TestSize.Level1) +{ + std::string networdId01 = "networdId01"; + std::string networdId02 = "networdId02"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_ONLINE); + softBusAdapter->UpdateRelationship(networdId02, DeviceChangeType::DEVICE_OFFLINE); + auto ret = softBusAdapter->ToNodeID(""); + EXPECT_EQ(networdId01, ret); + softBusAdapter->UpdateRelationship(networdId01, DeviceChangeType::DEVICE_OFFLINE); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_RemoveSessionServerAdapter_001 + * @tc.desc: test SoftBusAdapter RemoveSessionServerAdapter. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_RemoveSessionServerAdapter_001, TestSize.Level1) +{ + std::string sessionName = "sessionName01"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->RemoveSessionServerAdapter(sessionName); + EXPECT_EQ(SUCCESS, ret); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_GetDeviceList_001 + * @tc.desc: test SoftBusAdapter GetLocalDevice. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_GetDeviceList_001, TestSize.Level1) +{ + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->GetDeviceList(); + EXPECT_EQ(true, ret.empty()); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_GetLocalDevice_001 + * @tc.desc: test SoftBusAdapter GetLocalDevice. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_GetLocalDevice_001, TestSize.Level1) +{ + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->GetLocalDevice(); + EXPECT_EQ(true, ret.deviceId.empty()); + EXPECT_EQ(true, ret.deviceName.empty()); + EXPECT_EQ(true, ret.deviceType.empty()); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_GetSessionStatus_001 + * @tc.desc: test SoftBusAdapter GetSessionStatus. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_GetSessionStatus_001, TestSize.Level1) +{ + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + int32_t sessionId = 123; + int32_t status = -1; + softBusAdapter->OnSessionOpen(sessionId, status); + auto ret = softBusAdapter->GetSessionStatus(sessionId); + EXPECT_EQ(status, ret); + softBusAdapter->OnSessionClose(sessionId); + delete softBusAdapter; +} + +/** + * @tc.name: SoftBusAdapter_GetUdidByNodeId_001 + * @tc.desc: test SoftBusAdapter GetSessionStatus. + * @tc.type: FUNC + */ +HWTEST_F(NativeCommunicatorTest, SoftBusAdapter_GetUdidByNodeId_001, TestSize.Level1) +{ + std::string nodeId = "nodeId01"; + SoftBusAdapter *softBusAdapter = new SoftBusAdapter(); + auto ret = softBusAdapter->GetUdidByNodeId(nodeId); + EXPECT_EQ(true, ret.empty()); + delete softBusAdapter; +} +} \ No newline at end of file diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/src/object_store_test.cpp b/data_object/frameworks/innerkitsimpl/test/unittest/src/object_store_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4effc12b380c26120e441d801bfd00d5015a42c9 --- /dev/null +++ b/data_object/frameworks/innerkitsimpl/test/unittest/src/object_store_test.cpp @@ -0,0 +1,1172 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include +#include + +#include "auto_launch_export.h" +#include "flat_object_store.h" +#include "flat_object_storage_engine.h" +#include "distributed_object.h" +#include "distributed_objectstore.h" +#include "distributed_objectstore_impl.h" +#include "hilog/log.h" +#include "kv_store_delegate_manager.h" +#include "object_storage_engine.h" +#include "objectstore_errors.h" +#include "store_observer.h" +#include "ipc_skeleton.h" +#include "accesstoken_kit.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" + +using namespace testing::ext; +using namespace OHOS::ObjectStore; +using namespace OHOS::Security::AccessToken; +using namespace OHOS::HiviewDFX; +namespace { +constexpr static double SALARY = 100.5; +constexpr HiLogLabel LABEL = { LOG_CORE, 0, "DistributedTest" }; +class TableWatcherImpl : public TableWatcher { +public: + explicit TableWatcherImpl(const std::string &sessionId) : TableWatcher(sessionId) {} + void OnChanged(const std::string &sessionid, const std::vector &changedData) override; + virtual ~TableWatcherImpl(); +}; + +TableWatcherImpl::~TableWatcherImpl() {} +void TableWatcherImpl::OnChanged(const std::string &sessionid, const std::vector &changedData) {} + +class StatusNotifierImpl : public StatusWatcher { +public: + void OnChanged( + const std::string &sessionId, const std::string &networkId, const std::string &onlineStatus) override; + virtual ~StatusNotifierImpl(); +}; +StatusNotifierImpl::~StatusNotifierImpl() {} + +void StatusNotifierImpl::OnChanged(const std::string &sessionId, + const std::string &networkId, + const std::string &onlineStatus) +{ +} +static void TestSetSessionId(std::string bundleName, std::string sessionId) +{ + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + uint32_t ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +static void TestSaveAndRevokeSave(std::string bundleName, std::string sessionId) +{ + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + uint32_t ret = object->PutString("name", "zhangsan"); + EXPECT_EQ(SUCCESS, ret); + ret = object->PutDouble("salary", SALARY); + EXPECT_EQ(SUCCESS, ret); + ret = object->PutBoolean("isTrue", true); + EXPECT_EQ(SUCCESS, ret); + + ret = object->Save("local"); + EXPECT_EQ(SUCCESS, ret); + ret = object->RevokeSave(); + EXPECT_EQ(SUCCESS, ret); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +void GrantPermissionNative() +{ + const char **perms = new const char *[2]; + perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; + perms[1] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER"; + TokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = 2, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .processName = "distributed_object", + .aplStr = "system_basic", + }; + uint64_t tokenId = GetAccessTokenId(&infoInstance); + SetSelfTokenID(tokenId); + AccessTokenKit::ReloadNativeTokenInfo(); +} + +class NativeObjectStoreTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void NativeObjectStoreTest::SetUpTestCase(void) +{ + // input testsuit setup step，setup invoked before all testcases +} + +void NativeObjectStoreTest::TearDownTestCase(void) +{ + // input testsuit teardown step，teardown invoked after all testcases +} + +void NativeObjectStoreTest::SetUp(void) +{ + // input testcase setup step，setup invoked before each testcases + GrantPermissionNative(); +} + +void NativeObjectStoreTest::TearDown(void) +{ + // input testcase teardown step，teardown invoked after each testcases +} + +/** + * @tc.name: DistributedObjectStore_Create_Destroy_001 + * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + uint32_t ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObjectStore_Create_Destroy_002 + * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_002, TestSize.Level1) +{ + std::string sessionId = "123456"; + + auto objectStore = new DistributedObjectStoreImpl(nullptr); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_EQ(nullptr, object); + delete objectStore; +} + +/** + * @tc.name: DistributedObjectStore_Create_Destroy_003 + * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_003, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + DistributedObject *object2 = objectStore->CreateObject(sessionId); + EXPECT_EQ(nullptr, object2); + + uint32_t ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObjectStore_Create_Destroy_004 + * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_004, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + + uint32_t status = -1; + DistributedObject *object = objectStore->CreateObject(sessionId, status); + EXPECT_NE(nullptr, object); + EXPECT_EQ(SUCCESS, status); + + uint32_t ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObjectStore_Get_001 + * @tc.desc: test DistributedObjectStore Get. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Get_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + DistributedObject *object2 = nullptr; + uint32_t ret = objectStore->Get(sessionId, &object2); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(object, object2); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObjectStore_Watch_UnWatch_001 + * @tc.desc: test DistributedObjectStore Watch and UnWatch. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Watch_UnWatch_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + auto watcherPtr = std::shared_ptr(); + uint32_t ret = objectStore->Watch(object, watcherPtr); + EXPECT_EQ(SUCCESS, ret); + + ret = objectStore->UnWatch(object); + EXPECT_EQ(SUCCESS, ret); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObjectStore_SetStatusNotifier_001 + * @tc.desc: test DistributedObjectStore SetStatusNotifier. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_SetStatusNotifier_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + auto notifierPtr = std::shared_ptr(); + uint32_t ret = objectStore->SetStatusNotifier(notifierPtr); + EXPECT_EQ(ret, 0); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name: DistributedObject_Double_001 + * @tc.desc: test DistributedObjectStore PutDouble. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_Double_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + uint32_t ret = object->PutDouble("salary", SALARY); + EXPECT_EQ(ret, 0); + + double value = 0.0; + object->GetDouble("salary", value); + EXPECT_EQ(ret, 0); + EXPECT_EQ(value, SALARY); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name: DistributedObject_Boolean_001 + * @tc.desc: test DistributedObjectStore PutBoolean. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_Boolean_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + uint32_t ret = object->PutBoolean("isTrue", true); + EXPECT_EQ(SUCCESS, ret); + + bool value = false; + ret = object->GetBoolean("isTrue", value); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(true, value); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_String_001 + * @tc.desc: test DistributedObjectStore String. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_String_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + uint32_t ret = object->PutString("name", "zhangsan"); + EXPECT_EQ(SUCCESS, ret); + + std::string value = ""; + ret = object->GetString("name", value); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(value, "zhangsan"); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_GetSessionId_001 + * @tc.desc: test DistributedObjectStore GetSessionId. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetSessionId_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + std::string getSessionId = object->GetSessionId(); + EXPECT_EQ(sessionId, getSessionId); + uint32_t ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_TestSetSessionId_001 + * @tc.desc: test DistributedObjectStore TestSetSessionId. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_TestSetSessionId_001, TestSize.Level1) +{ + std::thread t1(TestSetSessionId, "default1", "session1"); + std::thread t2(TestSetSessionId, "default2", "session2"); + std::thread t3(TestSetSessionId, "default3", "session3"); + t1.join(); + t2.join(); + t3.join(); +} + +/** + * @tc.name: DistributedObject_GetType_001 + * @tc.desc: test DistributedObject GetType. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetType_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + + uint32_t ret = object->PutString("name", "zhangsan"); + EXPECT_EQ(SUCCESS, ret); + Type type; + ret = object->GetType("name", type); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(TYPE_STRING, type); + + ret = object->PutDouble("salary", SALARY); + EXPECT_EQ(SUCCESS, ret); + ret = object->GetType("salary", type); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(TYPE_DOUBLE, type); + + ret = object->PutBoolean("isTrue", true); + EXPECT_EQ(SUCCESS, ret); + ret = object->GetType("isTrue", type); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(TYPE_BOOLEAN, type); + + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_Save_RevokeSave_001 + * @tc.desc: test DistributedObjectStore Save. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_Save_RevokeSave_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + TestSaveAndRevokeSave(bundleName, sessionId); +} + +/** + * @tc.name: DistributedObject_Save_RevokeSave_002 + * @tc.desc: test DistributedObjectStore Save. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_Save_RevokeSave_002, TestSize.Level1) +{ + std::thread t1(TestSaveAndRevokeSave, "default1", "session1"); + std::thread t2(TestSaveAndRevokeSave, "default2", "session2"); + std::thread t3(TestSaveAndRevokeSave, "default3", "session3"); + t1.join(); + t2.join(); + t3.join(); +} + +/** + * @tc.name: DistributedObject_Open_001 + * @tc.desc: test ObjectStorageEngine Open, calling Open repeatedly. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_Open_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_CreateTable_001 + * @tc.desc: test ObjectStorageEngine CreateTable. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_CreateTable_002 + * @tc.desc: test ObjectStorageEngine CreateTable, calling CreateTable() repeatedly. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_002, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_NE(SUCCESS, ret); + ret = objectStorageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_CreateTable_003 + * @tc.desc: test ObjectStorageEngine CreateTable, calling CreateTable after calling Close(). + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_003, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->Close(); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_NE(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_GetTable_001 + * @tc.desc: test ObjectStorageEngine GetTable, not calling Open(). + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_001, TestSize.Level1) +{ + std::string sessionId = "session01"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + std::map result = {}; + uint32_t ret = objectStorageEngine->GetTable(sessionId, result); + EXPECT_NE(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_GetTable_002 + * @tc.desc: test ObjectStorageEngine GetTable, calling Open(),but not calling CreateTable(). + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_002, TestSize.Level1) +{ + std::string bundleName = "default02"; + std::string sessionId = "session02"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + std::map result = {}; + ret = objectStorageEngine->GetTable(sessionId, result); + EXPECT_NE(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_GetTable_003 + * @tc.desc: test ObjectStorageEngine GetTable, calling Open() and CreateTable(), but not calling UpdateItem(). + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_003, TestSize.Level1) +{ + std::string bundleName = "default03"; + std::string sessionId = "session03"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + std::map result = {}; + ret = objectStorageEngine->GetTable(sessionId, result); + EXPECT_NE(SUCCESS, ret); + ret = objectStorageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_GetTable_004 + * @tc.desc: test ObjectStorageEngine GetTable. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_004, TestSize.Level1) +{ + std::string bundleName = "default04"; + std::string sessionId = "session04"; + std::vector value = { 1, 8 }; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->UpdateItem(sessionId, "age", value); + EXPECT_EQ(SUCCESS, ret); + std::map result = {}; + ret = objectStorageEngine->GetTable(sessionId, result); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: FlatObjectStore_FilterData_001 + * @tc.desc: test FlatObjectStore FilterData. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_FilterData_001, TestSize.Level1) +{ + std::string bundleName = "default05"; + std::string sessionId = "session05"; + std::vector value = { 1, 8 }; + FlatObjectStore *flatObjectStore = new FlatObjectStore(bundleName); + uint32_t ret = flatObjectStore->CreateObject(sessionId); + EXPECT_EQ(SUCCESS, ret); + ret = flatObjectStore->Put(sessionId, "phone", value); + EXPECT_EQ(SUCCESS, ret); + ret = flatObjectStore->Put(sessionId, "age", value); + EXPECT_EQ(SUCCESS, ret); + std::map> data = { { "age", value }, { "age", value } }; + auto dataSize = data.size(); + flatObjectStore->FilterData(sessionId, data); + EXPECT_GT(dataSize, data.size()); + ret = flatObjectStore->Delete(sessionId); + EXPECT_EQ(SUCCESS, ret); + delete flatObjectStore; +} + +/** + * @tc.name: FlatObjectStore_UpdateItems_001 + * @tc.desc: test ObjectStorageEngine UpdateItems. input data is empty. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_001, TestSize.Level1) +{ + std::string bundleName = "default06"; + std::string sessionId = "session06"; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + std::map> data = {}; + ret = objectStorageEngine->UpdateItems(sessionId, data); + EXPECT_NE(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: FlatObjectStore_UpdateItems_002 + * @tc.desc: test FlatObjectStore FilterData. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_002, TestSize.Level1) +{ + std::string bundleName = "default07"; + std::string sessionId = "session07"; + std::vector value = { 1, 8 }; + ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + std::map> data = { { "age", value } }; + ret = objectStorageEngine->UpdateItems(sessionId, data); + EXPECT_EQ(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_OpenAndClose_001 + * @tc.desc: test FlatObjectStorageEngine OpenAndClose and Close when FlatObjectStorageEngine is not open. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_OpenAndClose_001, TestSize.Level1) +{ + std::string bundleName = "default07"; + FlatObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine(); + uint32_t ret = objectStorageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = objectStorageEngine->Close(); + EXPECT_EQ(SUCCESS, ret); + objectStorageEngine->isOpened_ = false; + ret = objectStorageEngine->Close(); + EXPECT_EQ(SUCCESS, ret); + delete objectStorageEngine; +} + +/** + * @tc.name: DistributedObject_NotifyChange_001 + * @tc.desc: test FlatObjectStorageEngine NotifyChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyChange_001, TestSize.Level1) +{ + std::string bundleName = "default07"; + std::string sessionId = "session07"; + std::shared_ptr storageEngine = std::make_shared(); + uint32_t ret = storageEngine->Open(bundleName); + ret = storageEngine->CreateTable(sessionId); + EXPECT_EQ(SUCCESS, ret); + std::map> filteredData; + storageEngine->NotifyChange(sessionId, filteredData); + ret = storageEngine->Close(); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_CheckRetrieveCache_001 + * @tc.desc: test FlatObjectStore CheckRetrieveCache. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_CheckRetrieveCache_001, TestSize.Level1) +{ + std::string sessionId = "session05"; + std::string bundleName = "default07"; + std::shared_ptr flatObjectStore = std::make_shared(bundleName); + uint32_t ret = flatObjectStore->CreateObject(sessionId); + EXPECT_EQ(SUCCESS, ret); + flatObjectStore->CheckRetrieveCache(sessionId); + ret = flatObjectStore->Delete(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_SyncAllData_001 + * @tc.desc: test FlatObjectStore SyncAllData. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_SyncAllData_001, TestSize.Level1) +{ + std::string sessionId = "session258"; + std::string bundleName = "default07"; + std::shared_ptr flatObjectStore = std::make_shared(bundleName); + uint32_t ret = flatObjectStore->CreateObject(sessionId); + EXPECT_EQ(SUCCESS, ret); + auto onComplete = [sessionId](const std::map &devices) { + for (auto item : devices) { + HiLog::Info(LABEL, "%{public}s pull data result %{public}d in device %{public}s", sessionId.c_str(), + item.second, (item.first).c_str()); + } + }; + ret = flatObjectStore->SyncAllData(sessionId, onComplete); + EXPECT_EQ(ERR_SINGLE_DEVICE, ret); + ret = flatObjectStore->SyncAllData("", onComplete); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); + ret = flatObjectStore->Delete(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_NotifyCachedStatus_001 + * @tc.desc: test DistributedObjectStore NotifyCachedStatus. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyCachedStatus_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + uint32_t status = 0; + DistributedObject *object = objectStore->CreateObject(sessionId, status); + EXPECT_NE(nullptr, object); + EXPECT_EQ(SUCCESS, status); + objectStore->NotifyCachedStatus(sessionId); + uint32_t ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_UnWatch_001 + * @tc.desc: test DistributedObjectStore UnWatch, DistributedObject is nullptr. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UnWatch_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName); + EXPECT_NE(nullptr, objectStore); + DistributedObject *object = objectStore->CreateObject(sessionId); + EXPECT_NE(nullptr, object); + uint32_t ret = objectStore->UnWatch(nullptr); + EXPECT_EQ(ERR_NULL_OBJECT, ret); + ret = objectStore->DeleteObject(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_OnComplete_001 + * @tc.desc: test FlatObjectStore OnComplete. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_OnComplete_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + uint32_t ret = storageEngine->Open(bundleName); + EXPECT_EQ(SUCCESS, ret); + ret = storageEngine->CreateTable(sessionId); + std::shared_ptr statusWatcher = std::make_shared(); + DistributedDB::DBStatus status = DistributedDB::DBStatus::OK; + std::map devices = { { sessionId, status } }; + storageEngine->OnComplete(sessionId, devices, statusWatcher); + ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_CreateTable_004 + * @tc.desc: test FlatObjectStorageEngine CreateTable, sessionId is empty. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_004, TestSize.Level1) +{ + std::string bundleName = "default"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + uint32_t ret = storageEngine->CreateTable(""); + EXPECT_EQ(ERR_DB_GETKV_FAIL, ret); +} + +/** + * @tc.name: DistributedObject_GetTable_005 + * @tc.desc: test FlatObjectStorageEngine GetTable, storageEngine is not open or sessionId is empty. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_005, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + std::map tableResult; + storageEngine->isOpened_ = false; + uint32_t ret = storageEngine->GetTable(sessionId, tableResult); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); + storageEngine->isOpened_ = true; + ret = storageEngine->GetTable("", tableResult); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); + storageEngine->DeleteTable(sessionId); +} + +/** + * @tc.name: DistributedObject_UpdateItem_003 + * @tc.desc: test FlatObjectStorageEngine UpdateItem, storageEngine is not open or error sessionid. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItem_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + storageEngine->isOpened_ = false; + std::vector value = { 1, 8 }; + uint32_t ret = storageEngine->UpdateItem(sessionId, "age", value); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); + storageEngine->isOpened_ = true; + ret = storageEngine->UpdateItem("123", "age", value); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); + storageEngine->DeleteTable(sessionId); +} + +/** + * @tc.name: DistributedObject_UpdateItems_004 + * @tc.desc: test FlatObjectStorageEngine UpdateItems, storageEngine is not open or error sessionid. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_003, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + storageEngine->isOpened_ = false; + std::vector value = { 1, 8 }; + std::map> data = { { "age", value } }; + uint32_t ret = storageEngine->UpdateItems(sessionId, data); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); + + storageEngine->isOpened_ = true; + ret = storageEngine->UpdateItems("123", data); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); + storageEngine->DeleteTable(sessionId); +} + +/** + * @tc.name: DistributedObject_DeleteTable_001 + * @tc.desc: test FlatObjectStorageEngine DeleteTable, storageEngine is not open or error sessionid. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_DeleteTable_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + storageEngine->isOpened_ = false; + uint32_t ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); + storageEngine->isOpened_ = true; + ret = storageEngine->DeleteTable("123"); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); + storageEngine->DeleteTable(sessionId); +} + +/** + * @tc.name: DistributedObject_GetItem_002 + * @tc.desc: test FlatObjectStorageEngine GetItem, storageEngine is not open or error key. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItem_002, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + storageEngine->isOpened_ = false; + std::vector value = { 1, 8 }; + uint32_t ret = storageEngine->GetItem(sessionId, "", value); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); + storageEngine->Open(bundleName); + ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_GetItem_003 + * @tc.desc: test FlatObjectStorageEngine GetItem, error key. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItem_003, TestSize.Level1) +{ + std::string sessionId = "123456"; + std::string bundleName = "default"; + std::shared_ptr storageEngine = std::make_shared(); + std::vector value = { 1, 8 }; + storageEngine->Open(bundleName); + uint32_t ret = storageEngine->GetItem(sessionId, "123", value); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); +} + +/** + * @tc.name: DistributedObject_RegisterObserver_001 + * @tc.desc: test FlatObjectStorageEngine RegisterObserver, storageEngine is not open. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_001, TestSize.Level1) +{ + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->isOpened_ = false; + auto tableWatcherPtr = std::make_shared(sessionId); + uint32_t ret = storageEngine->RegisterObserver(sessionId, tableWatcherPtr); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); +} + +/** + * @tc.name: DistributedObject_RegisterObserver_002 + * @tc.desc: test FlatObjectStorageEngine RegisterObserver, empty sessionId. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_002, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + auto tableWatcherPtr = std::make_shared(sessionId); + uint32_t ret = storageEngine->RegisterObserver("", tableWatcherPtr); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); + ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_RegisterObserver_003 + * @tc.desc: test FlatObjectStorageEngine RegisterObserver, repeat RegisterObserver. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_003, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + auto tableWatcherPtr = std::make_shared(sessionId); + // RegisterObserver observer already exist + uint32_t ret = storageEngine->RegisterObserver(sessionId, tableWatcherPtr); + EXPECT_EQ(SUCCESS, ret); + storageEngine->RegisterObserver(sessionId, tableWatcherPtr); + EXPECT_EQ(SUCCESS, ret); + ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_UnRegisterObserver_001 + * @tc.desc: test FlatObjectStorageEngine UnRegisterObserver, storageEngine is not open. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UnRegisterObserver_001, TestSize.Level1) +{ + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->isOpened_ = false; + uint32_t ret = storageEngine->UnRegisterObserver(sessionId); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); +} + +/** + * @tc.name: DistributedObject_UnRegisterObserver_001 + * @tc.desc: test FlatObjectStorageEngine UnRegisterObserver, empty sessionId. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UnRegisterObserver_002, TestSize.Level1) +{ + std::string bundleName = "default"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + uint32_t ret = storageEngine->UnRegisterObserver(""); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); +} + +/** + * @tc.name: DistributedObject_SetStatusNotifier_002 + * @tc.desc: test FlatObjectStorageEngine SetStatusNotifier. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_SetStatusNotifier_002, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + auto statusNotifier = std::make_shared(); + uint32_t ret = storageEngine->SetStatusNotifier(statusNotifier); + EXPECT_EQ(SUCCESS, ret); + ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_SetStatusNotifier_003 + * @tc.desc: test FlatObjectStorageEngine SetStatusNotifier, storageEngine is not open. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_SetStatusNotifier_003, TestSize.Level1) +{ + std::shared_ptr storageEngine = std::make_shared(); + auto statusNotifier = std::make_shared(); + storageEngine->isOpened_ = false; + uint32_t ret = storageEngine->SetStatusNotifier(statusNotifier); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); +} + +/** + * @tc.name: DistributedObject_GetItems_001 + * @tc.desc: test FlatObjectStorageEngine GetItems, storageEngine is not open or error key. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItems_001, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + storageEngine->isOpened_ = false; + std::vector value = { 1, 8 }; + std::map> data = { { "age", value } }; + uint32_t ret = storageEngine->GetItems(sessionId, data); + EXPECT_EQ(ERR_DB_NOT_INIT, ret); + storageEngine->Open(bundleName); + ret = storageEngine->GetItems("", data); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); + ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_NotifyStatus_001 + * @tc.desc: test FlatObjectStorageEngine NotifyStatus. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyStatus_001, TestSize.Level1) +{ + std::string bundleName = "default07"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + uint32_t ret = storageEngine->Open(bundleName); + storageEngine->NotifyStatus(sessionId, "local", "restored"); + ret = storageEngine->Close(); + EXPECT_EQ(SUCCESS, ret); +} + +/** + * @tc.name: DistributedObject_SyncAllData_002 + * @tc.desc: test FlatObjectStorageEngine SyncAllData. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_SyncAllData_002, TestSize.Level1) +{ + std::shared_ptr storageEngine = std::make_shared(); + auto onComplete = [](const std::map &) {}; + std::vector deviceIds = { "deviceIds" }; + uint32_t ret = storageEngine->SyncAllData("", deviceIds, onComplete); + EXPECT_EQ(ERR_DB_NOT_EXIST, ret); +} + +/** + * @tc.name: DistributedObject_UpdateItem_002 + * @tc.desc: test FlatObjectStorageEngine UpdateItem, error status. + * @tc.type: FUNC + */ +HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItem_002, TestSize.Level1) +{ + std::string bundleName = "default"; + std::string sessionId = "123456"; + std::shared_ptr storageEngine = std::make_shared(); + storageEngine->Open(bundleName); + storageEngine->CreateTable(sessionId); + std::vector value = { 1, 2 }; + uint32_t ret = storageEngine->UpdateItem(sessionId, std::string(1025, 't'), value); + EXPECT_EQ(ERR_CLOSE_STORAGE, ret); + ret = storageEngine->DeleteTable(sessionId); + EXPECT_EQ(SUCCESS, ret); +} +} // namespace diff --git a/data_object/frameworks/innerkitsimpl/test/unittest/src/process_communicator_impl_test.cpp b/data_object/frameworks/innerkitsimpl/test/unittest/src/process_communicator_impl_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2a16bf5b60600d08408c8fc1e0a6d24e1021c5cb --- /dev/null +++ b/data_object/frameworks/innerkitsimpl/test/unittest/src/process_communicator_impl_test.cpp @@ -0,0 +1,212 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "process_communicator_impl.h" + +#include +#include +#include + +#include "app_types.h" +#include "auto_launch_export.h" +#include "ipc_skeleton.h" +#include "objectstore_errors.h" + +namespace { +using namespace testing::ext; +using namespace OHOS::ObjectStore; + +static constexpr uint32_t MTU_SIZE = 4096 * 1024; + +class NativeProcessCommunicatorImplTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void NativeProcessCommunicatorImplTest::SetUpTestCase(void) +{ + // input testsuit setup step，setup invoked before all testcases +} + +void NativeProcessCommunicatorImplTest::TearDownTestCase(void) +{ + // input testsuit teardown step，teardown invoked after all testcases +} + +void NativeProcessCommunicatorImplTest::SetUp(void) +{ + // input testcase setup step，setup invoked before each testcases +} + +void NativeProcessCommunicatorImplTest::TearDown(void) +{ + // input testcase teardown step，teardown invoked after each testcases +} + +/** + * @tc.name: ProcessCommunicatorImpl_Start_Stop_001 + * @tc.desc: test ProcessCommunicatorImpl Start and Stop. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_Start_Stop_001, TestSize.Level1) +{ + std::string processLabel = "INVALID_SESSION_NAME"; + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + auto ret = processCommunicator->Start(processLabel); + EXPECT_EQ(DistributedDB::DBStatus::DB_ERROR, ret); + ret = processCommunicator->Stop(); + EXPECT_EQ(DistributedDB::DBStatus::DB_ERROR, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_RegOnDeviceChange_001 + * @tc.desc: test ProcessCommunicatorImpl RegOnDeviceChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_RegOnDeviceChange_001, TestSize.Level1) +{ + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + auto ret = + processCommunicator->RegOnDeviceChange([](const DistributedDB::DeviceInfos &devInfo, bool isOnline) -> void { + return; + }); + EXPECT_EQ(DistributedDB::DBStatus::OK, ret); + ret = processCommunicator->RegOnDeviceChange(nullptr); + EXPECT_EQ(DistributedDB::DBStatus::OK, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_RegOnDeviceChange_002 + * @tc.desc: test ProcessCommunicatorImpl RegOnDeviceChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_RegOnDeviceChange_002, TestSize.Level1) +{ + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + auto ret = + processCommunicator->RegOnDeviceChange([](const DistributedDB::DeviceInfos &devInfo, bool isOnline) -> void { + return; + }); + EXPECT_EQ(DistributedDB::DBStatus::OK, ret); + ret = processCommunicator->RegOnDeviceChange([](const DistributedDB::DeviceInfos &devInfo, bool isOnline) -> void { + return; + }); + EXPECT_EQ(DistributedDB::DBStatus::DB_ERROR, ret); + ret = processCommunicator->RegOnDeviceChange(nullptr); + EXPECT_EQ(DistributedDB::DBStatus::OK, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_RegOnDeviceChange_003 + * @tc.desc: test ProcessCommunicatorImpl RegOnDeviceChange. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_RegOnDeviceChange_003, TestSize.Level1) +{ + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + auto ret = + processCommunicator->RegOnDeviceChange([](const DistributedDB::DeviceInfos &devInfo, bool isOnline) -> void { + return; + }); + EXPECT_EQ(DistributedDB::DBStatus::OK, ret); + ret = processCommunicator->RegOnDeviceChange(nullptr); + EXPECT_EQ(DistributedDB::DBStatus::OK, ret); + ret = processCommunicator->RegOnDeviceChange(nullptr); + EXPECT_EQ(DistributedDB::DBStatus::DB_ERROR, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_RegOnDataReceive_001 + * @tc.desc: test ProcessCommunicatorImpl RegOnDataReceive. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_RegOnDataReceive_001, TestSize.Level1) +{ + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + auto ret = processCommunicator->RegOnDataReceive( + [](const DistributedDB::DeviceInfos &srcDevInfo, const uint8_t *data, uint32_t length) -> void { + return; + }); + EXPECT_EQ(DistributedDB::DBStatus::DB_ERROR, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_RegOnDataReceive_002 + * @tc.desc: test ProcessCommunicatorImpl RegOnDataReceive. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_RegOnDataReceive_002, TestSize.Level1) +{ + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + auto ret = processCommunicator->RegOnDataReceive(nullptr); + EXPECT_EQ(DistributedDB::DBStatus::DB_ERROR, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_SendData_001 + * @tc.desc: test ProcessCommunicatorImpl SendData. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_SendData_001, TestSize.Level1) +{ + std::string processLabel = "processLabel01"; + DistributedDB::DeviceInfos deviceInfos = { "identifier" }; + uint8_t data = 1; + uint32_t length = 1; + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + auto ret = processCommunicator->SendData(deviceInfos, &data, length); + EXPECT_EQ(DistributedDB::DBStatus::DB_ERROR, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_GetMtuSize_001 + * @tc.desc: test ProcessCommunicatorImpl GetMtuSize. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, ProcessCommunicatorImpl_GetMtuSize_001, TestSize.Level1) +{ + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + DistributedDB::DeviceInfos deviceInfos = { "identifier" }; + auto ret = processCommunicator->GetMtuSize(deviceInfos); + EXPECT_EQ(MTU_SIZE, ret); + ret = processCommunicator->GetMtuSize(); + EXPECT_EQ(MTU_SIZE, ret); + delete processCommunicator; +} + +/** + * @tc.name: ProcessCommunicatorImpl_IsSameProcessLabelStartedOnPeerDevice_001 + * @tc.desc: test ProcessCommunicatorImpl IsSameProcessLabelStartedOnPeerDevice. + * @tc.type: FUNC + */ +HWTEST_F(NativeProcessCommunicatorImplTest, IsSameProcessLabelStartedOnPeerDevice_001, TestSize.Level1) +{ + ProcessCommunicatorImpl *processCommunicator = new ProcessCommunicatorImpl(); + DistributedDB::DeviceInfos deviceInfos = { "identifier" }; + auto ret = processCommunicator->IsSameProcessLabelStartedOnPeerDevice(deviceInfos); + EXPECT_EQ(false, ret); + delete processCommunicator; +} +} diff --git a/data_object/frameworks/jskitsimpl/src/adaptor/js_module_init.cpp b/data_object/frameworks/jskitsimpl/src/adaptor/js_module_init.cpp index 5c68ed568a822b76b11bd19dddb2e2949838c54d..9dfe1b264eb7566e4e966a35d219964873081dff 100644 --- a/data_object/frameworks/jskitsimpl/src/adaptor/js_module_init.cpp +++ b/data_object/frameworks/jskitsimpl/src/adaptor/js_module_init.cpp @@ -1,17 +1,17 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +* Copyright (c) 2022 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ #include "js_common.h" #include "js_distributedobjectstore.h" @@ -28,30 +28,30 @@ using namespace OHOS::ObjectStore; static napi_value DistributedDataObjectExport(napi_env env, napi_value exports) { - napi_status status; - static napi_property_descriptor desc[] = { - DECLARE_NAPI_FUNCTION("createObjectSync", JSDistributedObjectStore::JSCreateObjectSync), - DECLARE_NAPI_FUNCTION("destroyObjectSync", JSDistributedObjectStore::JSDestroyObjectSync), - DECLARE_NAPI_FUNCTION("on", JSDistributedObjectStore::JSOn), - DECLARE_NAPI_FUNCTION("off", JSDistributedObjectStore::JSOff), - DECLARE_NAPI_FUNCTION("recordCallback", JSDistributedObjectStore::JSRecordCallback), - DECLARE_NAPI_FUNCTION("deleteCallback", JSDistributedObjectStore::JSDeleteCallback), - }; + napi_status status; + static napi_property_descriptor desc[] = { + DECLARE_NAPI_FUNCTION("createObjectSync", JSDistributedObjectStore::JSCreateObjectSync), + DECLARE_NAPI_FUNCTION("destroyObjectSync", JSDistributedObjectStore::JSDestroyObjectSync), + DECLARE_NAPI_FUNCTION("on", JSDistributedObjectStore::JSOn), + DECLARE_NAPI_FUNCTION("off", JSDistributedObjectStore::JSOff), + DECLARE_NAPI_FUNCTION("recordCallback", JSDistributedObjectStore::JSRecordCallback), + DECLARE_NAPI_FUNCTION("deleteCallback", JSDistributedObjectStore::JSDeleteCallback), + }; - status = napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); - CHECK_EQUAL_WITH_RETURN_NULL(status, napi_ok); - return exports; + status = napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); + CHECK_EQUAL_WITH_RETURN_NULL(status, napi_ok); + return exports; } // storage module define static napi_module storageModule = { - .nm_version = 1, - .nm_flags = 0, - .nm_filename = nullptr, - .nm_register_func = DistributedDataObjectExport, - .nm_modname = "data.distributedDataObject", - .nm_priv = ((void *)0), - .reserved = { 0 }, + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = DistributedDataObjectExport, + .nm_modname = "data.distributedDataObject", + .nm_priv = ((void *)0), + .reserved = { 0 }, }; // distributed_data_object.js @@ -82,5 +82,5 @@ static napi_module storageModule = { // distributeddataobject module register static __attribute__((constructor)) void RegisterModule() { - napi_module_register(&storageModule); + napi_module_register(&storageModule); } \ No newline at end of file diff --git a/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunit.test.js b/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunit.test.js index 85166bafa3ce4eeb9182af60d2f258df7a6db8bf..62314158628a6944b8f0a24922a8f7760a3690e0 100644 --- a/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunit.test.js +++ b/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunit.test.js @@ -768,7 +768,7 @@ describe('objectStoreTest',function () { g_object.on("status", statusCallback4); g_object.setSessionId("123456"); - + g_object.setSessionId(""); console.log(TAG + "************* OnstatusRestored001 end *************"); }) diff --git a/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunitV9.test.js b/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunitV9.test.js index 9d42284ab136394c044b90f75e55f9ab30f92b36..166ca74cf8c5b747e26713f02e916d86e80d7787 100644 --- a/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunitV9.test.js +++ b/data_object/frameworks/jskitsimpl/test/unittest/src/ObjectStoreJsunitV9.test.js @@ -12,7 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'; +import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it} from 'deccjsunit/index'; import distributedObject from '@ohos.data.distributedDataObject'; import abilityAccessCtrl from '@ohos.abilityAccessCtrl'; import featureAbility from '@ohos.ability.featureAbility'; @@ -53,7 +53,7 @@ async function grantPerm() { console.info("tokenId" + tokenID + " result:" + result); console.info("====grant Permission end===="); } -describe('objectStoreTest',function () { +describe('objectStoreTest', function () { beforeAll(async function (done) { await grantPerm(); done(); @@ -80,33 +80,35 @@ describe('objectStoreTest',function () { * @tc.desc: object join session and on,object can receive callback when data has been changed * @tc.type: FUNC */ - it('V9testcreate001', 0, function () { + it('V9testcreate001', 0, function () { console.log(TAG + "************* V9testcreate001 start *************"); var g_object; - try{ + try { g_object = distributedObject.create(123, {name: "Amy", age: 18, isVis: false}); - } - catch (error) { + } catch (error) { console.info(error.code + error.message); expect(error.code == 401).assertEqual(true); expect(error.message == "Parameter error. The type of 'context' must be 'Context'.").assertEqual(true); } try { g_object = distributedObject.create(context, 123); - } - catch (error) { + } catch (error) { console.info(error.code + error.message); expect(error.code == 401).assertEqual(true); expect(error.message == "Parameter error. The type of 'source' must be 'object'.").assertEqual(true); } g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("123456").then((err, data) => { + g_object.setSessionId("123456").then((data) => { console.info(TAG + "V9testcreate001"); - console.info(TAG + data); + console.info(TAG + data); + }).catch((error) => { + console.info(TAG + error); }); console.log(TAG + "************* V9testcreate001 end *************"); - g_object.setSessionId(""); + g_object.setSessionId((error, data) => { + console.info(TAG + error + "," + data); + }); }) /** @@ -119,16 +121,20 @@ describe('objectStoreTest',function () { var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); try { - g_object.setSessionId(123).then((err, data) => { + g_object.setSessionId(123).then((data) => { console.info(TAG + "setSessionId test"); console.info(TAG + data); + }).catch((err) => { + console.info(TAG + err.code + err.message); }); } catch (error) { expect(error.code == 401).assertEqual(true); expect(error.message == "Parameter error. The type of 'sessionId' must be 'string'.").assertEqual(true); } console.log(TAG + "************* V9testsetSessionId001 end *************"); - g_object.setSessionId(""); + g_object.setSessionId((error, data) => { + console.info(TAG + error + "," + data); + }); }) /** @@ -149,7 +155,9 @@ describe('objectStoreTest',function () { expect(error.message == "create table failed").assertEqual(true); }); console.log(TAG + "************* V9testsetSessionId002 end *************"); - g_object.setSessionId(""); + g_object.setSessionId((error, data) => { + console.info(TAG + error + "," + data); + }); }) /** @@ -157,18 +165,55 @@ describe('objectStoreTest',function () { * @tc.desc: object join session and on,object can receive callback when data has been changed * @tc.type: FUNC */ - it('V9testsetSessionId003', 0, function () { + it('V9testsetSessionId003', 0, function () { console.log(TAG + "************* V9testsetSessionId003 start *************"); var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("123456").then((object) => { + g_object.setSessionId("123456").then((data) => { console.info(TAG + "setSessionId test"); - console.info(TAG + object); + console.info(TAG + data); + }).catch((err) => { + console.info(TAG + err.code + err.message); }); console.log(TAG + "************* V9testsetSessionId003 end *************"); - g_object.setSessionId(""); + g_object.setSessionId((error, data) => { + console.info(TAG + error + "," + data); + }); + }) + + /** + * @tc.name: V9testsetSessionId004 + * @tc.desc: object join session and on,object can receive callback when data has been changed + * @tc.type: FUNC + */ + it('V9testsetSessionId004', 0, function () { + console.log(TAG + "************* V9testsetSessionId004 start *************"); + var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); + expect(g_object == undefined).assertEqual(false); + g_object.setSessionId("123456", (error, data) => { + console.info(TAG + error + "," + data); + console.info(TAG + "setSessionId test"); + }); + g_object.setSessionId("", (error, data) => { + console.info(TAG + error + "," + data); + }); + try { + g_object.setSessionId(1234, (error, data) => { + console.info(TAG + error + "," + data); + console.info(TAG + "setSessionId test"); + }); + } catch (error) { + console.log(error.code + error.message); + expect(error.code == 401).assertEqual(true); + expect(error.message == "Parameter error. The type of 'sessionId' must be 'string'.").assertEqual(true); + } + console.log(TAG + "************* V9testsetSessionId004 end *************"); + g_object.setSessionId("", (error, data) => { + console.info(TAG + error + "," + data); + }); }) + /** * @tc.name: V9testOn001 * @tc.desc: object join session and on,object can receive callback when data has been changed @@ -176,9 +221,13 @@ describe('objectStoreTest',function () { */ it('V9testOn001', 0, function () { console.log(TAG + "************* V9testOn001 start *************"); - var g_object = distributedObject.create(context, { name: "Amy", age: 18, isVis: false }); + var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("session1"); + g_object.setSessionId("session1").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect("session1" == g_object.__sessionId).assertEqual(true); console.info(TAG + " start call watch change"); g_object.on("change", function (sessionId, changeData) { @@ -203,7 +252,9 @@ describe('objectStoreTest',function () { } console.log(TAG + "************* V9testOn001 end *************"); - g_object.setSessionId(""); + g_object.setSessionId("", (error, data) => { + console.info(TAG + error + "," + data); + }); }) /** @@ -221,6 +272,7 @@ describe('objectStoreTest',function () { try { g_object.on(123, function (sessionId, changeData) { console.info("V9testOn002 callback start."); + console.info(TAG + sessionId); if (changeData != null && changeData != undefined) { changeData.forEach(element => { console.info(TAG + "data changed !" + element); @@ -234,7 +286,9 @@ describe('objectStoreTest',function () { expect(error.message == "Parameter error. The type of 'type' must be 'string'.").assertEqual(true); } console.log(TAG + "************* V9testOn002 end *************"); - g_object.setSessionId(""); + g_object.setSessionId("", (error, data) => { + console.info(TAG + error + "," + data); + }); }) /** @@ -246,7 +300,11 @@ describe('objectStoreTest',function () { console.log(TAG + "************* V9testOn003 start *************"); var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("session1"); + g_object.setSessionId("session1").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect("session1" == g_object.__sessionId).assertEqual(true); console.info(TAG + " start call watch change"); try { @@ -263,7 +321,9 @@ describe('objectStoreTest',function () { expect(error != undefined).assertEqual(true); } console.log(TAG + "************* V9testOn003 end *************"); - g_object.setSessionId(""); + g_object.setSessionId("", (error, data) => { + console.info(TAG + error + "," + data); + }); }) /** @@ -275,7 +335,11 @@ describe('objectStoreTest',function () { console.log(TAG + "************* V9testOff001 start *************"); var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("session5"); + g_object.setSessionId("session5").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect("session5" == g_object.__sessionId).assertEqual(true); g_object.on("change", changeCallback); @@ -303,7 +367,9 @@ describe('objectStoreTest',function () { console.info(TAG + " object is null,set name fail"); } console.log(TAG + "************* V9testOff001 end *************"); - g_object.setSessionId(""); + g_object.setSessionId((error, data) => { + console.info(TAG + error + "," + data); + }); }) /** @@ -315,7 +381,11 @@ describe('objectStoreTest',function () { console.log(TAG + "************* V9testOff002 start *************"); var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("session6"); + g_object.setSessionId("session6").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect("session6" == g_object.__sessionId).assertEqual(true); try { g_object.off(123); @@ -325,7 +395,12 @@ describe('objectStoreTest',function () { } console.info(TAG + " end call watch change"); console.log(TAG + "************* V9testOff002 end *************"); - g_object.setSessionId(""); + g_object.setSessionId().then((data) => { + console.info(TAG + data); + console.info(TAG + "setSessionId test"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); }) /** @@ -346,7 +421,12 @@ describe('objectStoreTest',function () { } console.log(TAG + "watch success"); console.log(TAG + "************* V9testOnStatus001 end *************"); - g_object.setSessionId(""); + g_object.setSessionId("").then((data) => { + console.info(TAG + data); + console.info(TAG + "setSessionId test"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); }) /** @@ -366,7 +446,11 @@ describe('objectStoreTest',function () { g_object.off("status"); console.log(TAG + "unwatch success"); console.log(TAG + "************* V9testOnStatus002 end *************"); - g_object.setSessionId(""); + g_object.setSessionId().then(() => { + console.info("leave session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); }) /** @@ -379,7 +463,11 @@ describe('objectStoreTest',function () { var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("tmpsession1"); + g_object.setSessionId("tmpsession1").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect("tmpsession1" == g_object.__sessionId).assertEqual(true); let result = await g_object.save("local"); @@ -387,17 +475,27 @@ describe('objectStoreTest',function () { expect(result.version == g_object.__version).assertEqual(true); expect(result.deviceId == "local").assertEqual(true); - g_object.setSessionId(""); + g_object.setSessionId((error, data) => { + console.info(TAG + error + "," + data); + }); g_object.name = undefined; g_object.age = undefined; g_object.isVis = undefined; - g_object.setSessionId("tmpsession1"); + g_object.setSessionId("tmpsession1").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect(g_object.name == "Amy").assertEqual(true); expect(g_object.age == 18).assertEqual(true); expect(g_object.isVis == false).assertEqual(true); console.log(TAG + "************* V9testSave001 end *************"); - g_object.setSessionId(""); + g_object.setSessionId().then(() => { + console.info("leave session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); }) /** @@ -410,7 +508,11 @@ describe('objectStoreTest',function () { var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("tmpsession1"); + g_object.setSessionId("tmpsession1").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect("tmpsession1" == g_object.__sessionId).assertEqual(true); try { g_object.save(1234).then((result) => { @@ -428,8 +530,19 @@ describe('objectStoreTest',function () { }).catch((error) => { expect(error != undefined).assertEqual(true); }); + + try { + g_object.save("local", 123); + } catch (error) { + expect(error.code == 401).assertEqual(true); + expect(error.message == "Parameter error. The type of 'callback' must be 'function'.").assertEqual(true); + } console.log(TAG + "************* V9testSave002 end *************"); - g_object.setSessionId(""); + g_object.setSessionId().then(() => { + console.info("leave session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); }) /** @@ -439,33 +552,78 @@ describe('objectStoreTest',function () { */ it('V9testRevokeSave001', 0, async function () { console.log(TAG + "************* V9testRevokeSave001 start *************"); - var g_object = distributedObject.create(context, { name: "Amy", age: 18, isVis: false }); + var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); expect(g_object == undefined).assertEqual(false); - g_object.setSessionId("123456"); + g_object.setSessionId("123456").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect("123456" == g_object.__sessionId).assertEqual(true); let result = await g_object.save("local"); expect(result.sessionId == "123456").assertEqual(true); expect(result.version == g_object.__version).assertEqual(true); expect(result.deviceId == "local").assertEqual(true); - result = await g_object.revokeSave(); - g_object.setSessionId(""); + g_object.setSessionId((error, data) => { + console.info(TAG + error + "," + data); + }); g_object.name = undefined; g_object.age = undefined; g_object.isVis = undefined; - g_object.setSessionId("123456"); + g_object.setSessionId("123456").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); expect(g_object.name == undefined).assertEqual(true); expect(g_object.age == undefined).assertEqual(true); expect(g_object.isVis == undefined).assertEqual(true); - expect(result.sessionId == "123456").assertEqual(true); - console.log(TAG + "************* V9testRevokeSave001 end *************"); - g_object.setSessionId(""); + g_object.setSessionId("", (error, data) => { + console.info(TAG + error + "," + data); + }); + }) + + /** + * @tc.name: V9testRevokeSave002 + * @tc.desc: test RevokeSave + * @tc.type: FUNC + */ + it('V9testRevokeSave002', 0, async function () { + console.log(TAG + "************* V9testRevokeSave002 start *************"); + var g_object = distributedObject.create(context, {name: "Amy", age: 18, isVis: false}); + expect(g_object == undefined).assertEqual(false); + g_object.setSessionId("123456").then(() => { + console.info("join session"); + }).catch((error) => { + console.info(TAG + error.code + error.message); + }); + expect("123456" == g_object.__sessionId).assertEqual(true); + let result = await g_object.save("local"); + expect(result.sessionId == "123456").assertEqual(true); + expect(result.version == g_object.__version).assertEqual(true); + expect(result.deviceId == "local").assertEqual(true); + try { + g_object.revokeSave(123).then((result) => { + expect(result.sessionId == "tmpsession1").assertEqual(true) + }).catch((err) => { + console.log(err.code + err.message); + }); + } catch (error) { + console.info(error.code + error.message); + expect(error.code == 401).assertEqual(true); + expect(error.message == "Parameter error. The type of 'callback' must be 'function'.").assertEqual(true); + } + console.log(TAG + "************* V9testRevokeSave002 end *************"); + g_object.setSessionId("", (error, data) => { + console.info(TAG + error + "," + data); + }); }) console.log(TAG + "*************Unit Test End*************"); diff --git a/data_object/interfaces/innerkits/objectstore_errors.h b/data_object/interfaces/innerkits/objectstore_errors.h index eb569752c55ceddc1713115d6b6c71d5b2e60040..6e2557f3d614728f3aa0c1f7ebff0b4e84cb686a 100644 --- a/data_object/interfaces/innerkits/objectstore_errors.h +++ b/data_object/interfaces/innerkits/objectstore_errors.h @@ -41,6 +41,8 @@ constexpr uint32_t ERR_UNRIGSTER = BASE_ERR_OFFSET + 16; constexpr uint32_t ERR_SINGLE_DEVICE = BASE_ERR_OFFSET + 17; constexpr uint32_t ERR_NULL_PTR = BASE_ERR_OFFSET + 18; constexpr uint32_t ERR_PROCESSING = BASE_ERR_OFFSET + 19; +constexpr uint32_t ERR_RESULTSET = BASE_ERR_OFFSET + 20; +constexpr uint32_t ERR_INVALID_ARGS = BASE_ERR_OFFSET + 21; } // namespace OHOS::ObjectStore #endif diff --git a/data_share/.gitignore b/data_share/.gitignore index 28b4e73f14620513d093b40455971deb3f132274..0e8de66cffd6efe339534df9de8ffae08815e15a 100644 --- a/data_share/.gitignore +++ b/data_share/.gitignore @@ -4,3 +4,4 @@ ._* CMakeLists.txt cmake-build-debug +.clang-format diff --git a/data_share/bundle.json b/data_share/bundle.json index 0bc3a758c9f5130b4297820323b2802eb23b1c6f..3eb640924115fb397baddddee0bc8eab3098b225 100644 --- a/data_share/bundle.json +++ b/data_share/bundle.json @@ -107,6 +107,9 @@ "header_base": "//foundation/distributeddatamgr/data_share/interfaces/inner_api/common/include" } } + ], + "test": [ + "//foundation/distributeddatamgr/data_share/test/native:unittest" ] } } diff --git a/data_share/frameworks/js/napi/common/include/datashare_js_utils.h b/data_share/frameworks/js/napi/common/include/datashare_js_utils.h index 788be9ddc3e2b6f6f326618e4d20c8fc11a8260c..31f1f8b2bca56de6d5e731db6552316f56a9074d 100644 --- a/data_share/frameworks/js/napi/common/include/datashare_js_utils.h +++ b/data_share/frameworks/js/napi/common/include/datashare_js_utils.h @@ -93,4 +93,4 @@ napi_value DataShareJSUtils::Convert2JSValue(napi_env env, const std::variantClear()); -} - -int DataShareBlockWriterImpl::SetColumnNum(uint32_t numColumns) -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return ConvertErrorCode(shareBlock_->SetColumnNum(numColumns)); -} - int DataShareBlockWriterImpl::AllocRow() { if (shareBlock_ == nullptr) { @@ -59,15 +41,6 @@ int DataShareBlockWriterImpl::AllocRow() return ConvertErrorCode(shareBlock_->AllocRow()); } -int DataShareBlockWriterImpl::FreeLastRow() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return ConvertErrorCode(shareBlock_->FreeLastRow()); -} - int DataShareBlockWriterImpl::Write(uint32_t column) { uint32_t currentRowIndex = 0; @@ -118,77 +91,6 @@ int DataShareBlockWriterImpl::Write(uint32_t column, const char *value, size_t s return ConvertErrorCode(shareBlock_->PutString(currentRowIndex, column, value, sizeIncludingNull)); } -const void *DataShareBlockWriterImpl::GetHeader() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return nullptr; - } - return shareBlock_->GetHeader(); -} - -size_t DataShareBlockWriterImpl::GetUsedBytes() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return shareBlock_->GetUsedBytes(); -} - -std::string DataShareBlockWriterImpl::Name() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - } - return shareBlock_->Name(); -} - -size_t DataShareBlockWriterImpl::Size() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return shareBlock_->Size(); -} - -uint32_t DataShareBlockWriterImpl::GetRowNum() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return shareBlock_->GetRowNum(); -} - -uint32_t DataShareBlockWriterImpl::GetColumnNum() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return shareBlock_->GetColumnNum(); -} - -size_t DataShareBlockWriterImpl::SetRawData(const void *rawData, size_t size) -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return shareBlock_->SetRawData(rawData, size); -} - -int DataShareBlockWriterImpl::GetFd() -{ - if (shareBlock_ == nullptr) { - LOG_ERROR("shareBlock_ is nullptr"); - return E_ERROR; - } - return shareBlock_->GetFd(); -} - AppDataFwk::SharedBlock *DataShareBlockWriterImpl::GetBlock() const { return shareBlock_; diff --git a/data_share/frameworks/native/common/src/ishared_result_set_stub.cpp b/data_share/frameworks/native/common/src/ishared_result_set_stub.cpp index e886f67d550577c78f9b35a6bdd9267ba7c65c36..de9a7f5390847955b4ba33a2b174aaf090ee0f52 100644 --- a/data_share/frameworks/native/common/src/ishared_result_set_stub.cpp +++ b/data_share/frameworks/native/common/src/ishared_result_set_stub.cpp @@ -109,20 +109,9 @@ int ISharedResultSetStub::HandleOnGoRequest(MessageParcel &data, MessageParcel & { int oldRow = data.ReadInt32(); int newRow = data.ReadInt32(); - std::vector columnNames; - resultSet_->GetAllColumnNames(columnNames); - auto block = resultSet_->GetBlock(); - int errCode = block->Clear(); - if (errCode != E_OK) { - reply.WriteInt32(errCode); - return NO_ERROR; - } - errCode = block->SetColumnNum(columnNames.size()); - if (errCode == E_OK) { - errCode = resultSet_->OnGo(oldRow, newRow); - } + int errCode = resultSet_->OnGo(oldRow, newRow); reply.WriteInt32(errCode); - LOG_DEBUG("errCode %{public}d", errCode); + LOG_DEBUG("HandleOnGoRequest call %{public}d", errCode); return NO_ERROR; } diff --git a/data_share/frameworks/native/consumer/include/datashare_connection.h b/data_share/frameworks/native/consumer/include/datashare_connection.h index 04eda043113456a6714c9c2a9496867d0558d58a..6baa5d909c2609347750473975be4fdf037b3b53 100644 --- a/data_share/frameworks/native/consumer/include/datashare_connection.h +++ b/data_share/frameworks/native/consumer/include/datashare_connection.h @@ -84,4 +84,4 @@ private: }; } // namespace DataShare } // namespace OHOS -#endif // DATASHARE_CONNECTION_H +#endif // DATASHARE_CONNECTION_H \ No newline at end of file diff --git a/data_share/frameworks/native/provider/src/js_datashare_ext_ability.cpp b/data_share/frameworks/native/provider/src/js_datashare_ext_ability.cpp index f9d38c8caa4ecb69516d997fb6f59c6f0b45ee22..eb34608462c0c01bea2dc6508ec388759e2aa9d4 100644 --- a/data_share/frameworks/native/provider/src/js_datashare_ext_ability.cpp +++ b/data_share/frameworks/native/provider/src/js_datashare_ext_ability.cpp @@ -698,4 +698,4 @@ bool MakeNapiColumn(napi_env env, napi_value &napiColumns, const std::vector DataShareKvServiceProxy::GetFeatureInterface(const std::stri return remoteObject; } -} // namespace OHOS::DataShare +} // namespace OHOS::DataShare \ No newline at end of file diff --git a/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp b/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp index f5562b846da397574d9d7d7143f1904e93f2afa6..afda9ef680a01b5f38655318602c24686b8ee467 100644 --- a/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp +++ b/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp @@ -40,7 +40,7 @@ int32_t DataShareServiceProxy::Insert(const std::string &uri, const DataShareVal } MessageParcel reply; - MessageOption option = { MessageOption::TF_ASYNC }; + MessageOption option; int32_t err = Remote()->SendRequest(DATA_SHARE_SERVICE_CMD_INSERT, data, reply, option); if (err != NO_ERROR) { LOG_ERROR("Insert fail to SendRequest. uri: %{public}s, err: %{public}d", uri.c_str(), err); @@ -64,7 +64,7 @@ int32_t DataShareServiceProxy::Update( } MessageParcel reply; - MessageOption option = { MessageOption::TF_ASYNC }; + MessageOption option; int32_t err = Remote()->SendRequest(DATA_SHARE_SERVICE_CMD_UPDATE, data, reply, option); if (err != NO_ERROR) { LOG_ERROR("Update fail to SendRequest. uri: %{public}s, err: %{public}d", uri.c_str(), err); @@ -87,7 +87,7 @@ int32_t DataShareServiceProxy::Delete(const std::string &uri, const DataSharePre } MessageParcel reply; - MessageOption option = { MessageOption::TF_ASYNC }; + MessageOption option; int32_t err = Remote()->SendRequest(DATA_SHARE_SERVICE_CMD_DELETE, data, reply, option); if (err != NO_ERROR) { LOG_ERROR("Delete fail to SendRequest. uri: %{public}s, err: %{public}d", uri.c_str(), err); @@ -120,4 +120,4 @@ std::shared_ptr DataShareServiceProxy::Query( } return ISharedResultSet::ReadFromParcel(reply); } -} // namespace OHOS::DataShare +} // namespace OHOS::DataShare \ No newline at end of file diff --git a/data_share/interfaces/inner_api/consumer/include/datashare_helper.h b/data_share/interfaces/inner_api/consumer/include/datashare_helper.h index 0106451b57369e068cc44b1dc64812fd30302231..f28a855feddf1a8038183dcfcc4476f0fb784580 100644 --- a/data_share/interfaces/inner_api/consumer/include/datashare_helper.h +++ b/data_share/interfaces/inner_api/consumer/include/datashare_helper.h @@ -234,4 +234,4 @@ private: }; } // namespace DataShare } // namespace OHOS -#endif // DATASHARE_HELPER_H +#endif // DATASHARE_HELPER_H \ No newline at end of file diff --git a/data_share/test/native/BUILD.gn b/data_share/test/native/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..360be1d7484d61ab550de6b67760bf742811145b --- /dev/null +++ b/data_share/test/native/BUILD.gn @@ -0,0 +1,76 @@ +# Copyright (C) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/multimedia/media_library/media_library.gni") + +group("unittest") { + testonly = true + + deps = [ ":NativeDataShareTest" ] +} + +ohos_unittest("NativeDataShareTest") { + module_out_path = "data_share/native_datashare" + + include_dirs = [ + "./unittest/mediadatashare_test/include", + "//base/security/access_token/frameworks/common/include", + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", + "$MEDIA_LIB_BASE_DIR/interfaces/innerkits/native/include", + "//foundation/aafwk/standard/interfaces/innerkits/uri/include", + "${ABILITY_RUNTIME_INNER_API_PATH}/ability_manager/include", + "${ABILITY_RUNTIME_INNER_API_PATH}/app_manager/include/appmgr", + "${ABILITY_RUNTIME_PATH}/interfaces/kits/native/ability/native", + "$MEDIA_LIB_INNERKITS_DIR/media_library_helper/include", + "//commonlibrary/c_utils/base/include", + "//utils/system/safwk/native/include", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "${MEDIA_LIB_SERVICES_DIR}/media_library/include", + "${MEDIA_LIB_BASE_DIR}/frameworks/innerkitsimpl/medialibrary_data_extension/include", + "${MEDIA_LIB_BASE_DIR}/interfaces/inner_api/media_library_helper/include", + "${MEDIA_LIB_COMMON_UTILS_DIR}/include", + "//third_party/json/include", + ] + + sources = [ + "./unittest/mediadatashare_test/src/get_self_permissions.cpp", + "./unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp", + ] + + deps = [ + "${ABILITY_RUNTIME_INNER_API_PATH}/ability_manager:ability_manager", + "${ABILITY_RUNTIME_PATH}/frameworks/native/ability/native:abilitykit_native", + "//foundation/filemanagement/user_file_service/frameworks/innerkits/file_access:file_access_extension_ability_kit", + "//foundation/multimedia/media_library/frameworks/innerkitsimpl/media_library_helper:media_library_packages", + "//foundation/multimedia/media_library/frameworks/innerkitsimpl/media_library_manager:media_library_manager", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "hilog_native:libhilog", + "hitrace_native:hitrace_meter", + "ipc:ipc_core", + "relational_store:native_appdatafwk", + "relational_store:native_rdb", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_strategy.h b/data_share/test/native/unittest/mediadatashare_test/include/get_self_permissions.h similarity index 32% rename from datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_strategy.h rename to data_share/test/native/unittest/mediadatashare_test/include/get_self_permissions.h index d2633023d8356633594a0e92fffa2be7622ee173..699a39c1cbba82ec695aa6259bbd563b8d434a76 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_strategy.h +++ b/data_share/test/native/unittest/mediadatashare_test/include/get_self_permissions.h @@ -13,35 +13,19 @@ * limitations under the License. */ -#ifndef DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_COMMUNICATION_STRAGETY_H -#define DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_COMMUNICATION_STRAGETY_H +#ifndef GET_SELF_PERMISSIONS_H +#define GET_SELF_PERMISSIONS_H +#include #include -#include "concurrent_map.h" -#include "app_device_change_listener.h" -#include "session.h" namespace OHOS { -namespace AppDistributedKv { -class CommunicationStrategy : public AppDistributedKv::AppDeviceChangeListener { +namespace Media { +class PermissionUtilsUnitTest { public: - static CommunicationStrategy &GetInstance(); - Status Init(); - void OnDeviceChanged(const AppDistributedKv::DeviceInfo &info, - const AppDistributedKv::DeviceChangeType &type) const override; - void GetStrategy(const std::string &deviceId, int32_t dataLen, std::vector &linkTypes); -private: - CommunicationStrategy() = default; - ~CommunicationStrategy() = default; - CommunicationStrategy(CommunicationStrategy const &) = delete; - void operator=(CommunicationStrategy const &) = delete; - CommunicationStrategy(CommunicationStrategy &&) = delete; - CommunicationStrategy &operator=(CommunicationStrategy &&) = delete; - void UpdateCommunicationStrategy(const AppDistributedKv::DeviceInfo &info, - const AppDistributedKv::DeviceChangeType &type) const; - mutable ConcurrentMap strategys_; + static void SetAccessTokenPermission(const std::string &processName, + const std::vector &permission, uint64_t &tokenId); }; -} // namespace AppDistributedKv -} // namespace OHOS - -#endif // DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_COMMUNICATION_STRAGETY_H +} // namespace Media +} // namespace OHOS +#endif // GET_SELF_PERMISSIONS_H diff --git a/data_share/test/native/unittest/mediadatashare_test/include/mediadatashare_unit_test.h b/data_share/test/native/unittest/mediadatashare_test/include/mediadatashare_unit_test.h new file mode 100644 index 0000000000000000000000000000000000000000..b92af901f7a67477d1865157d8b040e8958ecd6a --- /dev/null +++ b/data_share/test/native/unittest/mediadatashare_test/include/mediadatashare_unit_test.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MEDIA_DATASHARE_UNIT_TEST_H +#define MEDIA_DATASHARE_UNIT_TEST_H + +#include + +namespace OHOS { +namespace Media { +class MediaDataShareUnitTest : public testing::Test { +public: + /* SetUpTestCase:The preset action of the test suite is executed before the first TestCase */ + static void SetUpTestCase(void); + + /* TearDownTestCase:The test suite cleanup action is executed after the last TestCase */ + static void TearDownTestCase(void); + + /* SetUp:Execute before each test case */ + void SetUp(); + + /* TearDown:Execute after each test case */ + void TearDown(); +}; +} // namespace Media +} // namespace OHOS + +#endif // MEDIA_DATASHARE_UNIT_TEST_H diff --git a/data_share/test/native/unittest/mediadatashare_test/src/get_self_permissions.cpp b/data_share/test/native/unittest/mediadatashare_test/src/get_self_permissions.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6a3249ebd18fbd9917b6bc2ff7762db55018174c --- /dev/null +++ b/data_share/test/native/unittest/mediadatashare_test/src/get_self_permissions.cpp @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "get_self_permissions.h" + +#include + +#include "accesstoken_kit.h" +#include "media_log.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" + +namespace OHOS { +namespace Media { +void PermissionUtilsUnitTest::SetAccessTokenPermission(const std::string &processName, + const std::vector &permission, uint64_t &tokenId) +{ + auto perms = std::make_unique(permission.size()); + for (size_t i = 0; i < permission.size(); i++) { + perms[i] = permission[i].c_str(); + } + + NativeTokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = permission.size(), + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms.get(), + .acls = nullptr, + .processName = processName.c_str(), + .aplStr = "system_basic", + }; + tokenId = GetAccessTokenId(&infoInstance); + if (tokenId == 0) { + MEDIA_ERR_LOG("Get Acess Token Id Failed"); + return; + } + int ret = SetSelfTokenID(tokenId); + if (ret != 0) { + MEDIA_ERR_LOG("Set Acess Token Id Failed"); + return; + } + ret = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); + if (ret < 0) { + MEDIA_ERR_LOG("Reload Native Token Info Failed"); + return; + } +} +} // namespace Media +} // namespace OHOS + diff --git a/data_share/test/native/unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp b/data_share/test/native/unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..67bf175cece06ac95e0789b1137932a4e8cd76f0 --- /dev/null +++ b/data_share/test/native/unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp @@ -0,0 +1,668 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#define MLOG_TAG "DataShareUnitTest" + +#include "mediadatashare_unit_test.h" + +#include "datashare_helper.h" +#include "fetch_result.h" +#include "get_self_permissions.h" +#include "iservice_registry.h" +#include "datashare_log.h" +#include "media_file_utils.h" +#include "media_library_manager.h" +#include "medialibrary_errno.h" +#include "system_ability_definition.h" + +using namespace std; +using namespace testing::ext; + +namespace OHOS { +namespace Media { +constexpr int STORAGE_MANAGER_MANAGER_ID = 5003; +std::shared_ptr g_mediaDataShareHelper; + +std::shared_ptr CreateDataShareHelper(int32_t systemAbilityId) +{ + LOG_INFO("CreateDataShareHelper::CreateFileExtHelper "); + auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (saManager == nullptr) { + LOG_ERROR("CreateDataShareHelper::CreateFileExtHelper Get system ability " + "mgr failed."); + return nullptr; + } + auto remoteObj = saManager->GetSystemAbility(systemAbilityId); + while (remoteObj == nullptr) { + LOG_ERROR("CreateDataShareHelper::CreateFileExtHelper GetSystemAbility " + "Service Failed."); + return nullptr; + } + return DataShare::DataShareHelper::Creator(remoteObj, MEDIALIBRARY_DATA_URI); +} + +void MediaDataShareUnitTest::SetUpTestCase(void) +{ + vector perms; + perms.push_back("ohos.permission.READ_MEDIA"); + perms.push_back("ohos.permission.WRITE_MEDIA"); + perms.push_back("ohos.permission.FILE_ACCESS_MANAGER"); + uint64_t tokenId = 0; + PermissionUtilsUnitTest::SetAccessTokenPermission("MediaDataShareUnitTest", perms, tokenId); + ASSERT_TRUE(tokenId != 0); + + LOG_INFO("SetUpTestCase invoked"); + g_mediaDataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID); + ASSERT_TRUE(g_mediaDataShareHelper != nullptr); + + Uri deleteAssetUri(MEDIALIBRARY_DATA_URI); + DataShare::DataSharePredicates predicates; + string selections = MEDIA_DATA_DB_ID + " <> 0 "; + predicates.SetWhereClause(selections); + int retVal = g_mediaDataShareHelper->Delete(deleteAssetUri, predicates); + LOG_INFO("SetUpTestCase Delete retVal: %{public}d", retVal); + EXPECT_EQ((retVal >= 0), true); + + Uri uri(MEDIALIBRARY_DATA_URI); + DataShare::DataShareValuesBucket valuesBucket; + double valueD1 = 20.07; + valuesBucket.Put(MEDIA_DATA_DB_LONGITUDE, valueD1); + valuesBucket.Put(MEDIA_DATA_DB_TITLE, "dataShareTest003"); + int value1 = 1001; + valuesBucket.Put(MEDIA_DATA_DB_PARENT_ID, value1); + retVal = g_mediaDataShareHelper->Insert(uri, valuesBucket); + EXPECT_EQ((retVal > 0), true); + + valuesBucket.Clear(); + double valueD2 = 20.08; + valuesBucket.Put(MEDIA_DATA_DB_LONGITUDE, valueD2); + valuesBucket.Put(MEDIA_DATA_DB_TITLE, "dataShareTest004"); + int value2 = 1000; + valuesBucket.Put(MEDIA_DATA_DB_PARENT_ID, value2); + retVal = g_mediaDataShareHelper->Insert(uri, valuesBucket); + EXPECT_EQ((retVal > 0), true); + + valuesBucket.Clear(); + double valueD3 = 20.09; + valuesBucket.Put(MEDIA_DATA_DB_LONGITUDE, valueD3); + valuesBucket.Put(MEDIA_DATA_DB_TITLE, "dataShareTest005"); + int value3 = 999; + valuesBucket.Put(MEDIA_DATA_DB_PARENT_ID, value3); + retVal = g_mediaDataShareHelper->Insert(uri, valuesBucket); + EXPECT_EQ((retVal > 0), true); + LOG_INFO("SetUpTestCase end"); +} + +int32_t CreateFile(string displayName) +{ + LOG_INFO("CreateFile::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri createAssetUri(MEDIALIBRARY_DATA_URI + "/" + Media::MEDIA_FILEOPRN + "/" + Media::MEDIA_FILEOPRN_CREATEASSET); + DataShare::DataShareValuesBucket valuesBucket; + string relativePath = "Pictures/" + displayName + "/"; + displayName += ".jpg"; + MediaType mediaType = MEDIA_TYPE_IMAGE; + valuesBucket.Put(MEDIA_DATA_DB_MEDIA_TYPE, mediaType); + valuesBucket.Put(MEDIA_DATA_DB_NAME, displayName); + valuesBucket.Put(MEDIA_DATA_DB_RELATIVE_PATH, relativePath); + int32_t retVal = helper->Insert(createAssetUri, valuesBucket); + LOG_INFO("CreateFile::File: %{public}s, retVal: %{public}d", (relativePath + displayName).c_str(), retVal); + EXPECT_EQ((retVal > 0), true); + if (retVal <= 0) { + retVal = E_FAIL; + } + LOG_INFO("CreateFile::retVal = %{public}d. End", retVal); + return retVal; +} + +int32_t CreateAlbum(string displayName) +{ + LOG_INFO("CreateAlbum::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri createAlbumUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_ALBUMOPRN + "/" + MEDIA_ALBUMOPRN_CREATEALBUM); + DataShare::DataShareValuesBucket valuesBucket; + string dirPath = ROOT_MEDIA_DIR + "Pictures/" + displayName; + valuesBucket.Put(MEDIA_DATA_DB_FILE_PATH, dirPath); + valuesBucket.Put(MEDIA_DATA_DB_NAME, displayName); + auto retVal = helper->Insert(createAlbumUri, valuesBucket); + LOG_INFO("CreateAlbum::Album: %{public}s, retVal: %{public}d", dirPath.c_str(), retVal); + EXPECT_EQ((retVal > 0), true); + if (retVal <= 0) { + retVal = E_FAIL; + } + LOG_INFO("CreateAlbum::retVal = %{public}d. End", retVal); + return retVal; +} + +bool GetFileAsset(unique_ptr &fileAsset, bool isAlbum, string displayName) +{ + int32_t index = E_FAIL; + if (isAlbum) { + index = CreateAlbum(displayName); + } else { + index = CreateFile(displayName); + } + if (index == E_FAIL) { + LOG_ERROR("GetFileAsset failed"); + return false; + } + std::shared_ptr helper = g_mediaDataShareHelper; + vector columns; + DataShare::DataSharePredicates predicates; + string selections = MEDIA_DATA_DB_ID + " = " + to_string(index); + predicates.SetWhereClause(selections); + Uri queryFileUri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(queryFileUri, predicates, columns); + if (resultSet == nullptr) { + LOG_ERROR("GetFileAsset::resultSet == nullptr"); + return false; + } + + // Create FetchResult object using the contents of resultSet + unique_ptr> fetchFileResult = make_unique>(move(resultSet)); + if (fetchFileResult->GetCount() <= 0) { + LOG_ERROR("GetFileAsset::GetCount <= 0"); + return false; + } + + fileAsset = fetchFileResult->GetFirstObject(); + if (fileAsset == nullptr) { + LOG_ERROR("GetFileAsset::fileAsset = nullptr."); + return false; + } + return true; +} + +void MediaDataShareUnitTest::TearDownTestCase(void) +{ + LOG_INFO("TearDownTestCase invoked"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri deleteAssetUri(MEDIALIBRARY_DATA_URI); + DataShare::DataSharePredicates predicates; + string selections = MEDIA_DATA_DB_ID + " <> 0 "; + predicates.SetWhereClause(selections); + int retVal = helper->Delete(deleteAssetUri, predicates); + LOG_INFO("TearDownTestCase Delete retVal: %{public}d", retVal); + EXPECT_EQ((retVal >= 0), true); + + bool result = helper->Release(); + EXPECT_EQ(result, true); + LOG_INFO("TearDownTestCase end"); +} + +void MediaDataShareUnitTest::SetUp(void) {} +void MediaDataShareUnitTest::TearDown(void) {} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_001::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri uri(MEDIALIBRARY_DATA_URI); + DataShare::DataSharePredicates predicates; + predicates.EqualTo(MEDIA_DATA_DB_TITLE, "dataShareTest003"); + predicates.Limit(1, 0); + vector columns; + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_001, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_002, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_002::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.NotEqualTo(MEDIA_DATA_DB_TITLE, "dataShareTest003"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 2); + LOG_INFO("MediaDataShare_Predicates_Test_002, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_003, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_003::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.Contains(MEDIA_DATA_DB_TITLE, "dataShareTest"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 3); + LOG_INFO("MediaDataShare_Predicates_Test_003, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_004, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_004::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.BeginsWith(MEDIA_DATA_DB_TITLE, "dataShare"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 3); + LOG_INFO("MediaDataShare_Predicates_Test_004, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_005, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_005::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.EndsWith(MEDIA_DATA_DB_TITLE, "003"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_005, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_006, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_006::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.IsNull(MEDIA_DATA_DB_TITLE); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 0); + LOG_INFO("MediaDataShare_Predicates_Test_006, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_007, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_007::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.IsNotNull(MEDIA_DATA_DB_TITLE); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 3); + LOG_INFO("MediaDataShare_Predicates_Test_007, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_008, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_008::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.Like(MEDIA_DATA_DB_TITLE, "%Test003"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_008, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_009, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_009::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.Glob(MEDIA_DATA_DB_TITLE, "dataShareTes?003"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_009, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_010, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_010::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.Between(MEDIA_DATA_DB_PARENT_ID, "0", "999"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_010, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_011, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_011::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.NotBetween(MEDIA_DATA_DB_PARENT_ID, "0", "999"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 2); + LOG_INFO("MediaDataShare_Predicates_Test_011, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_012, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_012::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.GreaterThan(MEDIA_DATA_DB_PARENT_ID, 999); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 2); + LOG_INFO("MediaDataShare_Predicates_Test_012, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_013, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_013::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.LessThan(MEDIA_DATA_DB_PARENT_ID, 1000); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_013, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_014, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_014::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.GreaterThanOrEqualTo(MEDIA_DATA_DB_PARENT_ID, 1000); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 2); + LOG_INFO("MediaDataShare_Predicates_Test_014, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_015, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_015::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.LessThanOrEqualTo(MEDIA_DATA_DB_PARENT_ID, 1000); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 2); + LOG_INFO("MediaDataShare_Predicates_Test_015, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_016, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_016::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.EqualTo(MEDIA_DATA_DB_LONGITUDE, 20.08) + ->BeginWrap() + ->EqualTo(MEDIA_DATA_DB_TITLE, "dataShareTest004") + ->Or() + ->EqualTo(MEDIA_DATA_DB_PARENT_ID, 1000) + ->EndWrap(); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_016, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_017, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_017::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.EqualTo(MEDIA_DATA_DB_LONGITUDE, 20.08)->And()->EqualTo(MEDIA_DATA_DB_TITLE, "dataShareTest004"); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int result = 0; + if (resultSet != nullptr) { + resultSet->GetRowCount(result); + } + EXPECT_EQ(result, 1); + LOG_INFO("MediaDataShare_Predicates_Test_017, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_018, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_018::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.OrderByAsc(MEDIA_DATA_DB_PARENT_ID); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int columnIndex = 0; + std::string stringResult = ""; + if (resultSet != nullptr) { + resultSet->GoToFirstRow(); + resultSet->GetColumnIndex(MEDIA_DATA_DB_TITLE, columnIndex); + resultSet->GetString(columnIndex, stringResult); + } + EXPECT_EQ(stringResult, "dataShareTest005"); + LOG_INFO("MediaDataShare_Predicates_Test_018, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_Predicates_Test_019, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_Predicates_Test_019::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + DataShare::DataSharePredicates predicates; + predicates.OrderByDesc(MEDIA_DATA_DB_LONGITUDE); + vector columns; + Uri uri(MEDIALIBRARY_DATA_URI); + auto resultSet = helper->Query(uri, predicates, columns); + int columnIndex = 0; + std::string stringResult = ""; + if (resultSet != nullptr) { + resultSet->GoToFirstRow(); + resultSet->GetColumnIndex(MEDIA_DATA_DB_TITLE, columnIndex); + resultSet->GetString(columnIndex, stringResult); + } + EXPECT_EQ(stringResult, "dataShareTest005"); + LOG_INFO("MediaDataShare_Predicates_Test_019, End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ValuesBucket_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_ValuesBucket_Test_001::Start"); + DataShare::DataShareValuesBucket valuesBucket; + EXPECT_EQ(valuesBucket.IsEmpty(), true); + + valuesBucket.Put(MEDIA_DATA_DB_TITLE, "dataShare_Test_001"); + EXPECT_EQ(valuesBucket.IsEmpty(), false); + + bool isValid; + DataShare::DataShareValueObject object = valuesBucket.Get(MEDIA_DATA_DB_TITLE, isValid); + string value = object; + EXPECT_EQ(value, "dataShare_Test_001"); + + valuesBucket.Clear(); + EXPECT_EQ(valuesBucket.IsEmpty(), true); + LOG_INFO("MediaDataShare_ValuesBucket_Test_001 End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ValueObject_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_ValueObject_Test_001::Start"); + + int base = 100; + DataShare::DataShareValueObject object(base); + int value = object; + EXPECT_EQ(value, base); + + int64_t base64 = 100; + DataShare::DataShareValueObject object64(base64); + int64_t value64 = object64; + EXPECT_EQ(value64, base64); + + double baseD = 10.0; + DataShare::DataShareValueObject objectD(baseD); + double valueD = objectD; + EXPECT_EQ(valueD, baseD); + + bool baseB = true; + DataShare::DataShareValueObject objectB(baseB); + bool valueB = objectB; + EXPECT_EQ(valueB, baseB); + + vector baseV; + DataShare::DataShareValueObject objectV(baseV); + vector valueV = objectV; + EXPECT_EQ(valueV, baseV); + + DataShare::DataShareValueObject objectCopy(object); + int valueCopy = objectCopy; + EXPECT_EQ(valueCopy, value); + + DataShare::DataShareValueObject objectMove(std::move(object)); + int valueMove = objectMove; + EXPECT_EQ(valueMove, value); + + LOG_INFO("MediaDataShare_ValueObject_Test_001 End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_GetFileTypes_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_GetFileTypes_Test_001::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri uri(MEDIALIBRARY_DATA_URI); + std::string mimeTypeFilter("mimeTypeFiltertest"); + std::vector result = helper->GetFileTypes(uri, mimeTypeFilter); + EXPECT_EQ(result.size(), 0); + LOG_INFO("MediaDataShare_GetFileTypes_Test_001 End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_OpenRawFile_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_OpenRawFile_Test_001::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri uri(MEDIALIBRARY_DATA_URI); + std::string mode("modetest"); + int result = helper->OpenRawFile(uri, mode); + EXPECT_EQ(result, 0); + LOG_INFO("MediaDataShare_OpenRawFile_Test_001 End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_batchInsert_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_batchInsert_Test_001::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri uri(MEDIALIBRARY_DATA_URI); + DataShare::DataShareValuesBucket valuesBucket; + valuesBucket.Put("name", "ZhangSan"); + valuesBucket.Put("age", 20); + std::vector values; + values.push_back(valuesBucket); + int result = helper->BatchInsert(uri, values); + EXPECT_NE(result, 0); + LOG_INFO("MediaDataShare_batchInsert_Test_001 End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_NormalizeUri_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_NormalizeUri_Test_001::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri uri(MEDIALIBRARY_DATA_URI); + auto normalUri = helper->NormalizeUri(uri); + EXPECT_EQ(normalUri, uri); + LOG_INFO("MediaDataShare_NormalizeUri_Test_001 End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_DenormalizeUri_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_DenormalizeUri_Test_001::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri uri(MEDIALIBRARY_DATA_URI); + auto denormalUri = helper->DenormalizeUri(uri); + EXPECT_EQ(denormalUri, uri); + LOG_INFO("MediaDataShare_DenormalizeUri_Test_001 End"); +} + +HWTEST_F(MediaDataShareUnitTest, MediaDataShare_GetType_Test_001, TestSize.Level0) +{ + LOG_INFO("MediaDataShare_GetType_Test_001::Start"); + std::shared_ptr helper = g_mediaDataShareHelper; + Uri uri(MEDIALIBRARY_DATA_URI); + std::string result = helper->GetType(uri); + EXPECT_NE(result.c_str(), ""); + LOG_INFO("MediaDataShare_GetType_Test_001 End"); +} +} // namespace Media +} // namespace OHOS diff --git a/datamgr_service/BUILD.gn b/datamgr_service/BUILD.gn index 57f3ac5e8aec1a26d52861b137458951c9e98d18..e0313ca8b43d343cdfb6126fc1e09316f1bf4396 100644 --- a/datamgr_service/BUILD.gn +++ b/datamgr_service/BUILD.gn @@ -32,11 +32,10 @@ group("fuzztest") { "test/fuzztest/autolaunch_fuzzer:fuzztest", "test/fuzztest/blob_fuzzer:fuzztest", "test/fuzztest/devicekvstore_fuzzer:fuzztest", - "test/fuzztest/dfx_fuzzer:fuzztest", "test/fuzztest/distributedkvdatamanager_fuzzer:fuzztest", "test/fuzztest/kvstoredisksize_fuzzer:fuzztest", - "test/fuzztest/kvstorescheduler_fuzzer:fuzztest", "test/fuzztest/singlekvstore_fuzzer:fuzztest", + "test/fuzztest/taskscheduler_fuzzer:fuzztest", "test/fuzztest/typesutil_fuzzer:fuzztest", ] } diff --git a/datamgr_service/conf/config.json b/datamgr_service/conf/config.json index 2fa0bf789eb50de9cd818befa608420eab89ae12..91ca003bbdfef4b4bd57c1f761faafd67e6c6e49 100644 --- a/datamgr_service/conf/config.json +++ b/datamgr_service/conf/config.json @@ -81,4 +81,4 @@ "backupInternal" : 36000, "backupNumber" : 20 } -} \ No newline at end of file +} diff --git a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp index ff55792887026cd852dc74cd5a57caaa5f36628d..f0c9b940a0c5d32a3357467ef6c11d7bb62e40d8 100644 --- a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp @@ -23,8 +23,7 @@ namespace { constexpr const char *DEFAULT_OHOS_ACCOUNT_UID = ""; // default UID } -// AccountDelegate::BaseInstance AccountDelegate::getInstance_ = AccountDelegateDefaultImpl::GetBaseInstance; - +//AccountDelegate::BaseInstance AccountDelegate::getInstance_ = AccountDelegateDefaultImpl::GetBaseInstance; AccountDelegate *AccountDelegateDefaultImpl::GetBaseInstance() { static AccountDelegateDefaultImpl accountDelegate; diff --git a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_impl.cpp index d05bdc11bdc5a47a367fca61e5c98425db2be282..8d8558bf45c82c6128eba39c5e7007443df1c926 100644 --- a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_impl.cpp @@ -61,13 +61,13 @@ AccountDelegateImpl::~AccountDelegateImpl() void AccountDelegateImpl::NotifyAccountChanged(const AccountEventInfo &accountEventInfo) { - observerMap_.ForEach([&accountEventInfo] (const auto& key, const auto& val) { + observerMap_.ForEach([&accountEventInfo] (const auto& key, auto& val) { if (val->GetLevel() == AccountDelegate::Observer::LevelType::HIGH) { val->OnAccountChanged(accountEventInfo); } return false; }); - observerMap_.ForEach([&accountEventInfo] (const auto& key, const auto& val) { + observerMap_.ForEach([&accountEventInfo] (const auto& key, auto& val) { if (val->GetLevel() == AccountDelegate::Observer::LevelType::LOW) { val->OnAccountChanged(accountEventInfo); } diff --git a/datamgr_service/services/distributeddataservice/adapter/autils/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/autils/BUILD.gn index 3e56d2f99b141adee7d6d8b6a23c86e409a3f29a..bb40ed87a5d68ce39d119e9aaec521b7e2403001 100644 --- a/datamgr_service/services/distributeddataservice/adapter/autils/BUILD.gn +++ b/datamgr_service/services/distributeddataservice/adapter/autils/BUILD.gn @@ -16,7 +16,6 @@ ohos_static_library("distributeddata_autils_static") { sources = [ "src/constant.cpp", "src/directory_utils.cpp", - "src/kv_scheduler.cpp", "src/thread_pool/kv_store_task.cpp", "src/thread_pool/kv_store_thread.cpp", "src/thread_pool/kv_store_thread_pool.cpp", diff --git a/datamgr_service/services/distributeddataservice/adapter/autils/src/directory_utils.cpp b/datamgr_service/services/distributeddataservice/adapter/autils/src/directory_utils.cpp index 18680bdd04dfc77f2f5f12a5f41479b8325c6657..b126261064e9204ab9454c9263af7bc1adaf5d12 100644 --- a/datamgr_service/services/distributeddataservice/adapter/autils/src/directory_utils.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/autils/src/directory_utils.cpp @@ -161,4 +161,4 @@ std::string DirectoryUtils::IncludeDelimiterAtPathTail(const std::string &path) return path; } } // namespace DistributedKv -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread.cpp b/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread.cpp index b31b558fa7f7ddf4866e280069df8674b08970a1..52efe42d043857c24a9a44c4b35afee28f810370 100644 --- a/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread.cpp @@ -41,7 +41,11 @@ void KvStoreThread::Run(KvStoreThreadPool *pool) ZLOGW("input param is null."); return; } - pool->Run(); + + auto impl = reinterpret_cast(pool); + while (impl->IsRunning()) { + impl->ScheduleTask()(); + } ZLOGW("stop"); } diff --git a/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.cpp index 3ab63cbe14437c241553a5e29491703f1a3eaf5b..7a8ad6b835c6a7b1507026f27ba5498ea847bbb8 100644 --- a/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.cpp @@ -14,24 +14,17 @@ */ #define LOG_TAG "KvStoreThreadPoolImpl" - #include "kv_store_thread_pool_impl.h" + +#include +#include +#include + +#include "kv_store_thread.h" #include "log_print.h" namespace OHOS { namespace DistributedKv { -KvStoreThreadPoolImpl::KvStoreThreadPoolImpl(int threadNum, std::string poolName, bool startImmediately) - : taskList(), threadList(), threadNum(threadNum) -{ - this->poolName_ = poolName; - if (threadNum <= 0 || threadNum > MAX_POOL_SIZE) { - this->threadNum = DEFAULT_POOL_SIZE; - } - if (startImmediately && !running.exchange(true)) { - Start(); - } -} - KvStoreThreadPoolImpl::~KvStoreThreadPoolImpl() { Stop(); @@ -40,6 +33,7 @@ KvStoreThreadPoolImpl::~KvStoreThreadPoolImpl() void KvStoreThreadPoolImpl::Start() { ZLOGI("start"); + running = true; for (int i = 0; i < threadNum; i++) { threadList.emplace_back(this, poolName_.substr(0, MAX_THREAD_NAME_SIZE) + "_" + std::to_string(i)); } @@ -48,11 +42,12 @@ void KvStoreThreadPoolImpl::Start() void KvStoreThreadPoolImpl::Stop() { ZLOGW("stop"); - if (!running.exchange(false)) { + if (!running) { return; } { std::unique_lock lock(taskListMutex); + running = false; for (auto task = taskList.begin(); task != taskList.end(); task++) { ZLOGI("running task in stop()"); (*task)(); @@ -71,13 +66,24 @@ bool KvStoreThreadPoolImpl::IsRunning() const return running; } +KvStoreThreadPoolImpl::KvStoreThreadPoolImpl(int threadNum, std::string poolName, bool startImmediately) + : taskList(), threadList(), threadNum(threadNum) +{ + this->poolName_ = poolName; + if (threadNum <= 0 || threadNum > MAX_POOL_SIZE) { + this->threadNum = DEFAULT_POOL_SIZE; + } + if (startImmediately) { + Start(); + } +} + bool KvStoreThreadPoolImpl::AddTask(KvStoreTask &&task) { ZLOGD("start"); - if (!running.exchange(true)) { + if (threadList.empty()) { Start(); } - std::unique_lock lock(taskListMutex); if (!running) { return false; @@ -90,7 +96,9 @@ bool KvStoreThreadPoolImpl::AddTask(KvStoreTask &&task) KvStoreTask KvStoreThreadPoolImpl::ScheduleTask() { std::unique_lock lock(taskListMutex); - has_task.wait(lock, [this]() {return !running || !taskList.empty(); }); + if (taskList.empty() && running) { + has_task.wait(lock, [&]() {return !running || !taskList.empty(); }); + } if (taskList.empty()) { ZLOGW("taskList empty. schedule empty task(pool stopping?)"); return KvStoreTask([]() {;}); @@ -99,11 +107,5 @@ KvStoreTask KvStoreThreadPoolImpl::ScheduleTask() taskList.pop_front(); return ret; } -void KvStoreThreadPoolImpl::Run() -{ - while (IsRunning()) { - ScheduleTask()(); - } -} } // namespace DistributedKv } // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.h b/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.h index e006e3ef2d193851e68b37f24f0748a95c32e7f4..10051ff1f03e189ca0703840b0301171e366de30 100644 --- a/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.h +++ b/datamgr_service/services/distributeddataservice/adapter/autils/src/thread_pool/kv_store_thread_pool_impl.h @@ -19,7 +19,6 @@ #include #include #include -#include #include "kv_store_thread_pool.h" #include "kv_store_thread.h" @@ -34,8 +33,7 @@ public: KvStoreThreadPoolImpl& operator=(const KvStoreThreadPoolImpl &) = delete; KvStoreThreadPoolImpl& operator=(KvStoreThreadPoolImpl &&) = delete; bool AddTask(KvStoreTask &&task) override; - void Stop() override final; - void Run() override final; + void Stop() final; KvStoreTask ScheduleTask(); bool IsRunning() const; virtual ~KvStoreThreadPoolImpl(); @@ -46,7 +44,7 @@ private: std::list threadList{}; int threadNum; void Start(); - std::atomic running = false; + bool running = false; static constexpr int MAX_THREAD_NAME_SIZE = 11; }; } // namespace DistributedKv diff --git a/datamgr_service/services/distributeddataservice/adapter/autils/test/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/autils/test/BUILD.gn index 00571c839b97cfac46aa80e069896b3d288f6e86..283d74b86d3c61332dd29429c7086f2827f2551c 100644 --- a/datamgr_service/services/distributeddataservice/adapter/autils/test/BUILD.gn +++ b/datamgr_service/services/distributeddataservice/adapter/autils/test/BUILD.gn @@ -27,10 +27,7 @@ config("module_private_config") { ohos_unittest("KvStoreThreadPoolTest") { module_out_path = module_output_path - sources = [ - "unittest/kv_scheduler_test.cpp", - "unittest/kv_store_thread_pool_test.cpp", - ] + sources = [ "unittest/kv_store_thread_pool_test.cpp" ] configs = [ ":module_private_config" ] diff --git a/datamgr_service/services/distributeddataservice/adapter/autils/test/unittest/kv_store_thread_pool_test.cpp b/datamgr_service/services/distributeddataservice/adapter/autils/test/unittest/kv_store_thread_pool_test.cpp index 2175c98b5a73125e98fda299a43f10ee1d2e5a62..f95274403522392ded271cdf8c93d3685ce509f2 100644 --- a/datamgr_service/services/distributeddataservice/adapter/autils/test/unittest/kv_store_thread_pool_test.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/autils/test/unittest/kv_store_thread_pool_test.cpp @@ -127,4 +127,4 @@ HWTEST_F(KvStoreThreadPoolTest, TestApplyTask003, TestSize.Level1) EXPECT_EQ(var, 0); pool->Stop(); EXPECT_EQ(var, 8); -} \ No newline at end of file +} diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/communicator/BUILD.gn index 7df58e1ac0447bc4a467ed816ee0b3cc0678baec..90916afdd5ea1b368e678c3e0843eb7fe8e604d6 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/BUILD.gn +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/BUILD.gn @@ -23,12 +23,13 @@ ohos_static_library("distributeddata_communicator_static") { "src/communication_provider_impl.cpp", "src/communication_provider_impl.h", "src/communication_strategy.cpp", - "src/communication_strategy.h", "src/data_buffer.cpp", "src/device_manager_adapter.cpp", "src/process_communicator_impl.cpp", "src/softbus_adapter.h", "src/softbus_adapter_standard.cpp", + "src/softbus_client.cpp", + "src/softbus_client.h", ] include_dirs = [ diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/app_pipe_handler.h b/datamgr_service/services/distributeddataservice/adapter/communicator/src/app_pipe_handler.h index 1f1e5c3933194789c63f89d5bc76cbab66ec0b66..ec8db4b91b6af7b43c4241a8e6f7ceb9cdceb931 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/app_pipe_handler.h +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/app_pipe_handler.h @@ -20,7 +20,7 @@ #include #include #include -#include "kv_scheduler.h" +#include "task_scheduler.h" #include "log_print.h" #include "reporter.h" #include "app_data_change_listener.h" diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/ark_communication_provider.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/ark_communication_provider.cpp index 21c191e0b33290995bf866a11de568f4f3692a6c..b12996ec847bca68b1f5efdfb7779718d2cfe591 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/ark_communication_provider.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/ark_communication_provider.cpp @@ -25,18 +25,18 @@ namespace AppDistributedKv { using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; CommunicationProvider &ArkCommunicationProvider::Init() { - static ArkCommunicationProvider *instance = new ArkCommunicationProvider(); - if (instance->isInited) { - return *instance; + static ArkCommunicationProvider instance; + if (instance.isInited) { + return instance; } ZLOGI("begin"); std::lock_guard lock(mutex_); - if (!instance->isInited) { - instance->Initialize(); + if (!instance.isInited) { + instance.Initialize(); } - instance->isInited = true; + instance.isInited = true; ZLOGI("normal end"); - return *instance; + return instance; } ArkCommunicationProvider::ArkCommunicationProvider() : CommunicationProviderImpl(appPipeMgrImpl_) diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_provider_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_provider_impl.cpp index 69cb1c87fe83ed8bda736646e1f7b3cdff2aee91..75b71e644c371cb10d393a2022e9d6f8b0e2ccc9 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_provider_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_provider_impl.cpp @@ -14,8 +14,6 @@ */ #include "communication_provider_impl.h" - -#include "communication_strategy.h" #include "device_manager_adapter.h" #include "log_print.h" @@ -37,7 +35,6 @@ CommunicationProviderImpl::~CommunicationProviderImpl() Status CommunicationProviderImpl::Initialize() { - CommunicationStrategy::GetInstance().Init(); return Status::SUCCESS; } diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_strategy.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_strategy.cpp index 3a77fcc9453d8dd6a774d5767f7ce358f93b123c..f4e72eba71bcbf4dcd60d8a3196a4c922585ed0a 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_strategy.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/communication_strategy.cpp @@ -12,62 +12,61 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - + +#define LOG_TAG "CommunicationStrategy" #include "communication_strategy.h" #include "log_print.h" -#include "device_manager_adapter.h" #include "kvstore_utils.h" -#ifdef LOG_TAG -#undef LOG_TAG -#endif -#define LOG_TAG "CommunicationStrategy" namespace OHOS { namespace AppDistributedKv { -using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; -using KvStoreUtils = OHOS::DistributedKv::KvStoreUtils; CommunicationStrategy &CommunicationStrategy::GetInstance() { static CommunicationStrategy instance; return instance; } -Status CommunicationStrategy::Init() +void CommunicationStrategy::RegGetSyncDataSize(const std::string &type, + const std::function &getDataSize) { - return DmAdapter::GetInstance().StartWatchDeviceChange(this, {"strategy"}); + calcDataSizes_.InsertOrAssign(type, getDataSize); } -void CommunicationStrategy::OnDeviceChanged(const AppDistributedKv::DeviceInfo &info, - const AppDistributedKv::DeviceChangeType &type) const +size_t CommunicationStrategy::CalcSyncDataSize(const std::string &deviceId) { - UpdateCommunicationStrategy(info, type); + size_t dataSize = 0; + calcDataSizes_.ForEach([&dataSize, &deviceId](const std::string &key, auto &value) { + if (value) { + dataSize += value(deviceId); + } + return false; + }); + ZLOGD("calc data size:%{public}zu.", dataSize); + return dataSize; } -void CommunicationStrategy::UpdateCommunicationStrategy(const AppDistributedKv::DeviceInfo &info, - const AppDistributedKv::DeviceChangeType &type) const +void CommunicationStrategy::SetStrategy(const std::string &deviceId, Strategy strategy, + const std::function &action) { - ZLOGD("[UpdateCommunicationStrategy] to %{public}s, type:%{public}d", - KvStoreUtils::ToBeAnonymous(info.uuid).c_str(), type); - if (type == AppDistributedKv::DeviceChangeType::DEVICE_ONLINE) { - strategys_.InsertOrAssign(info.uuid, true); - } else if (type == AppDistributedKv::DeviceChangeType::DEVICE_ONREADY) { - strategys_.Erase(info.uuid); - } else { - ; + auto value = strategy; + if (strategy == Strategy::ON_LINE_SELECT_CHANNEL && CalcSyncDataSize(deviceId) < SWITCH_CONNECTION_THRESHOLD) { + value = Strategy::DEFAULT; + } + if (action) { + action(deviceId, value); } + strategys_.InsertOrAssign(deviceId, value); + return ; } -void CommunicationStrategy::GetStrategy(const std::string &deviceId, int32_t dataLen, std::vector &linkTypes) +CommunicationStrategy::Strategy CommunicationStrategy::GetStrategy(const std::string &deviceId) { - if (!strategys_.Contains(deviceId)) { - return; + auto result = strategys_.Find(deviceId); + if (!result.first) { + return Strategy::DEFAULT; } - linkTypes.emplace_back(LINK_TYPE_WIFI_WLAN_5G); - linkTypes.emplace_back(LINK_TYPE_WIFI_WLAN_2G); - linkTypes.emplace_back(LINK_TYPE_WIFI_P2P); - linkTypes.emplace_back(LINK_TYPE_BR); - return; + return result.second; } } // namespace AppDistributedKv } // namespace OHOS \ No newline at end of file diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/data_buffer.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/data_buffer.cpp index d15638598674702bcf14bf2e0c82a59d668264fb..7f4060c89d6f03d21df4b4715dcf003cb42b0881 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/data_buffer.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/data_buffer.cpp @@ -72,4 +72,4 @@ size_t DataBuffer::GetBufUsed() const return used_; } } // namespace AppDistributedKv -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp index 0c25128cf684087f22bf3eaf5c7751d3a2d46551..7157dad86b95f24cdc763ef95d4a83c953628ce1 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp @@ -106,7 +106,7 @@ std::function DeviceManagerAdapter::RegDevCallback() return; } constexpr int32_t INTERVAL = 500; - auto time = std::chrono::system_clock::now() + std::chrono::milliseconds(INTERVAL); + auto time = std::chrono::steady_clock::now() + std::chrono::milliseconds(INTERVAL); scheduler_.At(time, RegDevCallback()); }; } @@ -167,7 +167,7 @@ void DeviceManagerAdapter::Online(const DmDeviceInfo &info) item->OnDeviceChanged(dvInfo, DeviceChangeType::DEVICE_ONLINE); } } - auto time = std::chrono::system_clock::now() + std::chrono::milliseconds(SYNC_TIMEOUT); + auto time = std::chrono::steady_clock::now() + std::chrono::milliseconds(SYNC_TIMEOUT); scheduler_.At(time, [this, dvInfo]() { TimeOut(dvInfo.uuid); }); syncTask_.Insert(dvInfo.uuid, dvInfo.uuid); for (const auto &item : observers) { // set compatible identify, sync service meta @@ -437,6 +437,11 @@ std::string DeviceManagerAdapter::ToUUID(const std::string &id) return GetDeviceInfoFromCache(id).uuid; } +std::string DeviceManagerAdapter::ToUDID(const std::string &id) +{ + return GetDeviceInfoFromCache(id).udid; +} + std::vector DeviceManagerAdapter::ToUUID(const std::vector &devices) { std::vector uuids; diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp index 7ca4c6587255cd435abb9f9f6664ca514678565a..380a01a1b39cf35f5bbcfc277cb2004cd9fbae6a 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp @@ -15,11 +15,10 @@ #define LOG_TAG "processCommunication" -#include "process_communicator_impl.h" - #include "device_manager_adapter.h" #include "log_print.h" - +#include "softbus_adapter.h" +#include "process_communicator_impl.h" namespace OHOS { namespace AppDistributedKv { using namespace DistributedDB; @@ -147,13 +146,11 @@ uint32_t ProcessCommunicatorImpl::GetMtuSize() uint32_t ProcessCommunicatorImpl::GetMtuSize(const DeviceInfos &devInfo) { ZLOGI("GetMtuSize start"); - DeviceInfo deviceInfo = DmAdapter::GetInstance().GetDeviceInfo(devInfo.identifier); - DeviceType deviceType = GetDeviceType(deviceInfo.deviceType); - if (deviceType == SMART_WATCH || deviceType == KID_WATCH) { - ZLOGI("GetMtuSize deviceType: %{public}d", deviceInfo.deviceType); - return MTU_SIZE_WATCH; - } - return MTU_SIZE; + DeviceId deviceId = { + .deviceId = devInfo.identifier + }; + + return SoftBusAdapter::GetInstance()->GetMtuSize(deviceId); } DeviceInfos ProcessCommunicatorImpl::GetLocalDeviceInfos() diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h index 300f9196062295cfa7f0323f27c4faec3c9dc712..277d2d73d6002e8c305e2f06b89cb40e550d7d5c 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h @@ -26,10 +26,12 @@ #include #include "app_data_change_listener.h" +#include "app_device_change_listener.h" #include "block_data.h" #include "platform_specific.h" #include "session.h" #include "softbus_bus_center.h" +#include "softbus_client.h" namespace OHOS { namespace AppDistributedKv { class SoftBusAdapter { @@ -38,8 +40,6 @@ public: ~SoftBusAdapter(); static std::shared_ptr GetInstance(); - static std::string ToBeAnonymous(const std::string &name); - // add DataChangeListener to watch data change; Status StartWatchDataChange(const AppDataChangeListener *observer, const PipeInfo &pipeInfo); @@ -58,37 +58,42 @@ public: int RemoveSessionServerAdapter(const std::string &sessionName) const; - void InsertSession(const std::string &sessionName, int32_t connId); - - std::string DeleteSession(int32_t connId); - void NotifyDataListeners(const uint8_t *data, int size, const std::string &deviceId, const PipeInfo &pipeInfo); int32_t GetSessionStatus(int32_t connId); void OnSessionOpen(int32_t connId, int32_t status); - void OnSessionClose(int32_t connId); + std::string OnSessionClose(int32_t connId); int32_t Broadcast(const PipeInfo &pipeInfo, uint16_t mask); void OnBroadcast(const DeviceId &device, uint16_t mask); int32_t ListenBroadcastMsg(const PipeInfo &pipeInfo, std::function listener); + uint32_t GetMtuSize(const DeviceId &deviceId); + std::shared_ptr GetConnect(const std::string &deviceId); + + class SofBusDeviceChangeListenerImpl : public AppDistributedKv::AppDeviceChangeListener { + void OnDeviceChanged(const AppDistributedKv::DeviceInfo &info, + const AppDistributedKv::DeviceChangeType &type) const override; + }; private: std::shared_ptr> GetSemaphore(int32_t connId); - Status GetConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId, int32_t dataSize, int32_t &connId); - Status OpenConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId, int32_t dataSize, int32_t &connId); - void InitSessionAttribute(const PipeInfo &pipeInfo, const DeviceId &deviceId, int32_t dataSize, - SessionAttribute &attr); + std::string DelConnect(int32_t connId); + void DelSessionStatus(int32_t connId); + void AfterStrategyUpdate(const std::string &deviceId); + static constexpr uint32_t WAIT_MAX_TIME = 10; static std::shared_ptr instance_; ConcurrentMap dataChangeListeners_{}; - ConcurrentMap connects_{}; + std::mutex connMutex_{}; + std::map> connects_ {}; bool flag_ = true; // only for br flag ISessionListener sessionListener_{}; std::mutex statusMutex_{}; std::map>> sessionsStatus_; std::function onBroadcast_; + static SofBusDeviceChangeListenerImpl listener_; }; } // namespace AppDistributedKv } // namespace OHOS -#endif /* DISTRIBUTEDDATAFWK_SRC_SOFTBUS_ADAPTER_H */ \ No newline at end of file +#endif /* DISTRIBUTEDDATAFWK_SRC_SOFTBUS_ADAPTER_H */ diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp index d76d261f43d25ea5db0b48c51c915adf036794dc..e86d19455e649156a04b01e518ddf372c07de511 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp @@ -15,9 +15,9 @@ #include #include -#include "communication_strategy.h" #include "device_manager_adapter.h" #include "dfx_types.h" +#include "kvstore_utils.h" #include "log_print.h" #include "reporter.h" #include "securec.h" @@ -32,13 +32,6 @@ namespace OHOS { namespace AppDistributedKv { -constexpr int32_t HEAD_SIZE = 3; -constexpr int32_t END_SIZE = 3; -constexpr int32_t MIN_SIZE = HEAD_SIZE + END_SIZE + 3; -constexpr const char *REPLACE_CHAIN = "***"; -constexpr const char *DEFAULT_ANONYMOUS = "******"; -constexpr int32_t SOFTBUS_OK = 0; -constexpr int32_t SOFTBUS_ERR = 1; enum SoftBusAdapterErrorCode : int32_t { SESSION_ID_INVALID = 2, MY_SESSION_NAME_INVALID, @@ -48,11 +41,12 @@ enum SoftBusAdapterErrorCode : int32_t { }; constexpr int32_t SESSION_NAME_SIZE_MAX = 65; constexpr int32_t DEVICE_ID_SIZE_MAX = 65; -constexpr uint32_t WAIT_MAX_TIME = 5; +constexpr uint32_t DEFAULT_MTU_SIZE = 4096u; using namespace std; using namespace OHOS::DistributedDataDfx; using namespace OHOS::DistributedKv; using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; +using Strategy = CommunicationStrategy::Strategy; struct ConnDetailsInfo { char myName[SESSION_NAME_SIZE_MAX] = ""; char peerName[SESSION_NAME_SIZE_MAX] = ""; @@ -106,7 +100,7 @@ INodeStateCb g_callback = { .onNodeStatusChanged = OnCareEvent, }; } // namespace - +SoftBusAdapter::SofBusDeviceChangeListenerImpl SoftBusAdapter::listener_; SoftBusAdapter::SoftBusAdapter() { ZLOGI("begin"); @@ -116,6 +110,11 @@ SoftBusAdapter::SoftBusAdapter() sessionListener_.OnSessionClosed = AppDataListenerWrap::OnConnectClosed; sessionListener_.OnBytesReceived = AppDataListenerWrap::OnBytesReceived; sessionListener_.OnMessageReceived = AppDataListenerWrap::OnBytesReceived; + + auto status = DmAdapter::GetInstance().StartWatchDeviceChange(&listener_, {"softBusAdapter"}); + if (status != Status::SUCCESS) { + ZLOGW("register device change failed, status:%d", static_cast(status)); + } } SoftBusAdapter::~SoftBusAdapter() @@ -124,19 +123,7 @@ SoftBusAdapter::~SoftBusAdapter() if (onBroadcast_) { UnregNodeDeviceStateCb(&g_callback); } -} - -std::string SoftBusAdapter::ToBeAnonymous(const std::string &name) -{ - if (name.length() <= HEAD_SIZE) { - return DEFAULT_ANONYMOUS; - } - - if (name.length() < MIN_SIZE) { - return (name.substr(0, HEAD_SIZE) + REPLACE_CHAIN); - } - - return (name.substr(0, HEAD_SIZE) + REPLACE_CHAIN + name.substr(name.length() - END_SIZE, END_SIZE)); + connects_.clear(); } std::shared_ptr SoftBusAdapter::GetInstance() @@ -173,81 +160,70 @@ Status SoftBusAdapter::StopWatchDataChange(__attribute__((unused)) const AppData return Status::ERROR; } -Status SoftBusAdapter::OpenConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId, int32_t dataSize, - int32_t &connId) +Status SoftBusAdapter::SendData(const PipeInfo &pipeInfo, const DeviceId &deviceId, const uint8_t *data, int size, + const MessageInfo &info) { - SessionAttribute attr = { 0 }; - InitSessionAttribute(pipeInfo, deviceId, dataSize, attr); - int id = OpenSession(pipeInfo.pipeId.c_str(), pipeInfo.pipeId.c_str(), - DmAdapter::GetInstance().ToNetworkID(deviceId.deviceId).c_str(), "GROUP_ID", &attr); - ZLOGI("[OpenSession] to %{public}s,session:%{public}s, connId:%{public}d, linkNum:%{public}d", - ToBeAnonymous(deviceId.deviceId).c_str(), pipeInfo.pipeId.c_str(), id, attr.linkTypeNum); - if (connId < 0) { - ZLOGW("OpenSession %{public}s, type:%{public}d failed, connId:%{public}d", pipeInfo.pipeId.c_str(), - attr.dataType, id); - return Status::NETWORK_ERROR; + std::shared_ptr conn; + { + lock_guard lock(connMutex_); + std::string key = pipeInfo.pipeId + deviceId.deviceId; + if (connects_.find(key) == connects_.end()) { + connects_.emplace(key, std::make_shared(pipeInfo, deviceId, [this](int32_t connId) { + return GetSessionStatus(connId); + })); + } + conn = connects_[key]; } - int state = GetSessionStatus(id); - ZLOGI("waited for notification, state:%{public}d connId:%{public}d", state, id); - if (state != SOFTBUS_OK) { - ZLOGE("OpenSession callback result error"); - CloseSession(id); - return Status::NETWORK_ERROR; + + if (conn != nullptr) { + return conn->Send(data, size); } - connId = id; - return Status::SUCCESS; + return Status::ERROR; } -void SoftBusAdapter::InitSessionAttribute(const PipeInfo &pipeInfo, const DeviceId &deviceId, int32_t dataSize, - SessionAttribute &attr) +std::shared_ptr SoftBusAdapter::GetConnect(const std::string &deviceId) { - attr.dataType = TYPE_BYTES; - std::vector linkTypes; - CommunicationStrategy::GetInstance().GetStrategy(deviceId.deviceId, dataSize, linkTypes); - int index = 0; - for (auto const &element : linkTypes) { - attr.linkType[index++] = element; - if (index >= LINK_TYPE_MAX) { - break; + lock_guard lock(connMutex_); + for (const auto& conn : connects_) { + if (*conn.second == deviceId) { + return conn.second; } } - attr.linkTypeNum = index; - ZLOGD("set session attr pipeInfo:%{public}s deviceId:%{public}s link Num: %{public}d, link size: %{public}zu," - " size: %{public}d", pipeInfo.pipeId.c_str(), - ToBeAnonymous(deviceId.deviceId).c_str(), attr.linkTypeNum, linkTypes.size(), dataSize); + return nullptr; } -Status SoftBusAdapter::GetConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId, int32_t dataSize, int32_t &connId) +uint32_t SoftBusAdapter::GetMtuSize(const DeviceId &deviceId) { - auto result = connects_.Find(pipeInfo.pipeId + deviceId.deviceId); - if (result.first) { - connId = result.second; - return Status::SUCCESS; + std::shared_ptr conn = GetConnect(deviceId.deviceId); + if (conn != nullptr) { + return conn->GetMtuSize(); } - - return OpenConnect(pipeInfo, deviceId, dataSize, connId); + return DEFAULT_MTU_SIZE; } -Status SoftBusAdapter::SendData(const PipeInfo &pipeInfo, const DeviceId &deviceId, const uint8_t *data, int size, - const MessageInfo &info) +std::string SoftBusAdapter::DelConnect(int32_t connId) { - int connId = 0; - auto state = GetConnect(pipeInfo, deviceId, size, connId); - if (state != Status::SUCCESS) { - ZLOGW("get connect %{public}s, type:%{public}d failed, status:%{public}d", pipeInfo.pipeId.c_str(), - info.msgType, state); - return state; + lock_guard lock(connMutex_); + std::string name; + for (const auto& conn : connects_) { + if (*conn.second == connId) { + name = conn.first; + connects_.erase(conn.first); + break; + } } + return name; +} - ZLOGD("[SendData] to %{public}s, session:%{public}s, send len:%{public}d, connId:%{public}d", - ToBeAnonymous(deviceId.deviceId).c_str(), pipeInfo.pipeId.c_str(), size, connId); - int32_t ret = SendBytes(connId, data, size); - if (ret != SOFTBUS_OK) { - ZLOGE("[SendBytes] to %{public}d failed, ret:%{public}d.", connId, ret); - return Status::ERROR; +void SoftBusAdapter::DelSessionStatus(int32_t connId) +{ + lock_guard lock(statusMutex_); + auto it = sessionsStatus_.find(connId); + if (it != sessionsStatus_.end()) { + it->second->Clear(SOFTBUS_ERR); + sessionsStatus_.erase(it); } - return Status::SUCCESS; } int32_t SoftBusAdapter::GetSessionStatus(int32_t connId) @@ -262,14 +238,10 @@ void SoftBusAdapter::OnSessionOpen(int32_t connId, int32_t status) semaphore->SetValue(status); } -void SoftBusAdapter::OnSessionClose(int32_t connId) +std::string SoftBusAdapter::OnSessionClose(int32_t connId) { - lock_guard lock(statusMutex_); - auto it = sessionsStatus_.find(connId); - if (it != sessionsStatus_.end()) { - it->second->Clear(SOFTBUS_ERR); - sessionsStatus_.erase(it); - } + DelSessionStatus(connId); + return DelConnect(connId); } std::shared_ptr> SoftBusAdapter::GetSemaphore(int32_t connId) @@ -284,8 +256,8 @@ std::shared_ptr> SoftBusAdapter::GetSemaphore(int32_t connId) bool SoftBusAdapter::IsSameStartedOnPeer(const struct PipeInfo &pipeInfo, __attribute__((unused)) const struct DeviceId &peer) { - ZLOGI("pipeInfo:%{public}s deviceId:%{public}s", pipeInfo.pipeId.c_str(), ToBeAnonymous(peer.deviceId).c_str()); - + ZLOGI("pipeInfo:%{public}s deviceId:%{public}s", pipeInfo.pipeId.c_str(), + KvStoreUtils::ToBeAnonymous(peer.deviceId).c_str()); return true; } @@ -307,26 +279,6 @@ int SoftBusAdapter::RemoveSessionServerAdapter(const std::string &sessionName) c return RemoveSessionServer("ohos.distributeddata", sessionName.c_str()); } -void SoftBusAdapter::InsertSession(const std::string &sessionName, int32_t connId) -{ - ZLOGD("[InsertSession] connId:%{public}d", connId); - connects_.InsertOrAssign(sessionName, connId); -} - -std::string SoftBusAdapter::DeleteSession(int32_t connId) -{ - std::string name = ""; - connects_.EraseIf([&connId, &name](auto &key, int32_t id) { - if (connId == id) { - name = key; - return true; - } - return false; - }); - - return name; -} - void SoftBusAdapter::NotifyDataListeners(const uint8_t *data, int size, const std::string &deviceId, const PipeInfo &pipeInfo) { @@ -334,7 +286,7 @@ void SoftBusAdapter::NotifyDataListeners(const uint8_t *data, int size, const st auto ret = dataChangeListeners_.ComputeIfPresent(pipeInfo.pipeId, [&data, &size, &deviceId, &pipeInfo](const auto &key, const AppDataChangeListener *&value) { ZLOGD("ready to notify, pipeName:%{public}s, deviceId:%{public}s.", pipeInfo.pipeId.c_str(), - ToBeAnonymous(deviceId).c_str()); + KvStoreUtils::ToBeAnonymous(deviceId).c_str()); DeviceInfo deviceInfo = DmAdapter::GetInstance().GetDeviceInfo(deviceId); value->OnMessage(deviceInfo, data, size, pipeInfo); TrafficStat ts{ pipeInfo.pipeId, deviceId, 0, size }; @@ -354,9 +306,10 @@ int32_t SoftBusAdapter::Broadcast(const PipeInfo &pipeInfo, uint16_t mask) void SoftBusAdapter::OnBroadcast(const DeviceId &device, uint16_t mask) { - ZLOGI("device:%{public}s mask:0x%{public}x", ToBeAnonymous(device.deviceId).c_str(), mask); + ZLOGI("device:%{public}s mask:0x%{public}x", KvStoreUtils::ToBeAnonymous(device.deviceId).c_str(), mask); if (!onBroadcast_) { - ZLOGW("no listener device:%{public}s mask:0x%{public}x", ToBeAnonymous(device.deviceId).c_str(), mask); + ZLOGW("no listener device:%{public}s mask:0x%{public}x", + KvStoreUtils::ToBeAnonymous(device.deviceId).c_str(), mask); return; } onBroadcast_(device.deviceId, mask); @@ -426,13 +379,8 @@ int AppDataListenerWrap::OnConnectOpened(int connId, int result) } ZLOGD("[OnConnectOpened] conn id:%{public}d, my name:%{public}s, peer name:%{public}s, " - "peer devId:%{public}s, side:%{public}d", - connId, connInfo.myName, connInfo.peerName, SoftBusAdapter::ToBeAnonymous(connInfo.peerDevUuid).c_str(), - connInfo.side); - // only manage the connects opened by the local - if (connInfo.side == 1) { - softBusAdapter_->InsertSession(std::string(connInfo.myName) + connInfo.peerDevUuid, connId); - } + "peer devId:%{public}s, side:%{public}d", connId, connInfo.myName, connInfo.peerName, + KvStoreUtils::ToBeAnonymous(connInfo.peerDevUuid).c_str(), connInfo.side); return 0; } @@ -440,9 +388,8 @@ void AppDataListenerWrap::OnConnectClosed(int connId) { // when the local close the session, this callback function will not be triggered; // when the current function is called, soft bus has released the session resource, only connId is valid; - softBusAdapter_->OnSessionClose(connId); - std::string name = softBusAdapter_->DeleteSession(connId); - ZLOGI("[SessionClosed] connId:%{public}d, name:%{public}s", connId, SoftBusAdapter::ToBeAnonymous(name).c_str()); + std::string name = softBusAdapter_->OnSessionClose(connId); + ZLOGI("[SessionClosed] connId:%{public}d, name:%{public}s", connId, KvStoreUtils::ToBeAnonymous(name).c_str()); } void AppDataListenerWrap::OnBytesReceived(int connId, const void *data, unsigned int dataLen) @@ -455,8 +402,8 @@ void AppDataListenerWrap::OnBytesReceived(int connId, const void *data, unsigned } ZLOGD("[OnBytesReceived] conn id:%{public}d, peer name:%{public}s, " - "peer devId:%{public}s, side:%{public}d", - connId, connInfo.peerName, SoftBusAdapter::ToBeAnonymous(connInfo.peerDevUuid).c_str(), connInfo.side); + "peer devId:%{public}s, side:%{public}d, data len:%{public}u", connId, connInfo.peerName, + KvStoreUtils::ToBeAnonymous(connInfo.peerDevUuid).c_str(), connInfo.side, dataLen); NotifyDataListeners(reinterpret_cast(data), dataLen, connInfo.peerDevUuid, { std::string(connInfo.peerName), "" }); @@ -467,5 +414,33 @@ void AppDataListenerWrap::NotifyDataListeners(const uint8_t *data, const int siz { softBusAdapter_->NotifyDataListeners(data, size, deviceId, pipeInfo); } + +void SoftBusAdapter::SofBusDeviceChangeListenerImpl::OnDeviceChanged(const AppDistributedKv::DeviceInfo &info, + const AppDistributedKv::DeviceChangeType &type) const +{ + Strategy strategy = Strategy::BUTT; + switch (type) { + case AppDistributedKv::DeviceChangeType::DEVICE_ONLINE: + strategy = Strategy::ON_LINE_SELECT_CHANNEL; + break; + case AppDistributedKv::DeviceChangeType::DEVICE_ONREADY: + strategy = Strategy::DEFAULT; + break; + default: + break; + } + + if (strategy >= Strategy::BUTT) { + return; + } + + CommunicationStrategy::GetInstance().SetStrategy(info.uuid, strategy, + [this](const std::string deviceId, Strategy strategy) { + std::shared_ptr conn = SoftBusAdapter::GetInstance()->GetConnect(deviceId); + if (conn != nullptr) { + conn->AfterStrategyUpdate(strategy); + } + }); +} } // namespace AppDistributedKv -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fe9601d64a66d21c2381114f0aee49666fa623e9 --- /dev/null +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "SoftBusClient" +#include "device_manager_adapter.h" +#include "kvstore_utils.h" +#include "log_print.h" +#include "softbus_error_code.h" +#include "softbus_client.h" + +namespace OHOS::AppDistributedKv { +using namespace OHOS::DistributedKv; +using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; +SoftBusClient::SoftBusClient(const PipeInfo &pipeInfo, const DeviceId &deviceId, + const std::function &getConnStatus) + : pipe_(pipeInfo), device_(deviceId), getConnStatus_(getConnStatus) +{ + mtu_ = DEFAULT_MTU_SIZE; +} + +SoftBusClient::~SoftBusClient() +{ + if (connId_ > 0) { + CloseSession(connId_); + } +} + +bool SoftBusClient::operator==(int32_t connId) const +{ + return connId_ == connId; +} + +bool SoftBusClient::operator==(const std::string &deviceId) const +{ + return device_.deviceId == deviceId; +} + +void SoftBusClient::RestoreDefaultValue() +{ + connId_ = INVALID_CONNECT_ID; + status_ = ConnectStatus::DISCONNECT; + strategy_ = Strategy::DEFAULT; + mtu_ = DEFAULT_MTU_SIZE; +} + +uint32_t SoftBusClient::GetMtuSize() const +{ + ZLOGD("get mtu size connId:%{public}d mtu:%{public}d", connId_, mtu_); + return mtu_; +} + +Status SoftBusClient::Send(const uint8_t *data, int size) +{ + std::lock_guard lock(mutex_); + auto result = OpenConnect(); + if (result != Status::SUCCESS) { + return result; + } + + ZLOGD("send data connId:%{public}d, data size:%{public}d.", connId_, size); + int32_t ret = SendBytes(connId_, data, size); + if (ret != SOFTBUS_OK) { + ZLOGE("send data to connId%{public}d failed, ret:%{public}d.", connId_, ret); + return Status::ERROR; + } + + return Status::SUCCESS; +} + +Status SoftBusClient::OpenConnect() +{ + if (status_ == ConnectStatus::CONNECT_OK) { + return Status::SUCCESS; + } + + auto result = Open(); + if (result != Status::SUCCESS) { + return result; + } + status_ = ConnectStatus::CONNECT_OK; + UpdateMtuSize(); + return Status::SUCCESS; +} + +Status SoftBusClient::Open() +{ + Strategy strategy = CommunicationStrategy::GetInstance().GetStrategy(device_.deviceId); + SessionAttribute attr = { 0 }; + InitSessionAttribute(strategy, attr); + int id = OpenSession(pipe_.pipeId.c_str(), pipe_.pipeId.c_str(), + DmAdapter::GetInstance().ToNetworkID(device_.deviceId).c_str(), "GROUP_ID", &attr); + ZLOGI("open %{public}s,session:%{public}s,connId:%{public}d,linkNum:%{public}d,strategy:%{public}d", + KvStoreUtils::ToBeAnonymous(device_.deviceId).c_str(), pipe_.pipeId.c_str(), id, attr.linkTypeNum, strategy); + if (id < 0) { + ZLOGW("Open %{public}s, type:%{public}d failed, connId:%{public}d", + pipe_.pipeId.c_str(), attr.dataType, id); + return Status::NETWORK_ERROR; + } + + connId_ = id; + strategy_ = strategy; + int state = getConnStatus_(connId_); + ZLOGI("waited for notification, state:%{public}d connId:%{public}d", state, id); + if (state != SOFTBUS_OK) { + ZLOGE("open callback result error"); + return Status::NETWORK_ERROR; + } + return Status::SUCCESS; +} + +void SoftBusClient::InitSessionAttribute(Strategy strategy, SessionAttribute &attr) +{ + attr.dataType = TYPE_BYTES; + // If the dataType is BYTES, the default strategy is wifi_5G > wifi_2.4G > BR, without P2P; + if (strategy == Strategy::DEFAULT) { + return; + } + + int index = 0; + attr.linkType[index++] = LINK_TYPE_WIFI_WLAN_5G; + attr.linkType[index++] = LINK_TYPE_WIFI_WLAN_2G; + attr.linkType[index++] = LINK_TYPE_WIFI_P2P; + attr.linkType[index++] = LINK_TYPE_BR; + attr.linkTypeNum = index; +} + +void SoftBusClient::UpdateMtuSize() +{ + uint32_t mtu = 0; + auto result = GetSessionOption(connId_, SESSION_OPTION_MAX_SENDBYTES_SIZE, &mtu, sizeof(mtu)); + if (result != SOFTBUS_OK) { + return; + } + mtu_ = mtu; +} + +void SoftBusClient::AfterStrategyUpdate(Strategy strategy) +{ + std::lock_guard lock(mutex_); + if (strategy != strategy_ && connId_ > 0) { + ZLOGI("close connId:%{public}d,strategy current:%{public}d, new:%{public}d", connId_, strategy_, strategy); + CloseSession(connId_); + RestoreDefaultValue(); + } +} +} \ No newline at end of file diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.h b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.h new file mode 100644 index 0000000000000000000000000000000000000000..4a4346062453360f81d69acf203e97f0372b5f88 --- /dev/null +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_SOFTBUS_CLIENT_H +#define DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_SOFTBUS_CLIENT_H + +#include +#include + +#include "communication_strategy.h" +#include "session.h" +#include "softbus_bus_center.h" +namespace OHOS::AppDistributedKv { +class SoftBusClient { +public: + SoftBusClient(const PipeInfo &pipeInfo, const DeviceId &deviceId, + const std::function &getConnStatus); + ~SoftBusClient(); + + using Strategy = CommunicationStrategy::Strategy; + Status Send(const uint8_t *data, int size); + bool operator==(int32_t connId) const; + bool operator==(const std::string &deviceId) const; + uint32_t GetMtuSize() const; + void AfterStrategyUpdate(Strategy strategy); +private: + enum class ConnectStatus : int32_t { + CONNECT_OK, + DISCONNECT, + }; + + Status OpenConnect(); + Status Open(); + void InitSessionAttribute(Strategy strategy, SessionAttribute &attr); + void RestoreDefaultValue(); + void UpdateMtuSize(); + + static constexpr int32_t INVALID_CONNECT_ID = -1; + static constexpr uint32_t WAIT_MAX_TIME = 10; + static constexpr uint32_t DEFAULT_MTU_SIZE = 4096u; + int32_t connId_ = INVALID_CONNECT_ID; + Strategy strategy_ = Strategy::DEFAULT; + ConnectStatus status_ = ConnectStatus::DISCONNECT; + std::mutex mutex_; + PipeInfo pipe_; + DeviceId device_; + uint32_t mtu_; + std::function getConnStatus_; +}; +} + + +#endif // DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_SOFTBUS_CLIENT_H diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp index b82a8c76594550c51349274636190a127a5b84de..a321ad53c8767c8610ec3ce6fbca3aad0975ba3e 100644 --- a/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp @@ -14,18 +14,12 @@ */ #include "device_manager_adapter.h" - -#include "device_manager.h" -#include "device_manager_callback.h" -#include "dm_device_info.h" #include "gtest/gtest.h" #include "types.h" namespace { using namespace testing::ext; using namespace OHOS::AppDistributedKv; using namespace OHOS::DistributedData; -using DmDeviceInfo = OHOS::DistributedHardware::DmDeviceInfo; -using DeviceManager = OHOS::DistributedHardware::DeviceManager; class DeviceChangerListener final : public AppDeviceChangeListener { public: void OnDeviceChanged(const DeviceInfo &info, const DeviceChangeType &type) const override @@ -135,10 +129,7 @@ HWTEST_F(DeviceManagerAdapterTest, GetLocalDevice, TestSize.Level0) HWTEST_F(DeviceManagerAdapterTest, GetRemoteDevices, TestSize.Level0) { auto dvInfos = DeviceManagerAdapter::GetInstance().GetRemoteDevices(); - std::vector dmInfos; - auto ret = DeviceManager::GetInstance().GetTrustedDeviceList("ohos.distributeddata.service", "", dmInfos); - EXPECT_EQ(ret, 0); - EXPECT_EQ(dvInfos.size(), dmInfos.size()); + EXPECT_TRUE(dvInfos.empty()); } /** diff --git a/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/communication_fault_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/communication_fault_impl.cpp index c6a9cd5f753cb81fc13a0f1f623086993fd3c1d5..9c1b32bedd6b3de233f224d9fe15ed008931d022 100644 --- a/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/communication_fault_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/communication_fault_impl.cpp @@ -23,4 +23,4 @@ ReportStatus CommunicationFaultImpl::Report(const CommFaultMsg &msg) return ReportStatus::SUCCESS; } } // namespace DistributedDataDfx -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/runtime_fault_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/runtime_fault_impl.cpp index 1de2142155c98eac4afb8caefb44eebb5a4e3a9d..3fa0543a5b1417c3bc4a63bf5644315464129687 100644 --- a/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/runtime_fault_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/runtime_fault_impl.cpp @@ -23,4 +23,4 @@ ReportStatus RuntimeFaultImpl::Report(const FaultMsg &msg) return ReportStatus::SUCCESS; } } // namespace DistributedDataDfx -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/service_fault_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/service_fault_impl.cpp index 8a174c09c05e41ec7ac77f75846cd7ec4903f388..5fb3a55f87c46d53b4ea2c9678cad75d48c580f0 100644 --- a/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/service_fault_impl.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/dfx/src/fault/service_fault_impl.cpp @@ -23,4 +23,4 @@ ReportStatus ServiceFaultImpl::Report(const OHOS::DistributedDataDfx::FaultMsg & return ReportStatus::SUCCESS; } } // namespace DistributedDataDfx -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp b/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp index b38adc13725a6759a3f8eb213b2add6425b3fb9a..fa798432895b9bb2f2f68d8829113fa04b96541e 100644 --- a/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp +++ b/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp @@ -79,7 +79,7 @@ std::mutex HiViewAdapter::apiPerformanceMutex_; std::map> HiViewAdapter::apiPerformanceStat_; bool HiViewAdapter::running_ = false; -KvScheduler HiViewAdapter::scheduler_ {"HiView"}; +TaskScheduler HiViewAdapter::scheduler_ {"HiView"}; std::mutex HiViewAdapter::runMutex_; void HiViewAdapter::ReportFault(int dfxCode, const FaultMsg &msg) @@ -93,7 +93,7 @@ void HiViewAdapter::ReportFault(int dfxCode, const FaultMsg &msg) INTERFACE_NAME, msg.interfaceName, ERROR_TYPE, static_cast(msg.errorType)); }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); } void HiViewAdapter::ReportDBFault(int dfxCode, const DBFaultMsg &msg) @@ -107,7 +107,7 @@ void HiViewAdapter::ReportDBFault(int dfxCode, const DBFaultMsg &msg) MODULE_NAME, msg.moduleName, ERROR_TYPE, static_cast(msg.errorType)); }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); } @@ -128,7 +128,7 @@ void HiViewAdapter::ReportCommFault(int dfxCode, const CommFaultMsg &msg) STORE_ID, msg.storeId, SYNC_ERROR_INFO, message); }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); } void HiViewAdapter::ReportBehaviour(int dfxCode, const BehaviourMsg &msg) @@ -145,7 +145,7 @@ void HiViewAdapter::ReportBehaviour(int dfxCode, const BehaviourMsg &msg) STORE_ID, msg.storeId, BEHAVIOUR_INFO, message); }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); } void HiViewAdapter::ReportDatabaseStatistic(int dfxCode, const DbStat &stat) @@ -156,7 +156,7 @@ void HiViewAdapter::ReportDatabaseStatistic(int dfxCode, const DbStat &stat) dbStat_.insert({stat.GetKey(), {stat, 0, dfxCode}}); } }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); StartTimerThread(); } @@ -217,7 +217,7 @@ void HiViewAdapter::ReportTrafficStatistic(int dfxCode, const TrafficStat &stat) trafficStat_.insert({stat.GetKey(), {stat, 0, dfxCode}}); } }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); StartTimerThread(); } @@ -254,7 +254,7 @@ void HiViewAdapter::ReportVisitStatistic(int dfxCode, const VisitStat &stat) it->second.times++; } }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); StartTimerThread(); } @@ -294,7 +294,7 @@ void HiViewAdapter::ReportApiPerformanceStatistic(int dfxCode, const ApiPerforma } }); - scheduler_.At(std::chrono::system_clock::now(), std::move(task)); + scheduler_.At(std::chrono::steady_clock::now(), std::move(task)); StartTimerThread(); } diff --git a/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.h b/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.h index 397f859a6669abf979a890f8a83d69a95029f5d4..d7c57f93d0baadb1745152477fe86fe4994e07c1 100644 --- a/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.h +++ b/datamgr_service/services/distributeddataservice/adapter/dfx/src/hiview_adapter.h @@ -21,7 +21,7 @@ #include "dfx_types.h" #include "dfx_code_constant.h" #include "hisysevent.h" -#include "kv_scheduler.h" +#include "task_scheduler.h" #include "kv_store_thread_pool.h" #include "kv_store_task.h" #include "value_hash.h" @@ -70,7 +70,7 @@ private: private: static std::mutex runMutex_; static bool running_; - static DistributedKv::KvScheduler scheduler_; + static TaskScheduler scheduler_; static const inline int DAILY_REPORT_TIME = 23; static const inline int WAIT_TIME = 1 * 60 * 60; // 1 hours }; diff --git a/datamgr_service/services/distributeddataservice/adapter/include/autils/directory_utils.h b/datamgr_service/services/distributeddataservice/adapter/include/autils/directory_utils.h index ced19ca7953dc3b2f86ba9ff2e92eb831eacaec0..67ba84dda6bbe4c17c3f9b9358d90153ffbd1347 100644 --- a/datamgr_service/services/distributeddataservice/adapter/include/autils/directory_utils.h +++ b/datamgr_service/services/distributeddataservice/adapter/include/autils/directory_utils.h @@ -47,4 +47,4 @@ private: }; } // namespace DistributedKv } // namespace OHOS -#endif // DIRECTORY_UTILS_H \ No newline at end of file +#endif // DIRECTORY_UTILS_H diff --git a/datamgr_service/services/distributeddataservice/adapter/include/autils/kv_store_thread_pool.h b/datamgr_service/services/distributeddataservice/adapter/include/autils/kv_store_thread_pool.h index 1b1d7502a9392c0d17eabf0f2b4a24f2ca964c98..6b908a68b16092eca96c186339baf4cdec35da8c 100644 --- a/datamgr_service/services/distributeddataservice/adapter/include/autils/kv_store_thread_pool.h +++ b/datamgr_service/services/distributeddataservice/adapter/include/autils/kv_store_thread_pool.h @@ -32,7 +32,6 @@ public: KVSTORE_API static std::shared_ptr GetPool( int poolSize, std::string poolName, bool startImmediately = false); KVSTORE_API virtual void Stop() = 0; - KVSTORE_API virtual void Run() = 0; KVSTORE_API virtual bool AddTask(KvStoreTask &&task) = 0; KVSTORE_API static constexpr int MAX_POOL_SIZE = 64; // the max thread pool size KVSTORE_API static constexpr int DEFAULT_POOL_SIZE = 8; // the default thread pool size diff --git a/datamgr_service/services/distributeddataservice/adapter/include/autils/platform_specific.h b/datamgr_service/services/distributeddataservice/adapter/include/autils/platform_specific.h index c98b734b46746d3d2d5d4af0e6aa8c126ffbd75a..6634dbf40a545c24ca61c156dc41e15b40e3453b 100644 --- a/datamgr_service/services/distributeddataservice/adapter/include/autils/platform_specific.h +++ b/datamgr_service/services/distributeddataservice/adapter/include/autils/platform_specific.h @@ -22,4 +22,4 @@ #define OS_OHOS #endif -#endif // PLATFORM_SPECIFIC_H \ No newline at end of file +#endif // PLATFORM_SPECIFIC_H diff --git a/datamgr_service/services/distributeddataservice/adapter/include/autils/time_utils.h b/datamgr_service/services/distributeddataservice/adapter/include/autils/time_utils.h index bfa87ba77765112239e8d7a7fcaae1d09a25b0b8..a67f12f7c41fa0f3bdeb9734a4131c1585149293 100644 --- a/datamgr_service/services/distributeddataservice/adapter/include/autils/time_utils.h +++ b/datamgr_service/services/distributeddataservice/adapter/include/autils/time_utils.h @@ -35,4 +35,4 @@ public: }; } // namespace DistributedKv } // namespace OHOS -#endif \ No newline at end of file +#endif diff --git a/datamgr_service/services/distributeddataservice/adapter/include/communicator/communication_strategy.h b/datamgr_service/services/distributeddataservice/adapter/include/communicator/communication_strategy.h new file mode 100644 index 0000000000000000000000000000000000000000..e21c6d9eb659ce06f56a75bdeab66b95e1aa0bf8 --- /dev/null +++ b/datamgr_service/services/distributeddataservice/adapter/include/communicator/communication_strategy.h @@ -0,0 +1,56 @@ +/* +* Copyright (c) 2022 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_COMMUNICATION_STRATEGY_H +#define DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_COMMUNICATION_STRATEGY_H +#include +#include + +#include "../../../../../../kv_store/frameworks/common/concurrent_map.h" +#include "../../../../../../kv_store/frameworks/common/visibility.h" +namespace OHOS::AppDistributedKv { +class API_EXPORT CommunicationStrategy { +public: + enum class Strategy : int32_t { + // If AP is available, the AP is preferred. When AP is not available, only BR can be used; p2p is not support + DEFAULT, + // If AP is available, the AP is preferred. When AP is not available, BR is used for a small amount of data + // and P2P is used for a large amount of data; The strategy takes effect only at the device online stage; + ON_LINE_SELECT_CHANNEL, + BUTT + }; + static CommunicationStrategy &GetInstance(); + using Strategy = CommunicationStrategy::Strategy; + void RegGetSyncDataSize(const std::string &type, const std::function &getDataSize); + CommunicationStrategy::Strategy GetStrategy(const std::string &deviceId); + void SetStrategy(const std::string &deviceId, Strategy strategy, + const std::function &action); +private: + CommunicationStrategy() = default; + ~CommunicationStrategy() = default; + CommunicationStrategy(CommunicationStrategy const &) = delete; + void operator=(CommunicationStrategy const &) = delete; + CommunicationStrategy(CommunicationStrategy &&) = delete; + CommunicationStrategy &operator=(CommunicationStrategy &&) = delete; + + size_t CalcSyncDataSize(const std::string &deviceId); + + static constexpr uint32_t SWITCH_CONNECTION_THRESHOLD = 75 * 1024u; + ConcurrentMap> calcDataSizes_; + ConcurrentMap strategys_; +}; +} + +#endif // DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_COMMUNICATION_STRATEGY_H diff --git a/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h b/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h index 4211ec34abab608b3fe477bd6488d3050f524845..331365abb60a239b02808cbbbd60e88fcfce9a4a 100644 --- a/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h +++ b/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h @@ -25,7 +25,7 @@ #include "device_manager.h" #include "device_manager_callback.h" #include "dm_device_info.h" -#include "kv_scheduler.h" +#include "task_scheduler.h" #include "lru_bucket.h" namespace OHOS { @@ -33,7 +33,7 @@ namespace DistributedData { class API_EXPORT DeviceManagerAdapter { public: using DmDeviceInfo = OHOS::DistributedHardware::DmDeviceInfo; - using KvScheduler = OHOS::DistributedKv::KvScheduler; + using KvScheduler = OHOS::TaskScheduler; using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo; using PipeInfo = OHOS::AppDistributedKv::PipeInfo; using AppDeviceChangeListener = OHOS::AppDistributedKv::AppDeviceChangeListener; @@ -49,6 +49,7 @@ public: std::string GetUdidByNetworkId(const std::string &networkId); DeviceInfo GetLocalBasicInfo(); std::string ToUUID(const std::string &id); + std::string ToUDID(const std::string &id); static std::vector ToUUID(const std::vector &devices); static std::vector ToUUID(std::vector devices); std::string ToNetworkID(const std::string &id); @@ -76,7 +77,7 @@ private: LRUBucket deviceInfos_ {64}; static constexpr size_t TIME_TASK_CAPACITY = 50; KvScheduler scheduler_ {TIME_TASK_CAPACITY, "dm_adapter"}; - static constexpr int32_t SYNC_TIMEOUT = 30 * 1000; // ms + static constexpr int32_t SYNC_TIMEOUT = 10 * 1000; // ms ConcurrentMap syncTask_ {}; }; } // namespace DistributedData diff --git a/datamgr_service/services/distributeddataservice/adapter/include/dfx/dds_trace.h b/datamgr_service/services/distributeddataservice/adapter/include/dfx/dds_trace.h index 4247b53aebaa3e0eb07db321648a3e8fffd08924..a80b19d71b76afeba433918f0ae12aecb04d5f3e 100644 --- a/datamgr_service/services/distributeddataservice/adapter/include/dfx/dds_trace.h +++ b/datamgr_service/services/distributeddataservice/adapter/include/dfx/dds_trace.h @@ -52,12 +52,6 @@ public: Finish(traceValue_); } - void SetMiddleTrace(const std::string &before, const std::string &after) - { - traceValue_ = after; - Middle(before, after); - } - private: void Start(const std::string &value) { @@ -71,12 +65,6 @@ private: lastTime_ = System::now(); } } - void Middle(const std::string &beforeValue, const std::string &afterValue) - { - if ((traceSwitch_ & BYTRACE_ON) == BYTRACE_ON) { - MiddleTrace(TRACE_CHAIN_ON, beforeValue, afterValue); - } - } void Finish(const std::string &value) { if ((traceSwitch_ & BYTRACE_ON) == BYTRACE_ON) { diff --git a/datamgr_service/services/distributeddataservice/app/src/kvstore_account_observer.cpp b/datamgr_service/services/distributeddataservice/app/src/kvstore_account_observer.cpp index ae25f382f965bc96f2d38aca3a6d6fe7f21b6032..f8258225511affad7909ed7dcbb73977d1b0fe73 100644 --- a/datamgr_service/services/distributeddataservice/app/src/kvstore_account_observer.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/kvstore_account_observer.cpp @@ -35,4 +35,4 @@ void KvStoreAccountObserver::OnAccountChanged(const AccountEventInfo &eventInfo) ZLOGI("account event %d, end.", eventInfo.status); } } // namespace DistributedKv -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp b/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp index f7509538b32e47b88e259dcc4b03c5ee4ade4c88..79c4297db47f9871cdcdaaa94e7417b7b8ce8ae9 100644 --- a/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -669,4 +669,4 @@ int32_t KvStoreDataService::OnUninstall(const std::string &bundleName, int32_t u }); return 0; } -} // namespace OHOS::DistributedKv \ No newline at end of file +} // namespace OHOS::DistributedKv diff --git a/datamgr_service/services/distributeddataservice/app/src/kvstore_device_listener.cpp b/datamgr_service/services/distributeddataservice/app/src/kvstore_device_listener.cpp index 7524be32a4000ea0af886fc5f4f1ebd3c974436a..cc843fa434de9c5c7fc7a13cf8cedf5e2a8b97fc 100644 --- a/datamgr_service/services/distributeddataservice/app/src/kvstore_device_listener.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/kvstore_device_listener.cpp @@ -40,4 +40,4 @@ AppDistributedKv::ChangeLevelType KvStoreDeviceListener::GetChangeLevelType() co { return AppDistributedKv::ChangeLevelType::MIN; } -} // namespace OHOS::DistributedKv \ No newline at end of file +} // namespace OHOS::DistributedKv diff --git a/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.cpp b/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.cpp index ea7188cc59536fd36664f9e007de359976c11b53..2500c6dd5c8dc64db9f157a10a4de8b3035ae22c 100644 --- a/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.cpp @@ -23,6 +23,7 @@ #include "account_delegate.h" #include "bootstrap.h" #include "communication_provider.h" +#include "communication_strategy.h" #include "constant.h" #include "crypto_manager.h" #include "device_manager_adapter.h" @@ -44,6 +45,7 @@ using DmAdapter = DistributedData::DeviceManagerAdapter; using namespace std::chrono; using namespace OHOS::DistributedData; using namespace DistributedDB; +using namespace OHOS::AppDistributedKv; KvStoreMetaManager::MetaDeviceChangeListenerImpl KvStoreMetaManager::listener_; @@ -53,6 +55,9 @@ KvStoreMetaManager::KvStoreMetaManager() delegateManager_(Bootstrap::GetInstance().GetProcessLabel(), "default") { ZLOGI("begin."); + CommunicationStrategy::GetInstance().RegGetSyncDataSize("meta_store", [this](const std::string &deviceId) { + return this->GetSyncDataSize(deviceId); + }); } KvStoreMetaManager::~KvStoreMetaManager() @@ -332,7 +337,6 @@ void KvStoreMetaManager::KvStoreMetaObserver::OnChange(const DistributedDB::KvSt HandleChanges(CHANGE_FLAG::INSERT, data.GetEntriesInserted()); HandleChanges(CHANGE_FLAG::UPDATE, data.GetEntriesUpdated()); HandleChanges(CHANGE_FLAG::DELETE, data.GetEntriesDeleted()); - KvStoreMetaManager::GetInstance().SyncMeta(); } void KvStoreMetaManager::KvStoreMetaObserver::HandleChanges(CHANGE_FLAG flag, @@ -376,5 +380,15 @@ std::string KvStoreMetaManager::GetBackupPath() const return (DirectoryManager::GetInstance().GetMetaBackupPath() + "/" + Crypto::Sha256(label_ + "_" + Bootstrap::GetInstance().GetMetaDBName())); } + +size_t KvStoreMetaManager::GetSyncDataSize(const std::string &deviceId) +{ + auto metaDelegate = GetMetaKvStore(); + if (metaDelegate == nullptr) { + return 0; + } + + return metaDelegate->GetSyncDataSize(deviceId); +} } // namespace DistributedKv } // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.h b/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.h index 3e8c6dee0fc4236dc73edceaf3acbd12ac94b679..7cea63df6475223a177ac418ad933f26c8dc6b49 100644 --- a/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.h +++ b/datamgr_service/services/distributeddataservice/app/src/kvstore_meta_manager.h @@ -53,7 +53,7 @@ public: void InitBroadcast(); void InitDeviceOnline(); void SubscribeMeta(const std::string &keyPrefix, const ChangeObserver &observer); - + size_t GetSyncDataSize(const std::string &deviceId); private: using NbDelegate = std::shared_ptr; NbDelegate GetMetaKvStore(); diff --git a/datamgr_service/services/distributeddataservice/app/src/security/security.cpp b/datamgr_service/services/distributeddataservice/app/src/security/security.cpp index 48edc67948ebcd3165adf004c0d6c8d5585fff60..44845416b699867e7e28600cebc4f4f393cd8455 100644 --- a/datamgr_service/services/distributeddataservice/app/src/security/security.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/security/security.cpp @@ -36,7 +36,6 @@ using Anonymous = DistributedData::Anonymous; const std::string Security::LABEL_VALUES[S4 + 1] = { "", "s0", "s1", "s2", "s3", "s4" }; -ConcurrentMap Security::devicesUdid_; Security::Security() { ZLOGD("construct"); @@ -145,10 +144,8 @@ void Security::OnDeviceChanged(const AppDistributedKv::DeviceInfo &info, bool isOnline = type == AppDistributedKv::DeviceChangeType::DEVICE_ONLINE; if (isOnline) { - Sensitive sensitive = GetSensitiveByUuid(info.uuid); + (void)GetSensitiveByUuid(info.uuid); ZLOGD("device is online, deviceId:%{public}s", Anonymous::Change(info.uuid).c_str()); - auto secuiryLevel = sensitive.GetDeviceSecurityLevel(); - ZLOGI("device is online, secuiry Level:%{public}d", secuiryLevel); } else { EraseSensitiveByUuid(info.uuid); ZLOGD("device is offline, deviceId:%{public}s", Anonymous::Change(info.uuid).c_str()); @@ -160,36 +157,30 @@ bool Security::IsExits(const std::string &file) const return access(file.c_str(), F_OK) == 0; } -Sensitive Security::GetSensitiveByUuid(const std::string &uuid) +Sensitive Security::GetSensitiveByUuid(const std::string &uuid) const { - Sensitive sensitive; - devicesUdid_.Compute(uuid, [&sensitive](const auto &key, auto &value) { - if (value) { - sensitive = value; - return true; - } - auto &dmAdapter = DistributedData::DeviceManagerAdapter::GetInstance(); - auto devices = dmAdapter.GetRemoteDevices(); - devices.push_back(dmAdapter.GetLocalBasicInfo()); - for (auto &device : devices) { - auto deviceUuid = device.uuid; - ZLOGD("GetSensitiveByUuid(%{public}s) peer device is %{public}s", - Anonymous::Change(key).c_str(), Anonymous::Change(deviceUuid).c_str()); - if (key != deviceUuid) { - continue; + auto it = devicesUdid_.Find(uuid); + if (!it.first) { + taskScheduler_.Execute([this, uuid]() { + auto it = devicesUdid_.Find(uuid); + if (it.first) { + return; } - - value = Sensitive(device.udid); - value.GetDeviceSecurityLevel(); - sensitive = value; - return true; - } - return false; - }); - return sensitive; + auto udid = DistributedData::DeviceManagerAdapter::GetInstance().ToUDID(uuid); + if (udid.empty()) { + return; + } + Sensitive sensitive(udid); + auto level = sensitive.GetDeviceSecurityLevel(); + ZLOGI("udid:%{public}s, uuid:%{public}s, security level:%{public}d", + Anonymous::Change(udid).c_str(), Anonymous::Change(uuid).c_str(), level); + devicesUdid_.Insert(uuid, sensitive); + }); + } + return it.second; } -bool Security::EraseSensitiveByUuid(const std::string &uuid) +bool Security::EraseSensitiveByUuid(const std::string &uuid) const { devicesUdid_.Erase(uuid); return true; diff --git a/datamgr_service/services/distributeddataservice/app/src/security/security.h b/datamgr_service/services/distributeddataservice/app/src/security/security.h index ecb119a4e63248e86679c63a7ad2e719c42625a3..3bc48419e518ae63591f9047c38dc0f813f1a2b8 100644 --- a/datamgr_service/services/distributeddataservice/app/src/security/security.h +++ b/datamgr_service/services/distributeddataservice/app/src/security/security.h @@ -15,14 +15,14 @@ #ifndef OHOS_SECURITY_H #define OHOS_SECURITY_H - -#include #include +#include +#include +#include "app_device_change_listener.h" #include "iprocess_system_api_adapter.h" #include "kv_store_delegate_manager.h" -#include "app_device_change_listener.h" -#include "visibility.h" #include "sensitive.h" +#include "visibility.h" namespace OHOS::DistributedKv { class Security @@ -67,8 +67,8 @@ private: static const std::string Convert2Name(const SecurityOption &option); static int Convert2Security(const std::string &name); bool IsExits(const std::string &file) const; - static Sensitive GetSensitiveByUuid(const std::string &uuid); - static bool EraseSensitiveByUuid(const std::string &uuid); + Sensitive GetSensitiveByUuid(const std::string &uuid) const; + bool EraseSensitiveByUuid(const std::string &uuid) const; bool IsXattrValueValid(const std::string& value) const; int32_t GetCurrentUserStatus() const; DBStatus SetFileSecurityOption(const std::string &filePath, const SecurityOption &option); @@ -76,7 +76,8 @@ private: DBStatus GetFileSecurityOption(const std::string &filePath, SecurityOption &option) const; DBStatus GetDirSecurityOption(const std::string &filePath, SecurityOption &option) const; - static ConcurrentMap devicesUdid_; + mutable TaskScheduler taskScheduler_; + mutable ConcurrentMap devicesUdid_; }; } // namespace OHOS::DistributedKv diff --git a/datamgr_service/services/distributeddataservice/app/src/security/sensitive.cpp b/datamgr_service/services/distributeddataservice/app/src/security/sensitive.cpp index e035df4c2fed05d26862c3ef8e2f50f79301dbd9..535caff9347e1d272deb4c95955fa4cacea48ba8 100644 --- a/datamgr_service/services/distributeddataservice/app/src/security/sensitive.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/security/sensitive.cpp @@ -69,7 +69,7 @@ bool Sensitive::operator >= (const DistributedDB::SecurityOption &option) } uint32_t level = securityLevel; - if (level <= DATA_SEC_LEVEL1) { + if (level <= DATA_SEC_LEVEL1 && (option.securityLabel - 1) > level) { ZLOGI("the device security level hadn't gotten"); level = GetSensitiveLevel(deviceId); } diff --git a/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp b/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp index b524025ff2e21175a97082eae60bd023902e0133..8aa3554e68dab6ada3b7838a27b7d10ae4019d63 100644 --- a/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp @@ -47,7 +47,7 @@ RouteHeadHandlerImpl::RouteHeadHandlerImpl(const ExtendInfo &info) : userId_(info.userId), appId_(info.appId), storeId_(info.storeId), deviceId_(info.dstTarget), headSize_(0) { ZLOGI("init route handler, app:%{public}s, user:%{public}s, peer:%{public}s", appId_.c_str(), userId_.c_str(), - deviceId_.c_str()); + Anonymous::Change(deviceId_).c_str()); } void RouteHeadHandlerImpl::Init() @@ -168,13 +168,14 @@ bool RouteHeadHandlerImpl::PackDataBody(uint8_t *data, uint32_t totalLen) SessionAppId *appPair = reinterpret_cast(ptr); ptr += sizeof(SessionAppId); - uint32_t appLen = data + totalLen - ptr; - appPair->len = HostToNet(appLen); // left size - ret = memcpy_s(appPair->appId, appLen, session_.appId.data(), session_.appId.size()); + uint8_t *end = data + totalLen; + uint32_t appIdSize = session_.appId.size(); + ret = memcpy_s(appPair->appId, end - ptr, session_.appId.data(), appIdSize); if (ret != 0) { ZLOGE("strcpy for app id failed:%{public}d", ret); return false; } + appPair->len = HostToNet(appIdSize); return true; } diff --git a/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp b/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp index 59e823db4ba7059575d57c27fbec563a1534997d..6550e72a49f5261bfe7baecdd79716ccb4adaca9 100644 --- a/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp +++ b/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp @@ -57,7 +57,7 @@ CapMetaData UpgradeManager::GetCapability(const std::string &deviceId, bool &sta ZLOGI("load capability from meta"); CapMetaData capMetaData; auto dbKey = CapMetaRow::GetKeyFor(deviceId); - ZLOGD("cap key:%{public}s", std::string(dbKey.begin(), dbKey.end()).c_str()); + ZLOGD("cap key:%{public}s", Anonymous::Change(std::string(dbKey.begin(), dbKey.end())).c_str()); status = MetaDataManager::GetInstance().LoadMeta(std::string(dbKey.begin(), dbKey.end()), capMetaData); if (status) { capabilityMap_.Insert(deviceId, capMetaData); diff --git a/datamgr_service/services/distributeddataservice/app/test/moduletest/distributeddata_account_event_test.cpp b/datamgr_service/services/distributeddataservice/app/test/moduletest/distributeddata_account_event_test.cpp index c633a36d94d692072be08a2f69653b98684a59c3..57de3e71d55a5cb754df04e57098c2db7f8df4ef 100644 --- a/datamgr_service/services/distributeddataservice/app/test/moduletest/distributeddata_account_event_test.cpp +++ b/datamgr_service/services/distributeddataservice/app/test/moduletest/distributeddata_account_event_test.cpp @@ -96,4 +96,4 @@ void DistributedDataAccountEventTest::ChangeUser(int uid) if (setuid(uid)) { std::cout << "error to set uid " << uid << "errno is " << errno << std::endl; } -} \ No newline at end of file +} diff --git a/datamgr_service/services/distributeddataservice/framework/metadata/capability_meta_data.cpp b/datamgr_service/services/distributeddataservice/framework/metadata/capability_meta_data.cpp index 381156480567770080c3801cc0a8070e1a73ed1a..837203ea492a399df3b681f9aa7c70f0e2a5fcc0 100644 --- a/datamgr_service/services/distributeddataservice/framework/metadata/capability_meta_data.cpp +++ b/datamgr_service/services/distributeddataservice/framework/metadata/capability_meta_data.cpp @@ -39,4 +39,4 @@ std::vector CapMetaRow::GetKeyFor(const std::string &key) std::string str = Constant::Concatenate({ KEY_PREFIX, Constant::KEY_SEPARATOR, key }); return { str.begin(), str.end() }; } -} // namespace OHOS::DistributedData \ No newline at end of file +} // namespace OHOS::DistributedData diff --git a/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp b/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp index 8a50f4c89be5e7829c7e296bd3ffc9a5bc2ee6e5..d100f972e533b9403749e3b02d5d4dc0f598db7b 100644 --- a/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp +++ b/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp @@ -18,6 +18,7 @@ #include "kv_store_nb_delegate.h" #include "log_print.h" +#include "utils/anonymous.h" namespace OHOS::DistributedData { class MetaObserver : public DistributedDB::KvStoreObserver { @@ -135,7 +136,8 @@ bool MetaDataManager::SaveMeta(const std::string &key, const Serializable &value syncer_(metaStore_, status); } if (status != DistributedDB::DBStatus::OK) { - ZLOGE("failed! status:%{public}d isLocal:%{public}d, key:%{public}s", status, isLocal, key.c_str()); + ZLOGE("failed! status:%{public}d isLocal:%{public}d, key:%{public}s", + status, isLocal, Anonymous::Change(key).c_str()); } return status == DistributedDB::DBStatus::OK; } diff --git a/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp b/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp index 5e5a0fdfe191d709b188487a048a349289152542..d7867f890a79bae5bd763c8f15678eea40ecc782 100644 --- a/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp +++ b/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp @@ -176,4 +176,4 @@ std::string StoreMetaData::GetPrefix(const std::initializer_list &f return GetKey(fields).append(Constant::KEY_SEPARATOR); } } // namespace DistributedData -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/framework/metadata/strategy_meta_data.cpp b/datamgr_service/services/distributeddataservice/framework/metadata/strategy_meta_data.cpp index 272fcec571f13301971439cec31792308b945085..8acba8877c87211b69e14353aecdf54c841334d9 100644 --- a/datamgr_service/services/distributeddataservice/framework/metadata/strategy_meta_data.cpp +++ b/datamgr_service/services/distributeddataservice/framework/metadata/strategy_meta_data.cpp @@ -66,4 +66,4 @@ std::string StrategyMeta::GetPrefix(const std::initializer_list &fi { return Constant::Join(PREFIX, Constant::KEY_SEPARATOR, fields); } -} // namespace OHOS::DistributedData \ No newline at end of file +} // namespace OHOS::DistributedData diff --git a/datamgr_service/services/distributeddataservice/framework/serializable/serializable.cpp b/datamgr_service/services/distributeddataservice/framework/serializable/serializable.cpp index 540f0912c38900e5607d42b111d05d13fdc9738a..3fda76bd59a520d4278f21108f20ac4ac1a9c172 100644 --- a/datamgr_service/services/distributeddataservice/framework/serializable/serializable.cpp +++ b/datamgr_service/services/distributeddataservice/framework/serializable/serializable.cpp @@ -183,4 +183,4 @@ const Serializable::json &Serializable::GetSubNode(const json &node, const std:: return *it; } } // namespace DistributedData -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/framework/test/event_center_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/event_center_test.cpp index 11c318c16da1c68b4ab98a3eac2a6625f09e4842..647cb6b0578ae10f2278f254bd88624644465682 100644 --- a/datamgr_service/services/distributeddataservice/framework/test/event_center_test.cpp +++ b/datamgr_service/services/distributeddataservice/framework/test/event_center_test.cpp @@ -151,4 +151,4 @@ HWTEST_F(EventCenterTest, ImmediatelyASyncEvent, TestSize.Level2) EventCenter::GetInstance().PostEvent(std::make_unique()); ASSERT_EQ(currEvent_, TEST_EVT_END); ASSERT_EQ(waitEvent_, TEST_EVT_UNKNOWN); -} \ No newline at end of file +} diff --git a/datamgr_service/services/distributeddataservice/service/backup/include/backup_manager.h b/datamgr_service/services/distributeddataservice/service/backup/include/backup_manager.h index e0df6fb53ef74322439fe241166de632949dd647..43060215036ce0ee431f9655c56d82473d838218 100644 --- a/datamgr_service/services/distributeddataservice/service/backup/include/backup_manager.h +++ b/datamgr_service/services/distributeddataservice/service/backup/include/backup_manager.h @@ -16,7 +16,7 @@ #ifndef OHOS_DISTRIBUTED_DATA_SERVICES_BACKUP_BACKUP_MANAGER_H #define OHOS_DISTRIBUTED_DATA_SERVICES_BACKUP_BACKUP_MANAGER_H -#include "kv_scheduler.h" +#include "task_scheduler.h" #include "metadata/store_meta_data.h" #include "metadata/secret_key_meta_data.h" #include "types.h" @@ -64,7 +64,7 @@ private: int64_t backupSuccessTime_ = 0; int64_t backupNumber_ = 0; int64_t startNum_ = 0; - DistributedKv::KvScheduler scheduler_{ "backup" }; + TaskScheduler scheduler_ { "backup" }; }; } // namespace OHOS::DistributedData #endif // OHOS_DISTRIBUTED_DATA_SERVICES_BACKUP_BACKUP_MANAGER_H \ No newline at end of file diff --git a/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp b/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp index 2c98364589e7cfefd8ab60c83d2c275dcd6a8568..f3603d3bf921f0ca2642a3fd9daedbebb65efecd 100644 --- a/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp +++ b/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp @@ -22,7 +22,6 @@ #include "device_manager_adapter.h" #include "crypto_manager.h" #include "directory_manager.h" -#include "kv_scheduler.h" #include "log_print.h" #include "metadata/meta_data_manager.h" #include "types.h" diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_types_util.cpp b/datamgr_service/services/distributeddataservice/service/data_share/data_share_types_util.cpp index cb5b017b46fc3e3e66e3fcbf145eeb9785aabc29..9e08fb8bad75bd45cf5f8b4b6b7dc2b85af38071 100644 --- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_types_util.cpp +++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_types_util.cpp @@ -22,12 +22,12 @@ template<> bool Unmarshalling(Predicates &predicates, MessageParcel &parcel) { ZLOGD("Unmarshalling DataSharePredicates Start"); - std::vector operations{}; + std::vector operations {}; std::string whereClause = ""; std::vector whereArgs; std::string order = ""; int64_t mode = DataShare::INVALID_MODE; - if (!ITypesUtil::Unmarshal(parcel, operations, whereClause, whereArgs, order, mode)){ + if (!ITypesUtil::Unmarshal(parcel, operations, whereClause, whereArgs, order, mode)) { ZLOGE("predicate read whereClause failed"); return false; } diff --git a/datamgr_service/services/distributeddataservice/service/data_share/permission_proxy.h b/datamgr_service/services/distributeddataservice/service/data_share/permission_proxy.h index 1dda4f25f3a3a6d55e938f23a3bac5b6861db16e..600bf299c559864278dfd35aa937066a0ee60ef6 100644 --- a/datamgr_service/services/distributeddataservice/service/data_share/permission_proxy.h +++ b/datamgr_service/services/distributeddataservice/service/data_share/permission_proxy.h @@ -33,4 +33,4 @@ private: static inline bool IsSingleAllowProvider(const std::string &bundleName, const std::string &storeName); }; } // namespace OHOS::DataShare -#endif // DATASHARESERVICE_PERMISSION_PROXY_H +#endif // DATASHARESERVICE_PERMISSION_PROXY_H \ No newline at end of file diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp index 23bb5388a6337b526e80d49808096b411a62063e..dcbaae608551926b3b93a8d89e476935a83674ba 100644 --- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp +++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp @@ -23,6 +23,7 @@ #include "backup_manager.h" #include "checker/checker_manager.h" #include "communication_provider.h" +#include "communication_strategy.h" #include "crypto_manager.h" #include "device_manager_adapter.h" #include "directory_manager.h" @@ -33,6 +34,7 @@ #include "metadata/appid_meta_data.h" #include "metadata/meta_data_manager.h" #include "query_helper.h" +#include "permit_delegate.h" #include "upgrade.h" #include "utils/anonymous.h" #include "utils/constant.h" @@ -61,6 +63,10 @@ KVDBServiceImpl::Factory::~Factory() KVDBServiceImpl::KVDBServiceImpl() { + CommunicationStrategy::GetInstance().RegGetSyncDataSize("kv_store", [this](const std::string &deviceId) { + return GetSyncDataSize(deviceId); + }); + EventCenter::GetInstance().Subscribe(DeviceMatrix::MATRIX_META_FINISHED, [this](const Event &event) { auto &matrixEvent = static_cast(event); auto deviceId = matrixEvent.GetDeviceId(); @@ -93,7 +99,7 @@ KVDBServiceImpl::KVDBServiceImpl() if (policy.IsValueEffect()) { syncInfo.delay = policy.valueUint; } - ZLOGD("[online] appId:%{public}s, storeId:%{public}s", data.bundleName.c_str(), data.storeId.c_str()); + ZLOGI("[online] appId:%{public}s, storeId:%{public}s", data.bundleName.c_str(), data.storeId.c_str()); auto delay = GetSyncDelayTime(syncInfo.delay, { data.storeId }); KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(data.tokenId), delay, std::bind(&KVDBServiceImpl::DoSync, this, data, syncInfo, std::placeholders::_1, ACTION_SYNC), @@ -146,6 +152,7 @@ Status KVDBServiceImpl::Delete(const AppId &appId, const StoreId &storeId) MetaDataManager::GetInstance().DelMeta(metaData.GetSecretKey(), true); MetaDataManager::GetInstance().DelMeta(metaData.GetStrategyKey()); MetaDataManager::GetInstance().DelMeta(metaData.GetKeyLocal(), true); + PermitDelegate::GetInstance().DelCache(metaData.GetKey()); storeCache_.CloseStore(tokenId, storeId); ZLOGD("appId:%{public}s storeId:%{public}s instanceId:%{public}d", appId.appId.c_str(), storeId.storeId.c_str(), metaData.instanceId); @@ -396,7 +403,9 @@ Status KVDBServiceImpl::AfterCreate(const AppId &appId, const StoreId &storeId, } } - MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData); + if (!isCreated || oldMeta != metaData) { + MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData); + } AppIDMetaData appIdMeta; appIdMeta.bundleName = metaData.bundleName; appIdMeta.appId = metaData.appId; @@ -724,4 +733,29 @@ void KVDBServiceImpl::SyncAgent::ReInit(pid_t pid, const AppId &appId) delayTimes_.clear(); observers_.clear(); } + +size_t KVDBServiceImpl::GetSyncDataSize(const std::string &deviceId) +{ + std::vector metaData; + auto prefix = StoreMetaData::GetPrefix({DMAdapter::GetInstance().GetLocalDevice().uuid}); + if (!MetaDataManager::GetInstance().LoadMeta(prefix, metaData)) { + ZLOGE("load meta failed!"); + return 0; + } + + size_t totalSize = 0; + for (const auto &data : metaData) { + DistributedDB::DBStatus status; + auto observers = GetObservers(data.tokenId, data.storeId); + auto store = storeCache_.GetStore(data, observers, status); + if (store == nullptr) { + ZLOGE("failed! status:%{public}d appId:%{public}s storeId:%{public}s dir:%{public}s", status, + data.bundleName.c_str(), data.storeId.c_str(), data.dataDir.c_str()); + continue; + } + totalSize += store->GetSyncDataSize(deviceId); + } + + return totalSize; +} } // namespace OHOS::DistributedKv \ No newline at end of file diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h index 8dcee7ca8e922cf0bcae2e31c9855c984e37696c..c2aecdd74b0956d89f6e6f2ee4698408f7ac6223 100644 --- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h +++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h @@ -58,7 +58,7 @@ public: int32_t ResolveAutoLaunch(const std::string &identifier, DBLaunchParam ¶m) override; int32_t OnUserChange(uint32_t code, const std::string &user, const std::string &account) override; int32_t OnReady(const std::string &device) override; - + size_t GetSyncDataSize(const std::string &deviceId); private: using StoreMetaData = OHOS::DistributedData::StoreMetaData; using StrategyMeta = OHOS::DistributedData::StrategyMeta; diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.cpp b/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.cpp index 5c005bd010308f6bd9449b2624b3517a2d9e2b6a..d2610983872942b2ae54b9e092e96748c8bc7a08 100644 --- a/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.cpp +++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.cpp @@ -38,7 +38,7 @@ Status KvStoreSyncManager::AddSyncOperation(uintptr_t syncId, uint32_t delayMs, }; } - auto beginTime = std::chrono::system_clock::now() + std::chrono::milliseconds(delayMs); + auto beginTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(delayMs); KvSyncOperation syncOp{ syncId, opSeq, delayMs, syncFunc, endFunc, beginTime }; if (delayMs == 0) { if (endFunc != nullptr) { @@ -145,7 +145,7 @@ bool KvStoreSyncManager::GetTimeoutSyncOps(const TimePoint ¤tTime, std::li void KvStoreSyncManager::DoCheckSyncingTimeout(std::list &syncingOps) { auto syncingTimeoutPred = [](const KvSyncOperation &op) -> bool { - return op.beginTime + std::chrono::milliseconds(SYNCING_TIMEOUT_MS) < std::chrono::system_clock::now(); + return op.beginTime + std::chrono::milliseconds(SYNCING_TIMEOUT_MS) < std::chrono::steady_clock::now(); }; uint32_t count = DoRemoveSyncingOp(syncingTimeoutPred, syncingOps); @@ -170,7 +170,7 @@ void KvStoreSyncManager::Schedule(const TimePoint &time) if (!scheduleSyncOps_.empty()) { auto nextTime = scheduleSyncOps_.begin()->first; if (delaySchedule) { - nextTime = std::chrono::system_clock::now() + std::chrono::milliseconds(SYNC_MIN_DELAY_MS); + nextTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(SYNC_MIN_DELAY_MS); } AddTimer(nextTime); } diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.h b/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.h index 4712b2fd3fcd5eb1e08a2106fa915d1bbdf7b123..1376358c67f82124a533d7545088d6f086103835 100644 --- a/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.h +++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvstore_sync_manager.h @@ -20,7 +20,7 @@ #include #include -#include "kv_scheduler.h" +#include "task_scheduler.h" #include "kv_store_nb_delegate.h" #include "types.h" @@ -37,7 +37,7 @@ public: static KvStoreSyncManager syncManager; return &syncManager; } - using TimePoint = std::chrono::system_clock::time_point; + using TimePoint = std::chrono::steady_clock::time_point; using SyncEnd = std::function &)>; using SyncFunc = std::function; @@ -74,7 +74,7 @@ private: std::list delaySyncingOps_; std::multimap scheduleSyncOps_; - KvScheduler syncScheduler_{ "sync_mgr" }; + TaskScheduler syncScheduler_ { "sync_mgr" }; TimePoint nextScheduleTime_; std::atomic_uint32_t syncOpSeq_ = 0; }; diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.cpp b/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.cpp index e7862501b812eb179ca2c5307df0ea0784a27895..f328d26e44941e0e0024483a0b0c5c113b6262f4 100644 --- a/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.cpp +++ b/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.cpp @@ -65,7 +65,7 @@ StoreCache::Store StoreCache::GetStore(const StoreMetaData &data, std::shared_pt return !stores.empty(); }); - scheduler_.At(std::chrono::system_clock::now() + std::chrono::minutes(INTERVAL), + scheduler_.At(std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL), std::bind(&StoreCache::GarbageCollect, this)); return store; @@ -120,14 +120,14 @@ void StoreCache::SetObserver(uint32_t tokenId, const std::string &storeId, std:: void StoreCache::GarbageCollect() { DBManager manager("", ""); - auto current = std::chrono::system_clock::now(); + auto current = std::chrono::steady_clock::now(); stores_.EraseIf([&manager, ¤t](auto &key, std::map &delegates) { for (auto it = delegates.begin(); it != delegates.end();) { // if the kv store is BUSY we wait more INTERVAL minutes again - if ((it->second < current) || !it->second.Close(manager)) { - ++it; - } else { + if ((it->second < current) && it->second.Close(manager)) { it = delegates.erase(it); + } else { + ++it; } } return delegates.empty(); @@ -197,7 +197,7 @@ StoreCache::DBPassword StoreCache::GetDBPassword(const StoreMetaData &data) StoreCache::DBStoreDelegate::DBStoreDelegate(DBStore *delegate, std::shared_ptr observers) : delegate_(delegate) { - time_ = std::chrono::system_clock::now() + std::chrono::minutes(INTERVAL); + time_ = std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL); SetObservers(std::move(observers)); } @@ -213,7 +213,7 @@ StoreCache::DBStoreDelegate::~DBStoreDelegate() StoreCache::DBStoreDelegate::operator std::shared_ptr () { - time_ = std::chrono::system_clock::now() + std::chrono::minutes(INTERVAL); + time_ = std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL); mutex_.lock_shared(); if (delegate_ == nullptr) { mutex_.unlock_shared(); @@ -249,7 +249,7 @@ void StoreCache::DBStoreDelegate::OnChange(const DistributedDB::KvStoreChangedDa return; } - time_ = std::chrono::system_clock::now() + std::chrono::minutes(INTERVAL); + time_ = std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL); auto observers = observers_; std::vector key; auto inserts = Convert(data.GetEntriesInserted()); diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.h b/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.h index 8a83c7d6162a2253a3bae8aad9faabb7855ab6ba..10a4c8722f92f77c54b8fe505eff152d988c6692 100644 --- a/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.h +++ b/datamgr_service/services/distributeddataservice/service/kvdb/store_cache.h @@ -20,7 +20,7 @@ #include #include #include "concurrent_map.h" -#include "kv_scheduler.h" +#include "task_scheduler.h" #include "kv_store_nb_delegate.h" #include "metadata/store_meta_data.h" #include "refbase.h" @@ -46,7 +46,7 @@ public: using DBEntry = DistributedDB::Entry; using Observers = std::set, Less>; using StoreMetaData = OHOS::DistributedData::StoreMetaData; - using Time = std::chrono::system_clock::time_point; + using Time = std::chrono::steady_clock::time_point; using DBOption = DistributedDB::KvStoreNbDelegate::Option; using DBSecurity = DistributedDB::SecurityOption; using DBPassword = DistributedDB::CipherPassword; @@ -80,7 +80,7 @@ private: static constexpr int64_t INTERVAL = 1; static constexpr size_t TIME_TASK_NUM = 1; ConcurrentMap> stores_; - KvScheduler scheduler_{ TIME_TASK_NUM, "store_cache" }; + TaskScheduler scheduler_{ TIME_TASK_NUM, "store_cache" }; }; } // namespace OHOS::DistributedKv #endif // OHOS_DISTRIBUTED_DATA_SERVICE_KVDB_STORE_CACHE_H diff --git a/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp b/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp index d3de5e049de4a371a1bd5088278f499e900d4dcd..b4fcaa0fa30609890a0b462ce743e1c70114770d 100644 --- a/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp +++ b/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp @@ -562,7 +562,7 @@ int64_t ObjectStoreManager::GetTime(const std::string &key) void ObjectStoreManager::CloseAfterMinute() { - scheduler_.At(std::chrono::system_clock::now() + std::chrono::minutes(INTERVAL), + scheduler_.At(std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL), std::bind(&ObjectStoreManager::Close, this)); } diff --git a/datamgr_service/services/distributeddataservice/service/object/object_manager.h b/datamgr_service/services/distributeddataservice/service/object/object_manager.h index e2c2ee0c17a4e41021733224d084698e2a17e75d..67f74f5cb709275ec21a0072cb3bbf20ba5c5f21 100644 --- a/datamgr_service/services/distributeddataservice/service/object/object_manager.h +++ b/datamgr_service/services/distributeddataservice/service/object/object_manager.h @@ -21,7 +21,7 @@ #include "concurrent_map.h" #include "device_manager_adapter.h" #include "iobject_callback.h" -#include "kv_scheduler.h" +#include "task_scheduler.h" #include "kv_store_delegate_manager.h" #include "kvstore_sync_callback.h" #include "object_common.h" @@ -153,7 +153,7 @@ private: ConcurrentMap callbacks_; static constexpr size_t TIME_TASK_NUM = 1; static constexpr int64_t INTERVAL = 1; - KvScheduler scheduler_ { TIME_TASK_NUM, "object_mgr" }; + TaskScheduler scheduler_ { TIME_TASK_NUM, "object_mgr" }; }; } // namespace DistributedObject } // namespace OHOS diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_syncer.cpp b/datamgr_service/services/distributeddataservice/service/rdb/rdb_syncer.cpp index 983e5f3bd9d9d370f86d1b4ed22bf4ea66d9eb5b..7e884c1684db12171b2b1a71d9e28f1a18637e6b 100644 --- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_syncer.cpp +++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_syncer.cpp @@ -165,6 +165,9 @@ int32_t RdbSyncer::CreateMetaData(StoreMetaData &meta) } auto saved = MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta); + if (!saved) { + return RDB_ERROR; + } AppIDMetaData appIdMeta; appIdMeta.bundleName = meta.bundleName; appIdMeta.appId = meta.appId; diff --git a/datamgr_service/services/distributeddataservice/service/test/config_factory_test.cpp b/datamgr_service/services/distributeddataservice/service/test/config_factory_test.cpp index 099c6b599ec2a578a963a18fb0bcdcc24ef35ae9..6430fac49a239e8694df403b529cb632149f4093 100644 --- a/datamgr_service/services/distributeddataservice/service/test/config_factory_test.cpp +++ b/datamgr_service/services/distributeddataservice/service/test/config_factory_test.cpp @@ -112,4 +112,4 @@ HWTEST_F(ConfigFactoryTest, NetworkConfig, TestSize.Level0) ASSERT_EQ(networks->protocols[0].name, "OHOS softbus"); ASSERT_EQ(networks->protocols[0].address, "ohos.distributeddata"); ASSERT_EQ(networks->protocols[0].transport, "softbus"); -} \ No newline at end of file +} diff --git a/datamgr_service/services/distributeddataservice/service/test/crypto_manager_test.cpp b/datamgr_service/services/distributeddataservice/service/test/crypto_manager_test.cpp index c2c40ce4f6ead77b5b541c3cd80310298fe4aef3..a78020761ca1deef628312729da7642591afd3ca 100644 --- a/datamgr_service/services/distributeddataservice/service/test/crypto_manager_test.cpp +++ b/datamgr_service/services/distributeddataservice/service/test/crypto_manager_test.cpp @@ -82,6 +82,19 @@ HWTEST_F(CryptoManagerTest, CheckRootKey, TestSize.Level0) EXPECT_EQ(errCode, CryptoManager::ErrCode::SUCCESS); } +/** +* @tc.name: Encrypt001 +* @tc.desc: encrypt random key; +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(CryptoManagerTest, Encrypt001, TestSize.Level0) +{ + auto encryptKey = CryptoManager::GetInstance().Encrypt(randomKey); + EXPECT_EQ(encryptKey.size(), ENCRYPT_KEY_LENGTH); + encryptKey.assign(encryptKey.size(), 0); +} /** * @tc.name: Encrypt002 @@ -113,3 +126,33 @@ HWTEST_F(CryptoManagerTest, DecryptKey001, TestSize.Level0) encryptKey.assign(encryptKey.size(), 0); } +/** +* @tc.name: DecryptKey002 +* @tc.desc: decrypt the key, the source key is not encrypt; +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(CryptoManagerTest, DecryptKey002, TestSize.Level0) +{ + std::vector key; + auto result = CryptoManager::GetInstance().Decrypt(randomKey, key); + EXPECT_FALSE(result); + EXPECT_TRUE(key.empty()); +} + +/** +* @tc.name: DecryptKey003 +* @tc.desc: decrypt the key, the source key is empty; +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(CryptoManagerTest, DecryptKey003, TestSize.Level0) +{ + std::vector srcKey {}; + std::vector key; + auto result = CryptoManager::GetInstance().Decrypt(srcKey, key); + EXPECT_FALSE(result); + EXPECT_TRUE(key.empty()); +} \ No newline at end of file diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp index bffe01d4616f634f2018eaa55f54b07503e5697a..7a44f1793000c7373556fd4c12a1a6c29a4d85c9 100644 --- a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp +++ b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp @@ -295,5 +295,26 @@ DBStatus DBStoreMock::DeleteBatch(ConcurrentMap &store, const std::v }); return OK; } + +DBStatus DBStoreMock::GetKeys(const Key &keyPrefix, std::vector &keys) const +{ + keys.clear(); + std::vector entries; + keys.resize(entries.size()); + std::transform(entries.begin(), entries.end(), keys.begin(), [](auto &entry) { + return std::move(entry.key); + }); + keys.shrink_to_fit(); + return OK; +} + +size_t DBStoreMock::GetSyncDataSize(const std::string &device) const +{ + + if (device.empty()) { + return 0; + } + return 1024; +} } // namespace DistributedData } // namespace OHOS \ No newline at end of file diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h index e22b37b905966943b7f87e88795bb1556e2a29f4..be469e7d64df3c7766d03af365ae9fadf64e66c3 100644 --- a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h +++ b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h @@ -85,6 +85,8 @@ public: const std::function &)> &onComplete, const Query &query, bool wait) override; DBStatus RemoveDeviceData() override; + DBStatus GetKeys(const Key &keyPrefix, std::vector &keys) const override; + size_t GetSyncDataSize(const std::string &device) const override; private: DBStatus Get(ConcurrentMap &store, const Key &key, Value &value) const; diff --git a/datamgr_service/services/distributeddataservice/test/common/distributeddb/src/distributed_test_sysinfo.cpp b/datamgr_service/services/distributeddataservice/test/common/distributeddb/src/distributed_test_sysinfo.cpp index 654de9207f15935aea87d77f3032af9eaafe243d..3b7be386dd7eb747fe1be2878ab85c54735b2888 100644 --- a/datamgr_service/services/distributeddataservice/test/common/distributeddb/src/distributed_test_sysinfo.cpp +++ b/datamgr_service/services/distributeddataservice/test/common/distributeddb/src/distributed_test_sysinfo.cpp @@ -299,4 +299,4 @@ void DistributedTestSysInfo::SaveSecondToFirst() void DistributedTestSysInfo::SaveSecondToFirst() { } -#endif \ No newline at end of file +#endif diff --git a/datamgr_service/test/fuzztest/blob_fuzzer/blob_fuzzer.cpp b/datamgr_service/test/fuzztest/blob_fuzzer/blob_fuzzer.cpp index ea3f21392ce11f89f2e02bfcce446cad50d59a8a..be2dc922c59c0a21380b5d33ceb1ad2772434363 100644 --- a/datamgr_service/test/fuzztest/blob_fuzzer/blob_fuzzer.cpp +++ b/datamgr_service/test/fuzztest/blob_fuzzer/blob_fuzzer.cpp @@ -62,7 +62,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) std::vector fuzzVec(fuzzStr.begin(), fuzzStr.end()); int count = 10; - char str[count+1]; + char str[count + 1]; memcpy_s(str, count + 1, data, std::min((size_t) (count + 1), size)); str[count] = '\0'; Blob blob1(str); diff --git a/datamgr_service/test/fuzztest/taskscheduler_fuzzer/BUILD.gn b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..0f37df0c609bc40e9a4587b0dd65b325eca7c28d --- /dev/null +++ b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") + +##############################fuzztest########################################## +ohos_fuzztest("TaskSchedulerFuzzTest") { + module_out_path = "datamgr_service/distributeddatafwk" + + include_dirs = [ + "//foundation/distributeddatamgr/kv_store/frameworks/common", + ] + + fuzz_config_file = "//foundation/distributeddatamgr/datamgr_service/test/fuzztest/taskscheduler_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ "taskscheduler_fuzzer.cpp" ] + + deps = [] + + external_deps = [ "c_utils:utils" ] +} + +############################################################################### +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":TaskSchedulerFuzzTest", + ] +} +############################################################################### diff --git a/datamgr_service/test/fuzztest/taskscheduler_fuzzer/corpus/init b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..8eb5a7d6eb6b7d71f0c70c244e5768d62bee6ac5 --- /dev/null +++ b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +FUZZ \ No newline at end of file diff --git a/datamgr_service/test/fuzztest/taskscheduler_fuzzer/project.xml b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..be92381e05fc528d2fba5603365ee6df71b5b840 --- /dev/null +++ b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 30 + + 4096 + + diff --git a/datamgr_service/test/fuzztest/taskscheduler_fuzzer/taskscheduler_fuzzer.cpp b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/taskscheduler_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..84236170239c45aa125cdddf8d860a34a0fbd0d8 --- /dev/null +++ b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/taskscheduler_fuzzer.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "taskscheduler_fuzzer.h" + +#include +#include + +#include "task_scheduler.h" + +namespace OHOS { +static constexpr int MAX_DELAY_TIME = 5; +static constexpr int MAX_INTERVAL_TIME = 3; +void AtFuzz(size_t time) +{ + TaskScheduler taskScheduler; + std::chrono::steady_clock::time_point tp = std::chrono::steady_clock::now() + + std::chrono::duration(time % MAX_DELAY_TIME); + auto task = taskScheduler.At(tp, []() { }); + std::this_thread::sleep_for(std::chrono::seconds(MAX_INTERVAL_TIME)); + taskScheduler.Remove(task); +} + +void EveryFUZZ(size_t time) +{ + TaskScheduler taskScheduler; + std::chrono::duration delay(time % MAX_DELAY_TIME); + std::chrono::duration interval(time % MAX_INTERVAL_TIME); + taskScheduler.Every(delay, interval, []() { }); + std::this_thread::sleep_for(std::chrono::seconds(MAX_INTERVAL_TIME)); + taskScheduler.Every(0, delay, interval, []() { }); + taskScheduler.Every(1, delay, interval, []() { }); + std::this_thread::sleep_for(std::chrono::seconds(MAX_INTERVAL_TIME)); + taskScheduler.Every(interval, []() { }); + taskScheduler.Clean(); +} + +void ResetFuzz(size_t time) +{ + TaskScheduler taskScheduler; + std::chrono::duration interval(time % MAX_INTERVAL_TIME); + std::chrono::steady_clock::time_point tp1 = std::chrono::steady_clock::now() + + std::chrono::duration(MAX_DELAY_TIME / 2); + auto schedulerTask = taskScheduler.At(tp1, []() {}); + taskScheduler.Reset(schedulerTask, interval); +} +} // namespace OHOS +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + /* Run your code on data */ + OHOS::AtFuzz(size); + OHOS::EveryFUZZ(size); + OHOS::ResetFuzz(size); + return 0; +} diff --git a/datamgr_service/test/fuzztest/taskscheduler_fuzzer/taskscheduler_fuzzer.h b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/taskscheduler_fuzzer.h new file mode 100644 index 0000000000000000000000000000000000000000..d3ae7f0444ebf213d71e86ea794f1b25e8cc009c --- /dev/null +++ b/datamgr_service/test/fuzztest/taskscheduler_fuzzer/taskscheduler_fuzzer.h @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TASKSCHEDULER_FUZZER_H +#define TASKSCHEDULER_FUZZER_H + +#define FUZZ_PROJECT_NAME "taskscheduler_fuzzer" + +#endif // TASKSCHEDULER_FUZZER_H + diff --git a/kv_store/.gitattributes b/kv_store/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..51c63e295e0232f7095a8ee8e03713837e37f419 --- /dev/null +++ b/kv_store/.gitattributes @@ -0,0 +1,15 @@ +*.tgz filter=lfs diff=lfs merge=lfs -text +*.trp filter=lfs diff=lfs merge=lfs -text +*.apk filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.mp4 filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.asm filter=lfs diff=lfs merge=lfs -text +*.8svn filter=lfs diff=lfs merge=lfs -text +*.9svn filter=lfs diff=lfs merge=lfs -text +*.dylib filter=lfs diff=lfs merge=lfs -text +*.exe filter=lfs diff=lfs merge=lfs -text +*.a filter=lfs diff=lfs merge=lfs -text +*.so filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.dll filter=lfs diff=lfs merge=lfs -text diff --git a/kv_store/frameworks/common/task_scheduler.h b/kv_store/frameworks/common/task_scheduler.h index ef655cb50b37b7074d368cacbaabe64fb97796a0..7aaaec94e9c33bd5f25109e40864b22ead1edcdb 100644 --- a/kv_store/frameworks/common/task_scheduler.h +++ b/kv_store/frameworks/common/task_scheduler.h @@ -15,70 +15,85 @@ #ifndef OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_TASK_SCHEDULER_H #define OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_TASK_SCHEDULER_H +#include #include #include #include #include +#include #include #include #include + #include "visibility.h" namespace OHOS { class API_LOCAL TaskScheduler { public: - using Time = std::chrono::system_clock::time_point; - using Duration = std::chrono::system_clock::duration; - using System = std::chrono::system_clock; - using Iterator = std::map>::iterator; + using TaskId = uint64_t; + using Time = std::chrono::steady_clock::time_point; + using Duration = std::chrono::steady_clock::duration; + using Clock = std::chrono::steady_clock; using Task = std::function; - TaskScheduler(size_t capacity = std::numeric_limits::max()) + inline static constexpr TaskId INVALID_TASK_ID = static_cast(0l); + TaskScheduler(size_t capacity, const std::string &name) { capacity_ = capacity; isRunning_ = true; - thread_ = std::make_unique([this]() { this->Loop(); }); + taskId_ = INVALID_TASK_ID; + thread_ = std::make_unique([this, name]() { + auto realName = std::string("scheduler_") + name; + pthread_setname_np(pthread_self(), realName.c_str()); + Loop(); + }); } + TaskScheduler(const std::string &name) : TaskScheduler(std::numeric_limits::max(), name) {} + TaskScheduler(size_t capacity = std::numeric_limits::max()) : TaskScheduler(capacity, "") {} + ~TaskScheduler() { isRunning_ = false; - At(std::chrono::system_clock::now(), [](){}); + Clean(); + At(std::chrono::steady_clock::now(), []() {}); thread_->join(); } + // execute task at specific time - Iterator At(const Time &time, std::function task) + TaskId At(const Time &time, Task task) { std::unique_lock lock(mutex_); if (tasks_.size() >= capacity_) { - return tasks_.end(); + return INVALID_TASK_ID; } - - auto it = tasks_.insert({time, task}); + auto taskId = GenTaskId(); + auto it = tasks_.insert({ time, std::pair{ task, taskId } }); if (it == tasks_.begin()) { condition_.notify_one(); } - return it; + indexes_[taskId] = it; + return taskId; } - Iterator Reset(Iterator task, const Time &time, const Duration &interval) + + TaskId Reset(TaskId taskId, const Duration &interval) { std::unique_lock lock(mutex_); - if (tasks_.begin()->first > time) { - return {}; + auto index = indexes_.find(taskId); + if (index == indexes_.end()) { + return INVALID_TASK_ID; } - auto current = std::chrono::system_clock::now(); - if (current >= time) { - return {}; - } - - auto it = tasks_.insert({ current + interval, std::move(task->second) }); - if (it == tasks_.begin()) { + auto it = tasks_.insert({ std::chrono::steady_clock::now() + interval, std::move(index->second->second) }); + if (it == tasks_.begin() || index->second == tasks_.begin()) { condition_.notify_one(); } - tasks_.erase(task); - return it; + tasks_.erase(index->second); + indexes_[taskId] = it; + return taskId; } + void Clean() { std::unique_lock lock(mutex_); + indexes_.clear(); tasks_.clear(); } @@ -89,18 +104,22 @@ public: task(); this->Every(interval, task); }; - At(std::chrono::system_clock::now() + interval, waitFunc); + At(std::chrono::steady_clock::now() + interval, waitFunc); } + // remove task in SchedulerTask - void Remove(const Iterator &task) + void Remove(TaskId taskId) { std::unique_lock lock(mutex_); - auto it = tasks_.find(task->first); - if (it != tasks_.end()) { - tasks_.erase(it); - condition_.notify_one(); + auto index = indexes_.find(taskId); + if (index == indexes_.end()) { + return; } + tasks_.erase(index->second); + indexes_.erase(index); + condition_.notify_one(); } + // execute task periodically with duration after delay void Every(Duration delay, Duration interval, Task task) { @@ -108,8 +127,9 @@ public: task(); Every(interval, task); }; - At(std::chrono::system_clock::now() + delay, waitFunc); + At(std::chrono::steady_clock::now() + delay, waitFunc); } + // execute task for some times periodically with duration after delay void Every(int32_t times, Duration delay, Duration interval, Task task) { @@ -122,25 +142,34 @@ public: } }; - At(std::chrono::system_clock::now() + delay, waitFunc); + At(std::chrono::steady_clock::now() + delay, waitFunc); + } + + TaskId Execute(Task task) + { + return At(std::chrono::steady_clock::now(), std::move(task)); } private: + using InnerTask = std::pair, uint64_t>; void Loop() { while (isRunning_) { std::function exec; { std::unique_lock lock(mutex_); - if (tasks_.empty()) { - condition_.wait(lock); - } else { - condition_.wait_until(lock, tasks_.begin()->first); - } - if ((!tasks_.empty()) && (tasks_.begin()->first <= std::chrono::system_clock::now())) { - exec = tasks_.begin()->second; - tasks_.erase(tasks_.begin()); + condition_.wait(lock, [this] { + return !tasks_.empty(); + }); + if (tasks_.begin()->first > std::chrono::steady_clock::now()) { + auto time = tasks_.begin()->first; + condition_.wait_until(lock, time); + continue; } + auto it = tasks_.begin(); + exec = it->second.first; + indexes_.erase(it->second.second); + tasks_.erase(it); } if (exec) { @@ -148,12 +177,24 @@ private: } } } + + TaskId GenTaskId() + { + auto taskId = ++taskId_; + if (taskId == INVALID_TASK_ID) { + return ++taskId_; + } + return taskId; + } + volatile bool isRunning_; size_t capacity_; - std::multimap> tasks_; + std::multimap tasks_; + std::map indexes_; std::mutex mutex_; std::unique_ptr thread_; std::condition_variable condition_; + std::atomic taskId_; }; } // namespace OHOS #endif // OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_TASK_SCHEDULER_H diff --git a/kv_store/frameworks/common/test/task_scheduler_test.cpp b/kv_store/frameworks/common/test/task_scheduler_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..67e27fc266ad991264d9e13c43b6132bc46f9274 --- /dev/null +++ b/kv_store/frameworks/common/test/task_scheduler_test.cpp @@ -0,0 +1,153 @@ +/* +* Copyright (c) 2022 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "task_scheduler.h" + +#include + +#include "block_data.h" + +using namespace testing::ext; +using namespace OHOS; +using duration = std::chrono::steady_clock::duration; +class TaskSchedulerTest : public testing::Test { +public: + static constexpr uint32_t SHORT_INTERVAL = 100; + static constexpr uint32_t LONG_INTERVAL = 300; + static void SetUpTestCase(void){}; + static void TearDownTestCase(void){}; + void SetUp(){}; + void TearDown() {} +}; + +/** +* @tc.name: At +* @tc.desc: +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(TaskSchedulerTest, At, TestSize.Level0) +{ + TaskScheduler taskScheduler("atTest"); + auto expiredTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(SHORT_INTERVAL); + int testData = 10; + auto blockData = std::make_shared>(LONG_INTERVAL, testData); + auto atTaskId1 = taskScheduler.At(expiredTime, [blockData]() { + int testData = 11; + blockData->SetValue(testData); + }); + ASSERT_EQ(blockData->GetValue(), 11); + blockData->Clear(); + expiredTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(SHORT_INTERVAL); + auto atTaskId2 = taskScheduler.At(expiredTime, [blockData]() { + int testData = 12; + blockData->SetValue(testData); + }); + ASSERT_EQ(blockData->GetValue(), 12); + ASSERT_NE(atTaskId1, atTaskId2); +} + +/** +* @tc.name: Every +* @tc.desc: +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(TaskSchedulerTest, Every, TestSize.Level0) +{ + TaskScheduler taskScheduler("everyTest"); + auto blockData = std::make_shared>(LONG_INTERVAL, 0); + taskScheduler.Every(std::chrono::milliseconds(SHORT_INTERVAL), [blockData]() { + int testData = 1; + blockData->SetValue(testData); + }); + for (int i = 1; i < 5; ++i) { + ASSERT_EQ(blockData->GetValue(), 1); + } +} + +/** +* @tc.name: Reset +* @tc.desc: Reset before task execution and the task is tasks_.begin() or not +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(TaskSchedulerTest, Reset1, TestSize.Level0) +{ + TaskScheduler taskScheduler("reset1Test"); + auto expiredTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(SHORT_INTERVAL); + auto atTaskId1 = taskScheduler.At(expiredTime, []() {}); + ASSERT_EQ(atTaskId1, 1); + expiredTime += std::chrono::milliseconds(LONG_INTERVAL); + auto atTaskId2 = taskScheduler.At(expiredTime, []() {}); + ASSERT_EQ(atTaskId2, 2); + + auto resetTaskId1 = taskScheduler.Reset(atTaskId1, std::chrono::milliseconds(SHORT_INTERVAL)); + ASSERT_EQ(resetTaskId1, atTaskId1); + + auto resetTaskId2 = taskScheduler.Reset(atTaskId2, std::chrono::milliseconds(SHORT_INTERVAL)); + ASSERT_EQ(resetTaskId2, atTaskId2); +} + +/** +* @tc.name: Reset +* @tc.desc: Reset during task execution +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(TaskSchedulerTest, Reset2, TestSize.Level0) +{ + TaskScheduler taskScheduler("reset2Test"); + int testData = 10; + auto blockData = std::make_shared>(LONG_INTERVAL, testData); + auto expiredTime = std::chrono::steady_clock::now(); + auto atTaskId = taskScheduler.At(expiredTime, [blockData]() { + blockData->GetValue(); + }); + ASSERT_EQ(atTaskId, 1); + std::this_thread::sleep_for(std::chrono::milliseconds(SHORT_INTERVAL)); + auto resetTaskId = taskScheduler.Reset(atTaskId, std::chrono::milliseconds(0)); + ASSERT_EQ(resetTaskId, TaskScheduler::INVALID_TASK_ID); + blockData->SetValue(testData); +} + +/** +* @tc.name: Reset +* @tc.desc: Reset after task execution +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(TaskSchedulerTest, Reset3, TestSize.Level0) +{ + TaskScheduler taskScheduler("reset3Test"); + auto expiredTime = std::chrono::steady_clock::now(); + int testData = 10; + auto blockData = std::make_shared>(LONG_INTERVAL, testData); + auto atTaskId = taskScheduler.At(expiredTime, [blockData]() { + blockData->GetValue(); + }); + ASSERT_EQ(atTaskId, 1); + blockData->SetValue(testData); + blockData->SetValue(testData); + ASSERT_EQ(blockData->GetValue(), testData); + std::this_thread::sleep_for(std::chrono::milliseconds(SHORT_INTERVAL)); + auto resetTaskId = taskScheduler.Reset(atTaskId, std::chrono::milliseconds(0)); + ASSERT_EQ(resetTaskId, TaskScheduler::INVALID_TASK_ID); +} diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp index f7cfff7705cccd711ca00651965512a07cf98d6a..4960860c802400d1aebf9ded9f55c756b36f8025 100644 --- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp +++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kv_utils.cpp @@ -70,12 +70,12 @@ Entry KvUtils::ToEntry(const DataShareValuesBucket &valueBucket) return {}; } Entry entry; - Status status = ToEntryData(values, KEY, entry.key); + Status status = ToEntryKey(values, entry.key); if (status != Status::SUCCESS) { ZLOGE("GetEntry key failed: %{public}d", status); return {}; } - status = ToEntryData(values, VALUE, entry.value); + status = ToEntryValue(values, entry.value); if (status != Status::SUCCESS) { ZLOGE("GetEntry value failed: %{public}d", status); return {}; @@ -109,10 +109,27 @@ Status KvUtils::GetKeys(const DataShareAbsPredicates &predicates, std::vector &values, - const std::string &field, Blob &blob) +Status KvUtils::ToEntryKey(const std::map &values, Blob &blob) { - auto it = values.find(field); + auto it = values.find(KEY); + if (it == values.end()) { + ZLOGE("field is not find!"); + return Status::ERROR; + } + if (auto *val = std::get_if(&it->second)) { + std::vector uData; + std::string data = *val; + uData.insert(uData.end(), data.begin(), data.end()); + blob = Blob(uData); + return Status::SUCCESS; + } + ZLOGE("value bucket type is not string"); + return Status::ERROR; +} + +Status KvUtils::ToEntryValue(const std::map &values, Blob &blob) +{ + auto it = values.find(VALUE); if (it == values.end()) { ZLOGE("field is not find!"); return Status::ERROR; @@ -120,31 +137,31 @@ Status KvUtils::ToEntryData(const std::map uData; if (auto *val = std::get_if>(&it->second)) { - ZLOGE("Value bucket type blob"); + ZLOGD("Value bucket type blob"); std::vector data = *val; uData.push_back(KvUtils::BYTE_ARRAY); uData.insert(uData.end(), data.begin(), data.end()); } else if (auto *val = std::get_if(&it->second)) { - ZLOGE("Value bucket type int"); + ZLOGD("Value bucket type int"); int64_t data = *val; uint64_t data64 = htobe64(*reinterpret_cast(&data)); uint8_t *dataU8 = reinterpret_cast(&data64); uData.push_back(KvUtils::INTEGER); uData.insert(uData.end(), dataU8, dataU8 + sizeof(int64_t) / sizeof(uint8_t)); } else if (auto *val = std::get_if(&it->second)) { - ZLOGE("Value bucket type double"); + ZLOGD("Value bucket type double"); double data = *val; uint64_t data64 = htobe64(*reinterpret_cast(&data)); uint8_t *dataU8 = reinterpret_cast(&data64); uData.push_back(KvUtils::DOUBLE); uData.insert(uData.end(), dataU8, dataU8 + sizeof(double) / sizeof(uint8_t)); } else if (auto *val = std::get_if(&it->second)) { - ZLOGE("Value bucket type bool"); + ZLOGD("Value bucket type bool"); bool data = *val; uData.push_back(KvUtils::BOOLEAN); uData.push_back(static_cast(data)); } else if (auto *val = std::get_if(&it->second)) { - ZLOGE("Value bucket type string"); + ZLOGD("Value bucket type string"); std::string data = *val; uData.push_back(KvUtils::STRING); uData.insert(uData.end(), data.begin(), data.end()); diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn index 8ef04ec9c42779ee5ee666fb5eb8b947089dc29d..58252a4496a6e808a13a6ad548ccf9a92eb71dc7 100644 --- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn +++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn @@ -26,6 +26,7 @@ config("module_private_config") { # for ipc_core interfaces. "//commonlibrary/c_utils/base/include", "//foundation/distributeddatamgr/data_share/interfaces/inner_api/common/include", + "//foundation/distributeddatamgr/data_share/interfaces/inner_api/provider/include", "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata/include", ] } @@ -215,6 +216,44 @@ ohos_unittest("TypesUtilTest") { ] } +ohos_unittest("KvUtilTest") { + module_out_path = module_output_path + + sources = [ "unittest/kv_utils_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter", + "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata:distributeddata_inner", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "c_utils:utils", + "ipc:ipc_core", + ] +} + +ohos_unittest("KvstoreDatashareBridgeTest") { + module_out_path = module_output_path + + sources = [ "unittest/kvstore_datashare_bridge_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter", + "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata:distributeddata_inner", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "c_utils:utils", + "ipc:ipc_core", + ] +} + ############################################################################### group("unittest") { testonly = true @@ -226,6 +265,8 @@ group("unittest") { ":DeviceKvStoreTest", ":DistributedKvDataManagerEncryptTest", ":DistributedKvDataManagerTest", + ":KvUtilTest", + ":KvstoreDatashareBridgeTest", ":LocalSubscribeDeviceStoreTest", ":LocalSubscribeStoreTest", ":SingleKvStoreClientQueryTest", diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/blob_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/blob_test.cpp index 01cd1ef6d0acece29f91ce35193473fafbca4503..f4bdaff333808624e067a641f34edf077be981de 100644 --- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/blob_test.cpp +++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/blob_test.cpp @@ -58,8 +58,7 @@ HWTEST_F(BlobTest, Size001, TestSize.Level0) Blob blob3("12345"); EXPECT_EQ(blob3.Size(), (size_t)5); std::string strTmp = "123"; - const char *chr = strTmp.c_str(); - Blob blob4(chr); + Blob blob4(strTmp.c_str()); EXPECT_EQ(blob4.Size(), (size_t)3); std::vector vec = {'1', '2', '3', '4'}; Blob blob5(vec); @@ -67,6 +66,10 @@ HWTEST_F(BlobTest, Size001, TestSize.Level0) const char *chr1 = strTmp.c_str(); Blob blob6(chr1, strlen(chr1)); EXPECT_EQ(blob6.Size(), (size_t)3); + Blob blob7(nullptr); + EXPECT_EQ(blob7.Size(), (size_t)0); + Blob blob8(nullptr, strlen(chr1)); + EXPECT_EQ(blob8.Size(), (size_t)0); } /** @@ -85,8 +88,7 @@ HWTEST_F(BlobTest, Empty001, TestSize.Level0) Blob blob3("12345"); EXPECT_EQ(blob3.Empty(), false); std::string strTmp = "123"; - const char *chr = strTmp.c_str(); - Blob blob4(chr); + Blob blob4(strTmp.c_str()); EXPECT_EQ(blob4.Empty(), false); std::vector vec = {'1', '2', '3', '4'}; Blob blob5(vec); @@ -264,6 +266,8 @@ HWTEST_F(BlobTest, Operator004, TestSize.Level0) std::vector blob = { 1, 2, 3, 4 }; Blob blob1(move(blob)); EXPECT_EQ(blob1.Size(), 4); + std::vector blob2 = std::move(blob1); + EXPECT_EQ(blob2.size(), 4); } /** diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/kv_utils_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/kv_utils_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..00acd0a08b073938e99898aad40d523266a8d3f8 --- /dev/null +++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/kv_utils_test.cpp @@ -0,0 +1,768 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include "datashare_predicates.h" +#include "datashare_values_bucket.h" +#include "distributed_kv_data_manager.h" +#include "gtest/gtest.h" +#include "kv_utils.h" +#include "kvstore_datashare_bridge.h" +#include "kvstore_result_set.h" +#include "result_set_bridge.h" +#include "store_errno.h" +#include "types.h" + +namespace { +using namespace testing::ext; +using namespace OHOS::DistributedKv; +using namespace OHOS::DataShare; +using var_t = std::variant>; +class KvUtilTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp() {} + void TearDown() {} + +protected: + static DistributedKvDataManager manager; + static std::shared_ptr singleKvStore; + static constexpr const char *KEY = "key"; + static constexpr const char *VALUE = "value"; + static constexpr const char *VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\"," + "\"SCHEMA_MODE\":\"STRICT\"," + "\"SCHEMA_SKIPSIZE\":0," + "\"SCHEMA_DEFINE\":" + "{" + "\"age\":\"INTEGER, NOT NULL\"" + "}," + "\"SCHEMA_INDEXES\":[\"$.age\"]}"; + static std::string Entry2Str(const Entry &entry); + static void ClearEntry(Entry &entry); + static Blob VariantValue2Blob(const var_t &value); + static Blob VariantKey2Blob(const var_t &value); +}; +std::shared_ptr KvUtilTest::singleKvStore = nullptr; +DistributedKvDataManager KvUtilTest::manager; + +std::string KvUtilTest::Entry2Str(const Entry &entry) +{ + return entry.key.ToString() + entry.value.ToString(); +} + +void KvUtilTest::ClearEntry(Entry &entry) +{ + entry.key.Clear(); + entry.value.Clear(); +} + +Blob KvUtilTest::VariantKey2Blob(const var_t &value) +{ + std::vector uData; + if (auto *val = std::get_if(&value)) { + std::string data = *val; + uData.insert(uData.end(), data.begin(), data.end()); + } + return Blob(uData); +} + +Blob KvUtilTest::VariantValue2Blob(const var_t &value) +{ + std::vector data; + auto strValue = std::get_if(&value); + if (strValue != nullptr) { + data.push_back(KvUtils::STRING); + data.insert(data.end(), (*strValue).begin(), (*strValue).end()); + } + auto boolValue = std::get_if(&value); + if (boolValue != nullptr) { + data.push_back(KvUtils::BOOLEAN); + data.push_back(static_cast(*boolValue)); + } + uint8_t *tmp = nullptr; + auto dblValue = std::get_if(&value); + if (dblValue != nullptr) { + double tmp4dbl = *dblValue; + uint64_t tmp64 = htobe64(*reinterpret_cast(&tmp4dbl)); + tmp = reinterpret_cast(&tmp64); + data.push_back(KvUtils::DOUBLE); + data.insert(data.end(), tmp, tmp + sizeof(double) / sizeof(uint8_t)); + } + auto intValue = std::get_if(&value); + if (intValue != nullptr) { + int64_t tmp4int = *intValue; + uint64_t tmp64 = htobe64(*reinterpret_cast(&tmp4int)); + tmp = reinterpret_cast(&tmp64); + data.push_back(KvUtils::INTEGER); + data.insert(data.end(), tmp, tmp + sizeof(int64_t) / sizeof(uint8_t)); + } + auto u8ArrayValue = std::get_if>(&value); + if (u8ArrayValue != nullptr) { + data.push_back(KvUtils::BYTE_ARRAY); + data.insert(data.end(), (*u8ArrayValue).begin(), (*u8ArrayValue).end()); + } + return Blob(data); +} + +void KvUtilTest::SetUpTestCase(void) +{ + Options options = { .createIfMissing = true, .encrypt = false, .autoSync = false, + .kvStoreType = KvStoreType::SINGLE_VERSION, .schema = VALID_SCHEMA_STRICT_DEFINE }; + options.area = EL1; + options.baseDir = std::string("/data/service/el1/public/database/kvUtilTest"); + AppId appId = { "kvUtilTest" }; + StoreId storeId = { "test_single" }; + mkdir(options.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + manager.DeleteKvStore(appId, storeId, options.baseDir); + manager.GetSingleKvStore(options, appId, storeId, singleKvStore); + EXPECT_NE(singleKvStore, nullptr); + singleKvStore->Put("test_key_1", "{\"age\":1}"); + singleKvStore->Put("test_key_2", "{\"age\":2}"); + singleKvStore->Put("test_key_3", "{\"age\":3}"); + singleKvStore->Put("kv_utils", "{\"age\":4}"); +} + +void KvUtilTest::TearDownTestCase(void) +{ + manager.DeleteKvStore( + {"kvUtilTest"}, {"test_single"}, "/data/service/el1/public/database/kvUtilTest"); + (void)remove("/data/service/el1/public/database/kvUtilTest/key"); + (void)remove("/data/service/el1/public/database/kvUtilTest/kvdb"); + (void)remove("/data/service/el1/public/database/kvUtilTest"); +} + +/** +* @tc.name: KvStoreResultSetToResultSetBridge +* @tc.desc: kvStore resultSet to resultSet bridge, the former is nullptr +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, KvStoreResultSetToResultSetBridgeAbnormal, TestSize.Level0) +{ + std::shared_ptr resultSet = nullptr; + auto bridge = KvUtils::ToResultSetBridge(resultSet); + EXPECT_EQ(bridge, nullptr); +} + +/** +* @tc.name: KvStoreResultSetToResultSetBridge +* @tc.desc: kvStore resultSet to resultSet bridge +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, KvStoreResultSetToResultSetBridge, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.KeyPrefix("test"); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + std::shared_ptr resultSet = nullptr; + status = singleKvStore->GetResultSet(query, resultSet); + EXPECT_EQ(status, Status::SUCCESS); + EXPECT_NE(resultSet, nullptr); + EXPECT_EQ(resultSet->GetCount(), 3); + auto bridge = KvUtils::ToResultSetBridge(resultSet); + EXPECT_NE(bridge, nullptr); + +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query equalTo +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryEqualTo, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.EqualTo("$.age", 1); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.EqualTo("$.age", 1); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query not equalTo +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryNotEqualTo, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.NotEqualTo("$.age", 1); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.NotEqualTo("$.age", 1); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query greater than +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryGreaterThan, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.GreaterThan("$.age", 1); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.GreaterThan("$.age", 1); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query less than +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryLessThan, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.LessThan("$.age", 3); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.LessThan("$.age", 3); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query greater than or equalTo +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryGreaterThanOrEqualTo, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.GreaterThanOrEqualTo("$.age", 1); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.GreaterThanOrEqualTo("$.age", 1); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query less than or equalTo +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryLessThanOrEqualTo, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.LessThanOrEqualTo("$.age", 3); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.LessThanOrEqualTo("$.age", 3); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query in +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryIn, TestSize.Level0) +{ + std::vector vectInt{ 1, 2 }; + DataSharePredicates predicates; + predicates.In("$.age", vectInt); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.In("$.age", vectInt); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query not in +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryNotIn, TestSize.Level0) +{ + std::vector vectInt{ 1, 2 }; + DataSharePredicates predicates; + predicates.NotIn("$.age", vectInt); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.NotIn("$.age", vectInt); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query or, like +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryLike, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.Like("$.age", "1"); + predicates.Or(); + predicates.Like("$.age", "3"); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.Like("$.age", "1"); + trgQuery.Or(); + trgQuery.Like("$.age", "3"); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query and, unlike +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryUnlike, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.Unlike("$.age", "1"); + predicates.And(); + predicates.Unlike("$.age", "3"); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.Unlike("$.age", "1"); + trgQuery.And(); + trgQuery.Unlike("$.age", "3"); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query is null +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryIsNull, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.IsNull("$.age"); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.IsNull("$.age"); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query is not null +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryIsNotNull, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.IsNotNull("$.age"); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.IsNotNull("$.age"); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query is order by asc +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryOrderByAsc, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.OrderByAsc("$.age"); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.OrderByAsc("$.age"); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query is order by desc +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryOrderByDesc, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.OrderByDesc("$.age"); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.OrderByDesc("$.age"); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query is limit +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryLimit, TestSize.Level0) +{ + DataSharePredicates predicates; + predicates.Limit(0, 9); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.Limit(0, 9); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: PredicatesToQuery +* @tc.desc: to query is in keys +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, PredicatesToQueryInKeys, TestSize.Level0) +{ + std::vector keys { "test_field", "", "^test_field", "^", "test_field_name" }; + DataSharePredicates predicates; + predicates.InKeys(keys); + DataQuery query; + auto status = KvUtils::ToQuery(predicates, query); + EXPECT_EQ(status, Status::SUCCESS); + DataQuery trgQuery; + trgQuery.InKeys(keys); + EXPECT_EQ(query.ToString(), trgQuery.ToString()); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryAbnormal, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + Entry trgEntry {}; + auto entry = KvUtils::ToEntry(bucket); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); + bucket.Put("invalid key", "value"); + EXPECT_FALSE(bucket.IsEmpty()); + entry = KvUtils::ToEntry(bucket); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); + bucket.Put(KEY, "value"); + entry = KvUtils::ToEntry(bucket); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket value is null +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryNull, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + bucket.Put(KEY, {}); + bucket.Put(VALUE, {}); + auto entry = KvUtils::ToEntry(bucket); + Entry trgEntry; + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket value type is int64_t +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryInt64_t, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + Entry trgEntry; + var_t varValue; + varValue.emplace<1>(314); + var_t varKey; + varKey.emplace<3>("314"); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + auto entry = KvUtils::ToEntry(bucket); + trgEntry.key = VariantKey2Blob(varKey); + trgEntry.value = VariantValue2Blob(varValue); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket value type is double +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryDouble, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + Entry trgEntry; + var_t varValue; + varValue.emplace<2>(3.14); + var_t varKey; + varKey.emplace<3>("314"); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + auto entry = KvUtils::ToEntry(bucket); + trgEntry.key = VariantKey2Blob(varKey); + trgEntry.value = VariantValue2Blob(varValue); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket value type is string +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryString, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + Entry trgEntry; + var_t varValue; + varValue.emplace<3>("3.14"); + var_t varKey; + varKey.emplace<3>("314"); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + auto entry = KvUtils::ToEntry(bucket); + trgEntry.key = VariantKey2Blob(varKey); + trgEntry.value = VariantValue2Blob(varValue); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket value type is bool +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryBool, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + Entry trgEntry; + var_t varValue; + varValue.emplace<4>(true); + var_t varKey; + varKey.emplace<3>("314"); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + auto entry = KvUtils::ToEntry(bucket); + trgEntry.key = VariantKey2Blob(varKey); + trgEntry.value = VariantValue2Blob(varValue); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket value type is uint8array +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryUint8Array, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + Entry trgEntry; + var_t varValue; + std::vector vecUint8 { 3, 14 }; + varValue.emplace<5>(vecUint8); + var_t varKey; + varKey.emplace<3>("314"); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + auto entry = KvUtils::ToEntry(bucket); + trgEntry.key = VariantKey2Blob(varKey); + trgEntry.value = VariantValue2Blob(varValue); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entry, the bucket key type is not string +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntryInvalidKey, TestSize.Level0) +{ + DataShareValuesBucket bucket {}; + Entry trgEntry; + var_t varValue; + std::vector vecUint8 { 3, 14 }; + varValue.emplace<5>(vecUint8); + var_t varKey; + varKey.emplace<1>(314); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + auto entry = KvUtils::ToEntry(bucket); + trgEntry.key = VariantKey2Blob(varKey); + EXPECT_EQ(Entry2Str(entry), Entry2Str(trgEntry)); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entries, the buckets is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntriesAbnormal, TestSize.Level0) +{ + std::vector buckets {}; + auto entries = KvUtils::ToEntries(buckets); + EXPECT_TRUE(entries.empty()); +} + +/** +* @tc.name: ToEntry +* @tc.desc: dataShare values bucket to entries, the buckets has valid value +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, DataShareValuesBucketToEntriesNormal, TestSize.Level0) +{ + std::vector buckets {}; + DataShareValuesBucket bucket; + Entry trgEntryFirst; + Entry trgEntrySecond; + var_t varValue; + varValue.emplace<1>(314); + var_t varKey; + varKey.emplace<3>("314"); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + buckets.emplace_back(bucket); + trgEntryFirst.key = VariantKey2Blob(varKey); + trgEntryFirst.value = VariantValue2Blob(varValue); + bucket.Clear(); + varValue.emplace<2>(3.14); + varKey.emplace<3>("3.14"); + bucket.Put(KEY, varKey); + bucket.Put(VALUE, varValue); + buckets.emplace_back(bucket); + trgEntrySecond.key = VariantKey2Blob(varKey); + trgEntrySecond.value = VariantValue2Blob(varValue); + auto entries = KvUtils::ToEntries(buckets); + EXPECT_EQ(entries.size(), 2); + EXPECT_EQ(Entry2Str(entries[0]), Entry2Str(trgEntryFirst)); + EXPECT_EQ(Entry2Str(entries[1]), Entry2Str(trgEntrySecond)); +} + +/** +* @tc.name: GetKeys +* @tc.desc: get keys from data share predicates, the predicates is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, GetKeysFromDataSharePredicatesAbnormal, TestSize.Level0) +{ + DataSharePredicates predicates; + std::vector kvKeys; + auto status = KvUtils::GetKeys(predicates, kvKeys); + EXPECT_EQ(status, Status::ERROR); + predicates.EqualTo("$.age", 1); + status = KvUtils::GetKeys(predicates, kvKeys); + EXPECT_EQ(status, Status::NOT_SUPPORT); +} + +/** +* @tc.name: GetKeys +* @tc.desc: get keys from data share predicates, the predicates has valid value +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvUtilTest, GetKeysFromDataSharePredicatesNormal, TestSize.Level0) +{ + std::vector keys { "test_field", "", "^test_field", "^", "test_field_name" }; + DataSharePredicates predicates; + predicates.InKeys(keys); + std::vector kvKeys; + auto status = KvUtils::GetKeys(predicates, kvKeys); + EXPECT_EQ(status, Status::SUCCESS); + EXPECT_EQ(keys.size(), kvKeys.size()); + for (size_t i = 0; i < keys.size(); i++) { + EXPECT_EQ(keys[i], kvKeys[i].ToString()); + } +} +} // namespace \ No newline at end of file diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/kvstore_datashare_bridge_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/kvstore_datashare_bridge_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5cfe4a1221aac7fd2e1deee7d5e15d2a5f889c4f --- /dev/null +++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/kvstore_datashare_bridge_test.cpp @@ -0,0 +1,291 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "distributed_kv_data_manager.h" +#include "gtest/gtest.h" +#include "kv_utils.h" +#include "kvstore_datashare_bridge.h" +#include "store_errno.h" +#include "result_set_bridge.h" +#include "kvstore_result_set.h" +#include "types.h" + +namespace { +using namespace testing::ext; +using namespace OHOS::DistributedKv; +using namespace OHOS::DataShare; +class BridgeWriter final : public ResultSetBridge::Writer { +public: + int AllocRow() override; + int Write(uint32_t column) override; + int Write(uint32_t column, int64_t value) override; + int Write(uint32_t column, double value) override; + int Write(uint32_t column, const uint8_t *value, size_t size) override; + int Write(uint32_t column, const char *value, size_t size) override; + void SetAllocRowStatue(int status); + Key GetKey() const; + Key GetValue() const; + +private: + int allocStatus_ = E_OK; + std::vector key_; + std::vector value_; +}; + +void BridgeWriter::SetAllocRowStatue(int status) +{ + allocStatus_ = status; +} + +Key BridgeWriter::GetKey() const +{ + return key_; +} + +Value BridgeWriter::GetValue() const +{ + return value_; +} + +int BridgeWriter::AllocRow() +{ + return allocStatus_; +} + +int BridgeWriter::Write(uint32_t column) +{ + return E_OK; +} + +int BridgeWriter::Write(uint32_t column, int64_t value) +{ + return E_OK; +} + +int BridgeWriter::Write(uint32_t column, double value) +{ + return E_OK; +} + +int BridgeWriter::Write(uint32_t column, const uint8_t *value, size_t size) +{ + return E_OK; +} + +int BridgeWriter::Write(uint32_t column, const char *value, size_t size) +{ + if (column < 0 || column > 1 || value == nullptr) + { + return E_ERROR; + } + auto vec = std::vector(value, value + size - 1); + if (column == 0) { + key_.insert(key_.end(), vec.begin(), vec.end()); + } else { + value_.insert(value_.end(), vec.begin(), vec.end()); + } + return E_OK; +} + +class KvstoreDatashareBridgeTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp() {} + void TearDown() {} + +protected: + static DistributedKvDataManager manager; + static std::shared_ptr singleKvStore; +}; +std::shared_ptr KvstoreDatashareBridgeTest::singleKvStore = nullptr; +DistributedKvDataManager KvstoreDatashareBridgeTest::manager; +static constexpr int32_t INVALID_COUNT = -1; +static constexpr const char *VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\"," + "\"SCHEMA_MODE\":\"STRICT\"," + "\"SCHEMA_SKIPSIZE\":0," + "\"SCHEMA_DEFINE\":{" + "\"age\":\"INTEGER, NOT NULL\"" + "}," + "\"SCHEMA_INDEXES\":[\"$.age\"]}"; + +void KvstoreDatashareBridgeTest::SetUpTestCase(void) +{ + Options options = { .createIfMissing = true, .encrypt = false, .autoSync = false, + .kvStoreType = KvStoreType::SINGLE_VERSION, .schema = VALID_SCHEMA_STRICT_DEFINE }; + options.area = EL1; + options.baseDir = std::string("/data/service/el1/public/database/KvstoreDatashareBridgeTest"); + AppId appId = { "KvstoreDatashareBridgeTest" }; + StoreId storeId = { "test_single" }; + mkdir(options.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + manager.DeleteKvStore(appId, storeId, options.baseDir); + manager.GetSingleKvStore(options, appId, storeId, singleKvStore); + EXPECT_NE(singleKvStore, nullptr); + singleKvStore->Put("test_key_1", "{\"age\":1}"); + singleKvStore->Put("test_key_2", "{\"age\":2}"); + singleKvStore->Put("test_key_3", "{\"age\":3}"); + singleKvStore->Put("data_share", "{\"age\":4}"); +} + +void KvstoreDatashareBridgeTest::TearDownTestCase(void) +{ + manager.DeleteKvStore( + {"KvstoreDatashareBridgeTest"}, {"test_single"}, "/data/service/el1/public/database/KvstoreDatashareBridgeTest"); + (void)remove("/data/service/el1/public/database/KvstoreDatashareBridgeTest/key"); + (void)remove("/data/service/el1/public/database/KvstoreDatashareBridgeTest/kvdb"); + (void)remove("/data/service/el1/public/database/KvstoreDatashareBridgeTest"); +} + +/** +* @tc.name:ToDataShareResult +* @tc.desc: get row count, the kvStore resultSet is nullptr +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvstoreDatashareBridgeTest, GetRowCountByInvalidBridge, TestSize.Level0) +{ + auto bridge = std::make_shared(nullptr); + int32_t count; + auto result = bridge->GetRowCount(count); + EXPECT_EQ(result, E_ERROR); + EXPECT_EQ(count, INVALID_COUNT); + std::vector columnNames; + result = bridge->GetAllColumnNames(columnNames); + EXPECT_FALSE(columnNames.empty()); + EXPECT_EQ(result, E_OK); +} + +/** +* @tc.name:ToDataShareResultSet +* @tc.desc: kvStore resultSet to dataShare resultSet, the former has invalid predicate +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvstoreDatashareBridgeTest, KvStoreResultSetToDataShareResultSetAbnormal, TestSize.Level0) +{ + std::shared_ptr resultSet = nullptr; + DataQuery query; + query.KeyPrefix("key"); + singleKvStore->GetResultSet(query, resultSet); + EXPECT_NE(resultSet, nullptr); + auto bridge = KvUtils::ToResultSetBridge(resultSet); + int32_t count; + auto result = bridge->GetRowCount(count); + EXPECT_EQ(result, E_OK); + EXPECT_EQ(count, 0); +} + +/** +* @tc.name:ToDataShareResultSet +* @tc.desc: kvStore resultSet to dataShare resultSet, the former has valid predicate +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvstoreDatashareBridgeTest, KvStoreResultSetToDataShareResultSetNormal, TestSize.Level0) +{ + DataQuery query; + query.KeyPrefix("test"); + std::shared_ptr resultSet = nullptr; + singleKvStore->GetResultSet(query, resultSet); + EXPECT_NE(resultSet, nullptr); + auto bridge = KvUtils::ToResultSetBridge(resultSet); + int32_t count; + auto result = bridge->GetRowCount(count); + EXPECT_EQ(result, E_OK); + EXPECT_EQ(count, 3); + count = -1; + bridge->GetRowCount(count); + EXPECT_EQ(count, 3); +} + +/** +* @tc.name:BridgeOnGo +* @tc.desc: bridge on go, the input parameter is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvstoreDatashareBridgeTest, BridgeOnGoAbnormal, TestSize.Level0) +{ + DataQuery query; + query.KeyPrefix("test"); + std::shared_ptr resultSet = nullptr; + singleKvStore->GetResultSet(query, resultSet); + EXPECT_NE(resultSet, nullptr); + auto bridge = KvUtils::ToResultSetBridge(resultSet); + int32_t start = -1; + int32_t target = 0; + BridgeWriter writer; + EXPECT_FALSE(bridge->OnGo(start, target, writer)); + EXPECT_TRUE(writer.GetKey().Empty()); + EXPECT_TRUE(writer.GetValue().Empty()); + start = 0; + target = -1; + EXPECT_FALSE(bridge->OnGo(start, target, writer)); + EXPECT_TRUE(writer.GetKey().Empty()); + EXPECT_TRUE(writer.GetValue().Empty()); + start = 1; + target = 0; + EXPECT_FALSE(bridge->OnGo(start, target, writer)); + EXPECT_TRUE(writer.GetKey().Empty()); + EXPECT_TRUE(writer.GetValue().Empty()); + start = 1; + target = 3; + EXPECT_FALSE(bridge->OnGo(start, target, writer)); + EXPECT_TRUE(writer.GetKey().Empty()); + EXPECT_TRUE(writer.GetValue().Empty()); +} + +/** +* @tc.name:BridgeOnGo +* @tc.desc: bridge on go, the input parameter is valid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(KvstoreDatashareBridgeTest, BridgeOnGoNormal, TestSize.Level0) +{ + DataQuery query; + query.KeyPrefix("test"); + std::shared_ptr resultSet = nullptr; + singleKvStore->GetResultSet(query, resultSet); + EXPECT_NE(resultSet, nullptr); + auto bridge = KvUtils::ToResultSetBridge(resultSet); + int start = 0; + int target = 2; + BridgeWriter writer; + writer.SetAllocRowStatue(E_ERROR); + EXPECT_FALSE(bridge->OnGo(start, target, writer)); + EXPECT_TRUE(writer.GetKey().Empty()); + EXPECT_TRUE(writer.GetValue().Empty()); + writer.SetAllocRowStatue(E_OK); + EXPECT_TRUE(bridge->OnGo(start, target, writer)); + size_t keySize = 0; + size_t valueSize = 0; + for (auto i = start; i <= target; i++) { + resultSet->MoveToPosition(i); + Entry entry; + resultSet->GetEntry(entry); + keySize += entry.key.Size(); + valueSize += entry.value.Size(); + } + EXPECT_EQ(writer.GetKey().Size(), keySize); + EXPECT_EQ(writer.GetValue().Size(), valueSize); +} +} // namespace + \ No newline at end of file diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_query_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_query_test.cpp index 3a59a6fdc2b927cd369daaa84eabe5d273aa9a49..cefe8625eb0facc11014d627bc63ad0bab7c254e 100644 --- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_query_test.cpp +++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_query_test.cpp @@ -21,11 +21,10 @@ #include #include "distributed_kv_data_manager.h" #include "types.h" -#include "log_print.h" #include "gtest/gtest.h" +namespace { using namespace testing::ext; using namespace OHOS::DistributedKv; - class SingleKvStoreClientQueryTest : public testing::Test { public: static void SetUpTestCase(void); @@ -36,19 +35,21 @@ public: void TearDown(); - static std::shared_ptr singleKvStorePtr; + static std::shared_ptr singleKvStore; static Status statusGetKvStore; }; -const std::string VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\"," - "\"SCHEMA_MODE\":\"STRICT\"," - "\"SCHEMA_SKIPSIZE\":0," - "\"SCHEMA_DEFINE\":{" - "\"name\":\"INTEGER, NOT NULL\"" - "}," - "\"SCHEMA_INDEXES\":[\"$.name\"]}"; -std::shared_ptr SingleKvStoreClientQueryTest::singleKvStorePtr = nullptr; +static constexpr const char *VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\"," + "\"SCHEMA_MODE\":\"STRICT\"," + "\"SCHEMA_SKIPSIZE\":0," + "\"SCHEMA_DEFINE\":{" + "\"name\":\"INTEGER, NOT NULL\"" + "}," + "\"SCHEMA_INDEXES\":[\"$.name\"]}"; +std::shared_ptr SingleKvStoreClientQueryTest::singleKvStore = nullptr; Status SingleKvStoreClientQueryTest::statusGetKvStore = Status::ERROR; +static constexpr int32_t INVALID_NUMBER = -1; +static constexpr uint32_t MAX_QUERY_LENGTH = 1024; void SingleKvStoreClientQueryTest::SetUpTestCase(void) { @@ -70,15 +71,14 @@ void SingleKvStoreClientQueryTest::TearDown(void) {} /** -* @tc.name: TestQueryC001 -* @tc.desc: Query reset. +* @tc.name: DataQuery +* @tc.desc: the predicate is reset * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC001, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, TestQueryReset, TestSize.Level1) { - ZLOGD("TestQueryC001 start"); DataQuery query; EXPECT_TRUE(query.ToString().length() == 0); std::string str = "test value"; @@ -86,19 +86,49 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC001, TestSize.Level1) EXPECT_TRUE(query.ToString().length() > 0); query.Reset(); EXPECT_TRUE(query.ToString().length() == 0); - ZLOGD("TestQueryC001 end"); } /** -* @tc.name: TestQueryC002 -* @tc.desc: Query equalTo. +* @tc.name: DataQuery +* @tc.desc: the predicate is equalTo, the field is invalid * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC002, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryEqualToInvalidField, TestSize.Level1) +{ + DataQuery query; + query.EqualTo("", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("$.test_field_name^", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("", (int64_t)100); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("^", (int64_t)100); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("$.^", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("", false); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("^$.test_field_name", false); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("", std::string("str")); + EXPECT_TRUE(query.ToString().length() == 0); + query.EqualTo("^^^^^^^", std::string("str")); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is equalTo, the field is valid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryEqualToValidField, TestSize.Level1) { - ZLOGD("TestQueryC002 start"); DataQuery query; query.EqualTo("$.test_field_name", 100); EXPECT_TRUE(query.ToString().length() > 0); @@ -115,19 +145,49 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC002, TestSize.Level1) std::string str = ""; query.EqualTo("$.test_field_name", str); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC002 end"); } /** -* @tc.name: TestQueryC003 -* @tc.desc: Query notEqualTo. +* @tc.name: DataQuery +* @tc.desc: the predicate is notEqualTo, the field is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryNotEqualToValidField, TestSize.Level1) +{ + DataQuery query; + query.NotEqualTo("", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("$.test_field_name^test", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("", (int64_t)100); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("^$.test_field_name", (int64_t)100); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("^", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("", false); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("^^", false); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("", std::string("test_value")); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotEqualTo("$.test_field^_name", std::string("test_value")); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is notEqualTo, the field is valid * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC003, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryNotEqualToInvalidField, TestSize.Level1) { - ZLOGD("TestQueryC003 start"); DataQuery query; query.NotEqualTo("$.test_field_name", 100); EXPECT_TRUE(query.ToString().length() > 0); @@ -144,19 +204,45 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC003, TestSize.Level1) std::string str = "test value"; query.NotEqualTo("$.test_field_name", str); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC003 end"); } /** -* @tc.name: TestQueryC004 -* @tc.desc: Query greaterThan. +* @tc.name: DataQuery +* @tc.desc: the predicate is greaterThan, the field is invalid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC004, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryGreaterThanInvalidField, TestSize.Level1) +{ + DataQuery query; + query.GreaterThan("", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThan("$.^^", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThan("", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThan("^$.test_field_name", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThan("", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThan("^", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThan("", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThan("$.test_field_name^*%$#", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is greaterThan, the field is valid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryGreaterThanValidField, TestSize.Level1) { - ZLOGD("TestQueryC004 start"); DataQuery query; query.GreaterThan("$.test_field_name", 100); EXPECT_TRUE(query.ToString().length() > 0); @@ -167,22 +253,47 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC004, TestSize.Level1) query.GreaterThan("$.test_field_name", 1.23); EXPECT_TRUE(query.ToString().length() > 0); query.Reset(); - std::string str = "test value"; - query.GreaterThan("$.test_field_name", str); + query.GreaterThan("$.test_field_name$$$", "test value"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC004 end"); } /** -* @tc.name: TestQueryC005 -* @tc.desc: Query lessThan. +* @tc.name: DataQuery +* @tc.desc: the predicate is lessThan, the field is invalid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLessThanInvalidField, TestSize.Level1) +{ + DataQuery query; + query.LessThan("", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThan("$.^", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThan("", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThan("^$.test_field_name", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThan("", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThan("^^^", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThan("", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThan("$.test_field_name^", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is lessThan, the field is valid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC005, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLessThanValidField, TestSize.Level1) { - ZLOGD("TestQueryC005 start"); DataQuery query; query.LessThan("$.test_field_name", 100); EXPECT_TRUE(query.ToString().length() > 0); @@ -193,22 +304,47 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC005, TestSize.Level1) query.LessThan("$.test_field_name", 1.23); EXPECT_TRUE(query.ToString().length() > 0); query.Reset(); - std::string str = "test value"; - query.LessThan("$.test_field_name", str); + query.LessThan("$.test_field_name", "test value"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC005 end"); } /** -* @tc.name: TestQueryC006 -* @tc.desc: Query greaterThanOrEqualTo. +* @tc.name: DataQuery +* @tc.desc: the predicate is greaterThanOrEqualTo, the field is invalid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC006, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryGreaterThanOrEqualToInvalidField, TestSize.Level1) +{ + DataQuery query; + query.GreaterThanOrEqualTo("", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThanOrEqualTo("^$.test_field_name", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThanOrEqualTo("", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThanOrEqualTo("$.test_field_name^", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThanOrEqualTo("", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThanOrEqualTo("^$.^", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThanOrEqualTo("", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); + query.GreaterThanOrEqualTo("^^=", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is greaterThanOrEqualTo, the field is valid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryGreaterThanOrEqualToValidField, TestSize.Level1) { - ZLOGD("TestQueryC006 start"); DataQuery query; query.GreaterThanOrEqualTo("$.test_field_name", 100); EXPECT_TRUE(query.ToString().length() > 0); @@ -219,22 +355,47 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC006, TestSize.Level1) query.GreaterThanOrEqualTo("$.test_field_name", 1.23); EXPECT_TRUE(query.ToString().length() > 0); query.Reset(); - std::string str = "test value"; - query.GreaterThanOrEqualTo("$.test_field_name", str); + query.GreaterThanOrEqualTo("$.test_field_name", "test value"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC006 end"); } /** -* @tc.name: TestQueryC007 -* @tc.desc: Query lessThanOrEqualTo. +* @tc.name: DataQuery +* @tc.desc: the predicate is lessThanOrEqualTo, the field is invalid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLessThanOrEqualToInvalidField, TestSize.Level1) +{ + DataQuery query; + query.LessThanOrEqualTo("", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThanOrEqualTo("^$.test_field_name", 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThanOrEqualTo("", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThanOrEqualTo("$.test_field_name^", (int64_t) 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThanOrEqualTo("", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThanOrEqualTo("^", 1.23); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThanOrEqualTo("", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); + query.LessThanOrEqualTo("678678^", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is lessThanOrEqualTo, the field is valid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC007, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLessThanOrEqualToValidField, TestSize.Level1) { - ZLOGD("TestQueryC007 start"); DataQuery query; query.LessThanOrEqualTo("$.test_field_name", 100); EXPECT_TRUE(query.ToString().length() > 0); @@ -245,38 +406,81 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC007, TestSize.Level1) query.LessThanOrEqualTo("$.test_field_name", 1.23); EXPECT_TRUE(query.ToString().length() > 0); query.Reset(); - std::string str = "test value"; - query.LessThanOrEqualTo("$.test_field_name", str); + query.LessThanOrEqualTo("$.test_field_name", "test value"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC007 end"); } /** -* @tc.name: TestQueryC008 -* @tc.desc: Query isNull. +* @tc.name: DataQuery +* @tc.desc: the predicate is isNull, the field is invalid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryIsNullInvalidField, TestSize.Level1) +{ + DataQuery query; + query.IsNull(""); + EXPECT_TRUE(query.ToString().length() == 0); + query.IsNull("$.test^_field_name"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is isNull, the field is valid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC008, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryIsNullValidField, TestSize.Level1) { - ZLOGD("TestQueryC008 start"); DataQuery query; query.IsNull("$.test_field_name"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC008 end"); } /** -* @tc.name: TestQueryC009 -* @tc.desc: Query in. +* @tc.name: DataQuery +* @tc.desc: the predicate is in, the field is invalid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryInInvalidField, TestSize.Level1) +{ + DataQuery query; + std::vector vectInt{ 10, 20, 30 }; + query.In("", vectInt); + EXPECT_TRUE(query.ToString().length() == 0); + query.In("^", vectInt); + EXPECT_TRUE(query.ToString().length() == 0); + std::vector vectLong{ (int64_t) 100, (int64_t) 200, (int64_t) 300 }; + query.In("", vectLong); + EXPECT_TRUE(query.ToString().length() == 0); + query.In("$.test_field_name^", vectLong); + EXPECT_TRUE(query.ToString().length() == 0); + std::vector vectDouble{1.23, 2.23, 3.23}; + query.In("", vectDouble); + EXPECT_TRUE(query.ToString().length() == 0); + query.In("$.^test_field_name", vectDouble); + EXPECT_TRUE(query.ToString().length() == 0); + std::vector vectString{ "value 1", "value 2", "value 3" }; + query.In("", vectString); + EXPECT_TRUE(query.ToString().length() == 0); + query.In("$.test_field_^name^", vectString); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is in, the field is valid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC009, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryInValidField, TestSize.Level1) { - ZLOGD("TestQueryC009 start"); DataQuery query; std::vector vectInt{ 10, 20, 30 }; query.In("$.test_field_name", vectInt); @@ -293,19 +497,49 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC009, TestSize.Level1) std::vector vectString{ "value 1", "value 2", "value 3" }; query.In("$.test_field_name", vectString); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC009 end"); } /** -* @tc.name: TestQueryC010 -* @tc.desc: Query in. +* @tc.name: DataQuery +* @tc.desc: the predicate is notIn, the field is invalid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryNotInInvalidField, TestSize.Level1) +{ + DataQuery query; + std::vector vectInt{ 10, 20, 30 }; + query.NotIn("", vectInt); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotIn("$.^", vectInt); + EXPECT_TRUE(query.ToString().length() == 0); + std::vector vectLong{ (int64_t) 100, (int64_t) 200, (int64_t) 300 }; + query.NotIn("", vectLong); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotIn("^^", vectLong); + EXPECT_TRUE(query.ToString().length() == 0); + std::vector vectDouble{ 1.23, 2.23, 3.23 }; + query.NotIn("", vectDouble); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotIn("^$.test_field_name", vectDouble); + EXPECT_TRUE(query.ToString().length() == 0); + std::vector vectString{ "value 1", "value 2", "value 3" }; + query.NotIn("", vectString); + EXPECT_TRUE(query.ToString().length() == 0); + query.NotIn("$.^", vectString); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is notIn, the field is valid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC010, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryNotInValidField, TestSize.Level1) { - ZLOGD("TestQueryC010 start"); DataQuery query; std::vector vectInt{ 10, 20, 30 }; query.NotIn("$.test_field_name", vectInt); @@ -322,121 +556,199 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC010, TestSize.Level1) std::vector vectString{ "value 1", "value 2", "value 3" }; query.NotIn("$.test_field_name", vectString); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC010 end"); } /** -* @tc.name: TestQueryC011 -* @tc.desc: Query like. +* @tc.name: DataQuery +* @tc.desc: the predicate is like, the field is invalid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC011, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLikeInvalidField, TestSize.Level1) +{ + DataQuery query; + query.Like("", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); + query.Like("$.test_fi^eld_name", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is like, the field is valid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLikeValidField, TestSize.Level1) { - ZLOGD("TestQueryC011 start"); DataQuery query; query.Like("$.test_field_name", "test value"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC011 end"); } /** -* @tc.name: TestQueryC012 -* @tc.desc: Query unlike. +* @tc.name: DataQuery +* @tc.desc: the predicate is unlike, the field is invalid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC012, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryUnlikeInvalidField, TestSize.Level1) +{ + DataQuery query; + query.Unlike("", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); + query.Unlike("$.^", "test value"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is unlike, the field is valid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryUnlikeValidField, TestSize.Level1) { - ZLOGD("TestQueryC012 start"); DataQuery query; query.Unlike("$.test_field_name", "test value"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC012 end"); } /** -* @tc.name: TestQueryC013 -* @tc.desc: Query and. +* @tc.name: DataQuery +* @tc.desc: the predicate is and * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC013, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryAnd, TestSize.Level1) { - ZLOGD("TestQueryC013 start"); DataQuery query; query.Like("$.test_field_name1", "test value1"); query.And(); query.Like("$.test_field_name2", "test value2"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC013 end"); } /** -* @tc.name: TestQueryC014 -* @tc.desc: Query or. +* @tc.name: DataQuery +* @tc.desc: the predicate is or * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC014, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryOr, TestSize.Level1) { - ZLOGD("TestQueryC014 start"); DataQuery query; query.Like("$.test_field_name1", "test value1"); query.Or(); query.Like("$.test_field_name2", "test value2"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC014 end"); } /** -* @tc.name: TestQueryC015 -* @tc.desc: Query orderBy. +* @tc.name: DataQuery +* @tc.desc: the predicate is orderByAsc, the field is invalid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC015, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryOrderByAscInvalidField, TestSize.Level1) +{ + DataQuery query; + query.OrderByAsc(""); + EXPECT_TRUE(query.ToString().length() == 0); + query.OrderByAsc("$.^"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is orderByAsc, the field is valid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryOrderByAscValidField, TestSize.Level1) { - ZLOGD("TestQueryC015 start"); DataQuery query; query.OrderByAsc("$.test_field_name1"); - query.Reset(); + EXPECT_TRUE(query.ToString().length() > 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is orderByDesc, the field is invalid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryOrderByDescInvalidField, TestSize.Level1) +{ + DataQuery query; + query.OrderByDesc(""); + EXPECT_TRUE(query.ToString().length() == 0); + query.OrderByDesc("$.test^_field_name1"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is orderByDesc, the field is valid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryOrderByDescValidField, TestSize.Level1) +{ + DataQuery query; query.OrderByDesc("$.test_field_name1"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC015 end"); } /** -* @tc.name: TestQueryC016 -* @tc.desc: Query orderBy. +* @tc.name: DataQuery +* @tc.desc: the predicate is limit, the field is invalid. * @tc.type: FUNC -* @tc.require: AR000DPSF5 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC016, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLimitInvalidField, TestSize.Level1) +{ + DataQuery query; + query.Limit(INVALID_NUMBER, 100); + EXPECT_TRUE(query.ToString().length() == 0); + query.Limit(10, INVALID_NUMBER); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is limit, the field is valid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryLimitValidField, TestSize.Level1) { - ZLOGD("TestQueryC016 start"); DataQuery query; query.Limit(10, 100); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC016 end"); } /** -* @tc.name: TestSingleKvStoreQueryC001 -* @tc.desc: query single KvStore. +* @tc.name: DataQuery +* @tc.desc: query single kvStore by dataQuery, the predicate is notEqualTo * @tc.type: FUNC -* @tc.require: SR000DPCO9 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestSingleKvStoreQueryC001, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, SingleKvStoreQueryNotEqualTo, TestSize.Level1) { - ZLOGD("TestSingleKvStoreQueryC001 start"); DistributedKvDataManager manager; Options options = { .createIfMissing = true, .encrypt = true, .autoSync = true, .kvStoreType = KvStoreType::SINGLE_VERSION, .schema = VALID_SCHEMA_STRICT_DEFINE }; @@ -444,67 +756,63 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestSingleKvStoreQueryC001, TestSize.Leve options.baseDir = "/data/service/el1/public/database/SingleKvStoreClientQueryTest"; AppId appId = { "SingleKvStoreClientQueryTest" }; StoreId storeId = { "SingleKvStoreClientQueryTestStoreId1" }; - statusGetKvStore = manager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr); - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; - singleKvStorePtr->Put("test_key_1", "{\"name\":1}"); - singleKvStorePtr->Put("test_key_2", "{\"name\":2}"); - singleKvStorePtr->Put("test_key_3", "{\"name\":3}"); + statusGetKvStore = manager.GetSingleKvStore(options, appId, storeId, singleKvStore); + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; + singleKvStore->Put("test_key_1", "{\"name\":1}"); + singleKvStore->Put("test_key_2", "{\"name\":2}"); + singleKvStore->Put("test_key_3", "{\"name\":3}"); DataQuery query; query.NotEqualTo("$.name", 3); std::vector results; - Status status1 = singleKvStorePtr->GetEntries(query, results); + Status status1 = singleKvStore->GetEntries(query, results); ASSERT_EQ(status1, Status::SUCCESS); EXPECT_TRUE(results.size() == 2); results.clear(); - Status status2 = singleKvStorePtr->GetEntries(query, results); + Status status2 = singleKvStore->GetEntries(query, results); ASSERT_EQ(status2, Status::SUCCESS); EXPECT_TRUE(results.size() == 2); std::shared_ptr resultSet; - Status status3 = singleKvStorePtr->GetResultSet(query, resultSet); + Status status3 = singleKvStore->GetResultSet(query, resultSet); ASSERT_EQ(status3, Status::SUCCESS); EXPECT_TRUE(resultSet->GetCount() == 2); - auto closeResultSetStatus = singleKvStorePtr->CloseResultSet(resultSet); + auto closeResultSetStatus = singleKvStore->CloseResultSet(resultSet); ASSERT_EQ(closeResultSetStatus, Status::SUCCESS); - Status status4 = singleKvStorePtr->GetResultSet(query, resultSet); + Status status4 = singleKvStore->GetResultSet(query, resultSet); ASSERT_EQ(status4, Status::SUCCESS); EXPECT_TRUE(resultSet->GetCount() == 2); - closeResultSetStatus = singleKvStorePtr->CloseResultSet(resultSet); + closeResultSetStatus = singleKvStore->CloseResultSet(resultSet); ASSERT_EQ(closeResultSetStatus, Status::SUCCESS); int resultSize1; - Status status5 = singleKvStorePtr->GetCount(query, resultSize1); + Status status5 = singleKvStore->GetCount(query, resultSize1); ASSERT_EQ(status5, Status::SUCCESS); EXPECT_TRUE(resultSize1 == 2); int resultSize2; - Status status6 = singleKvStorePtr->GetCount(query, resultSize2); + Status status6 = singleKvStore->GetCount(query, resultSize2); ASSERT_EQ(status6, Status::SUCCESS); EXPECT_TRUE(resultSize2 == 2); - singleKvStorePtr->Delete("test_key_1"); - singleKvStorePtr->Delete("test_key_2"); - singleKvStorePtr->Delete("test_key_3"); + singleKvStore->Delete("test_key_1"); + singleKvStore->Delete("test_key_2"); + singleKvStore->Delete("test_key_3"); Status status = manager.CloseAllKvStore(appId); EXPECT_EQ(status, Status::SUCCESS); status = manager.DeleteAllKvStore(appId, options.baseDir); EXPECT_EQ(status, Status::SUCCESS); - ZLOGD("TestSingleKvStoreQueryC001 end"); } - /** -* @tc.name: TestSingleKvStoreQueryC002 -* @tc.desc: query single KvStore. +* @tc.name: DataQuery +* @tc.desc: query single kvStore by dataQuery, the predicate is notEqualTo and equalTo * @tc.type: FUNC -* @tc.require: SR000DPCO9 -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestSingleKvStoreQueryC002, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, SingleKvStoreQueryNotEqualToAndEqualTo, TestSize.Level1) { - ZLOGD("TestSingleKvStoreQueryC002 start"); - DistributedKvDataManager manager; Options options = { .createIfMissing = true, .encrypt = true, .autoSync = true, .kvStoreType = KvStoreType::SINGLE_VERSION, .schema = VALID_SCHEMA_STRICT_DEFINE }; @@ -512,105 +820,189 @@ HWTEST_F(SingleKvStoreClientQueryTest, TestSingleKvStoreQueryC002, TestSize.Leve options.baseDir = "/data/service/el1/public/database/SingleKvStoreClientQueryTest"; AppId appId = { "SingleKvStoreClientQueryTest" }; StoreId storeId = { "SingleKvStoreClientQueryTestStoreId2" }; - statusGetKvStore = manager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr); - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; - singleKvStorePtr->Put("test_key_1", "{\"name\":1}"); - singleKvStorePtr->Put("test_key_2", "{\"name\":2}"); - singleKvStorePtr->Put("test_key_3", "{\"name\":3}"); + statusGetKvStore = manager.GetSingleKvStore(options, appId, storeId, singleKvStore); + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; + singleKvStore->Put("test_key_1", "{\"name\":1}"); + singleKvStore->Put("test_key_2", "{\"name\":2}"); + singleKvStore->Put("test_key_3", "{\"name\":3}"); DataQuery query; query.NotEqualTo("$.name", 3); query.And(); query.EqualTo("$.name", 1); std::vector results1; - Status status1 = singleKvStorePtr->GetEntries(query, results1); + Status status1 = singleKvStore->GetEntries(query, results1); ASSERT_EQ(status1, Status::SUCCESS); EXPECT_TRUE(results1.size() == 1); std::vector results2; - Status status2 = singleKvStorePtr->GetEntries(query, results2); + Status status2 = singleKvStore->GetEntries(query, results2); ASSERT_EQ(status2, Status::SUCCESS); EXPECT_TRUE(results2.size() == 1); std::shared_ptr resultSet; - Status status3 = singleKvStorePtr->GetResultSet(query, resultSet); + Status status3 = singleKvStore->GetResultSet(query, resultSet); ASSERT_EQ(status3, Status::SUCCESS); EXPECT_TRUE(resultSet->GetCount() == 1); - auto closeResultSetStatus = singleKvStorePtr->CloseResultSet(resultSet); + auto closeResultSetStatus = singleKvStore->CloseResultSet(resultSet); ASSERT_EQ(closeResultSetStatus, Status::SUCCESS); - Status status4 = singleKvStorePtr->GetResultSet(query, resultSet); + Status status4 = singleKvStore->GetResultSet(query, resultSet); ASSERT_EQ(status4, Status::SUCCESS); EXPECT_TRUE(resultSet->GetCount() == 1); - closeResultSetStatus = singleKvStorePtr->CloseResultSet(resultSet); + closeResultSetStatus = singleKvStore->CloseResultSet(resultSet); ASSERT_EQ(closeResultSetStatus, Status::SUCCESS); int resultSize1; - Status status5 = singleKvStorePtr->GetCount(query, resultSize1); - ZLOGD("this is it %ul", status5); + Status status5 = singleKvStore->GetCount(query, resultSize1); ASSERT_EQ(status5, Status::SUCCESS); EXPECT_TRUE(resultSize1 == 1); int resultSize2; - Status status6 = singleKvStorePtr->GetCount(query, resultSize2); + Status status6 = singleKvStore->GetCount(query, resultSize2); ASSERT_EQ(status6, Status::SUCCESS); EXPECT_TRUE(resultSize2 == 1); - singleKvStorePtr->Delete("test_key_1"); - singleKvStorePtr->Delete("test_key_2"); - singleKvStorePtr->Delete("test_key_3"); + singleKvStore->Delete("test_key_1"); + singleKvStore->Delete("test_key_2"); + singleKvStore->Delete("test_key_3"); Status status = manager.CloseAllKvStore(appId); EXPECT_EQ(status, Status::SUCCESS); status = manager.DeleteAllKvStore(appId, options.baseDir); EXPECT_EQ(status, Status::SUCCESS); - ZLOGD("TestSingleKvStoreQueryC002 end"); } /** -* @tc.name: TestQueryC017 -* @tc.desc: Query group prefix isNotNull. +* @tc.name: DataQuery +* @tc.desc: query group, the predicate is prefix, isNotNull, but field is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryGroupAbnormal, TestSize.Level1) +{ + DataQuery query; + query.KeyPrefix(""); + EXPECT_TRUE(query.ToString().length() == 0); + query.KeyPrefix("prefix^"); + EXPECT_TRUE(query.ToString().length() == 0); + query.Reset(); + query.BeginGroup(); + query.IsNotNull(""); + EXPECT_TRUE(query.ToString().length() > 0); + query.IsNotNull("^$.name"); + EXPECT_TRUE(query.ToString().length() > 0); + query.EndGroup(); + EXPECT_TRUE(query.ToString().length() > 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: query group, the predicate is prefix, isNotNull. * @tc.type: FUNC -* @tc.require: AR000EPAMV -* @tc.author: YangLeda +* @tc.require: +* @tc.author: zuojiangjiang */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC017, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryByGroupNormal, TestSize.Level1) { - ZLOGD("TestQueryC017 start"); DataQuery query; query.KeyPrefix("prefix"); + EXPECT_TRUE(query.ToString().length() > 0); + query.Reset(); query.BeginGroup(); query.IsNotNull("$.name"); query.EndGroup(); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC017 end"); } /** -* @tc.name: TestQueryC018 -* @tc.desc: Query SetSuggestIndex. +* @tc.name: DataQuery +* @tc.desc: the predicate is setSuggestIndex, the field is invalid. +* @tc.type: FUNC +* @tc.require: +* @tc.author: liuwenhui +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQuerySetSuggestIndexInvalidField, TestSize.Level1) +{ + DataQuery query; + query.SetSuggestIndex(""); + EXPECT_TRUE(query.ToString().length() == 0); + query.SetSuggestIndex("test_field^_name"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is setSuggestIndex, the field is valid. * @tc.type: FUNC -* @tc.require: AR000F3PBJ +* @tc.require: * @tc.author: liuwenhui */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC018, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQuerySetSuggestIndexValidField, TestSize.Level1) { - ZLOGD("TestQueryC018 start"); DataQuery query; query.SetSuggestIndex("test_field_name"); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC018 end"); } /** -* @tc.name: TestQueryC019 -* @tc.desc: Query InKeys. +* @tc.name: DataQuery +* @tc.desc: the predicate is inKeys * @tc.type: FUNC -* @tc.require: AR000GOHO7 +* @tc.require: * @tc.author: taoyuxin */ -HWTEST_F(SingleKvStoreClientQueryTest, TestQueryC019, TestSize.Level1) +HWTEST_F(SingleKvStoreClientQueryTest, DataQuerySetInKeys, TestSize.Level1) { - ZLOGD("TestQueryC019 start"); DataQuery query; + query.InKeys({}); + EXPECT_TRUE(query.ToString().length() == 0); query.InKeys({"test_field_name"}); EXPECT_TRUE(query.ToString().length() > 0); - ZLOGD("TestQueryC019 end"); + query.InKeys({"test_field_name_hasKey"}); + EXPECT_TRUE(query.ToString().length() > 0); + query.Reset(); + std::vector keys { "test_field", "", "^test_field", "^", "test_field_name" }; + query.InKeys(keys); + EXPECT_TRUE(query.ToString().length() > 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc:the predicate is deviceId, the field is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryDeviceIdInvalidField, TestSize.Level1) +{ + DataQuery query; + query.DeviceId(""); + EXPECT_TRUE(query.ToString().length() == 0); + query.DeviceId("$$^"); + EXPECT_TRUE(query.ToString().length() == 0); + query.DeviceId("device_id^"); + EXPECT_TRUE(query.ToString().length() == 0); +} + +/** +* @tc.name: DataQuery +* @tc.desc: the predicate is valid deviceId, the field is valid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zuojiangjiang +*/ +HWTEST_F(SingleKvStoreClientQueryTest, DataQueryDeviceIdValidField, TestSize.Level1) +{ + DataQuery query; + query.DeviceId("device_id"); + EXPECT_TRUE(query.ToString().length() > 0); + query.Reset(); + std::string deviceId = ""; + uint32_t i = 0; + while(i < MAX_QUERY_LENGTH) { + deviceId += "device"; + i++; + } + query.DeviceId(deviceId); + EXPECT_TRUE(query.ToString().length() == 0); } +} // namespace \ No newline at end of file diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_test.cpp index 4badb313eb01da67fcc307c4985b481748d604e4..fb456e023c15d2087546c6eb0687ae4815fa8c98 100644 --- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_test.cpp +++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_client_test.cpp @@ -34,7 +34,7 @@ public: void TearDown(); - static std::shared_ptr singleKvStorePtr; // declare kvstore instance. + static std::shared_ptr singleKvStore; // declare kvstore instance. static Status status_; static int MAX_VALUE_SIZE; }; @@ -47,7 +47,7 @@ const std::string VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\"," "}," "\"SCHEMA_INDEXES\":[\"$.age\"]}"; -std::shared_ptr SingleKvStoreClientTest::singleKvStorePtr = nullptr; +std::shared_ptr SingleKvStoreClientTest::singleKvStore = nullptr; Status SingleKvStoreClientTest::status_ = Status::ERROR; int SingleKvStoreClientTest::MAX_VALUE_SIZE = 4 * 1024 * 1024; // max value size is 4M. @@ -62,7 +62,7 @@ void SingleKvStoreClientTest::SetUpTestCase(void) StoreId storeId = { "student_single" }; // define kvstore(database) name. mkdir(options.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); // [create and] open and initialize kvstore instance. - status_ = manager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr); + status_ = manager.GetSingleKvStore(options, appId, storeId, singleKvStore); } void SingleKvStoreClientTest::TearDownTestCase(void) @@ -164,9 +164,9 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::mapGetStoreId(); + auto storID = singleKvStore->GetStoreId(); EXPECT_EQ(storID.storeId, "student_single"); } @@ -179,30 +179,30 @@ HWTEST_F(SingleKvStoreClientTest, GetStoreId001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, PutGetDelete001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; Key skey = {"single_001"}; Value sval = {"value_001"}; - auto status = singleKvStorePtr->Put(skey, sval); + auto status = singleKvStore->Put(skey, sval); EXPECT_EQ(status, Status::SUCCESS) << "putting data failed"; - auto delStatus = singleKvStorePtr->Delete(skey); + auto delStatus = singleKvStore->Delete(skey); EXPECT_EQ(delStatus, Status::SUCCESS) << "deleting data failed"; - auto notExistStatus = singleKvStorePtr->Delete(skey); + auto notExistStatus = singleKvStore->Delete(skey); EXPECT_EQ(notExistStatus, Status::SUCCESS) << "deleting non-existing data failed"; - auto spaceStatus = singleKvStorePtr->Put(skey, {""}); + auto spaceStatus = singleKvStore->Put(skey, {""}); EXPECT_EQ(spaceStatus, Status::SUCCESS) << "putting space failed"; - auto spaceKeyStatus = singleKvStorePtr->Put({""}, {""}); + auto spaceKeyStatus = singleKvStore->Put({""}, {""}); EXPECT_NE(spaceKeyStatus, Status::SUCCESS) << "putting space keys failed"; - Status validStatus = singleKvStorePtr->Put(skey, sval); + Status validStatus = singleKvStore->Put(skey, sval); EXPECT_EQ(validStatus, Status::SUCCESS) << "putting valid keys and values failed"; Value rVal; - auto validPutStatus = singleKvStorePtr->Get(skey, rVal); + auto validPutStatus = singleKvStore->Get(skey, rVal); EXPECT_EQ(validPutStatus, Status::SUCCESS) << "Getting value failed"; EXPECT_EQ(sval, rVal) << "Got and put values not equal"; } @@ -216,22 +216,22 @@ HWTEST_F(SingleKvStoreClientTest, PutGetDelete001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, GetEntriesAndResultSet001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; // prepare 10 size_t sum = 10; int sum_1 = 10; std::string prefix = "prefix_"; for (size_t i = 0; i < sum; i++) { - singleKvStorePtr->Put({prefix + std::to_string(i)}, {std::to_string(i)}); + singleKvStore->Put({prefix + std::to_string(i)}, {std::to_string(i)}); } std::vector results; - singleKvStorePtr->GetEntries({prefix}, results); + singleKvStore->GetEntries({prefix}, results); EXPECT_EQ(results.size(), sum) << "entries size is not equal 10."; std::shared_ptr resultSet; - Status status = singleKvStorePtr->GetResultSet({prefix}, resultSet); + Status status = singleKvStore->GetResultSet({prefix}, resultSet); EXPECT_EQ(status, Status::SUCCESS); EXPECT_EQ(resultSet->GetCount(), sum_1) << "resultSet size is not equal 10."; resultSet->IsFirst(); @@ -248,10 +248,10 @@ HWTEST_F(SingleKvStoreClientTest, GetEntriesAndResultSet001, TestSize.Level1) resultSet->GetEntry(entry); for (size_t i = 0; i < sum; i++) { - singleKvStorePtr->Delete({prefix + std::to_string(i)}); + singleKvStore->Delete({prefix + std::to_string(i)}); } - auto closeResultSetStatus = singleKvStorePtr->CloseResultSet(resultSet); + auto closeResultSetStatus = singleKvStore->CloseResultSet(resultSet); EXPECT_EQ(closeResultSetStatus, Status::SUCCESS) << "close resultSet failed."; } @@ -264,24 +264,24 @@ HWTEST_F(SingleKvStoreClientTest, GetEntriesAndResultSet001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, GetEntriesByDataQuery, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; // prepare 10 size_t sum = 10; int sum_1 = 10; std::string prefix = "prefix_"; for (size_t i = 0; i < sum; i++) { - singleKvStorePtr->Put({prefix + std::to_string(i)}, {std::to_string(i)}); + singleKvStore->Put({prefix + std::to_string(i)}, {std::to_string(i)}); } std::vector results; - singleKvStorePtr->GetEntries({ prefix }, results); + singleKvStore->GetEntries({ prefix }, results); EXPECT_EQ(results.size(), sum) << "entries size is not equal 10."; DataQuery dataQuery; dataQuery.KeyPrefix(prefix); dataQuery.Limit(10, 0); std::shared_ptr resultSet; - Status status = singleKvStorePtr->GetResultSet(dataQuery, resultSet); + Status status = singleKvStore->GetResultSet(dataQuery, resultSet); EXPECT_EQ(status, Status::SUCCESS); EXPECT_EQ(resultSet->GetCount(), sum_1) << "resultSet size is not equal 10."; resultSet->IsFirst(); @@ -298,10 +298,10 @@ HWTEST_F(SingleKvStoreClientTest, GetEntriesByDataQuery, TestSize.Level1) resultSet->GetEntry(entry); for (size_t i = 0; i < sum; i++) { - singleKvStorePtr->Delete({prefix + std::to_string(i)}); + singleKvStore->Delete({prefix + std::to_string(i)}); } - auto closeResultSetStatus = singleKvStorePtr->CloseResultSet(resultSet); + auto closeResultSetStatus = singleKvStore->CloseResultSet(resultSet); EXPECT_EQ(closeResultSetStatus, Status::SUCCESS) << "close resultSet failed."; } @@ -315,9 +315,9 @@ HWTEST_F(SingleKvStoreClientTest, GetEntriesByDataQuery, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, GetEmptyEntries, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; std::vector results; - auto status = singleKvStorePtr->GetEntries({ "SUCCESS_TEST" }, results); + auto status = singleKvStore->GetEntries({ "SUCCESS_TEST" }, results); EXPECT_EQ(status, Status::SUCCESS) << "status is not SUCCESS."; EXPECT_EQ(results.size(), 0) << "entries size is not empty."; } @@ -332,13 +332,13 @@ HWTEST_F(SingleKvStoreClientTest, GetEmptyEntries, TestSize.Level1) HWTEST_F(SingleKvStoreClientTest, Subscribe001, TestSize.Level1) { auto observer = std::make_shared(); - auto subStatus = singleKvStorePtr->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer); + auto subStatus = singleKvStore->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer); EXPECT_EQ(subStatus, Status::SUCCESS) << "subscribe kvStore observer failed."; // subscribe repeated observer; - auto repeatedSubStatus = singleKvStorePtr->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer); + auto repeatedSubStatus = singleKvStore->SubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer); EXPECT_NE(repeatedSubStatus, Status::SUCCESS) << "repeat subscribe kvStore observer failed."; - auto unSubStatus = singleKvStorePtr->UnSubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer); + auto unSubStatus = singleKvStore->UnSubscribeKvStore(SubscribeType::SUBSCRIBE_TYPE_ALL, observer); EXPECT_EQ(unSubStatus, Status::SUCCESS) << "unsubscribe kvStore observer failed."; } @@ -351,19 +351,19 @@ HWTEST_F(SingleKvStoreClientTest, Subscribe001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, SyncCallback001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; auto syncCallback = std::make_shared(); - auto syncStatus = singleKvStorePtr->RegisterSyncCallback(syncCallback); + auto syncStatus = singleKvStore->RegisterSyncCallback(syncCallback); EXPECT_EQ(syncStatus, Status::SUCCESS) << "register sync callback failed."; - auto unRegStatus = singleKvStorePtr->UnRegisterSyncCallback(); + auto unRegStatus = singleKvStore->UnRegisterSyncCallback(); EXPECT_EQ(unRegStatus, Status::SUCCESS) << "un register sync callback failed."; Key skey = {"single_001"}; Value sval = {"value_001"}; - singleKvStorePtr->Put(skey, sval); - singleKvStorePtr->Delete(skey); + singleKvStore->Put(skey, sval); + singleKvStore->Delete(skey); std::map results; results.insert({"aaa", Status::INVALID_ARGUMENT}); @@ -379,18 +379,18 @@ HWTEST_F(SingleKvStoreClientTest, SyncCallback001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, RemoveDeviceData001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; Key skey = {"single_001"}; Value sval = {"value_001"}; - singleKvStorePtr->Put(skey, sval); + singleKvStore->Put(skey, sval); std::string deviceId = "no_exist_device_id"; - auto removeStatus = singleKvStorePtr->RemoveDeviceData(deviceId); + auto removeStatus = singleKvStore->RemoveDeviceData(deviceId); EXPECT_NE(removeStatus, Status::SUCCESS) << "remove device should not return success"; Value retVal; - auto getRet = singleKvStorePtr->Get(skey, retVal); + auto getRet = singleKvStore->Get(skey, retVal); EXPECT_EQ(getRet, Status::SUCCESS) << "get value failed."; EXPECT_EQ(retVal.Size(), sval.Size()) << "data base should be null."; } @@ -404,10 +404,10 @@ HWTEST_F(SingleKvStoreClientTest, RemoveDeviceData001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, SyncData001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; std::string deviceId = "no_exist_device_id"; std::vector deviceIds = { deviceId }; - auto syncStatus = singleKvStorePtr->Sync(deviceIds, SyncMode::PUSH); + auto syncStatus = singleKvStore->Sync(deviceIds, SyncMode::PUSH); EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success"; } @@ -416,11 +416,11 @@ HWTEST_F(SingleKvStoreClientTest, SyncData001, TestSize.Level1) * @tc.desc: Test schema single store. * @tc.type: FUNC * @tc.require: AR000DPSF1 -* @tc.author: YangLeda +* @tc.author: zuojiangjiang */ HWTEST_F(SingleKvStoreClientTest, TestSchemaStoreC001, TestSize.Level1) { - std::shared_ptr schemaSingleKvStorePtr; + std::shared_ptr schemasingleKvStore; DistributedKvDataManager manager; Options options; options.encrypt = true; @@ -430,17 +430,17 @@ HWTEST_F(SingleKvStoreClientTest, TestSchemaStoreC001, TestSize.Level1) options.schema = VALID_SCHEMA_STRICT_DEFINE; AppId appId = { "odmf" }; StoreId storeId = { "schema_store_id" }; - (void)manager.GetSingleKvStore(options, appId, storeId, schemaSingleKvStorePtr); - ASSERT_NE(schemaSingleKvStorePtr, nullptr) << "kvStorePtr is null."; - auto result = schemaSingleKvStorePtr->GetStoreId(); + (void)manager.GetSingleKvStore(options, appId, storeId, schemasingleKvStore); + ASSERT_NE(schemasingleKvStore, nullptr) << "kvStorePtr is null."; + auto result = schemasingleKvStore->GetStoreId(); EXPECT_EQ(result.storeId, "schema_store_id"); Key testKey = {"TestSchemaStoreC001_key"}; Value testValue = {"{\"age\":10}"}; - auto testStatus = schemaSingleKvStorePtr->Put(testKey, testValue); + auto testStatus = schemasingleKvStore->Put(testKey, testValue); EXPECT_EQ(testStatus, Status::SUCCESS) << "putting data failed"; Value resultValue; - auto getRet = schemaSingleKvStorePtr->Get(testKey, resultValue); + auto getRet = schemasingleKvStore->Get(testKey, resultValue); EXPECT_EQ(getRet, Status::SUCCESS) << "get value failed."; manager.DeleteKvStore(appId, storeId, options.baseDir); } @@ -454,11 +454,11 @@ HWTEST_F(SingleKvStoreClientTest, TestSchemaStoreC001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, SyncData002, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; std::string deviceId = "no_exist_device_id"; std::vector deviceIds = { deviceId }; uint32_t allowedDelayMs = 200; - auto syncStatus = singleKvStorePtr->Sync(deviceIds, SyncMode::PUSH, allowedDelayMs); + auto syncStatus = singleKvStore->Sync(deviceIds, SyncMode::PUSH, allowedDelayMs); EXPECT_EQ(syncStatus, Status::SUCCESS) << "sync device should return success"; } @@ -471,13 +471,13 @@ HWTEST_F(SingleKvStoreClientTest, SyncData002, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, SetSync001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; KvSyncParam syncParam{ 500 }; // 500ms - auto ret = singleKvStorePtr->SetSyncParam(syncParam); + auto ret = singleKvStore->SetSyncParam(syncParam); EXPECT_EQ(ret, Status::SUCCESS) << "set sync param should return success"; KvSyncParam syncParamRet; - singleKvStorePtr->GetSyncParam(syncParamRet); + singleKvStore->GetSyncParam(syncParamRet); EXPECT_EQ(syncParamRet.allowedDelayMs, syncParam.allowedDelayMs); } @@ -490,13 +490,13 @@ HWTEST_F(SingleKvStoreClientTest, SetSync001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, SetSync002, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; KvSyncParam syncParam2{ 50 }; // 50ms - auto ret = singleKvStorePtr->SetSyncParam(syncParam2); + auto ret = singleKvStore->SetSyncParam(syncParam2); EXPECT_NE(ret, Status::SUCCESS) << "set sync param should not return success"; KvSyncParam syncParamRet2; - ret = singleKvStorePtr->GetSyncParam(syncParamRet2); + ret = singleKvStore->GetSyncParam(syncParamRet2); EXPECT_NE(syncParamRet2.allowedDelayMs, syncParam2.allowedDelayMs); } @@ -509,7 +509,7 @@ HWTEST_F(SingleKvStoreClientTest, SetSync002, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch001, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; // store entries to kvstore. std::vector entries; @@ -524,21 +524,21 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch001, TestSize.Level2) entries.push_back(entry2); entries.push_back(entry3); - Status status = singleKvStorePtr->PutBatch(entries); + Status status = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status"; // get value from kvstore. Value valueRet1; - Status statusRet1 = singleKvStorePtr->Get(entry1.key, valueRet1); + Status statusRet1 = singleKvStore->Get(entry1.key, valueRet1); EXPECT_EQ(Status::SUCCESS, statusRet1) << "KvStoreSnapshot get data return wrong status"; EXPECT_EQ(entry1.value, valueRet1) << "value and valueRet are not equal"; Value valueRet2; - Status statusRet2 = singleKvStorePtr->Get(entry2.key, valueRet2); + Status statusRet2 = singleKvStore->Get(entry2.key, valueRet2); EXPECT_EQ(Status::SUCCESS, statusRet2) << "KvStoreSnapshot get data return wrong status"; EXPECT_EQ(entry2.value, valueRet2) << "value and valueRet are not equal"; Value valueRet3; - Status statusRet3 = singleKvStorePtr->Get(entry3.key, valueRet3); + Status statusRet3 = singleKvStore->Get(entry3.key, valueRet3); EXPECT_EQ(Status::SUCCESS, statusRet3) << "KvStoreSnapshot get data return wrong status"; EXPECT_EQ(entry3.value, valueRet3) << "value and valueRet are not equal"; } @@ -552,7 +552,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch001, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch002, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "SinglekvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; // before update. std::vector entriesBefore; @@ -567,7 +567,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch002, TestSize.Level2) entriesBefore.push_back(entry2); entriesBefore.push_back(entry3); - Status status = singleKvStorePtr->PutBatch(entriesBefore); + Status status = singleKvStore->PutBatch(entriesBefore); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore putbatch data return wrong status"; // after update. @@ -583,22 +583,22 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch002, TestSize.Level2) entriesAfter.push_back(entry5); entriesAfter.push_back(entry6); - status = singleKvStorePtr->PutBatch(entriesAfter); + status = singleKvStore->PutBatch(entriesAfter); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore putbatch failed, wrong status"; // get value from kvstore. Value valueRet1; - Status statusRet1 = singleKvStorePtr->Get(entry4.key, valueRet1); + Status statusRet1 = singleKvStore->Get(entry4.key, valueRet1); EXPECT_EQ(Status::SUCCESS, statusRet1) << "SingleKvStore getting data failed, wrong status"; EXPECT_EQ(entry4.value, valueRet1) << "value and valueRet are not equal"; Value valueRet2; - Status statusRet2 = singleKvStorePtr->Get(entry5.key, valueRet2); + Status statusRet2 = singleKvStore->Get(entry5.key, valueRet2); EXPECT_EQ(Status::SUCCESS, statusRet2) << "SingleKvStore getting data failed, wrong status"; EXPECT_EQ(entry5.value, valueRet2) << "value and valueRet are not equal"; Value valueRet3; - Status statusRet3 = singleKvStorePtr->Get(entry6.key, valueRet3); + Status statusRet3 = singleKvStore->Get(entry6.key, valueRet3); EXPECT_EQ(Status::SUCCESS, statusRet3) << "SingleKvStore get data return wrong status"; EXPECT_EQ(entry6.value, valueRet3) << "value and valueRet are not equal"; } @@ -612,7 +612,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch002, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch003, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; std::vector entries; Entry entry1, entry2, entry3; @@ -626,8 +626,8 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch003, TestSize.Level2) entries.push_back(entry2); entries.push_back(entry3); - Status status = singleKvStorePtr->PutBatch(entries); - EXPECT_EQ(Status::INVALID_ARGUMENT, status) << "singleKvStorePtr putbatch data return wrong status"; + Status status = singleKvStore->PutBatch(entries); + EXPECT_EQ(Status::INVALID_ARGUMENT, status) << "singleKvStore putbatch data return wrong status"; } /** @@ -639,7 +639,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch003, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch004, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; std::vector entries; Entry entry1, entry2, entry3; @@ -653,8 +653,8 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch004, TestSize.Level2) entries.push_back(entry2); entries.push_back(entry3); - Status status = singleKvStorePtr->PutBatch(entries); - EXPECT_EQ(Status::INVALID_ARGUMENT, status) << "singleKvStorePtr putbatch data return wrong status"; + Status status = singleKvStore->PutBatch(entries); + EXPECT_EQ(Status::INVALID_ARGUMENT, status) << "singleKvStore putbatch data return wrong status"; } static std::string SingleGenerate1025KeyLen() @@ -676,7 +676,7 @@ static std::string SingleGenerate1025KeyLen() HWTEST_F(SingleKvStoreClientTest, DdmPutBatch005, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; std::vector entries; Entry entry1, entry2, entry3; @@ -690,7 +690,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch005, TestSize.Level2) entries.push_back(entry2); entries.push_back(entry3); - Status status = singleKvStorePtr->PutBatch(entries); + Status status = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::INVALID_ARGUMENT, status) << "KvStore putbatch data return wrong status"; } @@ -703,7 +703,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch005, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch006, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; std::vector val(MAX_VALUE_SIZE); for (int i = 0; i < MAX_VALUE_SIZE; i++) { @@ -722,23 +722,23 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch006, TestSize.Level2) entries.push_back(entry1); entries.push_back(entry2); entries.push_back(entry3); - Status status = singleKvStorePtr->PutBatch(entries); - EXPECT_EQ(Status::SUCCESS, status) << "singleKvStorePtr putbatch data return wrong status"; + Status status = singleKvStore->PutBatch(entries); + EXPECT_EQ(Status::SUCCESS, status) << "singleKvStore putbatch data return wrong status"; // get value from kvstore. Value valueRet1; - Status statusRet1 = singleKvStorePtr->Get(entry1.key, valueRet1); - EXPECT_EQ(Status::SUCCESS, statusRet1) << "singleKvStorePtr get data return wrong status"; + Status statusRet1 = singleKvStore->Get(entry1.key, valueRet1); + EXPECT_EQ(Status::SUCCESS, statusRet1) << "singleKvStore get data return wrong status"; EXPECT_EQ(entry1.value, valueRet1) << "value and valueRet are not equal"; Value valueRet2; - Status statusRet2 = singleKvStorePtr->Get(entry2.key, valueRet2); - EXPECT_EQ(Status::SUCCESS, statusRet2) << "singleKvStorePtr get data return wrong status"; + Status statusRet2 = singleKvStore->Get(entry2.key, valueRet2); + EXPECT_EQ(Status::SUCCESS, statusRet2) << "singleKvStore get data return wrong status"; EXPECT_EQ(entry2.value, valueRet2) << "value and valueRet are not equal"; Value valueRet3; - Status statusRet3 = singleKvStorePtr->Get(entry3.key, valueRet3); - EXPECT_EQ(Status::SUCCESS, statusRet3) << "singleKvStorePtr get data return wrong status"; + Status statusRet3 = singleKvStore->Get(entry3.key, valueRet3); + EXPECT_EQ(Status::SUCCESS, statusRet3) << "singleKvStore get data return wrong status"; EXPECT_EQ(entry3.value, valueRet3) << "value and valueRet are not equal"; } @@ -751,7 +751,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmPutBatch006, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch001, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; // store entries to kvstore. std::vector entries; @@ -771,13 +771,13 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch001, TestSize.Level2) keys.push_back("SingleKvStoreDdmDeleteBatch001_2"); keys.push_back("SingleKvStoreDdmDeleteBatch001_3"); - Status status1 = singleKvStorePtr->PutBatch(entries); + Status status1 = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status1) << "singleKvStore putbatch data return wrong status"; - Status status2 = singleKvStorePtr->DeleteBatch(keys); + Status status2 = singleKvStore->DeleteBatch(keys); EXPECT_EQ(Status::SUCCESS, status2) << "singleKvStore deletebatch data return wrong status"; std::vector results; - singleKvStorePtr->GetEntries("SingleKvStoreDdmDeleteBatch001_", results); + singleKvStore->GetEntries("SingleKvStoreDdmDeleteBatch001_", results); size_t sum = 0; EXPECT_EQ(results.size(), sum) << "entries size is not equal 0."; } @@ -791,7 +791,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch001, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch002, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; // store entries to kvstore. std::vector entries; @@ -812,13 +812,13 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch002, TestSize.Level2) keys.push_back("SingleKvStoreDdmDeleteBatch002_3"); keys.push_back("SingleKvStoreDdmDeleteBatch002_4"); - Status status1 = singleKvStorePtr->PutBatch(entries); + Status status1 = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status1) << "KvStore putbatch data return wrong status"; - Status status2 = singleKvStorePtr->DeleteBatch(keys); + Status status2 = singleKvStore->DeleteBatch(keys); EXPECT_EQ(Status::SUCCESS, status2) << "KvStore deletebatch data return wrong status"; std::vector results; - singleKvStorePtr->GetEntries("SingleKvStoreDdmDeleteBatch002_", results); + singleKvStore->GetEntries("SingleKvStoreDdmDeleteBatch002_", results); size_t sum = 0; EXPECT_EQ(results.size(), sum) << "entries size is not equal 0."; } @@ -832,7 +832,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch002, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch003, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "SinglekvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; // Store entries to KvStore. std::vector entries; @@ -852,13 +852,13 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch003, TestSize.Level2) keys.push_back("SingleKvStoreDdmDeleteBatch003_2"); keys.push_back(""); - Status status1 = singleKvStorePtr->PutBatch(entries); + Status status1 = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status1) << "SingleKvStore putbatch data return wrong status"; - Status status2 = singleKvStorePtr->DeleteBatch(keys); + Status status2 = singleKvStore->DeleteBatch(keys); EXPECT_EQ(Status::INVALID_ARGUMENT, status2) << "KvStore deletebatch data return wrong status"; std::vector results; - singleKvStorePtr->GetEntries("SingleKvStoreDdmDeleteBatch003_", results); + singleKvStore->GetEntries("SingleKvStoreDdmDeleteBatch003_", results); size_t sum = 3; EXPECT_EQ(results.size(), sum) << "entries size is not equal 3."; } @@ -872,7 +872,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch003, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch004, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; // store entries to kvstore. std::vector entries; @@ -892,18 +892,18 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch004, TestSize.Level2) keys.push_back("SingleKvStoreDdmDeleteBatch004_2"); keys.push_back(" "); - Status status1 = singleKvStorePtr->PutBatch(entries); + Status status1 = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status1) << "SingleKvStore putbatch data return wrong status"; std::vector results1; - singleKvStorePtr->GetEntries("SingleKvStoreDdmDeleteBatch004_", results1); + singleKvStore->GetEntries("SingleKvStoreDdmDeleteBatch004_", results1); size_t sum1 = 3; EXPECT_EQ(results1.size(), sum1) << "entries size1111 is not equal 3."; - Status status2 = singleKvStorePtr->DeleteBatch(keys); + Status status2 = singleKvStore->DeleteBatch(keys); EXPECT_EQ(Status::INVALID_ARGUMENT, status2) << "SingleKvStore deletebatch data return wrong status"; std::vector results; - singleKvStorePtr->GetEntries("SingleKvStoreDdmDeleteBatch004_", results); + singleKvStore->GetEntries("SingleKvStoreDdmDeleteBatch004_", results); size_t sum = 3; EXPECT_EQ(results.size(), sum) << "entries size is not equal 3."; } @@ -917,7 +917,7 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch004, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch005, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; // store entries to kvstore. std::vector entries; @@ -938,18 +938,18 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch005, TestSize.Level2) Key keyTmp = SingleGenerate1025KeyLen(); keys.push_back(keyTmp); - Status status1 = singleKvStorePtr->PutBatch(entries); + Status status1 = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status1) << "SingleKvStore putbatch data return wrong status"; std::vector results1; - singleKvStorePtr->GetEntries("SingleKvStoreDdmDeleteBatch005_", results1); + singleKvStore->GetEntries("SingleKvStoreDdmDeleteBatch005_", results1); size_t sum1 = 3; EXPECT_EQ(results1.size(), sum1) << "entries111 size is not equal 3."; - Status status2 = singleKvStorePtr->DeleteBatch(keys); + Status status2 = singleKvStore->DeleteBatch(keys); EXPECT_EQ(Status::INVALID_ARGUMENT, status2) << "SingleKvStore deletebatch data return wrong status"; std::vector results; - singleKvStorePtr->GetEntries("SingleKvStoreDdmDeleteBatch005_", results); + singleKvStore->GetEntries("SingleKvStoreDdmDeleteBatch005_", results); size_t sum = 3; EXPECT_EQ(results.size(), sum) << "entries size is not equal 3."; } @@ -963,12 +963,12 @@ HWTEST_F(SingleKvStoreClientTest, DdmDeleteBatch005, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, Transaction001, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; std::shared_ptr observer = std::make_shared(); observer->ResetToZero(); SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL; - Status status = singleKvStorePtr->SubscribeKvStore(subscribeType, observer); + Status status = singleKvStore->SubscribeKvStore(subscribeType, observer); EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status"; Key key1 = "SingleKvStoreTransaction001_1"; @@ -990,24 +990,24 @@ HWTEST_F(SingleKvStoreClientTest, Transaction001, TestSize.Level2) keys.push_back("SingleKvStoreTransaction001_2"); keys.push_back("ISingleKvStoreTransaction001_3"); - status = singleKvStorePtr->StartTransaction(); + status = singleKvStore->StartTransaction(); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore startTransaction return wrong status"; - status = singleKvStorePtr->Put(key1, value1); // insert or update key-value + status = singleKvStore->Put(key1, value1); // insert or update key-value EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore put data return wrong status"; - status = singleKvStorePtr->PutBatch(entries); + status = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore putbatch data return wrong status"; - status = singleKvStorePtr->Delete(key1); + status = singleKvStore->Delete(key1); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore delete data return wrong status"; - status = singleKvStorePtr->DeleteBatch(keys); + status = singleKvStore->DeleteBatch(keys); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore DeleteBatch data return wrong status"; - status = singleKvStorePtr->Commit(); + status = singleKvStore->Commit(); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore Commit return wrong status"; usleep(200000); EXPECT_EQ(static_cast(observer->GetCallCount()), 1); - status = singleKvStorePtr->UnSubscribeKvStore(subscribeType, observer); + status = singleKvStore->UnSubscribeKvStore(subscribeType, observer); EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status"; } @@ -1020,12 +1020,12 @@ HWTEST_F(SingleKvStoreClientTest, Transaction001, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, Transaction002, TestSize.Level2) { - EXPECT_NE(nullptr, singleKvStorePtr) << "singleKvStorePtr is nullptr"; + EXPECT_NE(nullptr, singleKvStore) << "singleKvStore is nullptr"; std::shared_ptr observer = std::make_shared(); observer->ResetToZero(); SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL; - Status status = singleKvStorePtr->SubscribeKvStore(subscribeType, observer); + Status status = singleKvStore->SubscribeKvStore(subscribeType, observer); EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status"; Key key1 = "SingleKvStoreTransaction002_1"; @@ -1047,18 +1047,18 @@ HWTEST_F(SingleKvStoreClientTest, Transaction002, TestSize.Level2) keys.push_back("SingleKvStoreTransaction002_2"); keys.push_back("SingleKvStoreTransaction002_3"); - status = singleKvStorePtr->StartTransaction(); + status = singleKvStore->StartTransaction(); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore startTransaction return wrong status"; - status = singleKvStorePtr->Put(key1, value1); // insert or update key-value + status = singleKvStore->Put(key1, value1); // insert or update key-value EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore put data return wrong status"; - status = singleKvStorePtr->PutBatch(entries); + status = singleKvStore->PutBatch(entries); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore putbatch data return wrong status"; - status = singleKvStorePtr->Delete(key1); + status = singleKvStore->Delete(key1); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore delete data return wrong status"; - status = singleKvStorePtr->DeleteBatch(keys); + status = singleKvStore->DeleteBatch(keys); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore DeleteBatch data return wrong status"; - status = singleKvStorePtr->Rollback(); + status = singleKvStore->Rollback(); EXPECT_EQ(Status::SUCCESS, status) << "SingleKvStore Commit return wrong status"; usleep(200000); @@ -1067,7 +1067,7 @@ HWTEST_F(SingleKvStoreClientTest, Transaction002, TestSize.Level2) EXPECT_EQ(static_cast(observer->updateEntries_.size()), 0); EXPECT_EQ(static_cast(observer->deleteEntries_.size()), 0); - status = singleKvStorePtr->UnSubscribeKvStore(subscribeType, observer); + status = singleKvStore->UnSubscribeKvStore(subscribeType, observer); EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status"; observer = nullptr; } @@ -1081,7 +1081,7 @@ HWTEST_F(SingleKvStoreClientTest, Transaction002, TestSize.Level2) */ HWTEST_F(SingleKvStoreClientTest, DeviceSync001, TestSize.Level1) { - std::shared_ptr schemaSingleKvStorePtr; + std::shared_ptr schemasingleKvStore; DistributedKvDataManager manager; Options options; options.encrypt = true; @@ -1090,12 +1090,12 @@ HWTEST_F(SingleKvStoreClientTest, DeviceSync001, TestSize.Level1) options.baseDir = "/data/service/el1/public/database/odmf"; AppId appId = { "odmf" }; StoreId storeId = { "schema_store_id001" }; - manager.GetSingleKvStore(options, appId, storeId, schemaSingleKvStorePtr); - ASSERT_NE(schemaSingleKvStorePtr, nullptr) << "kvStorePtr is null."; - auto result = schemaSingleKvStorePtr->GetStoreId(); + manager.GetSingleKvStore(options, appId, storeId, schemasingleKvStore); + ASSERT_NE(schemasingleKvStore, nullptr) << "kvStorePtr is null."; + auto result = schemasingleKvStore->GetStoreId(); EXPECT_EQ(result.storeId, "schema_store_id001"); - auto testStatus = schemaSingleKvStorePtr->SetCapabilityEnabled(true); + auto testStatus = schemasingleKvStore->SetCapabilityEnabled(true); EXPECT_EQ(testStatus, Status::SUCCESS) << "set fail"; manager.DeleteKvStore(appId, storeId, options.baseDir); } @@ -1109,7 +1109,7 @@ HWTEST_F(SingleKvStoreClientTest, DeviceSync001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, DeviceSync002, TestSize.Level1) { - std::shared_ptr schemaSingleKvStorePtr; + std::shared_ptr schemasingleKvStore; DistributedKvDataManager manager; Options options; options.encrypt = true; @@ -1118,18 +1118,47 @@ HWTEST_F(SingleKvStoreClientTest, DeviceSync002, TestSize.Level1) options.baseDir = "/data/service/el1/public/database/odmf"; AppId appId = { "odmf" }; StoreId storeId = { "schema_store_id002" }; - manager.GetSingleKvStore(options, appId, storeId, schemaSingleKvStorePtr); - ASSERT_NE(schemaSingleKvStorePtr, nullptr) << "kvStorePtr is null."; - auto result = schemaSingleKvStorePtr->GetStoreId(); + manager.GetSingleKvStore(options, appId, storeId, schemasingleKvStore); + ASSERT_NE(schemasingleKvStore, nullptr) << "kvStorePtr is null."; + auto result = schemasingleKvStore->GetStoreId(); EXPECT_EQ(result.storeId, "schema_store_id002"); std::vector local = {"A", "B"}; std::vector remote = {"C", "D"}; - auto testStatus = schemaSingleKvStorePtr->SetCapabilityRange(local, remote); + auto testStatus = schemasingleKvStore->SetCapabilityRange(local, remote); EXPECT_EQ(testStatus, Status::SUCCESS) << "set range fail"; manager.DeleteKvStore(appId, storeId, options.baseDir); } + +/** +* @tc.name: DisableCapability +* @tc.desc: disable capability +* @tc.type: FUNC +* @tc.require: I605H3 +* @tc.author: WangKai +*/ +HWTEST_F(SingleKvStoreClientTest, DisableCapability, TestSize.Level1) +{ + std::shared_ptr singleKvStore; + DistributedKvDataManager manager; + Options options; + options.encrypt = true; + options.area = EL1; + options.kvStoreType = KvStoreType::SINGLE_VERSION; + options.baseDir = "/data/service/el1/public/database/odmf"; + AppId appId = { "odmf" }; + StoreId storeId = { "schema_store_id001" }; + manager.GetSingleKvStore(options, appId, storeId, singleKvStore); + ASSERT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; + auto result = singleKvStore->GetStoreId(); + EXPECT_EQ(result.storeId, "schema_store_id001"); + + auto testStatus = singleKvStore->SetCapabilityEnabled(false); + EXPECT_EQ(testStatus, Status::SUCCESS) << "set success"; + manager.DeleteKvStore(appId, storeId, options.baseDir); +} + /** * @tc.name: SyncWithCondition001 * @tc.desc: sync device data with condition; @@ -1139,11 +1168,11 @@ HWTEST_F(SingleKvStoreClientTest, DeviceSync002, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, SyncWithCondition001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; std::vector deviceIds = {"invalid_device_id1", "invalid_device_id2"}; DataQuery dataQuery; dataQuery.KeyPrefix("name"); - auto syncStatus = singleKvStorePtr->Sync(deviceIds, SyncMode::PUSH, dataQuery, nullptr); + auto syncStatus = singleKvStore->Sync(deviceIds, SyncMode::PUSH, dataQuery, nullptr); EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success"; } @@ -1156,11 +1185,11 @@ HWTEST_F(SingleKvStoreClientTest, SyncWithCondition001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, SubscribeWithQuery001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; std::vector deviceIds = {"invalid_device_id1", "invalid_device_id2"}; DataQuery dataQuery; dataQuery.KeyPrefix("name"); - auto syncStatus = singleKvStorePtr->SubscribeWithQuery(deviceIds, dataQuery); + auto syncStatus = singleKvStore->SubscribeWithQuery(deviceIds, dataQuery); EXPECT_NE(syncStatus, Status::SUCCESS) << "sync device should not return success"; } @@ -1173,10 +1202,10 @@ HWTEST_F(SingleKvStoreClientTest, SubscribeWithQuery001, TestSize.Level1) */ HWTEST_F(SingleKvStoreClientTest, UnSubscribeWithQuery001, TestSize.Level1) { - EXPECT_NE(singleKvStorePtr, nullptr) << "kvStorePtr is null."; + EXPECT_NE(singleKvStore, nullptr) << "kvStorePtr is null."; std::vector deviceIds = {"invalid_device_id1", "invalid_device_id2"}; DataQuery dataQuery; dataQuery.KeyPrefix("name"); - auto unSubscribeStatus = singleKvStorePtr->UnsubscribeWithQuery(deviceIds, dataQuery); + auto unSubscribeStatus = singleKvStore->UnsubscribeWithQuery(deviceIds, dataQuery); EXPECT_NE(unSubscribeStatus, Status::SUCCESS) << "sync device should not return success"; } diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/auto_sync_timer.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/auto_sync_timer.h index d9271dbb25e9d8371baae8c42cde7c9e24f439e5..1e3c918278575789fb92faa6cacb34a84867b90f 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/include/auto_sync_timer.h +++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/auto_sync_timer.h @@ -15,9 +15,10 @@ #ifndef SDB_AUTO_SYNC_TIMER_H #define SDB_AUTO_SYNC_TIMER_H #include + #include "concurrent_map.h" -#include "task_scheduler.h" #include "kvdb_service.h" +#include "task_scheduler.h" namespace OHOS::DistributedKv { class AutoSyncTimer { public: @@ -38,8 +39,8 @@ private: void AddSyncStores(const std::string &appId, std::set storeIds); bool HasSyncStores(); ConcurrentMap> stores_; - TaskScheduler::Iterator delaySyncTask_; - TaskScheduler::Iterator forceSyncTask_; + TaskScheduler::TaskId delaySyncTaskId_; + TaskScheduler::TaskId forceSyncTaskId_; std::mutex mutex_; TaskScheduler scheduler_{ TIME_TASK_NUM }; }; diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h index cdf31519f08f2f67fd0668743dece4ef6808f9f4..f9e1b76c54632032455c4ee7368a34652cf4b067 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h +++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h @@ -39,7 +39,7 @@ public: using DBQuery = DistributedDB::Query; using SyncInfo = KVDBService::SyncInfo; using Convert = std::function; - using TimePoint = std::chrono::system_clock::time_point; + using TimePoint = std::chrono::steady_clock::time_point; SingleStoreImpl(std::shared_ptr dbStore, const AppId &appId, const Options &options, const Convertor &cvt); ~SingleStoreImpl(); StoreId GetStoreId() const override; diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/store_manager.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/store_manager.h index 04ee3a7919d85bd58e8dd89ab4a44a522a27c880..1276732925d499638067dce1adf39ed33b327b2b 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/include/store_manager.h +++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/store_manager.h @@ -22,7 +22,6 @@ public: std::shared_ptr GetKVStore(const AppId &appId, const StoreId &storeId, const Options &options, Status &status); Status CloseKVStore(const AppId &appId, const StoreId &storeId); - Status CloseKVStore(const AppId &appId, std::shared_ptr &kvStore); Status CloseAllKVStore(const AppId &appId); Status GetStoreIds(const AppId &appId, std::vector &storeIds); Status Delete(const AppId &appId, const StoreId &storeId, const std::string &path); diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp index a472cd1528119cecb89574460133cd4fe1f82c32..8e2051fba565018e7e6e32e831476f688258edd3 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp +++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp @@ -28,16 +28,15 @@ AutoSyncTimer &AutoSyncTimer::GetInstance() void AutoSyncTimer::StartTimer() { std::lock_guard lockGuard(mutex_); - if (forceSyncTask_ == TaskScheduler::Iterator()) { - auto expiredTime = std::chrono::system_clock::now() + std::chrono::milliseconds(FORCE_SYNC_INTERVAL); - forceSyncTask_ = scheduler_.At(expiredTime, ProcessTask()); + if (forceSyncTaskId_ == TaskScheduler::INVALID_TASK_ID) { + auto expiredTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(FORCE_SYNC_INTERVAL); + forceSyncTaskId_ = scheduler_.At(expiredTime, ProcessTask()); } - if (delaySyncTask_ == TaskScheduler::Iterator()) { - auto expiredTime = std::chrono::system_clock::now() + std::chrono::milliseconds(AUTO_SYNC_INTERVAL); - delaySyncTask_ = scheduler_.At(expiredTime, ProcessTask()); + if (delaySyncTaskId_ == TaskScheduler::INVALID_TASK_ID) { + auto expiredTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(AUTO_SYNC_INTERVAL); + delaySyncTaskId_ = scheduler_.At(expiredTime, ProcessTask()); } else { - delaySyncTask_ = scheduler_.Reset(delaySyncTask_, delaySyncTask_->first, - std::chrono::milliseconds(AUTO_SYNC_INTERVAL)); + delaySyncTaskId_ = scheduler_.Reset(delaySyncTaskId_, std::chrono::milliseconds(AUTO_SYNC_INTERVAL)); } } @@ -108,7 +107,7 @@ void AutoSyncTimer::StopTimer() { std::lock_guard lockGuard(mutex_); scheduler_.Clean(); - forceSyncTask_ = {}; - delaySyncTask_ = {}; + forceSyncTaskId_ = TaskScheduler::INVALID_TASK_ID; + delaySyncTaskId_ = TaskScheduler::INVALID_TASK_ID; } } \ No newline at end of file diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp index aa659b90c38d9e566938eb07a8712f4a89e1f23f..606dfb4bf68f9a25ea46bc528ac12f3aa595dfc6 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp +++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp @@ -782,12 +782,12 @@ void SingleStoreImpl::DoAutoSync() } ZLOGD("app:%{public}s store:%{public}s!", appId_.c_str(), storeId_.c_str()); AutoSyncTimer::GetInstance().DoAutoSync(appId_, { { storeId_ } }); - expiration_ = system_clock::now() + seconds(interval_); + expiration_ = steady_clock::now() + seconds(interval_); } void SingleStoreImpl::Online(const std::string &device) { - if (!autoSync_ || system_clock::now() >= expiration_) { + if (!autoSync_ || steady_clock::now() >= expiration_) { return; } diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp index 15159f97a52a43b2760d8717b708f1c0c3308d0f..55f2e20cf1afb3ae2cdb8c7a32fae0917d0485f8 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp +++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp @@ -72,17 +72,6 @@ Status StoreManager::CloseKVStore(const AppId &appId, const StoreId &storeId) return StoreFactory::GetInstance().Close(appId, storeId); } -Status StoreManager::CloseKVStore(const AppId &appId, std::shared_ptr &kvStore) -{ - if (!appId.IsValid() || kvStore == nullptr) { - return INVALID_ARGUMENT; - } - - StoreId storeId{ kvStore->GetStoreId() }; - kvStore = nullptr; - return StoreFactory::GetInstance().Close(appId, storeId); -} - Status StoreManager::CloseAllKVStore(const AppId &appId) { ZLOGD("appId:%{public}s", appId.appId.c_str()); diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/task_executor.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/task_executor.cpp index 76a8bb72f2fb621dee47be5b4e7426f243ccd544..3b04517e83bdebbbcb6620db09706c6acc775265 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/src/task_executor.cpp +++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/task_executor.cpp @@ -26,7 +26,7 @@ bool TaskExecutor::Execute(TaskScheduler::Task &&task, int32_t interval) if (pool_ == nullptr) { return false; } - auto time = TaskScheduler::System::now() + std::chrono::milliseconds(interval); + auto time = TaskScheduler::Clock::now() + std::chrono::milliseconds(interval); pool_->At(time, std::move(task)); return true; } diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn b/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn index 795623c7abfd3dbe19583c35ac529817ffe08ebc..1fcd673c58c55b9f8b829aebfe9742669d3c1326 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn +++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn @@ -33,7 +33,7 @@ config("module_private_config") { lib_dirs = [ "//foundation/appexecfwk/libs" ] } -ohos_unittest("SingleStoreImpl") { +ohos_unittest("SingleStoreImplTest") { module_out_path = module_output_path sources = [ "single_store_impl_test.cpp" ] @@ -56,10 +56,131 @@ ohos_unittest("SingleStoreImpl") { ] } +ohos_unittest("StoreUtilTest") { + module_out_path = module_output_path + + sources = [ "store_util_test.cpp" ] + + configs = [ ":module_private_config" ] + + external_deps = [ + "c_utils:utils", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + deps = [ + "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter", + "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb", + "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata/:distributeddata_inner", + "//third_party/googletest:gtest", + ] +} + +ohos_unittest("BackupManagerTest") { + module_out_path = module_output_path + + sources = [ "backup_manager_test.cpp" ] + + configs = [ ":module_private_config" ] + + external_deps = [ + "c_utils:utils", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + deps = [ + "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter", + "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb", + "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata/:distributeddata_inner", + "//third_party/googletest:gtest", + ] +} + +ohos_unittest("AutoSyncTimerTest") { + module_out_path = module_output_path + + sources = [ "auto_sync_timer_test.cpp" ] + + configs = [ ":module_private_config" ] + + external_deps = [ + "c_utils:utils", + "hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + deps = [ + "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter", + "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb", + "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata/:distributeddata_inner", + "//third_party/googletest:gtest", + ] +} + +ohos_unittest("DevManagerTest") { + module_out_path = module_output_path + + sources = [ "dev_manager_test.cpp" ] + + configs = [ ":module_private_config" ] + + external_deps = [ + "c_utils:utils", + "hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + deps = [ + "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter", + "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb", + "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata/:distributeddata_inner", + "//third_party/googletest:gtest", + ] +} + +ohos_unittest("SingleStoreImplGetTopTest") { + module_out_path = module_output_path + + sources = [ "single_store_impl_get_top_test.cpp" ] + + configs = [ ":module_private_config" ] + + external_deps = [ + "c_utils:utils", + "hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + deps = [ + "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter", + "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb", + "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata/:distributeddata_inner", + "//third_party/googletest:gtest", + ] +} + ############################################################################### group("unittest") { testonly = true - deps = [ ":SingleStoreImpl" ] + deps = [] + deps += [ + ":AutoSyncTimerTest", + ":BackupManagerTest", + ":DevManagerTest", + ":SingleStoreImplGetTopTest", + ":SingleStoreImplTest", + ":StoreUtilTest", + ] } ############################################################################### diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/backup_manager_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/backup_manager_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0a25300375fad9ec3ef4f5aa1a396eef13505680 --- /dev/null +++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/backup_manager_test.cpp @@ -0,0 +1,472 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "BackupManagerTest" +#include +#include +#include + +#include "dev_manager.h" +#include "store_manager.h" +#include "store_util.h" +#include "sys/stat.h" +#include "types.h" +using namespace testing::ext; +using namespace OHOS::DistributedKv; +class BackupManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + Status DeleteBackUpFiles(std::shared_ptr kvStore, std::string baseDir, StoreId storeId); + void MkdirPath(std::string baseDir, AppId appId, StoreId storeId); + + std::shared_ptr CreateKVStore(std::string storeIdTest, std::string appIdTest, std::string baseDir, + KvStoreType type, bool encrypt); + std::shared_ptr kvStore_; +}; + +void BackupManagerTest::SetUpTestCase(void) +{ + std::string baseDir = "/data/service/el1/public/database/BackupManagerTest"; + mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + mkdir((baseDir + "/key").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); +} + +void BackupManagerTest::TearDownTestCase(void) +{ + std::string baseDir = "/data/service/el1/public/database/BackupManagerTest"; + StoreManager::GetInstance().Delete({ "BackupManagerTest" }, { "SingleKVStore" }, baseDir); + + (void)remove("/data/service/el1/public/database/BackupManagerTest/key"); + (void)remove("/data/service/el1/public/database/BackupManagerTest/kvdb"); + (void)remove("/data/service/el1/public/database/BackupManagerTest"); +} + +void BackupManagerTest::SetUp(void) +{ + std::string baseDir = "/data/service/el1/public/database/BackupManagerTest"; + kvStore_ = CreateKVStore("SingleKVStore", "BackupManagerTest", baseDir, SINGLE_VERSION, false); + if (kvStore_ == nullptr) { + kvStore_ = CreateKVStore("SingleKVStore", "BackupManagerTest", baseDir, SINGLE_VERSION, false); + } + ASSERT_NE(kvStore_, nullptr); +} + +void BackupManagerTest::TearDown(void) +{ + AppId appId = { "BackupManagerTest" }; + StoreId storeId = { "SingleKVStore" }; + std::string baseDir = "/data/service/el1/public/database/BackupManagerTest"; + auto status = DeleteBackUpFiles(kvStore_, baseDir, storeId); + ASSERT_EQ(status, SUCCESS); + kvStore_ = nullptr; + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} + +std::shared_ptr BackupManagerTest::CreateKVStore(std::string storeIdTest, std::string appIdTest, + std::string baseDir, KvStoreType type, bool encrypt) +{ + Options options; + options.kvStoreType = type; + options.securityLevel = S1; + options.encrypt = encrypt; + options.area = EL1; + options.baseDir = baseDir; + + AppId appId = { appIdTest }; + StoreId storeId = { storeIdTest }; + Status status = StoreManager::GetInstance().Delete(appId, storeId, options.baseDir); + return StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); +} +Status BackupManagerTest::DeleteBackUpFiles(std::shared_ptr kvStore, string baseDir, StoreId storeId) +{ + std::vector backupnames; + auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId); + for (auto file : files) { + auto filename = file.name.substr(0, file.name.length() - 4); + backupnames.emplace_back(filename); + } + if (backupnames.empty()) { + return SUCCESS; + } + std::map results; + return kvStore->DeleteBackup(backupnames, baseDir, results); +} +void BackupManagerTest::MkdirPath(std::string baseDir, AppId appId, StoreId storeId) +{ + mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + mkdir((baseDir + "/key").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + mkdir((baseDir + "/kvdb").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + mkdir((baseDir + "/kvdb/backup").c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + + std::string backUpToPath = { baseDir + "/kvdb/backup/" + storeId.storeId }; + mkdir(backUpToPath.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + + std::string backUpFile = backUpToPath + "/" + "testbackup.bak"; + auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(backUpFile); + ASSERT_EQ(fl, true); +} + +/** +* @tc.name: BackUp +* @tc.desc: the kvstore back up +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, BackUp, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + auto baseDir = "/data/service/el1/public/database/BackupManagerTest"; + auto status = kvStore_->Backup("testbackup", baseDir); + ASSERT_EQ(status, SUCCESS); +} +/** +* @tc.name: BackUpInvalidArguments +* @tc.desc: the kvstore back up and the arguments is invalid +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, BackUpInvalidArguments, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + auto baseDir = ""; + auto baseDir1 = "/data/service/el1/public/database/BackupManagerTest"; + auto status = kvStore_->Backup("testbackup", baseDir); + ASSERT_EQ(status, INVALID_ARGUMENT); + status = kvStore_->Backup("", baseDir); + ASSERT_EQ(status, INVALID_ARGUMENT); + status = kvStore_->Backup("autoBackup", baseDir1); + ASSERT_EQ(status, INVALID_ARGUMENT); +} +/** +* @tc.name: BackUpSameFile +* @tc.desc: the kvstore back up the same file +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, BackUpSameFile, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + auto baseDir = "/data/service/el1/public/database/BackupManagerTest"; + auto status = kvStore_->Backup("testbackup", baseDir); + ASSERT_EQ(status, SUCCESS); + status = kvStore_->Backup("testbackup", baseDir); + ASSERT_EQ(status, SUCCESS); +} +/** +* @tc.name: ReStore +* @tc.desc: the kvstore ReStore +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, ReStore, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + auto status = kvStore_->Put({ "Put Test" }, { "Put Value" }); + ASSERT_EQ(status, SUCCESS); + Value value; + status = kvStore_->Get({ "Put Test" }, value); + ASSERT_EQ(status, SUCCESS); + ASSERT_EQ(std::string("Put Value"), value.ToString()); + + auto baseDir = "/data/service/el1/public/database/BackupManagerTest"; + auto baseDir1 = ""; + status = kvStore_->Backup("testbackup", baseDir); + ASSERT_EQ(status, SUCCESS); + status = kvStore_->Delete("Put Test"); + ASSERT_EQ(status, SUCCESS); + status = kvStore_->Restore("testbackup", baseDir); + ASSERT_EQ(status, SUCCESS); + value = {}; + status = kvStore_->Get("Put Test", value); + ASSERT_EQ(status, SUCCESS); + ASSERT_EQ(std::string("Put Value"), value.ToString()); + status = kvStore_->Restore("testbackup", baseDir1); + ASSERT_EQ(status, INVALID_ARGUMENT); +} +/** +* @tc.name: DeleteBackup +* @tc.desc: the kvstore DeleteBackup +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, DeleteBackup, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + auto baseDir = "/data/service/el1/public/database/BackupManagerTest"; + std::string file1 = "testbackup1"; + std::string file2 = "testbackup2"; + std::string file3 = "testbackup3"; + std::string file4 = "autoBackup"; + kvStore_->Backup(file1, baseDir); + kvStore_->Backup(file2, baseDir); + kvStore_->Backup(file3, baseDir); + vector files = { file1, file2, file3, file4 }; + std::map results; + auto status = kvStore_->DeleteBackup(files, baseDir, results); + ASSERT_EQ(status, SUCCESS); + status = kvStore_->DeleteBackup(files, "", results); + ASSERT_EQ(status, INVALID_ARGUMENT); +} +/** +* @tc.name: RollbackKey +* @tc.desc: rollback the key +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, RollbackKey, TestSize.Level0) +{ + AppId appId = { "BackupManagerTestRollBackKey" }; + StoreId storeId = { "SingleKVStoreEncrypt" }; + std::string baseDir = "/data/service/el1/public/database/" + appId.appId; + MkdirPath(baseDir, appId, storeId); + + std::string buildKeyFile = "Prefix_backup_SingleKVStoreEncrypt_testbackup.key"; + std::string path = { baseDir + "/key/" + buildKeyFile + ".bk" }; + auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(path); + ASSERT_EQ(fl, true); + + std::string autoBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "autoBackup.bak"; + fl = OHOS::DistributedKv::StoreUtil::CreateFile(autoBackUpFile); + ASSERT_EQ(fl, true); + + std::shared_ptr kvStoreEncrypt; + kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true); + ASSERT_NE(kvStoreEncrypt, nullptr); + + auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId); + auto keyfiles = StoreUtil::GetFiles(baseDir + "/key"); + bool keyFlag = false; + for (auto keyfile : keyfiles) { + auto keyfilename = keyfile.name; + if (keyfilename == buildKeyFile + ".bk") { + keyFlag = true; + } + } + ASSERT_EQ(keyFlag, false); + + auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} + +/** +* @tc.name: RollbackData +* @tc.desc: rollback the data +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, RollbackData, TestSize.Level0) +{ + AppId appId = { "BackupManagerTestRollBackData" }; + StoreId storeId = { "SingleKVStoreEncrypt" }; + std::string baseDir = "/data/service/el1/public/database/" + appId.appId; + MkdirPath(baseDir, appId, storeId); + + std::string buildBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "testbackup.bak.bk"; + auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(buildBackUpFile); + ASSERT_EQ(fl, true); + + std::shared_ptr kvStoreEncrypt; + kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true); + ASSERT_NE(kvStoreEncrypt, nullptr); + + auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId); + bool dataFlag = false; + for (auto datafile : files) { + auto datafilename = datafile.name; + if (datafilename == "testbackup.bak.bk") { + dataFlag = true; + } + } + ASSERT_EQ(dataFlag, false); + + auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} + +/** +* @tc.name: Rollback +* @tc.desc: rollback the key +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, Rollback, TestSize.Level0) +{ + AppId appId = { "BackupManagerTestRollBack" }; + StoreId storeId = { "SingleKVStoreEncrypt" }; + std::string baseDir = "/data/service/el1/public/database/" + appId.appId; + MkdirPath(baseDir, appId, storeId); + + std::string buildKeyFile = "Prefix_backup_SingleKVStoreEncrypt_testbackup.key"; + std::string path = { baseDir + "/key/" + buildKeyFile + ".bk" }; + auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(path); + ASSERT_EQ(fl, true); + + std::string buildBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "testbackup.bak.bk"; + fl = OHOS::DistributedKv::StoreUtil::CreateFile(buildBackUpFile); + ASSERT_EQ(fl, true); + + std::shared_ptr kvStoreEncrypt; + kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true); + ASSERT_NE(kvStoreEncrypt, nullptr); + + auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId); + auto keyfiles = StoreUtil::GetFiles(baseDir + "/key"); + bool keyFlag = false; + for (auto keyfile : keyfiles) { + auto keyfilename = keyfile.name; + if (keyfilename == buildKeyFile + ".bk") { + keyFlag = true; + } + } + ASSERT_EQ(keyFlag, false); + + bool dataFlag = false; + for (auto datafile : files) { + auto datafilename = datafile.name; + if (datafilename == "testbackup.bak.bk") { + dataFlag = true; + } + } + ASSERT_EQ(dataFlag, false); + + auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} + +/** +* @tc.name: CleanTmp +* @tc.desc: Clean up temporary data +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, CleanTmp, TestSize.Level0) +{ + AppId appId = { "BackupManagerTestCleanTmp" }; + StoreId storeId = { "SingleKVStoreEncrypt" }; + std::string baseDir = "/data/service/el1/public/database/" + appId.appId; + MkdirPath(baseDir, appId, storeId); + + std::string buildKeyFile = "Prefix_backup_SingleKVStoreEncrypt_testbackup.key"; + std::string path = { baseDir + "/key/" + buildKeyFile }; + auto fl = OHOS::DistributedKv::StoreUtil::CreateFile(path); + ASSERT_EQ(fl, true); + + std::string buildBackUpFile = baseDir + "/kvdb/backup/" + storeId.storeId + "/" + "testbackup.bak.bk"; + fl = OHOS::DistributedKv::StoreUtil::CreateFile(buildBackUpFile); + ASSERT_EQ(fl, true); + + std::shared_ptr kvStoreEncrypt; + kvStoreEncrypt = CreateKVStore(storeId.storeId, appId.appId, baseDir, SINGLE_VERSION, true); + ASSERT_NE(kvStoreEncrypt, nullptr); + + auto files = StoreUtil::GetFiles(baseDir + "/kvdb/backup/" + storeId.storeId); + auto keyfiles = StoreUtil::GetFiles(baseDir + "/key"); + bool keyFlag = false; + for (auto keyfile : keyfiles) { + auto keyfilename = keyfile.name; + if (keyfilename == buildKeyFile + ".bk") { + keyFlag = true; + } + } + ASSERT_EQ(keyFlag, false); + + bool dataFlag = false; + for (auto datafile : files) { + auto datafilename = datafile.name; + if (datafilename == "testbackup.bak.bk") { + dataFlag = true; + } + } + ASSERT_EQ(dataFlag, false); + + auto status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} + +/** +* @tc.name: BackUpEncrypt +* @tc.desc: Back up an encrypt database and restore +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(BackupManagerTest, BackUpEntry, TestSize.Level0) +{ + AppId appId = { "BackupManagerTest" }; + StoreId storeId = { "SingleKVStoreEncrypt" }; + std::string baseDir = "/data/service/el1/public/database/BackupManagerTest"; + + auto kvStoreEncrypt = CreateKVStore(storeId.storeId, "BackupManagerTest", baseDir, SINGLE_VERSION, true); + if (kvStoreEncrypt == nullptr) { + kvStoreEncrypt = CreateKVStore(storeId.storeId, "BackupManagerTest", baseDir, SINGLE_VERSION, true); + } + ASSERT_NE(kvStoreEncrypt, nullptr); + + auto status = kvStoreEncrypt->Put({ "Put Test" }, { "Put Value" }); + ASSERT_EQ(status, SUCCESS); + Value value; + status = kvStoreEncrypt->Get({ "Put Test" }, value); + ASSERT_EQ(status, SUCCESS); + ASSERT_EQ(std::string("Put Value"), value.ToString()); + + status = kvStoreEncrypt->Backup("testbackup", baseDir); + ASSERT_EQ(status, SUCCESS); + status = kvStoreEncrypt->Delete("Put Test"); + ASSERT_EQ(status, SUCCESS); + status = kvStoreEncrypt->Restore("testbackup", baseDir); + ASSERT_EQ(status, SUCCESS); + value = {}; + status = kvStoreEncrypt->Get("Put Test", value); + ASSERT_EQ(status, SUCCESS); + ASSERT_EQ(std::string("Put Value"), value.ToString()); + + status = DeleteBackUpFiles(kvStoreEncrypt, baseDir, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} \ No newline at end of file diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/dev_manager_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/dev_manager_test.cpp index 44e9fd14a65f1b0dab22f20fc52d0f7b518d82bd..b143860233b04c2f1355a6125590507e70ceceb0 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/test/dev_manager_test.cpp +++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/dev_manager_test.cpp @@ -91,5 +91,5 @@ HWTEST_F(DevManagerTest, GetRemoteDevices001, TestSize.Level1) ZLOGI("GetRemoteDevices001 begin."); DevManager &devManager = OHOS::DistributedKv::DevManager::GetInstance(); vector devInfo = devManager.GetRemoteDevices(); - EXPECT_NE(devInfo.size(), 0); + EXPECT_EQ(devInfo.size(), 0); } diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_get_top_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_get_top_test.cpp index ee1da9623e22d58acca53eacba40d65f4f16de19..38ad5f63e249601eeff5805a44a68453cf3f161a 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_get_top_test.cpp +++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_get_top_test.cpp @@ -34,7 +34,7 @@ public: void TearDown(); - static std::shared_ptr singleKvStorePtr; // declare kvstore instance. + static std::shared_ptr singleKvStore; // declare kvstore instance. static Status initStatus; static int MAX_VALUE_SIZE; }; @@ -47,7 +47,7 @@ const std::string VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\"," "}," "\"SCHEMA_INDEXES\":[\"$.age\"]}"; -std::shared_ptr SingleStoreImplGetTopTest::singleKvStorePtr = nullptr; +std::shared_ptr SingleStoreImplGetTopTest::singleKvStore = nullptr; Status SingleStoreImplGetTopTest::initStatus = Status::ERROR; int SingleStoreImplGetTopTest::MAX_VALUE_SIZE = 4 * 1024 * 1024; // max value size is 4M. @@ -62,7 +62,7 @@ void SingleStoreImplGetTopTest::SetUpTestCase(void) StoreId storeId = { "test_single" }; // define kvstore(database) name. mkdir(options.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); // [create and] open and initialize kvstore instance. - initStatus = manager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr); + initStatus = manager.GetSingleKvStore(options, appId, storeId, singleKvStore); } void SingleStoreImplGetTopTest::TearDownTestCase(void) @@ -87,14 +87,14 @@ void SingleStoreImplGetTopTest::TearDown(void) */ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeAsc, TestSize.Level0) { - ASSERT_NE(singleKvStorePtr, nullptr); + ASSERT_NE(singleKvStore, nullptr); std::vector input; for (size_t i = 10; i < 30; ++i) { Entry entry; entry.key = std::to_string(i).append("_k"); entry.value = std::to_string(i).append("_v"); input.push_back(entry); - auto status =singleKvStorePtr->Put( + auto status =singleKvStore->Put( entry.key, entry.value); ASSERT_EQ(status, SUCCESS); } @@ -102,7 +102,7 @@ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeAsc, TestSize.Leve query.KeyPrefix("1"); query.OrderByWriteTime(true); std::vector output; - auto status = singleKvStorePtr->GetEntries(query, output); + auto status = singleKvStore->GetEntries(query, output); ASSERT_EQ(status, SUCCESS); ASSERT_EQ(output.size(), 10); for (size_t i = 0; i < output.size(); ++i) { @@ -120,14 +120,14 @@ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeAsc, TestSize.Leve */ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeDesc, TestSize.Level0) { - ASSERT_NE(singleKvStorePtr, nullptr); + ASSERT_NE(singleKvStore, nullptr); std::vector input; for (size_t i = 10; i < 30; ++i) { Entry entry; entry.key = std::to_string(i).append("_k"); entry.value = std::to_string(i).append("_v"); input.push_back(entry); - auto status =singleKvStorePtr->Put( + auto status =singleKvStore->Put( entry.key, entry.value); ASSERT_EQ(status, SUCCESS); } @@ -135,7 +135,7 @@ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeDesc, TestSize.Lev query.KeyPrefix("1"); query.OrderByWriteTime(false); std::vector output; - auto status = singleKvStorePtr->GetEntries(query, output); + auto status = singleKvStore->GetEntries(query, output); ASSERT_EQ(status, SUCCESS); ASSERT_EQ(output.size(), 10); for (size_t i = 0; i < output.size(); ++i) { @@ -153,23 +153,23 @@ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeDesc, TestSize.Lev */ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeNoPrefix, TestSize.Level0) { - ASSERT_NE(singleKvStorePtr, nullptr); + ASSERT_NE(singleKvStore, nullptr); std::vector input; for (size_t i = 10; i < 30; ++i) { Entry entry; entry.key = std::to_string(i).append("_k"); entry.value = std::to_string(i).append("_v"); input.push_back(entry); - auto status =singleKvStorePtr->Put( + auto status =singleKvStore->Put( entry.key, entry.value); ASSERT_EQ(status, SUCCESS); } - singleKvStorePtr->Put("test_key_1", "{\"name\":1}"); + singleKvStore->Put("test_key_1", "{\"name\":1}"); DataQuery query; query.OrderByWriteTime(true); query.EqualTo("$.name",1); std::vector output; - auto status = singleKvStorePtr->GetEntries(query, output); + auto status = singleKvStore->GetEntries(query, output); ASSERT_EQ(status, NOT_SUPPORT); ASSERT_EQ(output.size(), 0); } @@ -183,14 +183,14 @@ HWTEST_F(SingleStoreImplGetTopTest, GetEntriesOrderByWriteTimeNoPrefix, TestSize */ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeAsc, TestSize.Level0) { - ASSERT_NE(singleKvStorePtr, nullptr); + ASSERT_NE(singleKvStore, nullptr); std::vector input; for (size_t i = 10; i < 30; ++i) { Entry entry; entry.key = std::to_string(i).append("_k"); entry.value = std::to_string(i).append("_v"); input.push_back(entry); - auto status =singleKvStorePtr->Put( + auto status =singleKvStore->Put( entry.key, entry.value); ASSERT_EQ(status, SUCCESS); } @@ -198,7 +198,7 @@ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeAsc, TestSize.Le query.InKeys({"10_k", "11_k"}); query.OrderByWriteTime(true); std::shared_ptr output; - auto status = singleKvStorePtr->GetResultSet(query, output); + auto status = singleKvStore->GetResultSet(query, output); ASSERT_EQ(status, SUCCESS); ASSERT_NE(output, nullptr); ASSERT_EQ(output->GetCount(), 2); @@ -221,7 +221,7 @@ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeAsc, TestSize.Le */ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeDesc, TestSize.Level0) { - ASSERT_NE(singleKvStorePtr, nullptr); + ASSERT_NE(singleKvStore, nullptr); std::vector input; auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); }; std::map dictionary(cmp); @@ -231,7 +231,7 @@ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeDesc, TestSize.L entry.value = std::to_string(i).append("_v"); input.push_back(entry); dictionary[entry.key] = entry.value; - auto status =singleKvStorePtr->Put( + auto status =singleKvStore->Put( entry.key, entry.value); ASSERT_EQ(status, SUCCESS); } @@ -239,7 +239,7 @@ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeDesc, TestSize.L query.KeyPrefix("1"); query.OrderByWriteTime(false); std::shared_ptr output; - auto status = singleKvStorePtr->GetResultSet(query, output); + auto status = singleKvStore->GetResultSet(query, output); ASSERT_EQ(status, SUCCESS); ASSERT_NE(output, nullptr); ASSERT_EQ(output->GetCount(), 10); @@ -261,7 +261,7 @@ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeDesc, TestSize.L */ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeNoPrefix, TestSize.Level0) { - ASSERT_NE(singleKvStorePtr, nullptr); + ASSERT_NE(singleKvStore, nullptr); std::vector input; auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); }; std::map dictionary(cmp); @@ -271,16 +271,16 @@ HWTEST_F(SingleStoreImplGetTopTest, GetResultSetOrderByWriteTimeNoPrefix, TestSi entry.value = std::to_string(i).append("_v"); input.push_back(entry); dictionary[entry.key] = entry.value; - auto status =singleKvStorePtr->Put( + auto status =singleKvStore->Put( entry.key, entry.value); ASSERT_EQ(status, SUCCESS); } - singleKvStorePtr->Put("test_key_1", "{\"name\":1}"); + singleKvStore->Put("test_key_1", "{\"name\":1}"); DataQuery query; query.OrderByWriteTime(true); query.EqualTo("$.name", 1); std::shared_ptr output; - auto status = singleKvStorePtr->GetResultSet(query, output); + auto status = singleKvStore->GetResultSet(query, output); ASSERT_EQ(status, NOT_SUPPORT); ASSERT_EQ(output, nullptr); } \ No newline at end of file diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp index ed2d7787ee87d8da2785fae0e30e49ee08f115e7..78c47cba6ea2e8ccbfb5781867953553327fe873 100644 --- a/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp +++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp @@ -54,7 +54,7 @@ public: void SetUp(); void TearDown(); - std::shared_ptr CreateKVStore(std::string storeIdTest, KvStoreType type); + std::shared_ptr CreateKVStore(std::string storeIdTest, KvStoreType type, bool encrypt, bool backup); std::shared_ptr kvStore_; }; @@ -76,25 +76,35 @@ void SingleStoreImplTest::TearDownTestCase(void) void SingleStoreImplTest::SetUp(void) { - kvStore_ = CreateKVStore("SingleKVStore", SINGLE_VERSION); + kvStore_ = CreateKVStore("SingleKVStore", SINGLE_VERSION, false, true); + if (kvStore_ == nullptr) { + kvStore_ = CreateKVStore("SingleKVStore", SINGLE_VERSION, false, true); + } ASSERT_NE(kvStore_, nullptr); } void SingleStoreImplTest::TearDown(void) { + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStore" }; + kvStore_ = nullptr; + auto status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + auto baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); } -std::shared_ptr SingleStoreImplTest::CreateKVStore(std::string storeIdTest, KvStoreType type) +std::shared_ptr SingleStoreImplTest::CreateKVStore(std::string storeIdTest, KvStoreType type, + bool encrypt, bool backup) { Options options; options.kvStoreType = type; options.securityLevel = S1; + options.encrypt = encrypt; options.area = EL1; + options.backup = backup; options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; - SyncPolicy policy; - policy.type = PolicyType::IMMEDIATE_SYNC_ON_ONLINE; - policy.value.emplace<1>(100); - options.policies.emplace_back(policy); AppId appId = { "SingleStoreImplTest" }; StoreId storeId = { storeIdTest }; @@ -136,6 +146,51 @@ HWTEST_F(SingleStoreImplTest, Put, TestSize.Level0) ASSERT_EQ(value.ToString(), "Put2 Value"); } +/** + * @tc.name: Put_Invalid_Key + * @tc.desc: put invalid key-value data to the device kv store and single kv store + * @tc.type: FUNC + * @tc.require: I4XVQQ + * @tc.author: wu fengshan + */ +HWTEST_F(SingleStoreImplTest, Put_Invalid_Key, TestSize.Level0) +{ + std::shared_ptr kvStore; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "DeviceKVStore" }; + kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true); + ASSERT_NE(kvStore, nullptr); + + size_t MAX_DEV_KEY_LEN = 897; + std::string str(MAX_DEV_KEY_LEN, 'a'); + Blob key(str); + Blob value("test_value"); + Status status = kvStore->Put(key, value); + EXPECT_EQ(status, INVALID_ARGUMENT); + + Blob key1(""); + Blob value1("test_value1"); + status = kvStore->Put(key1, value1); + EXPECT_EQ(status, INVALID_ARGUMENT); + + kvStore = nullptr; + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); + + size_t MAX_SINGLE_KEY_LEN = 1025; + std::string str1(MAX_SINGLE_KEY_LEN, 'b'); + Blob key2(str1); + Blob value2("test_value2"); + status = kvStore_->Put(key2, value2); + EXPECT_EQ(status, INVALID_ARGUMENT); + + status = kvStore_->Put(key1, value1); + EXPECT_EQ(status, INVALID_ARGUMENT); +} + /** * @tc.name: PutBatch * @tc.desc: put some key-value data to the kv store @@ -403,6 +458,97 @@ HWTEST_F(SingleStoreImplTest, GetEntries_Prefix, TestSize.Level0) } } +/** + * @tc.name: GetEntries_Less_Prefix + * @tc.desc: get entries by prefix and the key size less than sizeof(uint32_t) + * @tc.type: FUNC + * @tc.require: I4XVQQ + * @tc.author: wu fengshan + */ +HWTEST_F(SingleStoreImplTest, GetEntries_Less_Prefix, TestSize.Level0) +{ + std::shared_ptr kvStore; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "DeviceKVStore" }; + kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true); + ASSERT_NE(kvStore, nullptr); + + std::vector input; + for (int i = 0; i < 10; ++i) { + Entry entry; + entry.key = std::to_string(i).append("_k"); + entry.value = std::to_string(i).append("_v"); + input.push_back(entry); + } + auto status = kvStore->PutBatch(input); + ASSERT_EQ(status, SUCCESS); + std::vector output; + status = kvStore->GetEntries({"1"}, output); + ASSERT_NE(output.empty(), true); + ASSERT_EQ(status, SUCCESS); + + kvStore = nullptr; + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); + + status = kvStore_->PutBatch(input); + ASSERT_EQ(status, SUCCESS); + std::vector output1; + status = kvStore_->GetEntries({"1"}, output1); + ASSERT_NE(output1.empty(), true); + ASSERT_EQ(status, SUCCESS); +} + +/** + * @tc.name: GetEntries_Greater_Prefix + * @tc.desc: get entries by prefix and the key size is greater than sizeof(uint32_t) + * @tc.type: FUNC + * @tc.require: I4XVQQ + * @tc.author: wu fengshan + */ +HWTEST_F(SingleStoreImplTest, GetEntries_Greater_Prefix, TestSize.Level0) +{ + std::shared_ptr kvStore; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "DeviceKVStore" }; + kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true); + ASSERT_NE(kvStore, nullptr); + + size_t KEY_LEN = sizeof(uint32_t); + std::vector input; + for (int i = 1; i < 10; ++i) { + Entry entry; + std::string str(KEY_LEN, i + '0'); + entry.key = str; + entry.value = std::to_string(i).append("_v"); + input.push_back(entry); + } + auto status = kvStore->PutBatch(input); + ASSERT_EQ(status, SUCCESS); + std::vector output; + std::string str1(KEY_LEN, '1'); + status = kvStore->GetEntries(str1, output); + ASSERT_NE(output.empty(), true); + ASSERT_EQ(status, SUCCESS); + + kvStore = nullptr; + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); + + status = kvStore_->PutBatch(input); + ASSERT_EQ(status, SUCCESS); + std::vector output1; + status = kvStore_->GetEntries(str1, output1); + ASSERT_NE(output1.empty(), true); + ASSERT_EQ(status, SUCCESS); +} + /** * @tc.name: GetEntries * @tc.desc: get entries by query @@ -561,6 +707,63 @@ HWTEST_F(SingleStoreImplTest, CloseResultSet, TestSize.Level0) ASSERT_EQ(outputTmp->GetEntry(entry), ALREADY_CLOSED); } +/** + * @tc.name: Move_Offset + * @tc.desc: Move the ResultSet Relative Distance + * @tc.type: FUNC + * @tc.require: I4XVQQ + * @tc.author: wu fengshan + */ +HWTEST_F(SingleStoreImplTest, Move_Offset, TestSize.Level0) +{ + std::vector input; + for (int i = 0; i < 10; ++i) { + Entry entry; + entry.key = std::to_string(i).append("_k"); + entry.value = std::to_string(i).append("_v"); + input.push_back(entry); + } + auto status = kvStore_->PutBatch(input); + ASSERT_EQ(status, SUCCESS); + + Key prefix = "2"; + std::shared_ptr output; + status = kvStore_->GetResultSet(prefix, output); + ASSERT_EQ(status, SUCCESS); + ASSERT_NE(output, nullptr); + + auto outputTmp = output; + ASSERT_EQ(outputTmp->Move(1), true); + status = kvStore_->CloseResultSet(output); + ASSERT_EQ(status, SUCCESS); + ASSERT_EQ(output, nullptr); + + std::shared_ptr kvStore; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "DeviceKVStore" }; + kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true); + ASSERT_NE(kvStore, nullptr); + + status = kvStore->PutBatch(input); + ASSERT_EQ(status, SUCCESS); + std::shared_ptr output1; + status = kvStore->GetResultSet(prefix, output1); + ASSERT_EQ(status, SUCCESS); + ASSERT_NE(output1, nullptr); + auto outputTmp1 = output1; + ASSERT_EQ(outputTmp1->Move(1), true); + status = kvStore->CloseResultSet(output1); + ASSERT_EQ(status, SUCCESS); + ASSERT_EQ(output1, nullptr); + + kvStore = nullptr; + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} + /** * @tc.name: GetCount * @tc.desc: close the result set @@ -604,7 +807,7 @@ HWTEST_F(SingleStoreImplTest, GetCount, TestSize.Level0) */ HWTEST_F(SingleStoreImplTest, RemoveDeviceData, TestSize.Level0) { - auto store = CreateKVStore("DeviceKVStore", DEVICE_COLLABORATION); + auto store = CreateKVStore("DeviceKVStore", DEVICE_COLLABORATION, false, true); ASSERT_NE(store, nullptr); std::vector input; auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); }; @@ -690,4 +893,402 @@ HWTEST_F(SingleStoreImplTest, UnRegisterSyncCallback, TestSize.Level0) ASSERT_EQ(status, SUCCESS); status = kvStore_->UnRegisterSyncCallback(); ASSERT_EQ(status, SUCCESS); +} + +/** +* @tc.name: disableBackup +* @tc.desc: Disable backup +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(SingleStoreImplTest, disableBackup, TestSize.Level0) +{ + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStoreNoBackup" }; + std::shared_ptr kvStoreNoBackup; + kvStoreNoBackup = CreateKVStore(storeId, SINGLE_VERSION, true, false); + ASSERT_NE(kvStoreNoBackup, nullptr); + auto baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + auto status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); + status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, SUCCESS); +} + +/** + * @tc.name: PutOverMaxValue + * @tc.desc: put key-value data to the kv store and the value size over the limits + * @tc.type: FUNC + * @tc.require: I605H3 + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, PutOverMaxValue, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + std::string value; + int maxsize = 1024 * 1024; + for (int i = 0; i <= maxsize; i++) { + value += "test"; + } + Value valuePut(value); + auto status = kvStore_->Put({ "Put Test" }, valuePut); + ASSERT_EQ(status, INVALID_ARGUMENT); +} +/** + * @tc.name: DeleteOverMaxKey + * @tc.desc: delete the values of the keys and the key size over the limits + * @tc.type: FUNC + * @tc.require: I605H3 + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, DeleteOverMaxKey, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + std::string str; + int maxsize = 1024; + for (int i = 0; i <= maxsize; i++) { + str += "key"; + } + Key key(str); + auto status = kvStore_->Put(key, "Put Test"); + ASSERT_EQ(status, INVALID_ARGUMENT); + Value value; + status = kvStore_->Get(key, value); + ASSERT_EQ(status, INVALID_ARGUMENT); + status = kvStore_->Delete(key); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: GetEntriesOverMaxKey + * @tc.desc: get entries the by prefix and the prefix size over the limits + * @tc.type: FUNC + * @tc.require: I605H3 + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetEntriesOverMaxPrefix, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + std::string str; + int maxsize = 1024; + for (int i = 0; i <= maxsize; i++) { + str += "key"; + } + const Key prefix(str); + std::vector output; + auto status = kvStore_->GetEntries(prefix, output); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: GetResultSetOverMaxPrefix + * @tc.desc: get result set the by prefix and the prefix size over the limits + * @tc.type: FUNC + * @tc.require: I605H3 + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetResultSetOverMaxPrefix, TestSize.Level0) +{ + ASSERT_NE(kvStore_, nullptr); + std::string str; + int maxsize = 1024; + for (int i = 0; i <= maxsize; i++) { + str += "key"; + } + const Key prefix(str); + std::shared_ptr output; + auto status = kvStore_->GetResultSet(prefix, output); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: RemoveNullDeviceData + * @tc.desc: remove local device data and the device is null + * @tc.type: FUNC + * @tc.require: I605H3 + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, RemoveNullDeviceData, TestSize.Level0) +{ + auto store = CreateKVStore("DeviceKVStore", DEVICE_COLLABORATION, false, true); + ASSERT_NE(store, nullptr); + std::vector input; + auto cmp = [](const Key &entry, const Key &sentry) { + return entry.Data() < sentry.Data(); + }; + std::map dictionary(cmp); + for (int i = 0; i < 10; ++i) { + Entry entry; + entry.key = std::to_string(i).append("_k"); + entry.value = std::to_string(i).append("_v"); + dictionary[entry.key] = entry.value; + input.push_back(entry); + } + auto status = store->PutBatch(input); + ASSERT_EQ(status, SUCCESS); + int count = 0; + status = store->GetCount({}, count); + ASSERT_EQ(status, SUCCESS); + ASSERT_EQ(count, 10); + const string device = { "" }; + status = store->RemoveDeviceData(device); + ASSERT_EQ(status, SUCCESS); +} + +/** + * @tc.name: CloseKVStoreWithInvalidAppId + * @tc.desc: close the kv store with invalid appid + * @tc.type: FUNC + * @tc.require: + * @tc.author: Yang Qing + */ +HWTEST_F(SingleStoreImplTest, CloseKVStoreWithInvalidAppId, TestSize.Level0) +{ + AppId appId = { "" }; + StoreId storeId = { "SingleKVStore" }; + Status status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: CloseKVStoreWithInvalidStoreId + * @tc.desc: close the kv store with invalid store id + * @tc.type: FUNC + * @tc.require: + * @tc.author: Yang Qing + */ +HWTEST_F(SingleStoreImplTest, CloseKVStoreWithInvalidStoreId, TestSize.Level0) +{ + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "" }; + Status status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: CloseAllKVStore + * @tc.desc: close all kv store + * @tc.type: FUNC + * @tc.require: + * @tc.author: Yang Qing + */ +HWTEST_F(SingleStoreImplTest, CloseAllKVStore, TestSize.Level0) +{ + AppId appId = { "SingleStoreImplTestCloseAll" }; + std::vector> kvStores; + for (int i = 0; i < 5; i++) { + std::shared_ptr kvStore; + Options options; + options.kvStoreType = SINGLE_VERSION; + options.securityLevel = S1; + options.area = EL1; + options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + std::string sId = "SingleStoreImplTestCloseAll" + std::to_string(i); + StoreId storeId = { sId }; + Status status; + kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); + ASSERT_NE(kvStore, nullptr); + kvStores.push_back(kvStore); + ASSERT_EQ(status, SUCCESS); + kvStore = nullptr; + } + Status status = StoreManager::GetInstance().CloseAllKVStore(appId); + ASSERT_EQ(status, SUCCESS); +} + +/** + * @tc.name: CloseAllKVStoreWithInvalidAppId + * @tc.desc: close the kv store with invalid appid + * @tc.type: FUNC + * @tc.require: + * @tc.author: Yang Qing + */ +HWTEST_F(SingleStoreImplTest, CloseAllKVStoreWithInvalidAppId, TestSize.Level0) +{ + AppId appId = { "" }; + Status status = StoreManager::GetInstance().CloseAllKVStore(appId); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: DeleteWithInvalidAppId + * @tc.desc: delete the kv store with invalid appid + * @tc.type: FUNC + * @tc.require: + * @tc.author: Yang Qing + */ +HWTEST_F(SingleStoreImplTest, DeleteWithInvalidAppId, TestSize.Level0) +{ + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + AppId appId = { "" }; + StoreId storeId = { "SingleKVStore" }; + Status status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: DeleteWithInvalidStoreId + * @tc.desc: delete the kv store with invalid storeid + * @tc.type: FUNC + * @tc.require: + * @tc.author: Yang Qing + */ +HWTEST_F(SingleStoreImplTest, DeleteWithInvalidStoreId, TestSize.Level0) +{ + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "" }; + Status status = StoreManager::GetInstance().Delete(appId, storeId, baseDir); + ASSERT_EQ(status, INVALID_ARGUMENT); +} + +/** + * @tc.name: GetKVStoreWithPersistentFalse + * @tc.desc: delete the kv store with the persistent is false + * @tc.type: FUNC + * @tc.require: + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetKVStoreWithPersistentFalse, TestSize.Level0) +{ + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStorePersistentFalse" }; + std::shared_ptr kvStore; + Options options; + options.kvStoreType = SINGLE_VERSION; + options.securityLevel = S1; + options.area = EL1; + options.persistent = false; + options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + Status status; + kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); + ASSERT_EQ(kvStore, nullptr); +} + +/** + * @tc.name: GetKVStoreWithInvalidType + * @tc.desc: delete the kv store with the KvStoreType is InvalidType + * @tc.type: FUNC + * @tc.require: + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetKVStoreWithInvalidType, TestSize.Level0) +{ + std::string baseDir = "/data/service/el1/public/database/SingleStoreImpStore"; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStoreInvalidType" }; + std::shared_ptr kvStore; + Options options; + options.kvStoreType = INVALID_TYPE; + options.securityLevel = S1; + options.area = EL1; + options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + Status status; + kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); + ASSERT_EQ(kvStore, nullptr); +} + +/** + * @tc.name: GetKVStoreWithCreateIfMissingFalse + * @tc.desc: delete the kv store with the createIfMissing is false + * @tc.type: FUNC + * @tc.require: + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetKVStoreWithCreateIfMissingFalse, TestSize.Level0) +{ + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStoreCreateIfMissingFalse" }; + std::shared_ptr kvStore; + Options options; + options.kvStoreType = SINGLE_VERSION; + options.securityLevel = S1; + options.area = EL1; + options.createIfMissing = false; + options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + Status status; + kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); + ASSERT_EQ(kvStore, nullptr); +} + +/** + * @tc.name: GetKVStoreWithAutoSync + * @tc.desc: delete the kv store with the autoSync is false + * @tc.type: FUNC + * @tc.require: + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetKVStoreWithAutoSync, TestSize.Level0) +{ + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStoreAutoSync" }; + std::shared_ptr kvStore; + Options options; + options.kvStoreType = SINGLE_VERSION; + options.securityLevel = S1; + options.area = EL1; + options.autoSync = false; + options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + Status status; + kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); + ASSERT_NE(kvStore, nullptr); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); +} + +/** + * @tc.name: GetKVStoreWithAreaEL2 + * @tc.desc: delete the kv store with the area is EL2 + * @tc.type: FUNC + * @tc.require: + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetKVStoreWithAreaEL2, TestSize.Level0) +{ + std::string baseDir = "/data/service/el2/100/SingleStoreImplTest"; + mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); + + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStoreAreaEL2" }; + std::shared_ptr kvStore; + Options options; + options.kvStoreType = SINGLE_VERSION; + options.securityLevel = S2; + options.area = EL2; + options.baseDir = "/data/service/el2/100/SingleStoreImplTest"; + Status status; + kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); + ASSERT_NE(kvStore, nullptr); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); +} + +/** + * @tc.name: GetKVStoreWithRebuildTrue + * @tc.desc: delete the kv store with the rebuild is true + * @tc.type: FUNC + * @tc.require: + * @tc.author: Wang Kai + */ +HWTEST_F(SingleStoreImplTest, GetKVStoreWithRebuildTrue, TestSize.Level0) +{ + std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + AppId appId = { "SingleStoreImplTest" }; + StoreId storeId = { "SingleKVStoreRebuildFalse" }; + std::shared_ptr kvStore; + Options options; + options.kvStoreType = SINGLE_VERSION; + options.securityLevel = S1; + options.area = EL1; + options.rebuild = true; + options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest"; + Status status; + kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status); + ASSERT_NE(kvStore, nullptr); + status = StoreManager::GetInstance().CloseKVStore(appId, storeId); + ASSERT_EQ(status, SUCCESS); } \ No newline at end of file diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/store_util_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/store_util_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..942fb8f2bdc49db1a52958e0bc94fb44df04092e --- /dev/null +++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/store_util_test.cpp @@ -0,0 +1,130 @@ +/* +* Copyright (c) 2022 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "store_util.h" + +#include +#include + +#include "store_manager.h" +#include "types.h" +using namespace testing::ext; +using namespace OHOS::DistributedKv; + +class StoreUtilTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + + void SetUp(); + void TearDown(); +}; + +void StoreUtilTest::SetUpTestCase(void) {} + +void StoreUtilTest::TearDownTestCase(void) {} + +void StoreUtilTest::SetUp(void) {} + +void StoreUtilTest::TearDown(void) {} +/** +* @tc.name: GetDBSecurity +* @tc.desc: get db security +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(StoreUtilTest, GetDBSecurity, TestSize.Level1) +{ + StoreUtil storeUtil_; + auto dbsecurity = storeUtil_.GetDBSecurity(-1); + ASSERT_EQ(dbsecurity.securityLabel, DistributedDB::NOT_SET); + ASSERT_EQ(dbsecurity.securityFlag, DistributedDB::ECE); + + dbsecurity = storeUtil_.GetDBSecurity(7); + ASSERT_EQ(dbsecurity.securityLabel, DistributedDB::NOT_SET); + ASSERT_EQ(dbsecurity.securityFlag, DistributedDB::ECE); + + dbsecurity = storeUtil_.GetDBSecurity(5); + ASSERT_EQ(dbsecurity.securityLabel, DistributedDB::S3); + ASSERT_EQ(dbsecurity.securityFlag, DistributedDB::SECE); + + dbsecurity = storeUtil_.GetDBSecurity(6); + ASSERT_EQ(dbsecurity.securityLabel, DistributedDB::S4); + ASSERT_EQ(dbsecurity.securityFlag, DistributedDB::ECE); +} +/** +* @tc.name: GetSecLevel +* @tc.desc: get secLevel +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(StoreUtilTest, GetSecLevel, TestSize.Level1) +{ + StoreUtil storeUtil_; + StoreUtil::DBSecurity dbSec = { DistributedDB::NOT_SET, DistributedDB::ECE }; + int32_t security = storeUtil_.GetSecLevel(dbSec); + ASSERT_EQ(security, dbSec.securityLabel); + + dbSec = { DistributedDB::S3, DistributedDB::ECE }; + security = storeUtil_.GetSecLevel(dbSec); + ASSERT_EQ(security, S3_EX); + dbSec = { DistributedDB::S3, DistributedDB::SECE }; + security = storeUtil_.GetSecLevel(dbSec); + ASSERT_EQ(security, S3); + + dbSec = { DistributedDB::S4, DistributedDB::ECE }; + security = storeUtil_.GetSecLevel(dbSec); + ASSERT_EQ(security, S4); +} +/** +* @tc.name: GetDBMode +* @tc.desc: get db mode +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(StoreUtilTest, GetDBMode, TestSize.Level1) +{ + StoreUtil storeUtil_; + StoreUtil::DBMode dbMode = storeUtil_.GetDBMode(SyncMode::PUSH); + ASSERT_EQ(dbMode, StoreUtil::DBMode::SYNC_MODE_PUSH_ONLY); + + dbMode = storeUtil_.GetDBMode(SyncMode::PULL); + ASSERT_EQ(dbMode, StoreUtil::DBMode::SYNC_MODE_PULL_ONLY); + + dbMode = storeUtil_.GetDBMode(SyncMode::PUSH_PULL); + ASSERT_EQ(dbMode, StoreUtil::DBMode::SYNC_MODE_PUSH_PULL); +} +/** +* @tc.name: GetObserverMode +* @tc.desc: get observer mode +* @tc.type: FUNC +* @tc.require: +* @tc.author: Wang Kai +*/ +HWTEST_F(StoreUtilTest, GetObserverMode, TestSize.Level1) +{ + StoreUtil storeUtil_; + uint32_t mode = storeUtil_.GetObserverMode(SubscribeType::SUBSCRIBE_TYPE_LOCAL); + ASSERT_EQ(mode, DistributedDB::OBSERVER_CHANGES_NATIVE); + + mode = storeUtil_.GetObserverMode(SubscribeType::SUBSCRIBE_TYPE_REMOTE); + ASSERT_EQ(mode, DistributedDB::OBSERVER_CHANGES_FOREIGN); + + mode = storeUtil_.GetObserverMode(SUBSCRIBE_TYPE_ALL); + ASSERT_EQ(mode, DistributedDB::OBSERVER_CHANGES_FOREIGN | DistributedDB::OBSERVER_CHANGES_NATIVE); +} \ No newline at end of file diff --git a/kv_store/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp b/kv_store/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp index a57ac72ea865a6a31c5910f62291d757f886aefe..0e7d5dc104b63a7a412afac28c9e445b28de0482 100644 --- a/kv_store/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp +++ b/kv_store/frameworks/jskitsimpl/distributeddata/src/js_device_kv_store.cpp @@ -143,9 +143,9 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V if (type == napi_string) { // number 2 means: required 2 arguments, CHECK_RETURN(argc == 2, "invalid arguments!", napi_invalid_arg); - status = JSUtil::GetValue(env, argv[0], va.deviceId); + JSUtil::GetValue(env, argv[0], va.deviceId); CHECK_RETURN(!va.deviceId.empty(), "invalid arg[0], i.e. invalid deviceId!", napi_invalid_arg); - status = napi_typeof(env, argv[1], &type); + napi_typeof(env, argv[1], &type); CHECK_RETURN((type == napi_string) || (type == napi_object), "invalid arg[1], type error!", napi_invalid_arg); if (type == napi_string) { status = JSUtil::GetValue(env, argv[1], va.keyPrefix); @@ -470,7 +470,7 @@ napi_value JsDeviceKVStore::New(napi_env env, napi_callback_info info) NAPI_ASSERT(env, kvStore !=nullptr, "no memory for kvStore"); auto finalize = [](napi_env env, void* data, void* hint) { - ZLOGD("deviceKvStore finalize."); + ZLOGI("deviceKvStore finalize."); auto* kvStore = reinterpret_cast(data); CHECK_RETURN_VOID(kvStore != nullptr, "finalize null!"); delete kvStore; diff --git a/kv_store/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp b/kv_store/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp index ebd7e10d886f0c9b297fafff0a91d4559c3b04d3..8cd0ed9ef09136e38079b2e3f303064fe0d9c190 100644 --- a/kv_store/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp +++ b/kv_store/frameworks/jskitsimpl/distributeddata/src/js_single_kv_store.cpp @@ -468,7 +468,7 @@ napi_value JsSingleKVStore::New(napi_env env, napi_callback_info info) NAPI_ASSERT(env, kvStore !=nullptr, "no memory for kvStore"); auto finalize = [](napi_env env, void* data, void* hint) { - ZLOGD("singleKVStore finalize."); + ZLOGI("singleKVStore finalize."); auto* kvStore = reinterpret_cast(data); CHECK_RETURN_VOID(kvStore != nullptr, "finalize null!"); delete kvStore; diff --git a/kv_store/frameworks/jskitsimpl/distributeddata/src/js_util.cpp b/kv_store/frameworks/jskitsimpl/distributeddata/src/js_util.cpp index ecbf2e2616ad218bd51da4b7883e369374942a34..6802fb660b28eb220bf00c823ba99c76f362880f 100644 --- a/kv_store/frameworks/jskitsimpl/distributeddata/src/js_util.cpp +++ b/kv_store/frameworks/jskitsimpl/distributeddata/src/js_util.cpp @@ -736,7 +736,6 @@ napi_status JSUtil::SetValue(napi_env env, const DistributedKv::Entry& in, napi_ } else { status = SetValue(env, Blob2VariantValue(in.value), vValue); } - status = SetValue(env, Blob2VariantValue(in.value), vValue); // Blob CHECK_RETURN((status == napi_ok), "invalid entry value", status); napi_set_named_property(env, value, "value", vValue); diff --git a/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_single_kv_store.h b/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_single_kv_store.h index c3a6b493aba846f46a88ab08be4e6a50e4bb4472..19344f38983209708e38368d5b886dc427bc942c 100644 --- a/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_single_kv_store.h +++ b/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_single_kv_store.h @@ -99,8 +99,8 @@ private: static void OffSyncComplete(napi_env env, size_t argc, napi_value* argv, std::shared_ptr ctxt); /* private non-static members */ - napi_status Subscribe(uint8_t type, std::shared_ptr observer); - napi_status UnSubscribe(uint8_t type, std::shared_ptr observer); + DistributedKv::Status Subscribe(uint8_t type, std::shared_ptr observer); + DistributedKv::Status UnSubscribe(uint8_t type, std::shared_ptr observer); napi_status RegisterSyncCallback(std::shared_ptr sync); napi_status UnRegisterSyncCallback(); diff --git a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_device_kv_store.cpp b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_device_kv_store.cpp index 2b67638af6f298d4a849ebffb8d1c1ea5e161bcc..95be2c150bbab05aee088533a15f76edf08172b6 100644 --- a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_device_kv_store.cpp +++ b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_device_kv_store.cpp @@ -30,21 +30,11 @@ constexpr int DEVICEID_WIDTH = 4; static std::string GetDeviceKey(const std::string& deviceId, const std::string& key) { std::ostringstream oss; - oss << std::setfill('0') << std::setw(DEVICEID_WIDTH) << deviceId.length(); - oss << deviceId << key; - return oss.str(); -} - -static napi_status GetLocalDeviceId(std::string &locDevId) -{ - DeviceInfo info; - DistributedKvDataManager manager; - Status daviceStatus = manager.GetLocalDevice(info); - if (daviceStatus != Status::SUCCESS) { - ZLOGE("GetLocalDevice return %{public}d", daviceStatus); - return napi_generic_failure; + if (!deviceId.empty()) { + oss << std::setfill('0') << std::setw(DEVICEID_WIDTH) << deviceId.length() << deviceId; } - return napi_ok; + oss << key; + return oss.str(); } JsDeviceKVStore::JsDeviceKVStore(const std::string& storeId) @@ -98,10 +88,11 @@ napi_value JsDeviceKVStore::Get(napi_env env, napi_callback_info info) auto input = [env, ctxt](size_t argc, napi_value* argv) { // number 2 means: required 2 arguments, + ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect."); - ctxt->status = (argc == 1) ? GetLocalDeviceId(ctxt->deviceId) - : JSUtil::GetValue(env, argv[0], ctxt->deviceId); - ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, - "The parameter deviceId is incorrect."); + if (argc > 1) { + ctxt->status = JSUtil::GetValue(env, argv[0], ctxt->deviceId); + ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, + "The parameter deviceId is incorrect."); + } int32_t pos = (argc == 1) ? 0 : 1; ctxt->status = JSUtil::GetValue(env, argv[pos], ctxt->key); ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "The type of key must be string."); @@ -129,56 +120,50 @@ napi_value JsDeviceKVStore::Get(napi_env env, napi_callback_info info) return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), execute, output); } -enum class ArgsType : uint8_t { - /* input arguments' combination type */ - DEVICEID_KEYPREFIX = 0, - DEVICEID_QUERY, - QUERY, - UNKNOWN = 255 -}; struct VariantArgs { /* input arguments' combinations */ - std::string deviceId; - std::string keyPrefix; - JsQuery* query; - ArgsType type = ArgsType::UNKNOWN; DataQuery dataQuery; std::string errMsg = ""; }; static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, VariantArgs& va) { - napi_status status = (argc == 1) ? GetLocalDeviceId(va.deviceId) : JSUtil::GetValue(env, argv[0], va.deviceId); int32_t pos = (argc == 1) ? 0 : 1; napi_valuetype type = napi_undefined; - status = napi_typeof(env, argv[pos], &type); - if (!(type == napi_string || type == napi_object)) { + napi_status status = napi_typeof(env, argv[pos], &type); + if (status != napi_ok||(type != napi_string && type != napi_object)) { va.errMsg = "The type of parameters keyPrefix/query is incorrect."; - return napi_invalid_arg; + return status != napi_ok?status:napi_invalid_arg; } if (type == napi_string) { - status = JSUtil::GetValue(env, argv[pos], va.keyPrefix); - if (va.keyPrefix.empty()) { + std::string keyPrefix; + status = JSUtil::GetValue(env, argv[pos], keyPrefix); + if (keyPrefix.empty()) { va.errMsg = "The type of parameters keyPrefix is incorrect."; return napi_invalid_arg; } - va.type = ArgsType::DEVICEID_KEYPREFIX; - } - if (type == napi_object) { + va.dataQuery.KeyPrefix(keyPrefix); + } else { bool result = false; status = napi_instanceof(env, argv[pos], JsQuery::Constructor(env), &result); if ((status == napi_ok) && (result != false)) { - status = JSUtil::Unwrap(env, argv[pos], reinterpret_cast(&va.query), JsQuery::Constructor(env)); - if (va.query == nullptr) { + JsQuery *jsQuery = nullptr; + status = JSUtil::Unwrap(env, argv[pos], reinterpret_cast(&jsQuery), JsQuery::Constructor(env)); + if (jsQuery == nullptr) { va.errMsg = "The parameters query is incorrect."; return napi_invalid_arg; } - va.type = ArgsType::DEVICEID_QUERY; + va.dataQuery = jsQuery->GetDataQuery(); } else { status = JSUtil::GetValue(env, argv[pos], va.dataQuery); ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status); } } + std::string deviceId; + if (argc > 1) { + JSUtil::GetValue(env, argv[0], deviceId); + va.dataQuery.DeviceId(deviceId); + } return status; }; @@ -210,22 +195,8 @@ napi_value JsDeviceKVStore::GetEntries(napi_env env, napi_callback_info info) auto execute = [ctxt]() { auto kvStore = reinterpret_cast(ctxt->native)->GetKvStorePtr(); - Status status = Status::INVALID_ARGUMENT; - if (ctxt->va.type == ArgsType::DEVICEID_KEYPREFIX) { - std::string deviceKey = GetDeviceKey(ctxt->va.deviceId, ctxt->va.keyPrefix); - OHOS::DistributedKv::Key keyPrefix(deviceKey); - status = kvStore->GetEntries(keyPrefix, ctxt->entries); - ZLOGD("kvStore->GetEntries() return %{public}d", status); - } else if (ctxt->va.type == ArgsType::DEVICEID_QUERY) { - auto query = ctxt->va.query->GetDataQuery(); - query.DeviceId(ctxt->va.deviceId); - status = kvStore->GetEntries(query, ctxt->entries); - ZLOGD("kvStore->GetEntries() return %{public}d", status); - } else if (ctxt->va.type == ArgsType::QUERY) { - auto query = ctxt->va.query->GetDataQuery(); - status = kvStore->GetEntries(query, ctxt->entries); - ZLOGD("kvStore->GetEntries() return %{public}d", status); - } + Status status = kvStore->GetEntries(ctxt->va.dataQuery, ctxt->entries); + ZLOGD("kvStore->GetEntries() return %{public}d", status); ctxt->status = (GenerateNapiError(status, ctxt->jsCode, ctxt->error) == Status::SUCCESS) ? napi_ok : napi_generic_failure; }; @@ -271,27 +242,8 @@ napi_value JsDeviceKVStore::GetResultSet(napi_env env, napi_callback_info info) auto execute = [ctxt]() { std::shared_ptr kvResultSet; auto kvStore = reinterpret_cast(ctxt->native)->GetKvStorePtr(); - Status status = Status::INVALID_ARGUMENT; - if (ctxt->va.type == ArgsType::DEVICEID_KEYPREFIX) { - std::string deviceKey = GetDeviceKey(ctxt->va.deviceId, ctxt->va.keyPrefix); - OHOS::DistributedKv::Key keyPrefix(deviceKey); - status = kvStore->GetResultSet(keyPrefix, kvResultSet); - ZLOGD("kvStore->GetResultSet() return %{public}d", status); - } else if (ctxt->va.type == ArgsType::DEVICEID_QUERY) { - auto query = ctxt->va.query->GetDataQuery(); - query.DeviceId(ctxt->va.deviceId); - status = kvStore->GetResultSet(query, kvResultSet); - ZLOGD("kvStore->GetResultSet() return %{public}d", status); - } else if (ctxt->va.type == ArgsType::QUERY) { - auto query = ctxt->va.query->GetDataQuery(); - status = kvStore->GetResultSet(query, kvResultSet); - ZLOGD("kvStore->GetResultSet() return %{public}d", status); - } else { - ctxt->va.dataQuery.DeviceId(ctxt->va.deviceId); - ZLOGD("ArgsType::DEVICEID_PREDICATES ToQuery return %{public}d", status); - status = kvStore->GetResultSet(ctxt->va.dataQuery, kvResultSet); - ZLOGD("ArgsType::DEVICEID_PREDICATES GetResultSetWithQuery return %{public}d", status); - }; + Status status = kvStore->GetResultSet(ctxt->va.dataQuery, kvResultSet); + ZLOGD("kvStore->GetResultSet() return %{public}d", status); ctxt->status = (GenerateNapiError(status, ctxt->jsCode, ctxt->error) == Status::SUCCESS) ? napi_ok : napi_generic_failure; ctxt->resultSet->SetKvStoreResultSetPtr(kvResultSet); @@ -323,8 +275,6 @@ napi_value JsDeviceKVStore::GetResultSize(napi_env env, napi_callback_info info) ASSERT_BUSINESS_ERR(ctxt, argc >= 1, Status::INVALID_ARGUMENT, "The number of parameters is incorrect."); ctxt->status = GetVariantArgs(env, argc, argv, ctxt->va); ASSERT_BUSINESS_ERR(ctxt, ctxt->status != napi_invalid_arg, Status::INVALID_ARGUMENT, ctxt->va.errMsg); - ASSERT_BUSINESS_ERR(ctxt, (ctxt->va.type == ArgsType::DEVICEID_QUERY) || (ctxt->va.type == ArgsType::QUERY), - Status::INVALID_ARGUMENT, "The type of parameters ArgsType is incorrect."); }; ctxt->GetCbInfo(env, info, input); @@ -332,11 +282,7 @@ napi_value JsDeviceKVStore::GetResultSize(napi_env env, napi_callback_info info) auto execute = [ctxt]() { auto kvStore = reinterpret_cast(ctxt->native)->GetKvStorePtr(); - auto query = ctxt->va.query->GetDataQuery(); - if (ctxt->va.type == ArgsType::DEVICEID_QUERY) { - query.DeviceId(ctxt->va.deviceId); - } - Status status = kvStore->GetCount(query, ctxt->resultSize); + Status status = kvStore->GetCount(ctxt->va.dataQuery, ctxt->resultSize); ZLOGD("kvStore->GetCount() return %{public}d", status); ctxt->status = (GenerateNapiError(status, ctxt->jsCode, ctxt->error) == Status::SUCCESS) ? napi_ok : napi_generic_failure; @@ -367,7 +313,7 @@ napi_value JsDeviceKVStore::New(napi_env env, napi_callback_info info) ASSERT_ERR(env, kvStore != nullptr,Status::INVALID_ARGUMENT, "no memory for kvStore"); auto finalize = [](napi_env env, void* data, void* hint) { - ZLOGD("deviceKvStore finalize."); + ZLOGI("deviceKvStore finalize."); auto* kvStore = reinterpret_cast(data); ASSERT_VOID(kvStore != nullptr, "finalize null!"); delete kvStore; diff --git a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_error_utils.cpp b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_error_utils.cpp index 8b513f2c145186f7fb068bf96118703447ca7600..6921fe844b0a64f27f9cb01fee2127bc78de280e 100644 --- a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_error_utils.cpp +++ b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_error_utils.cpp @@ -20,20 +20,14 @@ using JsErrorCode = OHOS::DistributedKVStore::JsErrorCode; static const std::map jsErrCodeMsgMap { {Status::INVALID_ARGUMENT, {401, "Parameter error."}}, - {Status::ILLEGAL_STATE, {-1, ""}}, - {Status::ERROR, {-1, ""}}, - {Status::SERVER_UNAVAILABLE, {-1, ""}}, - {Status::DB_ERROR, {-1, ""}}, {Status::OVER_MAX_SUBSCRIBE_LIMITS, {15100001, "Over max subscribe limits."}}, {Status::STORE_META_CHANGED, {15100002, "Open existed database with changed options."}}, {Status::CRYPT_ERROR, {15100003, "Database corrupted."}}, {Status::NOT_FOUND, {15100004, "Not found."}}, - {Status::NOT_SUPPORT, {15100005, "Not support the operation."}}, - {Status::ALREADY_CLOSED, {15100006, "Database or result set already closed."}}, + {Status::ALREADY_CLOSED, {15100005, "Database or result set already closed."}}, {Status::STORE_ALREADY_SUBSCRIBE, {0, ""}}, {Status::STORE_NOT_OPEN, {0, ""}}, {Status::STORE_NOT_SUBSCRIBE, {0, ""}}, - {Status::SECURITY_LEVEL_ERROR, {0, ""}}, }; const std::optional GetJsErrorCode(int32_t errorCode) @@ -52,6 +46,10 @@ Status GenerateNapiError(Status status, int32_t &errCode, std::string &errMessag auto napiError = errormsg.value(); errCode = napiError.jsCode; errMessage = napiError.message; + } else { + // unmatched status return unified error code + errCode = -1; + errMessage = ""; } ZLOGD("GenerateNapiError errCode is %{public}d", errCode); if (errCode == 0) { @@ -63,15 +61,29 @@ Status GenerateNapiError(Status status, int32_t &errCode, std::string &errMessag void ThrowNapiError(napi_env env, int32_t status, std::string errMessage, bool isParamsCheck) { ZLOGD("ThrowNapiError message: %{public}s", errMessage.c_str()); + if (status == Status::SUCCESS) { + return; + } auto errormsg = GetJsErrorCode(status); JsErrorCode napiError; if (errormsg.has_value()) { napiError = errormsg.value(); + } else { + napiError.jsCode = -1; + napiError.message = ""; } + if (isParamsCheck) { napiError.message += errMessage; napiError.jsCode = 401; } - napi_throw_error(env, std::to_string(napiError.jsCode).c_str(), napiError.message.c_str()); + + std::string jsCode; + if (napiError.jsCode == -1) { + jsCode = ""; + } else { + jsCode = std::to_string(napiError.jsCode); + } + napi_throw_error(env, jsCode.c_str(), napiError.message.c_str()); } } // namespace OHOS::DistributedKVStore \ No newline at end of file diff --git a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_single_kv_store.cpp b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_single_kv_store.cpp index 22f95068645ca233b7afb4b5bf58d00f7109cd92..8b61c52bd9ed6083072dd13ec450483969885846 100644 --- a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_single_kv_store.cpp +++ b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_single_kv_store.cpp @@ -641,9 +641,8 @@ void JsSingleKVStore::OnDataChange(napi_env env, size_t argc, napi_value* argv, } } - ctxt->status = - proxy->Subscribe(type, std::make_shared(proxy->uvQueue_, argv[1], proxy->IsSchemaStore())); - ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, Status::INVALID_ARGUMENT, "Subscribe failed!"); + Status status = proxy->Subscribe(type, std::make_shared(proxy->uvQueue_, argv[1], proxy->IsSchemaStore())); + ThrowNapiError(env, status, "", false); } /* @@ -669,7 +668,7 @@ void JsSingleKVStore::OffDataChange(napi_env env, size_t argc, napi_value* argv, auto proxy = reinterpret_cast(ctxt->native); bool found = false; - napi_status status = napi_ok; + Status status = Status::SUCCESS; auto traverseType = [argc, argv, proxy, env, &found, &status](uint8_t type, auto& observers) { auto it = observers.begin(); while (it != observers.end()) { @@ -679,7 +678,7 @@ void JsSingleKVStore::OffDataChange(napi_env env, size_t argc, napi_value* argv, } found = true; status = proxy->UnSubscribe(type, *it); - if (status != napi_ok) { + if (status != Status::SUCCESS) { break; // stop on fail. } it = observers.erase(it); @@ -689,11 +688,12 @@ void JsSingleKVStore::OffDataChange(napi_env env, size_t argc, napi_value* argv, std::lock_guard lck(proxy->listMutex_); for (uint8_t type = SUBSCRIBE_LOCAL; type < SUBSCRIBE_COUNT; type++) { traverseType(type, proxy->dataObserver_[type]); - if (status != napi_ok) { + if (status != Status::SUCCESS) { break; // stop on fail. } } ASSERT_BUSINESS_ERR(ctxt, found || (argc == 0), Status::INVALID_ARGUMENT, "not Subscribed!"); + ThrowNapiError(env, status, "", false); } /* @@ -777,29 +777,29 @@ napi_status JsSingleKVStore::UnRegisterSyncCallback() return napi_ok; } -napi_status JsSingleKVStore::Subscribe(uint8_t type, std::shared_ptr observer) +Status JsSingleKVStore::Subscribe(uint8_t type, std::shared_ptr observer) { auto subscribeType = ToSubscribeType(type); Status status = kvStore_->SubscribeKvStore(subscribeType, observer); ZLOGD("kvStore_->SubscribeKvStore(%{public}d) return %{public}d", type, status); if (status != Status::SUCCESS) { observer->Clear(); - return napi_generic_failure; + return status; } dataObserver_[type].push_back(observer); - return napi_ok; + return status; } -napi_status JsSingleKVStore::UnSubscribe(uint8_t type, std::shared_ptr observer) +Status JsSingleKVStore::UnSubscribe(uint8_t type, std::shared_ptr observer) { auto subscribeType = ToSubscribeType(type); Status status = kvStore_->UnSubscribeKvStore(subscribeType, observer); ZLOGD("kvStore_->UnSubscribeKvStore(%{public}d) return %{public}d", type, status); if (status == Status::SUCCESS) { observer->Clear(); - return napi_ok; + return status; } - return napi_generic_failure; + return status; } void JsSingleKVStore::DataObserver::OnChange(const ChangeNotification& notification) @@ -869,17 +869,7 @@ napi_value JsSingleKVStore::Get(napi_env env, napi_callback_info info) return NapiQueue::AsyncWork(env, ctxt, std::string(__FUNCTION__), execute, output); } -enum class ArgsType : uint8_t { - /* input arguments' combination type */ - KEYPREFIX = 0, - QUERY, - UNKNOWN = 255 -}; struct VariantArgs { - /* input arguments' combinations */ - std::string keyPrefix; - JsQuery* query; - ArgsType type = ArgsType::UNKNOWN; DataQuery dataQuery; std::string errMsg = ""; }; @@ -889,27 +879,29 @@ static napi_status GetVariantArgs(napi_env env, size_t argc, napi_value* argv, V // required 1 arguments :: napi_valuetype type = napi_undefined; napi_status status = napi_typeof(env, argv[0], &type); - if (!(type == napi_string || type == napi_object)) { + if (status != napi_ok || (type != napi_string && type != napi_object)) { va.errMsg = "The type of parameters keyPrefix/query is incorrect."; - return napi_invalid_arg; + return status != napi_ok ? status : napi_invalid_arg; } if (type == napi_string) { - status = JSUtil::GetValue(env, argv[0], va.keyPrefix); - if (va.keyPrefix.empty()) { + std::string keyPrefix; + JSUtil::GetValue(env, argv[0], keyPrefix); + if (keyPrefix.empty()) { va.errMsg = "The type of parameters keyPrefix is incorrect."; return napi_invalid_arg; } - va.type = ArgsType::KEYPREFIX; + va.dataQuery.KeyPrefix(keyPrefix); } else if (type == napi_object) { bool result = false; status = napi_instanceof(env, argv[0], JsQuery::Constructor(env), &result); if ((status == napi_ok) && (result != false)) { - status = JSUtil::Unwrap(env, argv[0], reinterpret_cast(&va.query), JsQuery::Constructor(env)); - if (va.query == nullptr) { + JsQuery *jsQuery = nullptr; + status = JSUtil::Unwrap(env, argv[0], reinterpret_cast(&jsQuery), JsQuery::Constructor(env)); + if (jsQuery == nullptr) { va.errMsg = "The parameters query is incorrect."; return napi_invalid_arg; } - va.type = ArgsType::QUERY; + va.dataQuery = jsQuery->GetDataQuery(); } else { status = JSUtil::GetValue(env, argv[0], va.dataQuery); ZLOGD("kvStoreDataShare->GetResultSet return %{public}d", status); @@ -944,16 +936,8 @@ napi_value JsSingleKVStore::GetEntries(napi_env env, napi_callback_info info) auto execute = [ctxt]() { auto kvStore = reinterpret_cast(ctxt->native)->GetKvStorePtr(); - Status status = Status::INVALID_ARGUMENT; - if (ctxt->va.type == ArgsType::KEYPREFIX) { - OHOS::DistributedKv::Key keyPrefix(ctxt->va.keyPrefix); - status = kvStore->GetEntries(keyPrefix, ctxt->entries); - ZLOGD("kvStore->GetEntries() return %{public}d", status); - } else if (ctxt->va.type == ArgsType::QUERY) { - auto query = ctxt->va.query->GetDataQuery(); - status = kvStore->GetEntries(query, ctxt->entries); - ZLOGD("kvStore->GetEntries() return %{public}d", status); - } + Status status = kvStore->GetEntries(ctxt->va.dataQuery, ctxt->entries); + ZLOGD("kvStore->GetEntries() return %{public}d", status); ctxt->status = (GenerateNapiError(status, ctxt->jsCode, ctxt->error) == Status::SUCCESS) ? napi_ok : napi_generic_failure; }; @@ -997,19 +981,8 @@ napi_value JsSingleKVStore::GetResultSet(napi_env env, napi_callback_info info) auto execute = [ctxt]() { std::shared_ptr kvResultSet; auto kvStore = reinterpret_cast(ctxt->native)->GetKvStorePtr(); - Status status = Status::INVALID_ARGUMENT; - if (ctxt->va.type == ArgsType::KEYPREFIX) { - OHOS::DistributedKv::Key keyPrefix(ctxt->va.keyPrefix); - status = kvStore->GetResultSet(keyPrefix, kvResultSet); - ZLOGD("kvStore->GetEntries() return %{public}d", status); - } else if (ctxt->va.type == ArgsType::QUERY) { - auto query = ctxt->va.query->GetDataQuery(); - status = kvStore->GetResultSet(query, kvResultSet); - ZLOGD("kvStore->GetEntries() return %{public}d", status); - } else { - status = kvStore->GetResultSet(ctxt->va.dataQuery, kvResultSet); - ZLOGD("ArgsType::PREDICATES GetResultSetWithQuery return %{public}d", status); - }; + Status status = kvStore->GetResultSet(ctxt->va.dataQuery, kvResultSet); + ZLOGD("kvStore->GetResultSet() return %{public}d", status); ctxt->status = (GenerateNapiError(status, ctxt->jsCode, ctxt->error) == Status::SUCCESS) ? napi_ok : napi_generic_failure; @@ -1268,7 +1241,7 @@ napi_value JsSingleKVStore::New(napi_env env, napi_callback_info info) ASSERT_ERR(env, kvStore != nullptr, Status::INVALID_ARGUMENT, "no memory for kvStore"); auto finalize = [](napi_env env, void* data, void* hint) { - ZLOGD("singleKVStore finalize."); + ZLOGI("singleKVStore finalize."); auto* kvStore = reinterpret_cast(data); ASSERT_VOID(kvStore != nullptr, "finalize null!"); delete kvStore; diff --git a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_util.cpp b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_util.cpp index 3ae6e551aca148005d27b60bad54dfd71d102bc7..36e1509223347713675a12198b4150834e6f81b0 100644 --- a/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_util.cpp +++ b/kv_store/frameworks/jskitsimpl/distributedkvstore/src/js_util.cpp @@ -729,7 +729,6 @@ napi_status JSUtil::SetValue(napi_env env, const DistributedKv::Entry& in, napi_ } else { status = SetValue(env, Blob2VariantValue(in.value), vValue); } - status = SetValue(env, Blob2VariantValue(in.value), vValue); // Blob ASSERT((status == napi_ok), "invalid entry value", status); napi_set_named_property(env, value, "value", vValue); @@ -812,6 +811,7 @@ napi_status JSUtil::GetValue(napi_env env, napi_value jsValue, ValuesBucket &val for (size_t i = 0; i < arrLen; ++i) { napi_value jsKey = 0; status = napi_get_element(env, keys, i, &jsKey); + ASSERT((status == napi_ok), "no element", status); std::string key; JSUtil::GetValue(env, jsKey, key); napi_value valueJs = 0; @@ -847,7 +847,7 @@ napi_status JSUtil::GetValue(napi_env env, napi_value in, std::vector(entry.key.Data().begin() + 1, entry.key.Data().end()); + entry.key = std::vector(entry.key.Data().begin(), entry.key.Data().end()); if (hasSchema) { entry.value = std::vector(entry.value.Data().begin() + 1, entry.value.Data().end()); } diff --git a/kv_store/frameworks/libs/distributeddb/common/include/auto_launch.h b/kv_store/frameworks/libs/distributeddb/common/include/auto_launch.h index a2794eb96202242ae83091bc64591e417b3e0b3c..00075878d7ee04d78c4dad1750e358b6e6ccb0d7 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/auto_launch.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/auto_launch.h @@ -40,7 +40,7 @@ enum class AutoLaunchItemState { }; enum class DBType { - DB_KV = 0, + DB_KV = 1, DB_RELATION, DB_INVALID, }; @@ -164,7 +164,7 @@ protected: void TryCloseRelationConnection(AutoLaunchItem &autoLaunchItem); - void EraseAutoLauchItem(const std::string &identifier, const std::string &userId); + void EraseAutoLaunchItem(const std::string &identifier, const std::string &userId); void NotifyInvalidParam(const AutoLaunchItem &autoLaunchItem); diff --git a/kv_store/frameworks/libs/distributeddb/common/include/data_value.h b/kv_store/frameworks/libs/distributeddb/common/include/data_value.h index 27085aa7468f210d222f1651c1370d868016b46c..25a0ae4b714b7f390fd23fd9ad34e9a8b0fe0ce4 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/data_value.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/data_value.h @@ -75,7 +75,6 @@ public: int SetText(const uint8_t *val, uint32_t length); int GetText(std::string &outVal) const; void ResetValue(); - int GetBlobLength(uint32_t &length) const; std::string ToString() const; private: diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h b/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h index 5b4794fe5fa568eb81013035c9ec1e4926b9f363..532cfae9d07418584a895d266c7111db5d1d293f 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h @@ -109,6 +109,11 @@ public: static const std::string SYSTEM_TABLE_PREFIX; + // Prefix Key in meta db + static const std::string DEVICEID_PREFIX_KEY; + static const std::string QUERY_SYNC_PREFIX_KEY; + static const std::string DELETE_SYNC_PREFIX_KEY; + static constexpr uint32_t AUTO_SYNC_TIMEOUT = 5000; // 5s static constexpr uint32_t MANUAL_SYNC_TIMEOUT = 5000; // 5s @@ -150,6 +155,8 @@ public: static constexpr uint32_t MAX_CONDITION_KEY_LEN = 128; static constexpr uint32_t MAX_CONDITION_VALUE_LEN = 128; static constexpr uint32_t MAX_CONDITION_COUNT = 32; + + static constexpr uint32_t REMOTE_QUERY_MAX_SQL_LEN = 1000000U; }; } // namespace DistributedDB diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h b/kv_store/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h index cc4f40cd06587eca4b6c7a86fc6acf548c28643a..b1b67e048c2f494b39a605c6326c3b9c5d88c514 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/db_dfx_adapter.h @@ -33,7 +33,7 @@ struct ReportTask { std::string storeId; int errCode = 0; }; -class DBDfxAdapter { +class DBDfxAdapter final { public: static void Dump(int fd, const std::vector &args); diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h b/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h index 6df071c3d5b80ab4041ad2ce7747100372679d30..13a1098cc42bb0be2f621e2ca2ea7c388aa3a787 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h @@ -16,8 +16,6 @@ #ifndef DISTRIBUTEDDB_ERRNO_H #define DISTRIBUTEDDB_ERRNO_H -#include - namespace DistributedDB { constexpr int E_OK = 0; constexpr int E_BASE = 1000; // different from the other errno. diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_types.h b/kv_store/frameworks/libs/distributeddb/common/include/db_types.h index 656beaacae8717a1d56d17299a70c706b939ea6b..0ea4d305f46160f8e8c7b21f0adb60e81a463a7a 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/db_types.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/db_types.h @@ -138,7 +138,7 @@ struct SyncTimeRange { }; // field types stored in sqlite -enum class StorageType { +enum class StorageType : int32_t { STORAGE_TYPE_NONE = 0, STORAGE_TYPE_NULL, STORAGE_TYPE_INTEGER, diff --git a/kv_store/frameworks/libs/distributeddb/common/include/performance_analysis.h b/kv_store/frameworks/libs/distributeddb/common/include/performance_analysis.h index 1b0da052c1d39ad4eb4c324fd32d3d5b6a776b73..286fe4ac35a53a7e6f718e26b437f97c140767db 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/performance_analysis.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/performance_analysis.h @@ -69,11 +69,10 @@ struct SingleStatistics { class PerformanceAnalysis { public: - explicit PerformanceAnalysis(uint32_t step); - ~PerformanceAnalysis(); - static PerformanceAnalysis *GetInstance(int stepNum = 20); + void Initialization(); + void TimeRecordStart(); void TimeRecordEnd(); @@ -88,9 +87,12 @@ public: void ClosePerformanceAnalysis(); - void SetFileNumber(const std::string &FileID); + void SetFileName(const std::string &fileName); private: + explicit PerformanceAnalysis(uint32_t step); + + ~PerformanceAnalysis(); bool IsStepValid(uint32_t step) const; @@ -117,7 +119,7 @@ private: bool isOpen_; std::ofstream outFile; int fileNumber_; - std::string fileID_; + std::string fileName_; }; } // namespace DistributedDB #endif diff --git a/kv_store/frameworks/libs/distributeddb/common/include/platform_specific.h b/kv_store/frameworks/libs/distributeddb/common/include/platform_specific.h index 10d91822f80e8a3641a9daa9f6969e88261b96e2..6573bcf4402e6c20213e518fdc1fa3250cdf667b 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/platform_specific.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/platform_specific.h @@ -34,8 +34,8 @@ enum FileType { struct FileAttr { std::string fileName; - FileType fileType; - uint64_t fileLen; + FileType fileType = FileType::FILE; + uint64_t fileLen = 0; }; // Shield the representation method of file handles on different platforms diff --git a/kv_store/frameworks/libs/distributeddb/common/include/runtime_context.h b/kv_store/frameworks/libs/distributeddb/common/include/runtime_context.h index e504950ba36f849929cd2808a7ba746be1d455b4..85c22557ed5b0b51ffe6569b6cad0dd04bfe0f6d 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/runtime_context.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/runtime_context.h @@ -137,6 +137,8 @@ public: virtual int SetPermissionConditionCallback(const PermissionConditionCallback &callback) = 0; virtual std::map GetPermissionCheckParam(const DBProperties &properties) = 0; + + virtual void StopTaskPool() = 0; protected: RuntimeContext() = default; virtual ~RuntimeContext() {} diff --git a/kv_store/frameworks/libs/distributeddb/common/include/semaphore_utils.h b/kv_store/frameworks/libs/distributeddb/common/include/semaphore_utils.h index 9cdb3f561dc4bec5784670af7ab9c798b0dc957d..c5e96e24a228745abb7ed2e83e4295f1ae6b1150 100644 --- a/kv_store/frameworks/libs/distributeddb/common/include/semaphore_utils.h +++ b/kv_store/frameworks/libs/distributeddb/common/include/semaphore_utils.h @@ -16,8 +16,6 @@ #ifndef SEMAPHORE_UTILS_H #define SEMAPHORE_UTILS_H -#include -#include #include #include #include "macro_utils.h" diff --git a/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp b/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp index e7f7bc533b5a8ed002c4bd91782098cb81c9bb53..42cb31e6dce822aef930ca08af2c2d86f14a1e74 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp @@ -62,13 +62,13 @@ void AutoLaunch::SetCommunicatorAggregator(ICommunicatorAggregator *aggregator) errCode = aggregator->RegOnConnectCallback(std::bind(&AutoLaunch::OnlineCallBack, this, std::placeholders::_1, std::placeholders::_2), nullptr); if (errCode != E_OK) { - LOGW("[AutoLaunch] RegOnConnectCallback errCode:%d", errCode); + LOGE("[AutoLaunch] RegOnConnectCallback errCode:%d", errCode); } errCode = aggregator->RegCommunicatorLackCallback( std::bind(&AutoLaunch::ReceiveUnknownIdentifierCallBack, this, std::placeholders::_1, std::placeholders::_2), nullptr); if (errCode != E_OK) { - LOGW("[AutoLaunch] RegCommunicatorLackCallback errCode:%d", errCode); + LOGE("[AutoLaunch] RegCommunicatorLackCallback errCode:%d", errCode); } } @@ -205,7 +205,7 @@ int AutoLaunch::GetKVConnectionInEnable(AutoLaunchItem &autoLaunchItem, const st return E_OK; } if (autoLaunchItem.conn == nullptr) { - EraseAutoLauchItem(identifier, userId); + EraseAutoLaunchItem(identifier, userId); return errCode; } bool isEmpty = false; @@ -219,7 +219,7 @@ int AutoLaunch::GetKVConnectionInEnable(AutoLaunchItem &autoLaunchItem, const st errCode = KvDBManager::ReleaseDatabaseConnection(kvConn); if (errCode != E_OK) { LOGE("[AutoLaunch] GetKVConnectionInEnable ReleaseDatabaseConnection failed errCode:%d", errCode); - EraseAutoLauchItem(identifier, userId); + EraseAutoLaunchItem(identifier, userId); return errCode; } std::lock_guard autoLock(dataLock_); @@ -235,7 +235,7 @@ int AutoLaunch::GetKVConnectionInEnable(AutoLaunchItem &autoLaunchItem, const st } else { LOGE("[AutoLaunch] GetKVConnectionInEnable RegisterObserverAndLifeCycleCallback err, do CloseConnection"); TryCloseConnection(autoLaunchItem); // do nothing if failed - EraseAutoLauchItem(identifier, userId); + EraseAutoLaunchItem(identifier, userId); } return errCode; } @@ -384,11 +384,12 @@ void AutoLaunch::ObserverFunc(const KvDBCommitNotifyData ¬ifyData, const std: int AutoLaunch::DisableKvStoreAutoLaunch(const std::string &normalIdentifier, const std::string &dualTupleIdentifier, const std::string &userId) { - std::string identifier = (autoLaunchItemMap_.count(normalIdentifier) == 0) ? dualTupleIdentifier : normalIdentifier; - LOGI("[AutoLaunch] DisableKvStoreAutoLaunch identifier=%.6s", STR_TO_HEX(identifier)); + std::string identifier; AutoLaunchItem autoLaunchItem; { std::unique_lock autoLock(dataLock_); + identifier = (autoLaunchItemMap_.count(normalIdentifier) == 0) ? dualTupleIdentifier : normalIdentifier; + LOGI("[AutoLaunch] DisableKvStoreAutoLaunch identifier=%.6s", STR_TO_HEX(identifier)); if (autoLaunchItemMap_.count(identifier) == 0 || autoLaunchItemMap_[identifier].count(userId) == 0) { LOGE("[AutoLaunch] DisableKvStoreAutoLaunch identifier is not exist!"); return -E_NOT_FOUND; @@ -423,7 +424,7 @@ int AutoLaunch::DisableKvStoreAutoLaunch(const std::string &normalIdentifier, co return errCode; } - EraseAutoLauchItem(identifier, userId); + EraseAutoLaunchItem(identifier, userId); cv_.notify_all(); if (autoLaunchItem.isWriteOpenNotified && autoLaunchItem.notifier) { RuntimeContext::GetInstance()->ScheduleTask([autoLaunchItem] { CloseNotifier(autoLaunchItem); }); @@ -435,7 +436,6 @@ int AutoLaunch::DisableKvStoreAutoLaunch(const std::string &normalIdentifier, co void AutoLaunch::GetAutoLaunchSyncDevices(const std::string &identifier, std::vector &devices) const { devices.clear(); - devices.shrink_to_fit(); std::lock_guard autoLock(dataLock_); if (autoLaunchItemMap_.count(identifier) == 0) { LOGD("[AutoLaunch] GetSyncDevices identifier is not exist!"); @@ -444,6 +444,7 @@ void AutoLaunch::GetAutoLaunchSyncDevices(const std::string &identifier, std::ve for (const auto &device : onlineDevices_) { devices.push_back(device); } + devices.shrink_to_fit(); } void AutoLaunch::CloseNotifier(const AutoLaunchItem &autoLaunchItem) @@ -693,17 +694,20 @@ int AutoLaunch::ReceiveUnknownIdentifierCallBack(const LabelType &label, const s const std::string identifier(label.begin(), label.end()); // originalUserId size maybe 0 std::string userId = originalUserId; - if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 && - autoLaunchItemMap_[identifier].size() > 1) { - LOGE("[AutoLaunch] normal tuple mode userId larger than one userId"); - goto EXT; - } - if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 && - autoLaunchItemMap_[identifier].size() == 1) { - // normal tuple mode - userId = autoLaunchItemMap_[identifier].begin()->first; + { + std::lock_guard autoLock(dataLock_); + if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 && + autoLaunchItemMap_[identifier].size() > 1) { + LOGE("[AutoLaunch] normal tuple mode userId larger than one userId"); + goto EXT; + } + if (originalUserId.size() == 0 && autoLaunchItemMap_.count(identifier) != 0 && + autoLaunchItemMap_[identifier].size() == 1) { + // normal tuple mode + userId = autoLaunchItemMap_[identifier].begin()->first; + } + LOGI("[AutoLaunch] ReceiveUnknownIdentifierCallBack identifier=%.6s", STR_TO_HEX(identifier)); } - LOGI("[AutoLaunch] ReceiveUnknownIdentifierCallBack identifier=%.6s", STR_TO_HEX(identifier)); int errCode; { std::lock_guard autoLock(dataLock_); @@ -733,7 +737,6 @@ int AutoLaunch::ReceiveUnknownIdentifierCallBack(const LabelType &label, const s autoLaunchItemMap_[identifier][userId].state = AutoLaunchItemState::IDLE; } return errCode; - EXT: return AutoLaunchExt(identifier, userId); } @@ -1179,7 +1182,7 @@ void AutoLaunch::TryCloseRelationConnection(AutoLaunchItem &autoLaunchItem) } } -void AutoLaunch::EraseAutoLauchItem(const std::string &identifier, const std::string &userId) +void AutoLaunch::EraseAutoLaunchItem(const std::string &identifier, const std::string &userId) { std::lock_guard autoLock(dataLock_); autoLaunchItemMap_[identifier].erase(userId); diff --git a/kv_store/frameworks/libs/distributeddb/common/src/data_value.cpp b/kv_store/frameworks/libs/distributeddb/common/src/data_value.cpp index 8c8fd72916c81aee3e6738c6a18651b084c7ef47..99fc897dcbb66b061a7e7a2a8aa2fbf05c10fc65 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/data_value.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/data_value.cpp @@ -84,9 +84,7 @@ int Blob::WriteBlob(const uint8_t *ptrArray, const uint32_t &size) std::vector Blob::ToVector() const { - std::vector vec; - vec.insert(vec.end(), ptr_, ptr_ + size_); - return vec; + return std::vector(ptr_, ptr_ + size_); } DataValue::DataValue() : type_(StorageType::STORAGE_TYPE_NULL) @@ -319,15 +317,6 @@ StorageType DataValue::GetType() const return type_; } -int DataValue::GetBlobLength(uint32_t &length) const -{ - if (type_ != StorageType::STORAGE_TYPE_BLOB && type_ != StorageType::STORAGE_TYPE_TEXT) { - return -E_NOT_SUPPORT; - } - length = value_.blobPtr->GetSize(); - return E_OK; -} - void DataValue::ResetValue() { switch (type_) { diff --git a/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp b/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp index e650872bf2c8da750ee3a6d59b25c87339f3a049..3d95b3fb3ab39b727da257ac29a130198230986c 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp @@ -74,4 +74,8 @@ const std::string DBConstant::LOG_TABLE_VERSION_2 = "2.0"; const std::string DBConstant::LOG_TABLE_VERSION_CURRENT = "2.0"; const std::string DBConstant::LOG_TABLE_VERSION_KEY = "log_table_version"; + +const std::string DBConstant::DEVICEID_PREFIX_KEY = "deviceId"; +const std::string DBConstant::QUERY_SYNC_PREFIX_KEY = "querySync"; +const std::string DBConstant::DELETE_SYNC_PREFIX_KEY = "deleteSync"; } \ No newline at end of file diff --git a/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp b/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp index 6ffcc0ddd74780e210dbc655538c291b4cb6ea2d..8416a038433306c78e4bfcc170db2066900e074a 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp @@ -36,7 +36,8 @@ namespace { #ifdef USE_DFX_ABILITY constexpr uint64_t HITRACE_LABEL = HITRACE_TAG_DISTRIBUTEDDATA; #endif -constexpr const char *DUMP_PARAM = "dump-distributeddb"; +constexpr const char *DUMP_PARAM = "--database"; +constexpr const char *DUMP_PARAM_ABBR = "-d"; } const std::string DBDfxAdapter::EVENT_CODE = "ERROR_CODE"; @@ -52,10 +53,15 @@ void DBDfxAdapter::Dump(int fd, const std::vector &args) if (!args.empty()) { const std::u16string u16DumpParam = std::wstring_convert, char16_t> {}.from_bytes(DUMP_PARAM); + const std::u16string u16DumpParamAbbr = + std::wstring_convert, char16_t> {}.from_bytes(DUMP_PARAM_ABBR); + auto findAbbr = std::any_of(args.begin(), args.end(), [&u16DumpParamAbbr](const std::u16string &arg) { + return arg == u16DumpParamAbbr; + }); auto find = std::any_of(args.begin(), args.end(), [&u16DumpParam](const std::u16string &arg) { return arg == u16DumpParam; }); - if (!find) { + if (!find && !findAbbr) { return; } } diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_fd.h b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_fd.h new file mode 100644 index 0000000000000000000000000000000000000000..7700f867884357a70113b8d1e9b26cce84a56755 --- /dev/null +++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_fd.h @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef EVENT_FD_H +#define EVENT_FD_H + +#include "platform_specific.h" + +#if defined EVLOOP_TIMER_ONLY +using Handle = int; +static const int INVALID_HANDLE = -1; +#define IS_VALID_HANDLE(h) false +#define CLOSE_HANDLE(h) +#else +#include +using Handle = int; +static const int INVALID_HANDLE = -1; +#define IS_VALID_HANDLE(h) ((h) > 0) +#define CLOSE_HANDLE(h) do { close(h); } while (0) +#endif + +namespace DistributedDB { +class EventFd final { +public: + EventFd() : fd_(INVALID_HANDLE) {} + explicit EventFd(Handle handle) : fd_(handle) {} + + ~EventFd() + { + // we can't close it. + fd_ = INVALID_HANDLE; + } + + bool IsValid() const + { + return IS_VALID_HANDLE(fd_); + } + + operator Handle() const + { + return fd_; + } + + bool operator==(const EventFd &other) const + { + return other.fd_ == fd_; + } + + void Close() + { + if (IsValid()) { + CLOSE_HANDLE(fd_); + fd_ = INVALID_HANDLE; + } + } + +private: + Handle fd_; +}; +} + +#endif // EVENT_FD_H diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h index 48964b5585161d970ec98bacbbd29ce326d2fe11..da3eb074927a102f3427c524a5d1fbf1c43a0fc6 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h +++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_impl.h @@ -18,7 +18,7 @@ #include #include -#include "../include/ievent.h" +#include "ievent.h" namespace DistributedDB { class EventLoopImpl; diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp index 0cbd9b0075131cef278e0cad5cad4872e474245d..8df03cc6133cfc0d403a87df69aab4f992a70570 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.cpp @@ -98,7 +98,8 @@ private: }; EventLoopImpl::EventLoopImpl() - : pollingSetChanged_(false) + : pollingSetChanged_(false), + running_(true) { OnKill([this](){ OnKillLoop(); }); } @@ -166,7 +167,7 @@ int EventLoopImpl::Run() loopThread_ = std::this_thread::get_id(); } - int errCode; + int errCode = E_OK; IncObjRef(this); while (running_) { diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h index 68ea99599c8955d6f37ad04f007e25cb4eb0676b..2fc2c502677e87c3ffbe8c652c4ffe55a4820a45 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h +++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_impl.h @@ -20,8 +20,8 @@ #include #include #include "platform_specific.h" -#include "../include/ievent_loop.h" -#include "../include/ievent.h" +#include "ievent_loop.h" +#include "ievent.h" #if defined EVLOOP_TIMER_ONLY #define EVENT_LOOP_USE_SELECT @@ -80,7 +80,7 @@ private: std::set polling_; bool pollingSetChanged_; std::thread::id loopThread_; - volatile bool running_ = true; + volatile bool running_; }; } diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp index 361edfe06a508b0f66c45ec6e0d9d2f06b72e2a9..de28f3261902fdde49c55d6e97a0571889c63790 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent.cpp @@ -13,7 +13,8 @@ * limitations under the License. */ -#include "../include/ievent.h" +#include "ievent.h" + #include "db_errno.h" #include "event_impl.h" diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent.h b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent.h new file mode 100644 index 0000000000000000000000000000000000000000..ce66e008d2e3f738a8822252e62baf056fada165 --- /dev/null +++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef IEVENT_H +#define IEVENT_H + +#include "ref_object.h" +#include "macro_utils.h" +#include "event_fd.h" + +namespace DistributedDB { +using EventTime = int64_t; +using EventsMask = unsigned int; +using EventAction = std::function; +using EventFinalizer = std::function; + +class IEvent : public virtual RefObject { +public: + enum EventType { + ET_READ = 0x01, + ET_WRITE = 0x02, + ET_ERROR = 0x04, + ET_TIMEOUT = 0x08, + }; + + IEvent() = default; + DISABLE_COPY_ASSIGN_MOVE(IEvent); + + virtual int SetAction(const EventAction &action, const EventFinalizer &finalizer = nullptr) = 0; + virtual int AddEvents(EventsMask events) = 0; + virtual int RemoveEvents(EventsMask events) = 0; + virtual int SetTimeout(EventTime timeout) = 0; + virtual int Detach(bool wait) = 0; + virtual void IgnoreFinalizer() = 0; + + // The following 2 static methods is used to create real event objects, + // instead of an event object factory. + static IEvent *CreateEvent(EventTime timeout, int &errCode); + static IEvent *CreateEvent(EventFd fd, EventsMask events, EventTime timeout, int &errCode); + +protected: + virtual ~IEvent() {}; +}; +} + +#endif // IEVENT_H diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent_loop.h b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent_loop.h new file mode 100644 index 0000000000000000000000000000000000000000..cfb3805317635c5630cf825592d753a389e1c9d8 --- /dev/null +++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/ievent_loop.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef IEVENT_LOOP_H +#define IEVENT_LOOP_H + +#include "ref_object.h" +#include "macro_utils.h" + +namespace DistributedDB { +class IEvent; + +// Abstract of event loop. +class IEventLoop : public virtual RefObject { +public: + IEventLoop() = default; + + DISABLE_COPY_ASSIGN_MOVE(IEventLoop); + + // Add an event object to the loop. + virtual int Add(IEvent *event) = 0; + + // Remove an event object from the loop. + virtual int Remove(IEvent *event) = 0; + + // Run the loop. + virtual int Run() = 0; + + virtual int Stop() = 0; + + // Create a loop object. + static IEventLoop *CreateEventLoop(int &errCode); + +protected: + virtual ~IEventLoop() {}; +}; +} + +#endif // IEVENT_LOOP_H diff --git a/kv_store/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp b/kv_store/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp index 3f7ee9bd27ac612edfa230eeb0c96c39cf07dccb..276024c3d0334b7f5cd8aa4220792e550a163fd5 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/flatbuffer_schema.cpp @@ -241,9 +241,14 @@ int SchemaObject::FlatBufferSchema::VerifyFlatBufferValue(const RawValue &inValu } namespace { +struct BaseTypeNode { + reflection::BaseType type; + FieldType fieldType; +}; + FieldType MapFieldType(reflection::BaseType inType) { - std::map fieldTypeMap{ + static const BaseTypeNode baseTypeNodes[] = { {reflection::BaseType::Bool, FieldType::LEAF_FIELD_BOOL}, {reflection::BaseType::Byte, FieldType::LEAF_FIELD_INTEGER}, {reflection::BaseType::UByte, FieldType::LEAF_FIELD_INTEGER}, @@ -257,12 +262,12 @@ FieldType MapFieldType(reflection::BaseType inType) {reflection::BaseType::Double, FieldType::LEAF_FIELD_DOUBLE}, {reflection::BaseType::String, FieldType::LEAF_FIELD_STRING}, {reflection::BaseType::Vector, FieldType::LEAF_FIELD_ARRAY}, - {reflection::BaseType::Obj, FieldType::INTERNAL_FIELD_OBJECT}, + {reflection::BaseType::Obj, FieldType::INTERNAL_FIELD_OBJECT} }; - if (fieldTypeMap.count(inType) == 0) { - return FieldType::LEAF_FIELD_NULL; - } - return fieldTypeMap[inType]; + const auto &result = std::find_if(std::begin(baseTypeNodes), std::end(baseTypeNodes), [inType](const auto &node) { + return node.type == inType; + }); + return result == std::end(baseTypeNodes) ? FieldType::LEAF_FIELD_NULL : (*result).fieldType; } RawString CheckDollarDotAndSkipIt(RawString inPath) @@ -763,12 +768,12 @@ int CompareFieldCount(bool isRoot, uint32_t selfCount, uint32_t otherCount) { if (isRoot) { if (otherCount < selfCount) { - LOGW("[FBSchema][CompareRoot] RootFieldSize: %" PRu32 " vs %" PRu32, selfCount, otherCount); + LOGW("[FBSchema][CompareRoot] RootFieldSize: %" PRIu32 " vs %" PRIu32, selfCount, otherCount); return -E_SCHEMA_UNEQUAL_INCOMPATIBLE; } } else { if (selfCount != otherCount) { - LOGW("[FBSchema][CompareRoot] StructFieldSize: %" PRu32 " vs %" PRu32, selfCount, otherCount); + LOGW("[FBSchema][CompareRoot] StructFieldSize: %" PRIu32 " vs %" PRIu32, selfCount, otherCount); return -E_SCHEMA_UNEQUAL_INCOMPATIBLE; } } @@ -821,7 +826,8 @@ int CompareFieldInfo(const reflection::Field &selfField, const reflection::Field auto selfElementType = selfType->element(); auto otherElementType = otherType->element(); if (selfElementType != otherElementType) { - LOGE("[FBSchema][CompareField] ElementType diff:%" PRu32 " vs %" PRu32, selfElementType, otherElementType); + LOGE("[FBSchema][CompareField] ElementType diff:%" PRIu32 " vs %" PRIu32, selfElementType, + otherElementType); return -E_SCHEMA_UNEQUAL_INCOMPATIBLE; } } diff --git a/kv_store/frameworks/libs/distributeddb/common/src/json_object.cpp b/kv_store/frameworks/libs/distributeddb/common/src/json_object.cpp index 69594366bf5536caa696f5e3ef4b8c5e5a566886..06f497aefc339fba45d81a18a49e32ba30651fcd 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/json_object.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/json_object.cpp @@ -17,9 +17,7 @@ #include #include -#include #include -#include #include "db_errno.h" #include "log_print.h" @@ -329,7 +327,7 @@ int JsonObject::GetSubFieldPath(const FieldPath &inPath, std::set &ou std::vector subFields = valueNode.getMemberNames(); for (const auto &eachSubField : subFields) { FieldPath eachSubPath = inPath; - eachSubPath.push_back(eachSubField); + eachSubPath.emplace_back(eachSubField); outSubPath.insert(eachSubPath); } return E_OK; diff --git a/kv_store/frameworks/libs/distributeddb/common/src/notification_chain.cpp b/kv_store/frameworks/libs/distributeddb/common/src/notification_chain.cpp index 6477186937cb7dbe12c36283b8340a14f6b862ac..1bfecec6665030547b0c7e3bbd7f5dfb1019c46a 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/notification_chain.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/notification_chain.cpp @@ -187,7 +187,7 @@ int NotificationChain::ListenerChain::UnRegisterListener(Listener *listener, boo void NotificationChain::ListenerChain::BackupListenerSet(std::set &backupSet) const { for (auto listener : listenerSet_) { - listener->IncObjRef(listener); + RefObject::IncObjRef(listener); backupSet.insert(listener); } } diff --git a/kv_store/frameworks/libs/distributeddb/common/src/parcel.cpp b/kv_store/frameworks/libs/distributeddb/common/src/parcel.cpp index 815597416fac4d7b0f33071646184778e6420739..0041d37cf625260a5b3689286bf454a0fa0e3622 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/parcel.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/parcel.cpp @@ -524,6 +524,15 @@ uint32_t Parcel::GetMultiVerCommitsLen(const std::vector &co void Parcel::EightByteAlign() { + if (IsError()) { + LOGE("EightByteAlign already error"); + return; + } + if (BYTE_8_ALIGN(parcelLen_) > totalLen_) { + LOGE("byte 8 align failed"); + isError_ = true; + return; + } bufPtr_ += BYTE_8_ALIGN(parcelLen_) - parcelLen_; parcelLen_ = BYTE_8_ALIGN(parcelLen_); } diff --git a/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp b/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp index 94207bf3067e745c01fb5968713d78265568c21c..75e11259c98c5eeec81997b041aef69dc3252397 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp @@ -30,16 +30,20 @@ const std::string PerformanceAnalysis::DEFAULT_FILE_NAME = "default00"; PerformanceAnalysis *PerformanceAnalysis::GetInstance(int stepNum) { static PerformanceAnalysis inst(stepNum); + inst.Initialization(); return &inst; } PerformanceAnalysis::PerformanceAnalysis(uint32_t inStepNum) : isOpen_(false) { - if (inStepNum == 0) { - stepNum_ = 0; - } stepNum_ = inStepNum; + fileNumber_ = 0; + fileName_ = std::string(DEFAULT_FILE_NAME) + std::to_string(fileNumber_); +} + +void PerformanceAnalysis::Initialization() +{ counts_.resize(stepNum_); timeRecordData_.timeInfo.resize(stepNum_); stepTimeRecordInfo_.resize(stepNum_); @@ -51,8 +55,6 @@ PerformanceAnalysis::PerformanceAnalysis(uint32_t inStepNum) for (auto iter = counts_.begin(); iter != counts_.end(); ++iter) { *iter = 0; } - fileNumber_ = 0; - fileID_ = std::string(DEFAULT_FILE_NAME) + std::to_string(fileNumber_); } PerformanceAnalysis::~PerformanceAnalysis() {}; @@ -190,7 +192,7 @@ std::string PerformanceAnalysis::GetStatistics() void PerformanceAnalysis::OutStatistics() { - std::string addrStatistics = STATISTICAL_DATA_FILE_NAME_HEADER + fileID_ + CSV_FILE_EXTENSION; + std::string addrStatistics = STATISTICAL_DATA_FILE_NAME_HEADER + fileName_ + CSV_FILE_EXTENSION; outFile.open(addrStatistics, std::ios_base::app); if (!outFile.is_open()) { return; @@ -220,11 +222,11 @@ void PerformanceAnalysis::Clear() iter.min = ULLONG_MAX; iter.average = 0; } - fileID_ = std::string(DEFAULT_FILE_NAME) + std::to_string(fileNumber_); + fileName_ = std::string(DEFAULT_FILE_NAME) + std::to_string(fileNumber_); } -void PerformanceAnalysis::SetFileNumber(const std::string &FileID) +void PerformanceAnalysis::SetFileName(const std::string &fileName) { - fileID_ = FileID; + fileName_ = fileName; } } // namespace DistributedDB diff --git a/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp b/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp index bfd275a5e67641d703cea21a55d65d8b5f1fd02a..839d643b5588d013a835de7c3b2352f03394c909 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/platform_specific.cpp @@ -313,6 +313,11 @@ int OpenFile(const std::string &fileName, FileHandle &handle) int CloseFile(FileHandle &handle) { + if (handle.handle == -1) { + LOGI("[CloseFile] file handle is invalid!"); + return E_OK; + } + if (close(handle.handle) != 0) { LOGE("close file failed, errno:%d", errno); return -E_SYSTEM_API_FAIL; @@ -327,17 +332,13 @@ int FileLock(const FileHandle &handle, bool isBlock) LOGE("[FileLock] can not open file when lock it:[%d]", errno); return -E_SYSTEM_API_FAIL; } + // windows下的LockFile与Linux差异较大，先不替换 return E_OK; } int FileUnlock(FileHandle &handle) { - if (handle.handle == -1) { - LOGI("[FileUnlock] file handle is invalid!"); - return E_OK; - } - - return CloseFile(handle); + return E_OK; } #else namespace { @@ -455,6 +456,7 @@ int GetRealPath(const std::string &inOriPath, std::string &outRealPath) return E_OK; } +#ifndef RUNNING_ON_SIMULATED_ENV int GetCurrentSysTimeInMicrosecond(uint64_t &outTime) { struct timeval rawTime; @@ -467,6 +469,7 @@ int GetCurrentSysTimeInMicrosecond(uint64_t &outTime) static_cast(rawTime.tv_usec); return E_OK; } +#endif // RUNNING_ON_SIMULATED_ENV namespace { const uint64_t MULTIPLES_BETWEEN_MICROSECONDS_AND_NANOSECONDS = 1000; @@ -588,6 +591,10 @@ int OpenFile(const std::string &fileName, FileHandle &handle) int CloseFile(FileHandle &handle) { + if (handle.handle == -1) { + LOGI("[CloseFile] file handle is invalid!"); + return E_OK; + } if (close(handle.handle) != 0) { LOGE("close file failed, errno:%d", errno); return -E_SYSTEM_API_FAIL; @@ -635,7 +642,7 @@ int FileUnlock(FileHandle &handle) LOGE("Unlock file failed. errno:%d", errno); return -E_SYSTEM_API_FAIL; } - return CloseFile(handle); + return E_OK; } #endif } // namespace OS diff --git a/kv_store/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp b/kv_store/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp index 03db2eb0f285673b6c975cbe3aa55f93404a3767..285596f4f09c085275feaf38b71b5ce9fa789232 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/relational/prepared_stmt.cpp @@ -89,7 +89,7 @@ int PreparedStmt::Serialize(Parcel &parcel) const } } - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); if (parcel.IsError()) { return -E_PARSE_FAIL; } @@ -137,7 +137,10 @@ int PreparedStmt::DeSerialize(Parcel &parcel) } } - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); + if (parcel.IsError()) { + return -E_PARSE_FAIL; + } return E_OK; } } diff --git a/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_result_set_impl.cpp b/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_result_set_impl.cpp index cd361a07e1da2cfa2e5049a1158d3d53593b4afe..ecb7f55c5281fce255d2ee4779578535811019ef 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_result_set_impl.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_result_set_impl.cpp @@ -13,10 +13,10 @@ * limitations under the License. */ #ifdef RELATIONAL_STORE -#include "relational_result_set_impl.h" #include +#include "relational_result_set_impl.h" #include "kv_store_errno.h" namespace DistributedDB { diff --git a/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp b/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp index e602066006e94fc46ab81d3456c4bf6e042e9b2d..46a2bac72f2a2187d32028e4ade0fab424e0b85f 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_row_data_set.cpp @@ -79,7 +79,7 @@ int RelationalRowDataSet::Serialize(Parcel &parcel) const rowData->Serialize(parcel); }; - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); if (parcel.IsError()) { return -E_PARSE_FAIL; } @@ -118,7 +118,10 @@ int RelationalRowDataSet::DeSerialize(Parcel &parcel) } data_.push_back(rowData); } - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); + if (parcel.IsError()) { + return -E_PARSE_FAIL; + } return E_OK; }; diff --git a/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp b/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp index ca82ea7a6104c42c27bb04988e1055c553e41357..0ad6fd4a54510f96b8feb2f5a1f8b575ff96d47b 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp @@ -418,7 +418,6 @@ int TableInfo::CompareWithTableFields(const std::map &in auto itInTable = inTableFields.begin(); int errCode = -E_RELATIONAL_TABLE_EQUAL; while (itLocal != fields_.end() && itInTable != inTableFields.end()) { - LOGD("--> field name %s", itLocal->first.c_str()); if (itLocal->first == itInTable->first) { // Same field if (!itLocal->second.CompareWithField(itInTable->second, isLite)) { // Compare field LOGW("[Relational][Compare] Table field is incompatible"); // not compatible @@ -560,8 +559,6 @@ int TableInfo::CompareWithLiteTableFields(const std::map int TableInfo::CompareWithLiteSchemaTable(const TableInfo &liteTableInfo) const { - LOGE("--> check table primary key, %d %d %d", primaryKey_.empty(), liteTableInfo.GetPrimaryKey().empty(), autoInc_); - if (!liteTableInfo.GetPrimaryKey().empty() && (primaryKey_.at(0) != "rowid") && liteTableInfo.GetPrimaryKey() != primaryKey_) { LOGE("[Relational][Compare] Table primary key is not same"); diff --git a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp index 073681bc912a82146ac441f0dc485c757ecec4ba..022ff75a83f8bc353094a2936b7c400e0cebd887 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp @@ -21,7 +21,7 @@ namespace DistributedDB { RuntimeContext *RuntimeContext::GetInstance() { - // static char instMemory[sizeof(RuntimeContextImpl)]; + static char instMemory[sizeof(RuntimeContextImpl)]; static std::mutex instLock_; static std::atomic instPtr = nullptr; // For Double-Checked Locking, we need check insPtr twice @@ -30,7 +30,7 @@ RuntimeContext *RuntimeContext::GetInstance() if (instPtr == nullptr) { // Use instMemory to make sure this singleton not free before other object. // This operation needn't to malloc memory, we needn't to check nullptr. - instPtr = new RuntimeContextImpl; + instPtr = new (instMemory) RuntimeContextImpl; LOGI("DistributedDB Version : %s", SOFTWARE_VERSION_STRING.c_str()); } } diff --git a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp index d2b30e81c1170a607ba99856da5ba98f575d41e5..8398c979b1f0b460c6b4364776d2c7b71687cc43 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp @@ -393,9 +393,8 @@ int RuntimeContextImpl::RunPermissionCheck(const PermissionCheckParam ¶m, ui } if (checkResult) { return E_OK; - } else { - return -E_NOT_PERMIT; } + return -E_NOT_PERMIT; } int RuntimeContextImpl::EnableKvStoreAutoLaunch(const KvDBProperties &properties, AutoLaunchNotifier notifier, @@ -539,11 +538,17 @@ int RuntimeContextImpl::GetSecurityOption(const std::string &filePath, SecurityO bool RuntimeContextImpl::CheckDeviceSecurityAbility(const std::string &devId, const SecurityOption &option) const { - std::lock_guard autoLock(systemApiAdapterLock_); - if (systemApiAdapter_ == nullptr) { - return true; + std::shared_ptr tempSystemApiAdapter = nullptr; + { + std::lock_guard autoLock(systemApiAdapterLock_); + if (systemApiAdapter_ == nullptr) { + LOGI("[CheckDeviceSecurityAbility] security not set"); + return true; + } + tempSystemApiAdapter = systemApiAdapter_; } - return systemApiAdapter_->CheckDeviceSecurityAbility(devId, option); + + return tempSystemApiAdapter->CheckDeviceSecurityAbility(devId, option); } int RuntimeContextImpl::SetProcessSystemApiAdapter(const std::shared_ptr &adapter) @@ -718,4 +723,14 @@ std::map RuntimeContextImpl::GetPermissionCheckParam(c } return permissionConditionCallback_(param); } + +void RuntimeContextImpl::StopTaskPool() +{ + std::lock_guard autoLock(taskLock_); + if (taskPool_ != nullptr) { + taskPool_->Stop(); + TaskPool::Release(taskPool_); + taskPool_ = nullptr; + } +} } // namespace DistributedDB diff --git a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.h b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.h index 7ee478543f1d4e8a663e0cbe52a847c100552710..e79d23eee3db91ab9ccfcff3a0139bb23817a405 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.h +++ b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.h @@ -21,8 +21,8 @@ #include #include "auto_launch.h" -#include "evloop/include/ievent.h" -#include "evloop/include/ievent_loop.h" +#include "evloop/src/ievent.h" +#include "evloop/src/ievent_loop.h" #include "icommunicator_aggregator.h" #include "lock_status_observer.h" #include "task_pool.h" @@ -125,6 +125,8 @@ public: int SetPermissionConditionCallback(const PermissionConditionCallback &callback) override; std::map GetPermissionCheckParam(const DBProperties &properties) override; + + void StopTaskPool() override; private: static constexpr int MAX_TP_THREADS = 10; // max threads of the task pool. static constexpr int MIN_TP_THREADS = 1; // min threads of the task pool. diff --git a/kv_store/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp b/kv_store/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp index e1669b7f7487619e5a464d8aeb4cbe2430ed7fbe..82325e7c574f930fbd91d6a625b146266a2ae7a5 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/schema_negotiate.cpp @@ -213,12 +213,12 @@ int SchemaNegotiate::SerializeData(const RelationalSyncOpinion &opinions, Parcel (void)parcel.WriteString(MAGIC); (void)parcel.WriteUInt32(SYNC_OPINION_VERSION); (void)parcel.WriteUInt32(static_cast(opinions.size())); - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); for (const auto &it : opinions) { (void)parcel.WriteString(it.first); (void)parcel.WriteUInt32(it.second.permitSync); (void)parcel.WriteUInt32(it.second.requirePeerConvert); - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); } return parcel.IsError() ? -E_INVALID_ARGS : E_OK; } @@ -242,7 +242,7 @@ int SchemaNegotiate::DeserializeData(Parcel &parcel, RelationalSyncOpinion &opin } uint32_t opinionSize; (void)parcel.ReadUInt32(opinionSize); - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); static const uint32_t MAX_OPINION_SIZE = 1024; // max 1024 opinions if (parcel.IsError() || opinionSize > MAX_OPINION_SIZE) { return -E_INVALID_ARGS; @@ -257,7 +257,7 @@ int SchemaNegotiate::DeserializeData(Parcel &parcel, RelationalSyncOpinion &opin uint32_t requirePeerConvert; (void)parcel.ReadUInt32(requirePeerConvert); tableOpinion.requirePeerConvert = static_cast(requirePeerConvert); - (void)parcel.EightByteAlign(); + parcel.EightByteAlign(); opinion[tableName] = tableOpinion; } return parcel.IsError() ? -E_INVALID_ARGS : E_OK; diff --git a/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp b/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp index 14048fc12f4441730d6137df9300ab421a70892e..489bc22128438451d7a5bcbb6a3bef54adca8be5 100644 --- a/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp +++ b/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp @@ -330,10 +330,10 @@ int SchemaObject::VerifyValue(ValueSource sourceType, const RawValue &inValue) c } RawValue rawValue; + std::vector cache; if (schemaSkipSize_ % SchemaConstant::SECURE_BYTE_ALIGN == 0) { rawValue = {inValue.first + schemaSkipSize_, inValue.second - schemaSkipSize_}; } else { - std::vector cache; cache.assign(inValue.first + schemaSkipSize_, inValue.first + inValue.second); rawValue = {cache.data(), cache.size()}; } diff --git a/kv_store/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h b/kv_store/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h index 30ca55f93cf29aecb48df41b115b33eca8e391ac..c3a31cdc1271b90bd2d3680f78464a12bb4bee26 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/include/communicator_aggregator.h @@ -16,20 +16,20 @@ #ifndef COMMUNICATORAGGREGATOR_H #define COMMUNICATORAGGREGATOR_H +#include +#include +#include #include #include #include -#include #include -#include -#include -#include "iadapter.h" -#include "parse_result.h" -#include "icommunicator.h" #include "frame_combiner.h" #include "frame_retainer.h" -#include "send_task_scheduler.h" +#include "iadapter.h" +#include "icommunicator.h" #include "icommunicator_aggregator.h" +#include "parse_result.h" +#include "send_task_scheduler.h" namespace DistributedDB { // Forward Declarations @@ -83,8 +83,8 @@ public: // Called by communicator to make itself really in work void ActivateCommunicator(const LabelType &commLabel); - // SerialBuffer surely is heap memory, CreateSendTask responsible for lifecycle - int CreateSendTask(const std::string &dstTarget, SerialBuffer *inBuff, FrameType inType, + // SerialBuffer surely is heap memory, ScheduleSendTask responsible for lifecycle + int ScheduleSendTask(const std::string &dstTarget, SerialBuffer *inBuff, FrameType inType, const TaskConfig &inConfig, const OnSendEnd &onEnd = nullptr); static void EnableCommunicatorNotFoundFeedback(bool isEnable); diff --git a/kv_store/frameworks/libs/distributeddb/communicator/include/frame_combiner.h b/kv_store/frameworks/libs/distributeddb/communicator/include/frame_combiner.h index 33124c497c406cbd976f569d8614838d7af6e688..d1ec81f82671369e3cfbdaee5aea45d27b8db7e6 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/include/frame_combiner.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/include/frame_combiner.h @@ -16,20 +16,20 @@ #ifndef FRAME_COMBINER_H #define FRAME_COMBINER_H +#include #include #include -#include -#include "semaphore_utils.h" +#include "combine_status.h" #include "macro_utils.h" #include "parse_result.h" -#include "combine_status.h" #include "runtime_context.h" +#include "semaphore_utils.h" namespace DistributedDB { class SerialBuffer; // Forward Declarations struct CombineWork { - SerialBuffer *buffer; + SerialBuffer *buffer = nullptr; CombineStatus status; ParseResult frameInfo; }; diff --git a/kv_store/frameworks/libs/distributeddb/communicator/include/frame_retainer.h b/kv_store/frameworks/libs/distributeddb/communicator/include/frame_retainer.h index 259007369b33411447f08540796833d1b75c028e..a0b144087082fcda0f754da9890f2dbc5fdaee5d 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/include/frame_retainer.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/include/frame_retainer.h @@ -27,16 +27,16 @@ namespace DistributedDB { class SerialBuffer; // Forward Declarations struct FrameInfo { - SerialBuffer *buffer; + SerialBuffer *buffer = nullptr; std::string srcTarget; LabelType commLabel; - uint32_t frameId; + uint32_t frameId = 0u; }; struct RetainWork { - SerialBuffer *buffer; - uint32_t frameId; - uint32_t remainTime; // in second + SerialBuffer *buffer = nullptr; + uint32_t frameId = 0u; + uint32_t remainTime = 0u; // in second }; class FrameRetainer { diff --git a/kv_store/frameworks/libs/distributeddb/communicator/include/iadapter.h b/kv_store/frameworks/libs/distributeddb/communicator/include/iadapter.h index f238114ca4b16f8c80e900dfa7e09465bfe47c02..d68916fa6cbbb99dbef38d2d1f6b250e993adc3e 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/include/iadapter.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/include/iadapter.h @@ -16,10 +16,10 @@ #ifndef IADAPTER_H #define IADAPTER_H -#include #include #include #include +#include #include "communicator_type_define.h" #include "iprocess_communicator.h" diff --git a/kv_store/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h b/kv_store/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h index ee5c59dfda2febf2acba05f9bc6a86cf63eaf89b..06ae9e7c1e91e74188cf57540be44690eb309fe8 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/include/icommunicator_aggregator.h @@ -17,9 +17,9 @@ #define ICOMMUNICATORAGGREGATOR_H #include +#include "communicator_type_define.h" #include "iadapter.h" #include "ref_object.h" -#include "communicator_type_define.h" namespace DistributedDB { class ICommunicator; // Forward Declaration diff --git a/kv_store/frameworks/libs/distributeddb/communicator/include/parse_result.h b/kv_store/frameworks/libs/distributeddb/communicator/include/parse_result.h index 0e1278821a1492a77cf03e5780ac876fcb4a60ec..99d0cebd6137e708a567e4d7fc116d7f5a4c7729 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/include/parse_result.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/include/parse_result.h @@ -16,8 +16,8 @@ #ifndef PARSE_RESULT_H #define PARSE_RESULT_H -#include #include +#include #include "communicator_type_define.h" namespace DistributedDB { diff --git a/kv_store/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h b/kv_store/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h index 8c1e3e12ec32d62d6dd55ad06ba06e00473b05fa..0725474062a4a2efc4239b2ef34b10ce39aa90d1 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/include/send_task_scheduler.h @@ -16,14 +16,14 @@ #ifndef SEND_TASK_SCHEDULER_H #define SEND_TASK_SCHEDULER_H -#include +#include #include +#include #include -#include #include -#include -#include "macro_utils.h" +#include #include "communicator_type_define.h" +#include "macro_utils.h" namespace DistributedDB { enum class TargetPolicy { @@ -34,14 +34,14 @@ enum class TargetPolicy { class SerialBuffer; // Forward Declaration struct SendTask { - SerialBuffer *buffer; + SerialBuffer *buffer = nullptr; std::string dstTarget; OnSendEnd onEnd; }; struct SendTaskInfo { - bool delayFlag; - Priority taskPrio; + bool delayFlag = false; + Priority taskPrio = Priority::LOW; }; using TaskListByTarget = std::map>; diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.cpp index e5c97f4126738d07594a7101a7fe5464d81b48c3..04b818e8185f8eb0e625d4d64315ad4f8fd87a52 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.cpp +++ b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.cpp @@ -116,7 +116,7 @@ int Communicator::SendMessage(const std::string &dstTarget, const Message *inMsg } int error = E_OK; // if error is not E_OK , null pointer will be returned - SerialBuffer *buffer = ProtocolProto::ToSerialBuffer(inMsg, error, extendHandle, false); + SerialBuffer *buffer = ProtocolProto::ToSerialBuffer(inMsg, extendHandle, false, error); extendHandle = nullptr; if (error != E_OK) { LOGE("[Comm][Send] Serial fail, label=%s, error=%d.", VEC_TO_STR(commLabel_), error); @@ -131,7 +131,7 @@ int Communicator::SendMessage(const std::string &dstTarget, const Message *inMsg } TaskConfig taskConfig {config.nonBlock, config.timeout, inMsg->GetPriority()}; - errCode = commAggrHandle_->CreateSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, taskConfig, onEnd); + errCode = commAggrHandle_->ScheduleSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, taskConfig, onEnd); if (errCode == E_OK) { // if ok, free inMsg, otherwise the caller should take over inMsg delete inMsg; @@ -226,7 +226,7 @@ void Communicator::TriggerVersionNegotiation(const std::string &dstTarget) } TaskConfig config{true, 0, Priority::HIGH}; - errCode = commAggrHandle_->CreateSendTask(dstTarget, buffer, FrameType::EMPTY, config); + errCode = commAggrHandle_->ScheduleSendTask(dstTarget, buffer, FrameType::EMPTY, config); if (errCode != E_OK) { LOGE("[Comm][TrigVer] Send empty frame fail, errCode=%d", errCode); // if send fails, free buffer, otherwise buffer will be taked over by comminucator aggregator @@ -259,7 +259,7 @@ void Communicator::TriggerUnknownMessageFeedback(const std::string &dstTarget, M } TaskConfig config{true, 0, Priority::HIGH}; - errCode = commAggrHandle_->CreateSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config); + errCode = commAggrHandle_->ScheduleSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config); if (errCode != E_OK) { LOGE("[Comm][TrigFeedback] Send unknown message feedback frame fail, errCode=%d", errCode); // if send fails, free buffer, otherwise buffer will be taked over by comminucator aggregator diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.h b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.h index c1f2ce39d4a8139905cfa57a6acf19e31b0e90be..fd9436ddfa66735c52262ada5bfd6d6382608d0f 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.h +++ b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator.h @@ -16,16 +16,16 @@ #ifndef COMMUNICATOR_H #define COMMUNICATOR_H -#include -#include #include -#include +#include #include #include -#include -#include "serial_buffer.h" -#include "icommunicator.h" +#include +#include +#include #include "communicator_aggregator.h" +#include "icommunicator.h" +#include "serial_buffer.h" namespace DistributedDB { class Communicator : public ICommunicator { diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp index c3b3df30e9000313d9f0f210cd8dad6e65a2b904..3cb9f9aab447e1014d37bdebba8e481af0ac4e28 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp +++ b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp @@ -15,11 +15,12 @@ #include "communicator_aggregator.h" -#include "hash.h" +#include #include "communicator.h" #include "communicator_linker.h" #include "db_common.h" #include "endian_convert.h" +#include "hash.h" #include "log_print.h" #include "protocol_proto.h" @@ -278,7 +279,7 @@ void DoOnSendEndByTaskIfNeed(const OnSendEnd &onEnd, int result) } } -int CommunicatorAggregator::CreateSendTask(const std::string &dstTarget, SerialBuffer *inBuff, +int CommunicatorAggregator::ScheduleSendTask(const std::string &dstTarget, SerialBuffer *inBuff, FrameType inType, const TaskConfig &inConfig, const OnSendEnd &onEnd) { if (inBuff == nullptr) { @@ -316,7 +317,7 @@ int CommunicatorAggregator::CreateSendTask(const std::string &dstTarget, SerialB std::lock_guard wakingLockGuard(wakingMutex_); wakingSignal_ = true; wakingCv_.notify_one(); - LOGI("[CommAggr][Create] Exit ok, thread=%s, frameId=%u", GetThreadId().c_str(), info.frameId); // Delete In Future + LOGI("[CommAggr][Create] Exit ok, thread=%s, frameId=%u", GetThreadId().c_str(), info.frameId); return E_OK; } @@ -341,9 +342,9 @@ void CommunicatorAggregator::SendDataRoutine() while (!shutdown_) { if (scheduler_.GetNoDelayTaskCount() == 0) { std::unique_lock wakingUniqueLock(wakingMutex_); - LOGI("[CommAggr][Routine] Send done and sleep."); // Delete In Future + LOGI("[CommAggr][Routine] Send done and sleep."); wakingCv_.wait(wakingUniqueLock, [this] { return this->wakingSignal_; }); - LOGI("[CommAggr][Routine] Send continue."); // Delete In Future + LOGI("[CommAggr][Routine] Send continue."); wakingSignal_ = false; continue; } @@ -364,7 +365,7 @@ void CommunicatorAggregator::SendDataRoutine() } // > std::vector>> eachPacket; - if (piecePackets.size() == 0) { + if (piecePackets.empty()) { // Case that no need to split a frame, just use original buffer as a packet std::pair tmpEntry = taskToSend.buffer->GetReadOnlyBytesForEntireBuffer(); std::pair> entry; @@ -390,8 +391,8 @@ void CommunicatorAggregator::SendPacketsAndDisposeTask(const SendTask &inTask, bool taskNeedFinalize = true; int errCode = E_OK; for (auto &entry : eachPacket) { - LOGI("[CommAggr][SendPackets] DoSendBytes, dstTarget=%s{private}, extendHeadLength=%u, totalLength=%u.", - inTask.dstTarget.c_str(), entry.second.first, entry.second.second); + LOGI("[CommAggr][SendPackets] DoSendBytes, dstTarget=%s{private}, extendHeadLength=%" PRIu32 + ", totalLength=%" PRIu32 ".", inTask.dstTarget.c_str(), entry.second.first, entry.second.second); ProtocolProto::DisplayPacketInformation(entry.first + entry.second.first, entry.second.second); errCode = adapterHandle_->SendBytes(inTask.dstTarget, entry.first, entry.second.second); if (errCode == -E_WAIT_RETRY) { @@ -477,7 +478,7 @@ void CommunicatorAggregator::NotifySendableToAllCommunicator() void CommunicatorAggregator::OnBytesReceive(const std::string &srcTarget, const uint8_t *bytes, uint32_t length, const std::string &userId) { - ProtocolProto::DisplayPacketInformation(bytes, length); // For debug, delete in the future + ProtocolProto::DisplayPacketInformation(bytes, length); ParseResult packetResult; int errCode = ProtocolProto::CheckAndParsePacket(srcTarget, bytes, length, packetResult); if (errCode != E_OK) { @@ -534,10 +535,7 @@ void CommunicatorAggregator::OnTargetChange(const std::string &target, bool isCo LOGE("[CommAggr][OnTarget] TargetOnline fail, target=%s{private}, errCode=%d.", target.c_str(), errCode); } } else { - int errCode = commLinker_->TargetOffline(target, relatedLabels); - if (errCode != E_OK) { - LOGE("[CommAggr][OnTarget] TargetOffline fail, target=%s{private}, errCode=%d.", target.c_str(), errCode); - } + commLinker_->TargetOffline(target, relatedLabels); } // All related communicator online or offline this target, no matter TargetOnline or TargetOffline fail or not std::lock_guard commMapLockGuard(commMapMutex_); @@ -780,7 +778,7 @@ void CommunicatorAggregator::GenerateLocalSourceId() // The localSourceId is std::atomic, so there is no concurrency risk uint64_t identityHash = Hash::HashFunc(identity); if (identityHash != localSourceId_) { - LOGI("[CommAggr][GenSrcId] identity=%s{private}, localSourceId=%llu.", identity.c_str(), ULL(identityHash)); + LOGI("[CommAggr][GenSrcId] identity=%s{private}, localSourceId=%" PRIu64, identity.c_str(), ULL(identityHash)); } localSourceId_ = identityHash; } @@ -806,7 +804,7 @@ void CommunicatorAggregator::TriggerVersionNegotiation(const std::string &dstTar } TaskConfig config{true, 0, Priority::HIGH}; - errCode = CreateSendTask(dstTarget, buffer, FrameType::EMPTY, config); + errCode = ScheduleSendTask(dstTarget, buffer, FrameType::EMPTY, config); if (errCode != E_OK) { LOGE("[CommAggr][TrigVer] Send empty frame fail, errCode=%d", errCode); // if send fails, free buffer, otherwise buffer will be taked over by SendTaskScheduler @@ -858,10 +856,10 @@ void CommunicatorAggregator::TriggerCommunicatorNotFoundFeedback(const std::stri } TaskConfig config{true, 0, Priority::HIGH}; - errCode = CreateSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config); + errCode = ScheduleSendTask(dstTarget, buffer, FrameType::APPLICATION_MESSAGE, config); if (errCode != E_OK) { LOGE("[CommAggr][TrigNotFound] Send communicator not found feedback frame fail, errCode=%d", errCode); - // if send fails, free buffer, otherwise buffer will be taked over by CreateSendTask + // if send fails, free buffer, otherwise buffer will be taked over by ScheduleSendTask delete buffer; buffer = nullptr; } diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp index 41cbd01c74627e900fe58d3f3213e36e20cbbc55..ba17b2c0eb30cf81cd4a9a8dff9ef5d94956f069 100644 --- a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp +++ b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp @@ -14,12 +14,12 @@ */ #include "communicator_linker.h" -#include "hash.h" +#include "communicator_aggregator.h" #include "db_errno.h" +#include "hash.h" #include "log_print.h" -#include "protocol_proto.h" #include "platform_specific.h" -#include "communicator_aggregator.h" +#include "protocol_proto.h" namespace DistributedDB { namespace { @@ -51,7 +51,7 @@ void CommunicatorLinker::Initialize() } std::string curTimeStr = std::to_string(curTime); localDistinctValue_ = Hash::HashFunc(curTimeStr); - LOGI("[Linker][Init] curTime=%llu, distinct=%llu.", ULL(curTime), ULL(localDistinctValue_)); + LOGI("[Linker][Init] curTime=%" PRIu64 ", distinct=%" PRIu64 ".", ULL(curTime), ULL(localDistinctValue_)); } // Create async task to send out label_exchange and waiting for label_exchange_ack. @@ -73,7 +73,7 @@ int CommunicatorLinker::TargetOnline(const std::string &inTarget, std::set