From 3f1ea8ac2785edfe310b1bd316a985476f65deef Mon Sep 17 00:00:00 2001 From: caochuan Date: Mon, 17 Apr 2023 13:34:46 +0800 Subject: [PATCH 1/5] feat: add notify interface Signed-off-by: caochuan --- bundle.json | 6 +- interfaces/inner_api/file_access/BUILD.gn | 50 +++++++ .../observer/file_access_observer_proxy.h | 37 +++++ .../observer/file_access_observer_service.h | 97 +++++++++++++ .../observer/file_access_observer_stub.h | 42 ++++++ .../include/observer/ifile_observer_base.h | 40 ++++++ .../include/observer/iobserver_callback.h | 35 +++++ .../observer/observer_callback_proxy.h | 35 +++++ .../include/observer/observer_callback_stub.h | 42 ++++++ .../observer/file_access_observer_proxy.cpp | 124 ++++++++++++++++ .../observer/file_access_observer_service.cpp | 87 ++++++++++++ .../observer/file_access_observer_stub.cpp | 132 ++++++++++++++++++ .../src/observer/observer_callback_proxy.cpp | 77 ++++++++++ .../src/observer/observer_callback_stub.cpp | 80 +++++++++++ sa_profile/5010.xml | 24 ++++ sa_profile/BUILD.gn | 20 +++ 16 files changed, 927 insertions(+), 1 deletion(-) create mode 100644 interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h create mode 100644 interfaces/inner_api/file_access/include/observer/file_access_observer_service.h create mode 100644 interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h create mode 100644 interfaces/inner_api/file_access/include/observer/ifile_observer_base.h create mode 100644 interfaces/inner_api/file_access/include/observer/iobserver_callback.h create mode 100644 interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h create mode 100644 interfaces/inner_api/file_access/include/observer/observer_callback_stub.h create mode 100644 interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp create mode 100644 interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp create mode 100644 interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp create mode 100644 interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp create mode 100644 interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp create mode 100755 sa_profile/5010.xml create mode 100644 sa_profile/BUILD.gn diff --git a/bundle.json b/bundle.json index 6ceec5fd..18f5bd37 100644 --- a/bundle.json +++ b/bundle.json @@ -24,6 +24,8 @@ "components": [ "ability_base", "ability_runtime", + "ability_tools", + "access_token", "hiviewdfx", "ipc", "relational_store", @@ -41,7 +43,9 @@ "//foundation/filemanagement/user_file_service/interfaces/inner_api/file_access:file_access_extension_ability_module", "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_access_module:fileaccess", "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_access_ext_ability:fileaccessextensionability_napi", - "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_extension_info_module:fileextensioninfo" + "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_extension_info_module:fileextensioninfo", + "//foundation/filemanagement/user_file_service/interfaces/inner_api/file_access:file_access_observer", + "//foundation/filemanagement/user_file_service/sa_profile:observer_sa_profile" ], "base_group": [] } , diff --git a/interfaces/inner_api/file_access/BUILD.gn b/interfaces/inner_api/file_access/BUILD.gn index 2deb848a..1cc6e376 100644 --- a/interfaces/inner_api/file_access/BUILD.gn +++ b/interfaces/inner_api/file_access/BUILD.gn @@ -37,6 +37,7 @@ config("ability_public_config") { visibility = [ ":*" ] include_dirs = [ "include", + "include/observer", "${user_file_service_path}/utils", "${ability_runtime_kits_path}/appkit/native/ability_runtime/app", "${ability_runtime_kits_path}/appkit/native/app/include", @@ -70,6 +71,7 @@ ohos_shared_library("file_access_extension_ability_kit") { ] deps = [ + ":file_access_observer", "${ability_runtime_path}/frameworks/native/appkit:app_context", "${access_token_path}/interfaces/innerkits/accesstoken:libtokenid_sdk", ] @@ -98,6 +100,54 @@ ohos_shared_library("file_access_extension_ability_kit") { innerapi_tags = [ "platformsdk" ] } +ohos_shared_library("file_access_observer") { + include_dirs = [ + "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/context", + "//foundation/communication/ipc/ipc/native/src/napi/include", + ] + + sources = [ + "src/observer/file_access_observer_proxy.cpp", + "src/observer/file_access_observer_service.cpp", + "src/observer/file_access_observer_stub.cpp", + "src/observer/observer_callback_proxy.cpp", + "src/observer/observer_callback_stub.cpp", + ] + configs = [ ":ability_config" ] + + public_configs = [ + ":ability_public_config", + "${ability_runtime_path}/frameworks/native/ability:ability_context_public_config", + ] + + deps = [ + "${ability_runtime_path}/frameworks/native/appkit:app_context", + "${access_token_path}/interfaces/innerkits/accesstoken:libtokenid_sdk", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:extensionkit_native", + "ability_runtime:napi_common", + "ability_runtime:runtime", + "access_token:libaccesstoken_sdk", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "hitrace_native:hitrace_meter", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "multimedia_image_framework:image_native", + "napi:ace_napi", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + subsystem_name = "filemanagement" + part_name = "user_file_service" +} + ohos_shared_library("file_access_extension_ability_module") { sources = [ "src/file_access_ext_ability_module_loader.cpp" ] diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h new file mode 100644 index 00000000..129fa2ca --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2023 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 FILE_ACCESS_OBSERVER_PROXY_H +#define FILE_ACCESS_OBSERVER_PROXY_H + +#include "ifile_observer_base.h" +#include "iremote_broker.h" +#include "iremote_proxy.h" + +namespace OHOS { +namespace FileAccessFwk { +using Uri = OHOS::Uri; +class FileAccessObserverProxy : public IRemoteProxy { +public: + explicit FileAccessObserverProxy(const sptr& impl) : IRemoteProxy(impl) {} + ~FileAccessObserverProxy() = default; + int32_t RegisterNotify(Uri uri, const sptr &observer, bool notifyForDescendants) override; + int32_t UnregisterNotify(const sptr &observer) override; +private: + static inline BrokerDelegator delegator_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_ACCESS_OBSERVER_PROXY_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h new file mode 100644 index 00000000..b1eaca61 --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2023 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 FILE_ACCESS_OBSERVER_SERVICE_H +#define FILE_ACCESS_OBSERVER_SERVICE_H + +#include +#include +#include +#include + +#include "file_access_observer_stub.h" +#include "iremote_object.h" +#include "image_source.h" +#include "js_native_api_types.h" +#include "uri.h" + +namespace OHOS { +namespace FileAccessFwk { +using namespace Media; + +#define DECLARE_DELAYED_STATS_SP_SINGLETON(MyClass) \ +public: \ + ~MyClass(); \ +private: \ + friend DelayedStatsSpSingleton; \ + MyClass(); \ + +template +class DelayedStatsSpSingleton : public NoCopyable { +public: + static sptr GetInstance(); + static void DestroyInstance(); + +private: + static sptr instance_; + static std::mutex mutex_; +}; + +template +sptr DelayedStatsSpSingleton::instance_ = nullptr; + +template +std::mutex DelayedStatsSpSingleton::mutex_; + +template +sptr DelayedStatsSpSingleton::GetInstance() +{ + if (!instance_) { + std::lock_guard lock(mutex_); + if (instance_ == nullptr) { + instance_ = new T(); + } + } + + return instance_; +} + +template +void DelayedStatsSpSingleton::DestroyInstance() +{ + std::lock_guard lock(mutex_); + if (instance_) { + instance_.clear(); + instance_ = nullptr; + } +} + +class FileAccessObserverService final : public SystemAbility, public FileAccessObserverStub { + DECLARE_SYSTEM_ABILITY(FileAccessObserverService) + DECLARE_DELAYED_STATS_SP_SINGLETON(FileAccessObserverService); + +public: + virtual void OnStart() override; + virtual void OnStop() override; + int32_t RegisterNotify(Uri uri, const sptr &observer, bool notifyForDescendants) override; + int32_t UnregisterNotify(const sptr &observer) override; + int32_t Dump(int32_t fd, const std::vector& args) override; + bool IsServiceReady() const; +private: + bool ready_ = false; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_ACCESS_OBSERVER_SERVICE_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h new file mode 100644 index 00000000..75c0749f --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2023 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 FILE_ACCESS_OBSERVER_STUB_H +#define FILE_ACCESS_OBSERVER_STUB_H + +#include +#include + +#include "ifile_observer_base.h" +#include "iremote_stub.h" +#include "message_option.h" +#include "message_parcel.h" +#include "refbase.h" + +namespace OHOS { +namespace FileAccessFwk { +class FileAccessObserverStub : public IRemoteStub { +public: + FileAccessObserverStub() = default; + virtual ~FileAccessObserverStub() = default; + int32_t OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; + int32_t RegisterNotifyStub(MessageParcel &data, MessageParcel &reply); + int32_t UnregisterNotifyStub(MessageParcel &data, MessageParcel &reply); +private: + int32_t ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option); +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_ACCESS_OBSERVER_STUB_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h b/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h new file mode 100644 index 00000000..f80701ac --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2023 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 I_FILE_OBSERVER_BASE_H +#define I_FILE_OBSERVER_BASE_H + +#include "iremote_broker.h" +#include "iremote_object.h" +#include "iobserver_callback.h" +#include "uri.h" + +namespace OHOS { +namespace FileAccessFwk { +using Uri = OHOS::Uri; +class IFileObserverBase : public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.FileAccessFwk.IFileAccessObserverBase"); +public: + enum { + CMD_REGISTER_NOTIFY = 0, + CMD_UNREGISTER_NOTIFY + }; + virtual int32_t RegisterNotify(Uri uri, const sptr &observer, bool notifyForDescendants) = 0; + virtual int32_t UnregisterNotify(const sptr &observer) = 0; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // I_FILE_OBSERVER_BASE_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/include/observer/iobserver_callback.h b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h new file mode 100644 index 00000000..a6bd5baf --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2023 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 I_FILE_ACCESS_OBSERVER_H +#define I_FILE_ACCESS_OBSERVER_H + +#include "iremote_broker.h" +#include "iremote_object.h" + +namespace OHOS { +namespace FileAccessFwk { +class IFileAccessObserver : public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.FileAccessFwk.IFileAccessObserver"); +public: + enum { + CMD_ONCHANGE = 0 + }; + virtual void OnChange(std::string message) = 0; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // I_FILE_ACCESS_OBSERVER_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h new file mode 100644 index 00000000..a975ee4d --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2023 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 OBSERVER_CALLBACK_PROXY_H +#define OBSERVER_CALLBACK_PROXY_H + +#include "iobserver_callback.h" +#include "iremote_broker.h" +#include "iremote_proxy.h" + +namespace OHOS { +namespace FileAccessFwk { +class ObserverCallbackProxy : public IRemoteProxy { +public: + explicit ObserverCallbackProxy(const sptr& impl) : IRemoteProxy(impl) {} + ~ObserverCallbackProxy() = default; + void OnChange(std::string message) override; +private: + static inline BrokerDelegator delegator_; +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // OBSERVER_CALLBACK_PROXY_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h new file mode 100644 index 00000000..7b24aafa --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2023 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 OBSERVER_CALLBACK_STUB_H +#define OBSERVER_CALLBACK_STUB_H + +#include +#include + +#include "iobserver_callback.h" +#include "iremote_stub.h" +#include "message_option.h" +#include "message_parcel.h" +#include "refbase.h" + +namespace OHOS { +namespace FileAccessFwk { +class ObserverCallbackStub : public IRemoteStub { +public: + ObserverCallbackStub() = default; + virtual ~ObserverCallbackStub() = default; + int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; + void OnChange(std::string message) override {} +private: + int32_t OnChangeStub(MessageParcel &data, MessageParcel &reply); + int32_t ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option); +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // OBSERVER_CALLBACK_STUB_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp new file mode 100644 index 00000000..1cf2bfbe --- /dev/null +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2023 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 "file_access_observer_proxy.h" + +#include "file_access_framework_errno.h" +#include "hilog_wrapper.h" +#include "hitrace_meter.h" +#include "ipc_types.h" +#include "message_option.h" +#include "message_parcel.h" + +namespace OHOS { +namespace FileAccessFwk { +int32_t FileAccessObserverProxy::RegisterNotify(Uri uri, const sptr &observer, + bool notifyForDescendants) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify"); + MessageParcel data; + if (!data.WriteInterfaceToken(FileAccessObserverProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (!data.WriteParcelable(&uri)) { + HILOG_ERROR("fail to WriteParcelable uri"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (!data.WriteRemoteObject(observer->AsObject())) { + HILOG_ERROR("fail to WriteRemoteObject observer"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (!data.WriteBool(notifyForDescendants)) { + HILOG_ERROR("fail to WriteBool notifyForDescendants"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_REGISTER_NOTIFY, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest. err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return err; + } + + int ret = E_IPCS; + if (!reply.ReadInt32(ret)) { + HILOG_ERROR("fail to ReadInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (ret != ERR_OK) { + HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +int32_t FileAccessObserverProxy::UnregisterNotify(const sptr &observer) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotify"); + MessageParcel data; + if (!data.WriteInterfaceToken(FileAccessObserverProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (!data.WriteRemoteObject(observer->AsObject())) { + HILOG_ERROR("fail to WriteRemoteObject observer"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_UNREGISTER_NOTIFY, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest. err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return err; + } + + int ret = E_IPCS; + if (!reply.ReadInt32(ret)) { + HILOG_ERROR("fail to ReadInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (ret != ERR_OK) { + HILOG_ERROR("UnregisterNotify operation failed ret : %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} +} // namespace FileAccessFwk +} // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp new file mode 100644 index 00000000..cdbdf15b --- /dev/null +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2023 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 "file_access_observer_service.h" + +#include + +#include "file_access_framework_errno.h" +#include "hilog_wrapper.h" +#include "hitrace_meter.h" +#include "system_ability_definition.h" + +namespace OHOS { +namespace FileAccessFwk { +namespace { +auto pms = DelayedStatsSpSingleton::GetInstance(); +const bool G_REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(pms.GetRefPtr()); +} +FileAccessObserverService::FileAccessObserverService() : SystemAbility(FILE_MANAGER_SERVICE_ID, true) {} +FileAccessObserverService::~FileAccessObserverService() {} + +void FileAccessObserverService::OnStart() +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnStart"); + if (!Publish(DelayedStatsSpSingleton::GetInstance())) { + HILOG_ERROR("OnStart register to system ability manager failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + ready_ = true; + return; +} + +void FileAccessObserverService::OnStop() +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnStop"); + if (!ready_) { + HILOG_ERROR("OnStop is not ready, nothing to do"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + ready_ = false; +} + +int32_t FileAccessObserverService::Dump(int32_t fd, const std::vector& args) +{ + return 0; +} + +bool FileAccessObserverService::IsServiceReady() const +{ + return ready_; +} + +int32_t FileAccessObserverService::RegisterNotify(Uri uri, const sptr &observer, + bool notifyForDescendants) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify"); + if (observer == nullptr) { + HILOG_ERROR("RegisterNotify failed with invalid observer"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +int32_t FileAccessObserverService::UnregisterNotify(const sptr &observer) +{ + return ERR_OK; +} +} +} \ No newline at end of file diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp new file mode 100644 index 00000000..6cb2357b --- /dev/null +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2023 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 "file_access_observer_stub.h" + +#include +#include + +#include "access_token.h" +#include "accesstoken_kit.h" +#include "file_access_framework_errno.h" +#include "hilog_wrapper.h" +#include "hitrace_meter.h" +#include "ipc_object_stub.h" +#include "ipc_skeleton.h" +#include "ipc_types.h" +#include "message_parcel.h" +#include "uri.h" + +namespace OHOS { +namespace FileAccessFwk { +int32_t FileAccessObserverStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, + MessageOption& option) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnRemoteRequest"); + std::u16string descriptor = FileAccessObserverStub::GetDescriptor(); + std::u16string remoteDescriptor = data.ReadInterfaceToken(); + if (descriptor != remoteDescriptor) { + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_INVALID_STATE; + } + int ret = ChooseCodeStub(code, data, reply, option); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; +} + +int32_t FileAccessObserverStub::ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, + MessageOption &option) +{ + int32_t ret; + switch (code) { + case static_cast(IFileObserverBase::CMD_REGISTER_NOTIFY): { + ret = RegisterNotifyStub(data, reply); + break; + } + case static_cast(IFileObserverBase::CMD_UNREGISTER_NOTIFY): { + ret = UnregisterNotifyStub(data, reply); + break; + } + default: { + ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); + break; + } + } + return ret; +} + +int32_t FileAccessObserverStub::RegisterNotifyStub(MessageParcel &data, MessageParcel &reply) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotifyStub"); + std::shared_ptr uri(data.ReadParcelable()); + if (uri == nullptr) { + HILOG_ERROR("RegisterNotify uri is nullptr"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_URIS; + } + + sptr obj = data.ReadRemoteObject(); + if (obj == nullptr) { + HILOG_INFO("get remote obj fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + sptr observer = iface_cast(obj); + if (observer == nullptr) { + HILOG_INFO("get observer fail"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + bool notifyForDescendants = data.ReadBool(); + int ret = RegisterNotify(*uri, observer, notifyForDescendants); + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("Parameter RegisterNotify fail to WriteInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +int32_t FileAccessObserverStub::UnregisterNotifyStub(MessageParcel &data, MessageParcel &reply) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotifyStub"); + sptr obj = data.ReadRemoteObject(); + if (obj == nullptr) { + HILOG_INFO("get remote obj fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + sptr observer = iface_cast(obj); + if (observer == nullptr) { + HILOG_INFO("get observer fail"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = UnregisterNotify(observer); + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("Parameter UnregisterNotify fail to WriteInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} +} +} \ No newline at end of file diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp new file mode 100644 index 00000000..2645db65 --- /dev/null +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2023 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 "observer_callback_proxy.h" + +#include "file_access_framework_errno.h" +#include "hilog_wrapper.h" +#include "hitrace_meter.h" +#include "ipc_types.h" +#include "message_option.h" +#include "message_parcel.h" + +namespace OHOS { +namespace FileAccessFwk { +void ObserverCallbackProxy::OnChange(std::string message) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChange"); + MessageParcel data; + if (!data.WriteInterfaceToken(ObserverCallbackProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + + if (!data.WriteString(message)) { + HILOG_ERROR("fail to WriteBool notifyForDescendants"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_ONCHANGE, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest. err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + + int ret = E_IPCS; + if (!reply.ReadInt32(ret)) { + HILOG_ERROR("fail to ReadInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + + if (ret != ERR_OK) { + HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + + std::string messageTemp; + if (!reply.ReadString(messageTemp)) { + HILOG_ERROR("fail to ReadString message"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; + } + + message = messageTemp; + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return; +} +} // namespace FileAccessFwk +} // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp new file mode 100644 index 00000000..b9808fa4 --- /dev/null +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2023 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 "observer_callback_stub.h" + +#include +#include + +#include "access_token.h" +#include "accesstoken_kit.h" +#include "file_access_framework_errno.h" +#include "hilog_wrapper.h" +#include "hitrace_meter.h" +#include "ipc_object_stub.h" +#include "ipc_skeleton.h" +#include "ipc_types.h" +#include "message_parcel.h" + +namespace OHOS { +namespace FileAccessFwk { +int ObserverCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, + MessageOption& option) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnRemoteRequest"); + std::u16string descriptor = ObserverCallbackStub::GetDescriptor(); + std::u16string remoteDescriptor = data.ReadInterfaceToken(); + if (descriptor != remoteDescriptor) { + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_INVALID_STATE; + } + int ret = ChooseCodeStub(code, data, reply, option); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; +} + +int32_t ObserverCallbackStub::ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, + MessageOption &option) +{ + int32_t ret; + switch (code) { + case static_cast(IFileAccessObserver::CMD_ONCHANGE): { + ret = OnChangeStub(data, reply); + break; + } + default: { + ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); + break; + } + } + return ret; +} + +int32_t ObserverCallbackStub::OnChangeStub(MessageParcel &data, MessageParcel &reply) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChangeStub"); + std::string message; + if (!data.ReadString(message)) { + HILOG_ERROR("Parameter OnChangeStub fail to ReadString message"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + OnChange(message); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} +} +} \ No newline at end of file diff --git a/sa_profile/5010.xml b/sa_profile/5010.xml new file mode 100755 index 00000000..f649a1b7 --- /dev/null +++ b/sa_profile/5010.xml @@ -0,0 +1,24 @@ + + + + foundation + + 5010 + libfile_access_observer.z.so + false + false + 1 + + \ No newline at end of file diff --git a/sa_profile/BUILD.gn b/sa_profile/BUILD.gn new file mode 100644 index 00000000..f8a27c25 --- /dev/null +++ b/sa_profile/BUILD.gn @@ -0,0 +1,20 @@ +# Copyright (c) 2023 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/ohos/sa_profile/sa_profile.gni") +import("//foundation/filemanagement/user_file_service/filemanagement_aafwk.gni") + +ohos_sa_profile("observer_sa_profile") { + sources = [ "5010.xml" ] + part_name = "user_file_service" +} \ No newline at end of file -- Gitee From d0a7bfe9d14e07e0daf53ab5d6077da5468066f9 Mon Sep 17 00:00:00 2001 From: caochuan Date: Fri, 28 Apr 2023 14:04:07 +0800 Subject: [PATCH 2/5] add: observer change Signed-off-by: caochuan Signed-off-by: CaoChuan --- .../js/napi/file_access_module/BUILD.gn | 8 +- .../napi_fileaccess_helper.cpp | 154 +++++++++++++++++- .../napi_fileaccess_helper.h | 2 + .../napi_observer_callback.cpp | 111 +++++++++++++ .../napi_observer_callback.h | 68 ++++++++ interfaces/inner_api/file_access/BUILD.gn | 5 +- .../file_access/include/file_access_helper.h | 15 ++ .../observer/file_access_observer_common.h | 84 ++++++++++ .../observer/file_access_observer_proxy.h | 5 +- .../observer/file_access_observer_service.h | 6 +- .../observer/file_access_observer_stub.h | 1 + .../include/observer/ifile_observer_base.h | 8 +- .../include/observer/iobserver_callback.h | 5 +- .../observer/observer_callback_proxy.h | 6 + .../include/observer/observer_callback_stub.h | 8 +- .../file_access/libfile_access_observer.map | 26 +++ .../file_access/src/file_access_helper.cpp | 75 +++++++++ .../observer/file_access_observer_proxy.cpp | 62 ++++++- .../observer/file_access_observer_service.cpp | 44 ++++- .../observer/file_access_observer_stub.cpp | 24 ++- .../src/observer/observer_callback_proxy.cpp | 45 +++++ .../src/observer/observer_callback_stub.cpp | 28 +++- 22 files changed, 769 insertions(+), 21 deletions(-) create mode 100644 frameworks/js/napi/file_access_module/napi_observer_callback.cpp create mode 100644 frameworks/js/napi/file_access_module/napi_observer_callback.h create mode 100644 interfaces/inner_api/file_access/include/observer/file_access_observer_common.h create mode 100644 interfaces/inner_api/file_access/libfile_access_observer.map diff --git a/frameworks/js/napi/file_access_module/BUILD.gn b/frameworks/js/napi/file_access_module/BUILD.gn index 8d37402d..1a2eca98 100644 --- a/frameworks/js/napi/file_access_module/BUILD.gn +++ b/frameworks/js/napi/file_access_module/BUILD.gn @@ -34,13 +34,18 @@ ohos_shared_library("fileaccess") { "file_info/napi_file_info_exporter.cpp", "file_info/napi_file_iterator_exporter.cpp", "napi_fileaccess_helper.cpp", + "napi_observer_callback.cpp", "napi_utils.cpp", "native_fileaccess_module.cpp", "root_info/napi_root_info_exporter.cpp", "root_info/napi_root_iterator_exporter.cpp", ] - deps = [ "${user_file_service_path}/interfaces/inner_api/file_access:file_access_extension_ability_kit" ] + deps = [ + "${user_file_service_path}/interfaces/inner_api/file_access:file_access_extension_ability_kit", + "${user_file_service_path}/interfaces/inner_api/file_access:file_access_observer", + "//foundation/ability/ability_runtime/frameworks/js/napi/inner/napi_common:napi_common", + ] external_deps = [ "ability_base:want", @@ -52,6 +57,7 @@ ohos_shared_library("fileaccess") { "common_event_service:cesfwk_innerkits", "file_api:filemgmt_libn", "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", "multimedia_image_framework:image", ] } diff --git a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp index 9fc199b4..add25018 100644 --- a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp +++ b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp @@ -28,6 +28,7 @@ #include "napi_base_context.h" #include "napi_common_fileaccess.h" #include "napi_file_info_exporter.h" +#include "napi_observer_callback.h" #include "napi_root_iterator_exporter.h" #include "pixel_map_napi.h" #include "root_iterator_entity.h" @@ -223,6 +224,7 @@ napi_value NAPI_GetFileAccessAbilityInfo(napi_env env, napi_callback_info info) napi_value FileAccessHelperInit(napi_env env, napi_value exports) { + //描述 napi_property_descriptor properties[] = { DECLARE_NAPI_FUNCTION("openFile", NAPI_OpenFile), DECLARE_NAPI_FUNCTION("mkDir", NAPI_Mkdir), @@ -236,7 +238,9 @@ napi_value FileAccessHelperInit(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("access", NAPI_Access), DECLARE_NAPI_FUNCTION("getFileInfoFromUri", NAPI_GetFileInfoFromUri), DECLARE_NAPI_FUNCTION("getFileInfoFromRelativePath", NAPI_GetFileInfoFromRelativePath), - DECLARE_NAPI_FUNCTION("getThumbnail", NAPI_GetThumbnail) + DECLARE_NAPI_FUNCTION("getThumbnail", NAPI_GetThumbnail), + DECLARE_NAPI_FUNCTION("on", NAPI_RegisterObserver), + DECLARE_NAPI_FUNCTION("off", NAPI_UnregisterObserver) }; napi_value cons = nullptr; NAPI_CALL(env, @@ -256,6 +260,7 @@ napi_value FileAccessHelperInit(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("createFileAccessHelper", NAPI_CreateFileAccessHelper), DECLARE_NAPI_FUNCTION("getFileAccessAbilityInfo", NAPI_GetFileAccessAbilityInfo), }; + //定义 暴露方法 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(export_properties) / sizeof(export_properties[0]), export_properties)); return exports; @@ -1198,5 +1203,152 @@ napi_value NAPI_GetThumbnail(napi_env env, napi_callback_info info) } return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; } + +struct FileObserverCallbackWrapper { + sptr callback; +}; +napi_value NAPI_RegisterObserver(napi_env env, napi_callback_info info) +{ + HILOG_ERROR("cjw enter NAPI_RegisterObserver"); + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::THREE)) { + NError(EINVAL).ThrowErr(env); + return nullptr; + } + + bool succ = false; + bool notifyDesc = false; + std::unique_ptr uriPtr; + std::tie(succ, uriPtr, std::ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); + if (!succ) { + NError(EINVAL).ThrowErr(env, "succ false"); + return nullptr; + } + std::tie(succ, notifyDesc) = NVal(env, funcArg[NARG_POS::SECOND]).ToBool(); + if (!succ) { + NError(EINVAL).ThrowErr(env, "get desc false"); + return nullptr; + } + + napi_value napiCallback = funcArg[NARG_POS::THIRD]; + if (!NVal(env, napiCallback).TypeIs(napi_function)) { + NError(EINVAL).ThrowErr(env, "Argument must be function"); + return nullptr; + } + std::shared_ptr observer = std::make_shared(env, napiCallback); + sptr callback = new (std::nothrow) NapiObserverCallback(observer); + if (callback == nullptr) { + NError(EINVAL).ThrowErr(env, "new NapiNotifyCallback fail."); + return nullptr; + } + + auto finalize = [](napi_env env, void *data, void *hint) { + FileObserverCallbackWrapper *observerWrapper = static_cast(data); + if (observerWrapper != nullptr) { + delete observerWrapper; + } + }; + std::unique_ptr observerWrapper = std::make_unique(); + observerWrapper->callback = callback; + if (napi_wrap(env, napiCallback, observerWrapper.get(), finalize, nullptr, nullptr) != napi_ok) { + //finalize(env, createResult.first.get(), nullptr); + HILOG_ERROR("cjw napi_wrap error"); + } + observerWrapper.release(); + + + FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + if (fileAccessHelper == nullptr) { + NError(EINVAL).ThrowErr(env, "fileAccessHelper is nullptr."); + return nullptr; + } + HILOG_ERROR("cjw call fileAccessHelper register"); + std::string uriString(uriPtr.get()); + OHOS::Uri uri(uriString); + auto retCode = fileAccessHelper->RegisterNotify(uri, notifyDesc, callback); + if (retCode != ERR_OK) { + NError(retCode).ThrowErr(env, "FileAccessHelper::On fail."); + return nullptr; + } + return NVal::CreateUndefined(env).val_; + + // std::string uriString(uriPtr.get()); + // HILOG_ERROR("cjw call fileAccessHelper register"); + // auto cbExec = [fileAccessHelper, uriString, notifyDesc, callback]() -> NError { + // OHOS::Uri uri(uriString); + // int ret = fileAccessHelper->RegisterNotify(uri, notifyDesc, callback); + // return NError(ret); + // }; + + // auto cbComplete = [](napi_env env, NError err) -> NVal { + // if (err) { + // return { env, err.GetNapiErr(env) }; + // } + // return NVal::CreateUndefined(env); + // }; + // const std::string procedureName = "on"; + // NVal thisVar(env, funcArg.GetThisVar()); + // NVal cb(env, funcArg[NARG_POS::THIRD]); + // if (!cb.TypeIs(napi_function)) { + // NError(EINVAL).ThrowErr(env); + // return nullptr; + // } + // return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; +} + +napi_value NAPI_UnregisterObserver(napi_env env, napi_callback_info info) +{ + HILOG_ERROR("cjw enter NAPI_UnregisterObserver"); + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::TWO)) { + NError(EINVAL).ThrowErr(env); + return nullptr; + } + + bool succ = false; + std::unique_ptr uriPtr; + std::tie(succ, uriPtr, std::ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String(); + if (!succ) { + NError(EINVAL).ThrowErr(env, "succ false"); + return nullptr; + } + std::string uriString(uriPtr.get()); + OHOS::Uri uri(uriString); + + napi_value napiCallback = funcArg[NARG_POS::SECOND]; + if (!NVal(env, napiCallback).TypeIs(napi_function)) { + NError(EINVAL).ThrowErr(env, "Argument must be function"); + return nullptr; + } + + FileObserverCallbackWrapper *observerWrapper = nullptr; + if (napi_unwrap(env, napiCallback, (void **)&observerWrapper) != napi_ok) { + HILOG_ERROR("Faild to get fileAccessHelper"); + return nullptr; + } + if (observerWrapper != nullptr) { + HILOG_ERROR("CJW observerWrapper IS null"); + } + + // std::shared_ptr observer = std::make_shared(env, napiCallback); + // sptr callback = new (std::nothrow) NapiObserverCallback(observer); + // if (callback == nullptr) { + // NError(EINVAL).ThrowErr(env, "new NapiNotifyCallback fail."); + // return nullptr; + // } + + FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); + if (fileAccessHelper == nullptr) { + NError(EINVAL).ThrowErr(env, "Get FileAccessHelper fail"); + return nullptr; + } + + auto retCode = fileAccessHelper->UnregisterNotify(uri, observerWrapper->callback); + if (retCode != ERR_OK) { + NError(retCode).ThrowErr(env, "FileAccessHelper::Off fail."); + return nullptr; + } + return NVal::CreateUndefined(env).val_; +} } // namespace FileAccessFwk } // namespace OHOS diff --git a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.h b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.h index 209bbc0f..851f0301 100644 --- a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.h +++ b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.h @@ -37,6 +37,8 @@ namespace FileAccessFwk { napi_value NAPI_GetFileInfoFromUri(napi_env env, napi_callback_info info); napi_value NAPI_GetFileInfoFromRelativePath(napi_env env, napi_callback_info info); napi_value NAPI_GetThumbnail(napi_env env, napi_callback_info info); + napi_value NAPI_RegisterObserver(napi_env env, napi_callback_info info); + napi_value NAPI_UnregisterObserver(napi_env env, napi_callback_info info); } // namespace FileAccessFwk } // namespace OHOS #endif // NAPI_FILEACCESS_HELPER_H diff --git a/frameworks/js/napi/file_access_module/napi_observer_callback.cpp b/frameworks/js/napi/file_access_module/napi_observer_callback.cpp new file mode 100644 index 00000000..2a975d5a --- /dev/null +++ b/frameworks/js/napi/file_access_module/napi_observer_callback.cpp @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2023 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 "napi_observer_callback.h" + +#include + +#include "n_val.h" +#include "uv.h" + +using namespace OHOS::FileManagement::LibN; +namespace OHOS { +namespace FileAccessFwk { +namespace { + const int ARGS_ONE = 1; +} + +NapiObserver::NapiObserver(napi_env env, napi_value callback) +{ + env_ = env; + napi_create_reference(env_, callback, 1, &cbOnRef_); + napi_get_uv_event_loop(env_, &loop_); +} + +NapiObserver::~NapiObserver() +{ + napi_delete_reference(env_, cbOnRef_); +} + +void NapiObserver::OnChange(std::string message) +{ + HILOG_ERROR("cjw napi2 message = %{public}s", message.c_str()); + uv_work_t* work = new uv_work_t(); + if (work == nullptr) { + HILOG_ERROR("failed to new uv_work_t"); + return; + } + CallbackParam* param = new CallbackParam(this, message); + if (param == nullptr) { + HILOG_ERROR("failed to new param"); + delete work; + return; + } + work->data = param; + int ret = uv_queue_work(loop_, work, + [](uv_work_t *work) {}, + [](uv_work_t *work, int status) { + CallbackParam *param = reinterpret_cast(work->data); + napi_handle_scope scope = nullptr; + // 打开handle scope用于管理napi_value的生命周期，否则会内存泄漏 + napi_open_handle_scope(param->napiObserver_->env_, &scope); + if (scope == nullptr) { + HILOG_ERROR("napi_open_handle_scope failed"); + return; + } + + NVal napiNotifyMessage = NVal::CreateObject(param->napiObserver_->env_); + napiNotifyMessage.AddProp("message", + NVal::CreateUTF8String(param->napiObserver_->env_, param->message_).val_); + + napi_value callback = nullptr; + napi_value args[ARGS_ONE] = {napiNotifyMessage.val_}; + napi_get_reference_value(param->napiObserver_->env_, param->napiObserver_->cbOnRef_, &callback); + napi_value global = nullptr; + napi_get_global(param->napiObserver_->env_, &global); + napi_value result = nullptr; + napi_status ret = napi_call_function(param->napiObserver_->env_, global, callback, ARGS_ONE, args, &result); + if (ret != napi_ok) { + HILOG_ERROR("Notify failed, status:%{public}d.", ret); + } + // 关闭handle scope释放napi_value + napi_close_handle_scope(param->napiObserver_->env_, scope); + delete param; + delete work; + }); + if (ret != 0) { + delete (CallbackParam *)(work->data); + work->data = nullptr; + delete work; + work = nullptr; + return; + } + + return; +} + +bool NapiObserverCallback::Equal(void *observer) +{ + HILOG_ERROR("cjw Equal Napi"); + auto napiObserver = static_cast(observer); + auto name = napiObserver->className_; + HILOG_ERROR("cjw Equal classname = %{public}s", name.c_str()); + if (this->observer_->cbOnRef_ != napiObserver->observer_->cbOnRef_) { + return false; + } + return true; +} +} // namespace FileAccessFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/file_access_module/napi_observer_callback.h b/frameworks/js/napi/file_access_module/napi_observer_callback.h new file mode 100644 index 00000000..911cf861 --- /dev/null +++ b/frameworks/js/napi/file_access_module/napi_observer_callback.h @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2023 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 NAPI_OBSERVER_CALLBACK_H +#define NAPI_OBSERVER_CALLBACK_H + +#include "file_access_framework_errno.h" +#include "hilog_wrapper.h" +#include "observer_callback_stub.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" +#include "napi/native_api.h" +#include "uri.h" + +namespace OHOS { +namespace FileAccessFwk { +class NapiObserver { +public: + NapiObserver(napi_env env, napi_value callback); + virtual ~NapiObserver(); + //void OnChange(std::string message, const napi_ref cbRef); + void OnChange(std::string message); + napi_ref cbOnRef_ = nullptr; +private: + struct CallbackParam { + NapiObserver *napiObserver_; + std::string message_; + CallbackParam(NapiObserver *napiObserver, std::string message) : + napiObserver_(napiObserver), message_(message) {} + }; + napi_env env_; + uv_loop_s *loop_ = nullptr; +}; + +class NapiObserverCallback : public ObserverCallbackStub { +public: + NapiObserverCallback(std::shared_ptr observer): observer_(observer){} + virtual ~NapiObserverCallback() {} + void OnChange(std::string message) override + { + observer_->OnChange(message); + } + + std::string GetClassName() override + { + return className_; + } + bool Equal(void *observer) override; + std::shared_ptr observer_ =nullptr; +private: + std::string className_ = "NapiObserverCallback"; +}; + +} // namespace FileAccessFwk +} // namespace OHOS +#endif // NAPI_OBSERVER_CALLBACK_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/BUILD.gn b/interfaces/inner_api/file_access/BUILD.gn index 1cc6e376..7ef99529 100644 --- a/interfaces/inner_api/file_access/BUILD.gn +++ b/interfaces/inner_api/file_access/BUILD.gn @@ -19,6 +19,7 @@ config("ability_config") { include_dirs = [ "include", "${user_file_service_path}/utils", + "${user_file_service_path}/frameworks/js/napi/file_access_module", "${ability_runtime_services_path}/common/include", "${ability_runtime_kits_path}/ability/native/include/continuation/distributed", "${ability_runtime_kits_path}/ability/native/include/continuation/kits", @@ -105,7 +106,7 @@ ohos_shared_library("file_access_observer") { "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/context", "//foundation/communication/ipc/ipc/native/src/napi/include", ] - + shlib_type = "sa" sources = [ "src/observer/file_access_observer_proxy.cpp", "src/observer/file_access_observer_service.cpp", @@ -114,7 +115,7 @@ ohos_shared_library("file_access_observer") { "src/observer/observer_callback_stub.cpp", ] configs = [ ":ability_config" ] - + version_script = "libfile_access_observer.map" public_configs = [ ":ability_public_config", "${ability_runtime_path}/frameworks/native/ability:ability_context_public_config", diff --git a/interfaces/inner_api/file_access/include/file_access_helper.h b/interfaces/inner_api/file_access/include/file_access_helper.h index 21c49471..835e3529 100644 --- a/interfaces/inner_api/file_access/include/file_access_helper.h +++ b/interfaces/inner_api/file_access/include/file_access_helper.h @@ -32,6 +32,7 @@ #include "refbase.h" #include "uri.h" #include "want.h" +#include "observer_callback_stub.h" using Uri = OHOS::Uri; @@ -85,6 +86,9 @@ public: int GetFileInfoFromUri(Uri &selectFile, FileInfo &fileInfo); int GetFileInfoFromRelativePath(std::string &selectFile, FileInfo &fileInfo); int GetRoots(std::vector &rootInfoVec); + int RegisterNotify(Uri uri, bool notifyForDescendants, sptr &observer); + int UnregisterNotify(Uri uri, sptr &observer); + int Notify(); private: sptr GetProxyByUri(Uri &uri); sptr GetProxyByBundleName(const std::string &bundleName); @@ -121,6 +125,17 @@ public: private: RemoteDiedHandler handler_; }; + +class FileAccessObserver : public ObserverCallbackStub { + public: + FileAccessObserver() {}; + virtual ~FileAccessObserver() {}; + void OnChange(std::string message) override; + std::string GetClassName() override; + bool Equal(void *observer) override; + private: + std::string className_ = "FileAccessObserver"; + }; } // namespace FileAccessFwk } // namespace OHOS #endif // FILE_ACCESS_HELPER_H diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_common.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_common.h new file mode 100644 index 00000000..bd35c291 --- /dev/null +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_common.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2023 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 FILE_ACCESS_OBSERVER_COMMON_H +#define FILE_ACCESS_OBSERVER_COMMON_H + +#include +#include + +#include "file_access_extension_info.h" +#include "hilog_wrapper.h" +#include "parcel.h" + +namespace OHOS { +namespace FileAccessFwk { + +enum NotifyType { + NOTIFY_ADD, + NOTIFY_DELETE, + NOTIFY_UPDATE +} + +struct NotifyMessage : public virtual OHOS::Parcelable { +public: + NotifyType notifyType_; + std::vector uris_; + NotifyMessage() = default; + NotifyMessage(const NotifyType notifyType, const std::vector &uris) + : notifyType_(notifyType), uris_(uris) {} + + void ReadFromParcel(Parcel &parcel) + { + notifyType_ = parcel.ReadInt32(); + auto count = parcel.ReadInt32(); + for (int i = 0, i < count, i++) { + uris_.push_back(parcel.ReadString()); + } + } + + virtual bool Marshalling(Parcel &parcel) const override + { + if (!parcel.WriteInt32(notifyType_)) { + HILOG_ERROR("NotifyMessage Unmarshalling error:write deviceType fail."); + return false; + } + if (!parcel.WriteInt32(uris_.size())) { + HILOG_ERROR("NotifyMessage Unmarshalling error:write notifyType fail."); + return false; + } + for (int i = 0, i < uris_.size(), i++) { + if (!parcel.WriteString(uris_[i])) { + HILOG_ERROR("NotifyMessage Unmarshalling error:write srcUri fail."); + return false; + } + } + return true; + } + + static NotifyMessage *Unmarshalling(Parcel &parcel) + { + NotifyMessage *message = new(std::nothrow) NotifyMessage(); + if (message == nullptr) { + HILOG_ERROR("NotifyMessage Unmarshalling error:new object fail."); + return nullptr; + } + message->ReadFromParcel(parcel); + return message; + } +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_ACCESS_OBSERVER_COMMON_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h index 129fa2ca..3b6a097f 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h @@ -27,8 +27,9 @@ class FileAccessObserverProxy : public IRemoteProxy { public: explicit FileAccessObserverProxy(const sptr& impl) : IRemoteProxy(impl) {} ~FileAccessObserverProxy() = default; - int32_t RegisterNotify(Uri uri, const sptr &observer, bool notifyForDescendants) override; - int32_t UnregisterNotify(const sptr &observer) override; + int32_t OnChange(std::string message) override; + int32_t RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) override; + int32_t UnregisterNotify(Uri uri, sptr &observer) override; private: static inline BrokerDelegator delegator_; }; diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h index b1eaca61..e3323de1 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h @@ -85,12 +85,14 @@ class FileAccessObserverService final : public SystemAbility, public FileAccessO public: virtual void OnStart() override; virtual void OnStop() override; - int32_t RegisterNotify(Uri uri, const sptr &observer, bool notifyForDescendants) override; - int32_t UnregisterNotify(const sptr &observer) override; + int32_t OnChange(std::string message) override; + int32_t RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) override; + int32_t UnregisterNotify(Uri uri, sptr &observer) override; int32_t Dump(int32_t fd, const std::vector& args) override; bool IsServiceReady() const; private: bool ready_ = false; + std::vector> observer_; }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h index 75c0749f..57097f26 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h @@ -32,6 +32,7 @@ public: FileAccessObserverStub() = default; virtual ~FileAccessObserverStub() = default; int32_t OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; + int32_t OnChangeStub(MessageParcel &data, MessageParcel &reply); int32_t RegisterNotifyStub(MessageParcel &data, MessageParcel &reply); int32_t UnregisterNotifyStub(MessageParcel &data, MessageParcel &reply); private: diff --git a/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h b/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h index f80701ac..11417518 100644 --- a/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h +++ b/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h @@ -30,10 +30,12 @@ public: public: enum { CMD_REGISTER_NOTIFY = 0, - CMD_UNREGISTER_NOTIFY + CMD_UNREGISTER_NOTIFY, + CMD_ONCHANGE }; - virtual int32_t RegisterNotify(Uri uri, const sptr &observer, bool notifyForDescendants) = 0; - virtual int32_t UnregisterNotify(const sptr &observer) = 0; + virtual int32_t OnChange(std::string message) = 0; + virtual int32_t RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) = 0; + virtual int32_t UnregisterNotify(Uri uri, sptr &observer) = 0; }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/include/observer/iobserver_callback.h b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h index a6bd5baf..a82a525f 100644 --- a/interfaces/inner_api/file_access/include/observer/iobserver_callback.h +++ b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h @@ -26,9 +26,12 @@ public: DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.FileAccessFwk.IFileAccessObserver"); public: enum { - CMD_ONCHANGE = 0 + CMD_ONCHANGE = 0, + CMD_GETCLASSNAME }; virtual void OnChange(std::string message) = 0; + virtual std::string GetClassName() = 0; + virtual bool Equal(void *observer) = 0; }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h index a975ee4d..f473f42e 100644 --- a/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h @@ -19,6 +19,7 @@ #include "iobserver_callback.h" #include "iremote_broker.h" #include "iremote_proxy.h" +#include "hilog_wrapper.h" namespace OHOS { namespace FileAccessFwk { @@ -27,6 +28,11 @@ public: explicit ObserverCallbackProxy(const sptr& impl) : IRemoteProxy(impl) {} ~ObserverCallbackProxy() = default; void OnChange(std::string message) override; + std::string GetClassName() override; + bool Equal(void *observer) override + { HILOG_ERROR("cjw proxy Equal"); + return false; + } private: static inline BrokerDelegator delegator_; }; diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h index 7b24aafa..45954e0a 100644 --- a/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h @@ -29,11 +29,13 @@ namespace OHOS { namespace FileAccessFwk { class ObserverCallbackStub : public IRemoteStub { public: - ObserverCallbackStub() = default; - virtual ~ObserverCallbackStub() = default; + // ObserverCallbackStub() = default; + // virtual ~ObserverCallbackStub() = default; int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; - void OnChange(std::string message) override {} + //void OnChange(std::string message) override {} + //std::string GetClassName() = 0; private: + int32_t GetClassNameStub(MessageParcel &data, MessageParcel &reply); int32_t OnChangeStub(MessageParcel &data, MessageParcel &reply); int32_t ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option); }; diff --git a/interfaces/inner_api/file_access/libfile_access_observer.map b/interfaces/inner_api/file_access/libfile_access_observer.map new file mode 100644 index 00000000..64d74d93 --- /dev/null +++ b/interfaces/inner_api/file_access/libfile_access_observer.map @@ -0,0 +1,26 @@ +# Copyright (c) 2023 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. + +1.0 { + global: + extern "C++" { + *FileAccessObserverProxy*; + *FileAccessObserverService*; + *FileAccessObserverStub*; + *ObserverCallbackStub*; + *ObserverCallbackProxy*; + **; + }; + local: + *; +}; \ No newline at end of file diff --git a/interfaces/inner_api/file_access/src/file_access_helper.cpp b/interfaces/inner_api/file_access/src/file_access_helper.cpp index 93e1d279..a095bc4c 100644 --- a/interfaces/inner_api/file_access/src/file_access_helper.cpp +++ b/interfaces/inner_api/file_access/src/file_access_helper.cpp @@ -30,6 +30,7 @@ #include "system_ability_definition.h" #include "tokenid_kit.h" #include "n_error.h" +#include "file_access_observer_proxy.h" namespace OHOS { namespace FileAccessFwk { @@ -1187,6 +1188,80 @@ int FileAccessHelper::GetFileInfoFromRelativePath(std::string &selectFile, FileI return ERR_OK; } +void FileAccessObserver::OnChange(std::string message) +{ + HILOG_ERROR("enter onchanged"); +} +std::string FileAccessObserver::GetClassName() +{ + HILOG_ERROR("enter onchanged"); + return className_; +} +bool FileAccessObserver::Equal(void *observer) +{ + HILOG_ERROR("enter onchanged"); + return false; +} +int FileAccessHelper::RegisterNotify(Uri uri, bool notifyForDescendants, sptr &observer) +{ + HILOG_ERROR("cjw enter RegisterNotify"); + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (!systemAbilityManager) { + return E_GETRESULT; + } + + sptr remoteObject = systemAbilityManager->GetSystemAbility(5010); + if (!remoteObject) { + return E_GETRESULT; + } + auto proxy = iface_cast(remoteObject); + int ret = proxy->RegisterNotify(uri, observer, true); + HILOG_ERROR("cjw ret = %{public}d", ret); + return ret; +} + +int FileAccessHelper::UnregisterNotify(Uri uri, sptr &observer) +{ + HILOG_ERROR("cjw enter UnregisterNotify"); + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (!systemAbilityManager) { + return E_GETRESULT; + } + + sptr remoteObject = systemAbilityManager->GetSystemAbility(5010); + if (!remoteObject) { + return E_GETRESULT; + } + auto proxy = iface_cast(remoteObject); + int ret = proxy->UnregisterNotify(uri, observer); + HILOG_ERROR("cjw ret = %{public}d", ret); + return ret; + +} + +int FileAccessHelper::Notify() +{ + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (!systemAbilityManager) { + return E_GETRESULT; + } + + sptr remoteObject = systemAbilityManager->GetSystemAbility(5010); + if (!remoteObject) { + return E_GETRESULT; + } + auto proxy = iface_cast(remoteObject); + Uri uri("test"); + sptr observer = new FileAccessObserver(); + int ret = proxy->RegisterNotify(uri, observer, true); + HILOG_ERROR("cjw ret = %{public}d", ret); + return ret; + +} + void FileAccessDeathRecipient::OnRemoteDied(const wptr &remote) { if (handler_) { diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp index 1cf2bfbe..47c1ec4a 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp @@ -24,9 +24,61 @@ namespace OHOS { namespace FileAccessFwk { -int32_t FileAccessObserverProxy::RegisterNotify(Uri uri, const sptr &observer, +int32_t FileAccessObserverProxy::OnChange(std::string message) +{ + HILOG_ERROR("cjw proxy OnChange = %{public}s", message.c_str()); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChange"); + MessageParcel data; + if (!data.WriteInterfaceToken(FileAccessObserverProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (!data.WriteString(message)) { + HILOG_ERROR("fail to WriteString message"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_ONCHANGE, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest. err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = E_IPCS; + if (!reply.ReadInt32(ret)) { + HILOG_ERROR("fail to ReadInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (ret != ERR_OK) { + HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + std::string messageTemp; + if (!reply.ReadString(messageTemp)) { + HILOG_ERROR("fail to ReadString message"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + message = messageTemp; + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +int32_t FileAccessObserverProxy::RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) { + HILOG_ERROR("cjw enter RegisterNotify proxy"); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify"); MessageParcel data; if (!data.WriteInterfaceToken(FileAccessObserverProxy::GetDescriptor())) { @@ -79,7 +131,7 @@ int32_t FileAccessObserverProxy::RegisterNotify(Uri uri, const sptr &observer) +int32_t FileAccessObserverProxy::UnregisterNotify(Uri uri, sptr &observer) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotify"); MessageParcel data; @@ -89,6 +141,12 @@ int32_t FileAccessObserverProxy::UnregisterNotify(const sptrAsObject())) { HILOG_ERROR("fail to WriteRemoteObject observer"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp index cdbdf15b..189bc404 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp @@ -66,21 +66,61 @@ bool FileAccessObserverService::IsServiceReady() const return ready_; } -int32_t FileAccessObserverService::RegisterNotify(Uri uri, const sptr &observer, +int32_t FileAccessObserverService::RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) { + //判断是否重复注册了 + //(callback->AsObject().GetRefPtr() == callbacks_[i]->AsObject().GetRefPtr()) + HILOG_ERROR("cjw enter RegisterNotify service"); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify"); if (observer == nullptr) { HILOG_ERROR("RegisterNotify failed with invalid observer"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } + HILOG_ERROR("cjw observer RegisterNotify add %{public}p", observer->AsObject().GetRefPtr()); + observer_.push_back(observer); + HILOG_ERROR("cjw observer_ size = %{public}d", observer_.size()); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } -int32_t FileAccessObserverService::UnregisterNotify(const sptr &observer) +int32_t FileAccessObserverService::UnregisterNotify(Uri uri, sptr &observer) { + //observer_.erase(observer); + HILOG_ERROR("cjw observer_ size = %{public}d", observer_.size()); + // auto myObserver = static_cast observer_; + // for (auto iter = myObserver.begin(); iter != myObserver.end(); ) { + // if ((*iter)->observer_->cbOnRef_ == (*iter)->observer_->cbOnRef_) { + // HILOG_ERROR("cjw erase observer size = %{public}d", myObserver.size()); + // iter = myObserver.erase(iter); + // } else { + // iter++; + // } + // } + HILOG_ERROR("cjw observer add %{public}p", observer->AsObject().GetRefPtr()); + for (auto iter = observer_.begin(); iter != observer_.end(); ) { + if (observer->AsObject().GetRefPtr() == (*iter)->AsObject().GetRefPtr()) { + HILOG_ERROR("cjw erase observer %{public}p", (*iter)->AsObject().GetRefPtr()); + iter = observer_.erase(iter); + } else { + iter++; + } + } + OnChange("aaaaa"); + return ERR_OK; +} + +int32_t FileAccessObserverService::OnChange(std::string message) +{ + HILOG_ERROR("cjw Service OnChange"); + if (observer_.size() > 0) { + for (auto observer : observer_) { + observer->OnChange(message); + } + } else { + HILOG_ERROR("cjw observer_ in null"); + } return ERR_OK; } } diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp index 6cb2357b..7d0dd1d6 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp @@ -105,6 +105,13 @@ int32_t FileAccessObserverStub::RegisterNotifyStub(MessageParcel &data, MessageP int32_t FileAccessObserverStub::UnregisterNotifyStub(MessageParcel &data, MessageParcel &reply) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotifyStub"); + std::shared_ptr uri(data.ReadParcelable()); + if (uri == nullptr) { + HILOG_ERROR("UnregisterNotify uri is nullptr"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_URIS; + } + sptr obj = data.ReadRemoteObject(); if (obj == nullptr) { HILOG_INFO("get remote obj fail."); @@ -119,7 +126,7 @@ int32_t FileAccessObserverStub::UnregisterNotifyStub(MessageParcel &data, Messag return E_IPCS; } - int ret = UnregisterNotify(observer); + int ret = UnregisterNotify(*uri, observer); if (!reply.WriteInt32(ret)) { HILOG_ERROR("Parameter UnregisterNotify fail to WriteInt32 ret"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); @@ -128,5 +135,20 @@ int32_t FileAccessObserverStub::UnregisterNotifyStub(MessageParcel &data, Messag FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } + +int32_t FileAccessObserverStub::OnChangeStub(MessageParcel &data, MessageParcel &reply) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChangeStub"); + std::string message; + if (!data.ReadString(message)) { + HILOG_ERROR("Parameter OnChangeStub fail to ReadString message"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + HILOG_ERROR("cjw stub message = %{public}s", message.c_str()); + OnChange(message); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} } } \ No newline at end of file diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp index 2645db65..93d7dfa4 100644 --- a/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp @@ -26,6 +26,7 @@ namespace OHOS { namespace FileAccessFwk { void ObserverCallbackProxy::OnChange(std::string message) { + HILOG_ERROR("cjw proxy message = %{public}s", message.c_str()); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChange"); MessageParcel data; if (!data.WriteInterfaceToken(ObserverCallbackProxy::GetDescriptor())) { @@ -73,5 +74,49 @@ void ObserverCallbackProxy::OnChange(std::string message) FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return; } + +std::string ObserverCallbackProxy::GetClassName() +{ + HILOG_ERROR("cjw proxy GetClassName"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetClassName"); + std::string result = "remote error"; + MessageParcel data; + if (!data.WriteInterfaceToken(ObserverCallbackProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return result; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_GETCLASSNAME, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest. err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return result; + } + + int ret = E_IPCS; + if (!reply.ReadInt32(ret)) { + HILOG_ERROR("fail to ReadInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return result; + } + + if (ret != ERR_OK) { + HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return result; + } + + if (!reply.ReadString(result)) { + HILOG_ERROR("fail to ReadString message"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return result; + } + HILOG_ERROR("cjw proxy className = %{public}s", result.c_str()); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return result; +} } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp index b9808fa4..cb72a51c 100644 --- a/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp @@ -54,6 +54,10 @@ int32_t ObserverCallbackStub::ChooseCodeStub(uint32_t code, MessageParcel &data, ret = OnChangeStub(data, reply); break; } + case static_cast(IFileAccessObserver::CMD_GETCLASSNAME): { + ret = GetClassNameStub(data, reply); + break; + } default: { ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); break; @@ -71,10 +75,32 @@ int32_t ObserverCallbackStub::OnChangeStub(MessageParcel &data, MessageParcel &r FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } - + HILOG_ERROR("cjw stub message = %{public}s", message.c_str()); OnChange(message); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } + +int32_t ObserverCallbackStub::GetClassNameStub(MessageParcel &data, MessageParcel &reply) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetClassNameStub"); + std::string className; + className = GetClassName(); + int ret = ERR_OK; + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("Parameter GetClassName fail to WriteInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + HILOG_ERROR("cjw stub className = %{public}s", className.c_str()); + + if (!reply.WriteString(className)) { + HILOG_ERROR("fail to ReadString className"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} } } \ No newline at end of file -- Gitee From aec77a3d63c9b3e21610d7d4d6735c7d5321fedc Mon Sep 17 00:00:00 2001 From: CaoChuan Date: Fri, 19 May 2023 01:36:34 +0000 Subject: [PATCH 3/5] add tree struct Signed-off-by: CaoChuan --- bundle.json | 3 +- etc/BUILD.gn | 7 + etc/faf_service.cfg | 10 + .../napi_fileaccess_helper.cpp | 1 - .../include/js_file_access_ext_ability.h | 2 + .../observer/file_access_observer_common.h | 10 +- .../observer/file_access_observer_proxy.h | 1 + .../observer/file_access_observer_service.h | 54 +++- .../observer/file_access_observer_stub.h | 10 + .../src/js_file_access_ext_ability.cpp | 20 ++ .../observer/file_access_observer_service.cpp | 231 +++++++++++++++--- .../observer/file_access_observer_stub.cpp | 7 + sa_profile/5010.xml | 2 +- 13 files changed, 318 insertions(+), 40 deletions(-) create mode 100644 etc/BUILD.gn create mode 100644 etc/faf_service.cfg diff --git a/bundle.json b/bundle.json index 18f5bd37..fa66f61b 100644 --- a/bundle.json +++ b/bundle.json @@ -45,7 +45,8 @@ "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_access_ext_ability:fileaccessextensionability_napi", "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_extension_info_module:fileextensioninfo", "//foundation/filemanagement/user_file_service/interfaces/inner_api/file_access:file_access_observer", - "//foundation/filemanagement/user_file_service/sa_profile:observer_sa_profile" + "//foundation/filemanagement/user_file_service/sa_profile:observer_sa_profile", + "//foundation/filemanagement/user_file_service/etc:faf_service.cfg" ], "base_group": [] } , diff --git a/etc/BUILD.gn b/etc/BUILD.gn new file mode 100644 index 00000000..b367cee3 --- /dev/null +++ b/etc/BUILD.gn @@ -0,0 +1,7 @@ +import("//build/ohos.gni") +ohos_prebuilt_etc("faf_service.cfg") { + source = "faf_service.cfg" + relative_install_dir = "init" + subsystem_name = "filemanagement" + part_name = "user_file_service" +} \ No newline at end of file diff --git a/etc/faf_service.cfg b/etc/faf_service.cfg new file mode 100644 index 00000000..fded146f --- /dev/null +++ b/etc/faf_service.cfg @@ -0,0 +1,10 @@ +{ + "services" : [{ + "name" : "faf_service", + "path" : ["/system/bin/sa_main", "/system/profile/faf_service.xml"], + "uid" : "1006", + "gid" : ["1006", "shell"], + "secon" : "u:r:faf_service:s0" + } + ] +} \ No newline at end of file diff --git a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp index add25018..59aabb9c 100644 --- a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp +++ b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp @@ -1256,7 +1256,6 @@ napi_value NAPI_RegisterObserver(napi_env env, napi_callback_info info) } observerWrapper.release(); - FileAccessHelper *fileAccessHelper = GetFileAccessHelper(env, funcArg.GetThisVar()); if (fileAccessHelper == nullptr) { NError(EINVAL).ThrowErr(env, "fileAccessHelper is nullptr."); diff --git a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h index 097771a2..aa4e2a88 100644 --- a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h +++ b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h @@ -72,6 +72,8 @@ public: int GetRoots(std::vector &rootInfoVec) override; int Access(const Uri &uri, bool &isExist) override; int Query(const Uri &uri, std::vector &columns, std::vector &results) override; + int RegisterNotify(const Uri &uri); + int UnregisterNotify(const Uri &uri); private: NativeValue* CallObjectMethod(const char *name, NativeValue * const *argv = nullptr, size_t argc = 0); diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_common.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_common.h index bd35c291..b22d4511 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_common.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_common.h @@ -27,10 +27,10 @@ namespace OHOS { namespace FileAccessFwk { enum NotifyType { - NOTIFY_ADD, + NOTIFY_ADD = 0, NOTIFY_DELETE, NOTIFY_UPDATE -} +}; struct NotifyMessage : public virtual OHOS::Parcelable { public: @@ -42,9 +42,9 @@ public: void ReadFromParcel(Parcel &parcel) { - notifyType_ = parcel.ReadInt32(); + notifyType_ = NotifyType(parcel.ReadInt32()); auto count = parcel.ReadInt32(); - for (int i = 0, i < count, i++) { + for (int i = 0; i < count; i++) { uris_.push_back(parcel.ReadString()); } } @@ -59,7 +59,7 @@ public: HILOG_ERROR("NotifyMessage Unmarshalling error:write notifyType fail."); return false; } - for (int i = 0, i < uris_.size(), i++) { + for (int i = 0; i < uris_.size(); i++) { if (!parcel.WriteString(uris_[i])) { HILOG_ERROR("NotifyMessage Unmarshalling error:write srcUri fail."); return false; diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h index 3b6a097f..dcaf6f60 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_proxy.h @@ -16,6 +16,7 @@ #ifndef FILE_ACCESS_OBSERVER_PROXY_H #define FILE_ACCESS_OBSERVER_PROXY_H +#include "file_access_observer_common.h" #include "ifile_observer_base.h" #include "iremote_broker.h" #include "iremote_proxy.h" diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h index e3323de1..ded86f19 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h @@ -16,6 +16,8 @@ #ifndef FILE_ACCESS_OBSERVER_SERVICE_H #define FILE_ACCESS_OBSERVER_SERVICE_H +#include +#include #include #include #include @@ -77,8 +79,8 @@ void DelayedStatsSpSingleton::DestroyInstance() instance_ = nullptr; } } - -class FileAccessObserverService final : public SystemAbility, public FileAccessObserverStub { +static constexpr uint32_t OBS_NUM_MAX = 50; +class FileAccessObserverService final : public SystemAbility, public FileAccessObserverStub, public std::enable_shared_from_this { DECLARE_SYSTEM_ABILITY(FileAccessObserverService) DECLARE_DELAYED_STATS_SP_SINGLETON(FileAccessObserverService); @@ -89,10 +91,56 @@ public: int32_t RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) override; int32_t UnregisterNotify(Uri uri, sptr &observer) override; int32_t Dump(int32_t fd, const std::vector& args) override; + void OnCallBackDied(const wptr &remote); bool IsServiceReady() const; private: + struct DeathRecipientRef { + DeathRecipientRef(sptr deathRec) : deathRecipient_(deathRec), ref_(1) {} + sptr deathRecipient_; + std::atomic ref_; + }; + + // struct ObserverEntry { + // ObserverEntry(sptr observer, std::shared_ptr deathRef, bool isDes) + // : observer_(observer), deathRecipientRef_(deathRef), isDescendants_(isDes) + // { + // } + // sptr observer_; + // std::shared_ptr deathRecipientRef_; + // bool isDescendants_; + // }; + + struct ObserverEntry { + ObserverEntry(sptr observer, bool isDes) + : observer_(observer), isDescendants_(isDes) + { + } + sptr observer_; + bool isDescendants_; + }; + + using ObsMap = std::map, std::list>; + class ObserverNode { + public: + ObserverNode(const std::string &nodeName): nodeName_(nodeName) {} + virtual ~ObserverNode() = default; + void GetObs(const std::vector &path, uint32_t index, Uri &uri, ObsMap &obsMap); + bool AddObserver(const std::vector &path, uint32_t index, const ObserverEntry &entry); + bool RemoveObserver(const std::vector &path, uint32_t index, sptr dataObserver); + inline bool RemoveObserver(sptr observer); + bool RemoveObserver(sptr observer); + private: + std::string nodeName_; + std::list observerEntry_; + std::map> childrens_; + }; +private: + std::shared_ptr AddObsDeathRecipient(const sptr &dataObserver); + void RemoveObsDeathRecipient(const sptr &dataObserver, bool isForce = false); + std::mutex nodeMutex_; bool ready_ = false; - std::vector> observer_; + std::shared_ptr mRootNode_ =std::make_shared("root"); + std::map, std::shared_ptr> obsRecipientRefs_; }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h index 57097f26..33b7f6bf 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_stub.h @@ -38,6 +38,16 @@ public: private: int32_t ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option); }; +class DataObsCallbackRecipient : public IRemoteObject::DeathRecipient { +public: + using RemoteDiedHandler = std::function &)>; + explicit DataObsCallbackRecipient(RemoteDiedHandler handler) : handler_(handler) {} + virtual ~DataObsCallbackRecipient() = default; + virtual void OnRemoteDied(const wptr &remote); + +private: + RemoteDiedHandler handler_; +}; } // namespace FileAccessFwk } // namespace OHOS #endif // FILE_ACCESS_OBSERVER_STUB_H \ No newline at end of file diff --git a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp index 231cc6ff..a0f08abc 100644 --- a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp +++ b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp @@ -837,6 +837,16 @@ int JsFileAccessExtAbility::ListFile(const FileInfo &fileInfo, const int64_t off HILOG_ERROR("Create js NativeValue fail."); return ret; } + bool testFlag = false; + if (nativeFilter == nullptr) { + HILOG_ERROR("cjw js nativeFilter is nullptr before convert."); + } + NativeObject *objFilter = ConvertNativeValueTo(nativeFilter); + if (objFilter == nullptr) { + HILOG_ERROR("cjw js ConvertNativeValue fail."); + } else { + ret = ConvertFromJsValue(engine, objFilter->GetProperty("excludeMedia"), testFlag); + } } else { nativeFilter = engine.CreateNull(); if (nativeFilter == nullptr) { @@ -1200,5 +1210,15 @@ int JsFileAccessExtAbility::GetFileInfoFromUri(const Uri &selectFile, FileInfo & FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } + +int JsFileAccessExtAbility::RegisterNotify(const Uri &uri) +{ + return ERR_OK; +} + +int JsFileAccessExtAbility::UnregisterNotify(const Uri &uri) +{ + return ERR_OK; +} } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp index 189bc404..dc74648b 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp @@ -73,55 +73,228 @@ int32_t FileAccessObserverService::RegisterNotify(Uri uri, sptrAsObject().GetRefPtr() == callbacks_[i]->AsObject().GetRefPtr()) HILOG_ERROR("cjw enter RegisterNotify service"); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify"); - if (observer == nullptr) { + if (observer->AsObject() == nullptr) { HILOG_ERROR("RegisterNotify failed with invalid observer"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } - HILOG_ERROR("cjw observer RegisterNotify add %{public}p", observer->AsObject().GetRefPtr()); - observer_.push_back(observer); - HILOG_ERROR("cjw observer_ size = %{public}d", observer_.size()); + //std::lock_guard lock(nodeMutex_); + // auto deathRecipientRef = AddObsDeathRecipient(observer->AsObject()); + // if (deathRecipientRef == nullptr) { + // return E_IPCS; + // } + std::vector path = { uri.GetScheme(), uri.GetAuthority() }; + uri.GetPathSegments(path); + HILOG_ERROR("cjw SA RegisterNotify"); + //if (mRootNode_ != nullptr && !mRootNode_->AddObserver(path, 0, ObserverEntry(observer, deathRecipientRef, notifyForDescendants))) { + if (mRootNode_ != nullptr && !mRootNode_->AddObserver(path, 0, ObserverEntry(observer, notifyForDescendants))) { + HILOG_ERROR("The number of subscribers for this uri : %{public}s.", uri.ToString().c_str()); + //RemoveObsDeathRecipient(observer->AsObject()); + return E_IPCS; + } + // HILOG_ERROR("cjw observer RegisterNotify add %{public}p", observer->AsObject().GetRefPtr()); + FileAccessObserverService::OnChange("123test"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } int32_t FileAccessObserverService::UnregisterNotify(Uri uri, sptr &observer) { - //observer_.erase(observer); - HILOG_ERROR("cjw observer_ size = %{public}d", observer_.size()); - // auto myObserver = static_cast observer_; - // for (auto iter = myObserver.begin(); iter != myObserver.end(); ) { - // if ((*iter)->observer_->cbOnRef_ == (*iter)->observer_->cbOnRef_) { - // HILOG_ERROR("cjw erase observer size = %{public}d", myObserver.size()); - // iter = myObserver.erase(iter); - // } else { - // iter++; - // } - // } - HILOG_ERROR("cjw observer add %{public}p", observer->AsObject().GetRefPtr()); - for (auto iter = observer_.begin(); iter != observer_.end(); ) { - if (observer->AsObject().GetRefPtr() == (*iter)->AsObject().GetRefPtr()) { - HILOG_ERROR("cjw erase observer %{public}p", (*iter)->AsObject().GetRefPtr()); - iter = observer_.erase(iter); - } else { - iter++; - } + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotify"); + if (observer->AsObject() == nullptr) { + HILOG_ERROR("UnregisterNotify failed with invalid observer"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; } - OnChange("aaaaa"); + std::lock_guard lock(nodeMutex_); + std::vector path = { uri.GetScheme(), uri.GetAuthority() }; + uri.GetPathSegments(path); + if (mRootNode_ != nullptr) { + HILOG_ERROR("cjw SA UnregisterNotify"); + mRootNode_->RemoveObserver(path, 0, observer); + } + FileAccessObserverService::OnChange("123test"); + //RemoveObsDeathRecipient(observer->AsObject()); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } int32_t FileAccessObserverService::OnChange(std::string message) { HILOG_ERROR("cjw Service OnChange"); - if (observer_.size() > 0) { - for (auto observer : observer_) { - observer->OnChange(message); + ObsMap changeRes; + std::vector path; + { + std::lock_guard lock(nodeMutex_); + path.clear(); + Uri uri("file://media/root/file"); + path.emplace_back(uri.GetScheme()); + path.emplace_back(uri.GetAuthority()); + uri.GetPathSegments(path); + HILOG_ERROR("OnChange uri = %{public}s", uri.ToString().c_str()); + for (auto p : path) { + HILOG_ERROR("OnChange path = %{public}s", p.c_str()); + } + mRootNode_->GetObs(path, 0, uri, changeRes); + } + if (changeRes.empty()) { + return E_IPCS; + } + for (const auto &[obs, value] : changeRes) { + if (obs != nullptr && !value.empty()) { + //obs->OnChange({ changeInfo.changeType_, move(value), changeInfo.data_, changeInfo.size_ }); + obs->OnChange(message); } - } else { - HILOG_ERROR("cjw observer_ in null"); } return ERR_OK; } + +void FileAccessObserverService::RemoveObsDeathRecipient(const sptr &observer, bool isForce) +{ + auto it = obsRecipientRefs_.find(observer); + if (it == obsRecipientRefs_.end()) { + return; + } + + if (isForce || it->second->ref_ <= 1) { + HILOG_DEBUG("this observer deathRecipient will be remove, sum:%{public}ud", + it->second->ref_.load(std::memory_order_relaxed)); + observer->RemoveDeathRecipient(it->second->deathRecipient_); + obsRecipientRefs_.erase(it); + return; + } +} + +void FileAccessObserverService::OnCallBackDied(const wptr &remote) +{ + HILOG_DEBUG("this observer died"); + auto observer = remote.promote(); + if (observer == nullptr) { + return; + } + std::lock_guard lock(nodeMutex_); + if (mRootNode_ != nullptr) { + mRootNode_->RemoveObserver(observer); + } + RemoveObsDeathRecipient(observer, true); +} + +std::shared_ptr FileAccessObserverService::AddObsDeathRecipient( + const sptr &observer) +{ + HILOG_ERROR("cjw enter AddObsDeathRecipient"); + auto it = obsRecipientRefs_.find(observer); + if (it != obsRecipientRefs_.end()) { + if (std::numeric_limits::max() - 1 < it->second->ref_) { + HILOG_ERROR("the num of observer reach max limit"); + return nullptr; + } + } else { + std::weak_ptr thisWeakPtr(shared_from_this()); + sptr deathRecipient = + new DataObsCallbackRecipient([thisWeakPtr](const wptr &remote) { + auto FileAccessObserverService = thisWeakPtr.lock(); + if (FileAccessObserverService) { + FileAccessObserverService->OnCallBackDied(remote); + } + }); + observer->AddDeathRecipient(deathRecipient); + it = obsRecipientRefs_.emplace(observer, std::make_shared(deathRecipient)).first; + } + HILOG_DEBUG("this observer will be added, sum:%{public}ud", it->second->ref_.load(std::memory_order_relaxed)); + return it->second; +} + +void FileAccessObserverService::ObserverNode::GetObs(const std::vector &path, uint32_t index, Uri &uri, ObsMap &obsRes) +{ + HILOG_ERROR("cjw enter GetObs path[index] = %{public}s", path[index].c_str()); + if (path.size() == index) { + for (auto entry : observerEntry_) { + obsRes.try_emplace(entry.observer_, std::list()).first->second.push_back(uri); + HILOG_ERROR("cjw execute emplace uri = %{public}s", uri.ToString().c_str()); + } + return; + } + + for (const auto &entry : observerEntry_) { + if (entry.isDescendants_) { + obsRes.try_emplace(entry.observer_, std::list()).first->second.push_back(uri); + HILOG_ERROR("cjw execute emplace uri = %{public}s", uri.ToString().c_str()); + } + } + + auto it = childrens_.find(path[index]); + if (it == childrens_.end()) { + return; + } + it->second->GetObs(path, ++index, uri, obsRes); + + return; +} + +bool FileAccessObserverService::ObserverNode::AddObserver(const std::vector &path, uint32_t index, const ObserverEntry &entry) +{ + HILOG_ERROR("cjw enter ObserverNode::AddObserver NodeName = %{public}s", nodeName_.c_str()); + if (path.size() == index) { + if (observerEntry_.size() >= OBS_NUM_MAX) { + return false; + } + //entry.deathRecipientRef_->ref_++; + observerEntry_.emplace_back(entry); + HILOG_ERROR("cjw AddObserver execute emplace"); + return true; + } + HILOG_ERROR("cjw enter ObserverNode NodeName = %{public}s", path[index].c_str()); + auto it = childrens_.try_emplace(path[index], std::make_shared(path[index])).first; + HILOG_ERROR("cjw AddObserver new ObserverNode"); + return it->second->AddObserver(path, ++index, entry); +} + +bool FileAccessObserverService::ObserverNode::RemoveObserver(const std::vector &path, uint32_t index, + sptr dataObserver) +{ + HILOG_ERROR("cjw enter ObserverNode::RemoveObserver"); + if (index == path.size()) { + observerEntry_.remove_if([dataObserver](const ObserverEntry &entry) { + if (entry.observer_->AsObject() != dataObserver->AsObject()) { + return false; + } + //entry.deathRecipientRef_->ref_--; + return true; + }); + return observerEntry_.empty() && childrens_.empty(); + } + auto child = childrens_.find(path[index]); + if (child != childrens_.end() && child->second->RemoveObserver(path, ++index, dataObserver)) { + childrens_.erase(child); + HILOG_ERROR("cjw execute erase"); + } + return observerEntry_.empty() && childrens_.empty(); +} + +bool FileAccessObserverService::ObserverNode::RemoveObserver(sptr dataObserver) +{ + for (auto child = childrens_.begin(); child != childrens_.end();) { + if (child->second->RemoveObserver(dataObserver)) { + child = childrens_.erase(child); + } else { + child++; + } + } + observerEntry_.remove_if([dataObserver](const ObserverEntry &entry) { + if (entry.observer_->AsObject() != dataObserver) { + return false; + } + //entry.deathRecipientRef_->ref_--; + return true; + }); + return observerEntry_.empty() && childrens_.empty(); +} + +inline bool FileAccessObserverService::ObserverNode::RemoveObserver(sptr dataObserver) +{ + auto obs = dataObserver->AsObject(); + return obs != nullptr && RemoveObserver(obs); +} } } \ No newline at end of file diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp index 7d0dd1d6..c4a0b9f4 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp @@ -150,5 +150,12 @@ int32_t FileAccessObserverStub::OnChangeStub(MessageParcel &data, MessageParcel FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } + +void DataObsCallbackRecipient::OnRemoteDied(const wptr &remote) +{ + if (handler_) { + handler_(remote); + } +} } } \ No newline at end of file diff --git a/sa_profile/5010.xml b/sa_profile/5010.xml index f649a1b7..eccc1130 100755 --- a/sa_profile/5010.xml +++ b/sa_profile/5010.xml @@ -13,7 +13,7 @@ limitations under the License. --> - foundation + faf_service 5010 libfile_access_observer.z.so -- Gitee From 15a01b62df0dbc66d7ca4a254f468c31c03e4271 Mon Sep 17 00:00:00 2001 From: CaoChuan Date: Sat, 20 May 2023 10:49:20 +0000 Subject: [PATCH 4/5] fix: bug Signed-off-by: CaoChuan --- bundle.json | 4 +- etc/BUILD.gn | 4 +- ...af_service.cfg => file_access_service.cfg} | 6 +- .../js/napi/file_access_module/BUILD.gn | 11 + .../napi_observer_callback.cpp | 22 +- .../napi_observer_callback.h | 10 +- interfaces/inner_api/file_access/BUILD.gn | 1 + .../include/file_access_ext_ability.h | 3 + .../include/file_access_ext_proxy.h | 2 + .../include/file_access_ext_stub.h | 2 + .../include/file_access_ext_stub_impl.h | 2 + .../file_access/include/file_access_helper.h | 6 +- .../include/ifile_access_ext_base.h | 4 + .../include/js_file_access_ext_ability.h | 4 + .../include/observer/iobserver_callback.h | 7 +- .../observer/observer_callback_proxy.h | 10 +- .../include/observer/observer_callback_stub.h | 8 +- .../src/file_access_ext_ability.cpp | 39 + .../file_access/src/file_access_ext_proxy.cpp | 87 + .../file_access/src/file_access_ext_stub.cpp | 59 + .../src/file_access_ext_stub_impl.cpp | 28 + .../file_access/src/file_access_helper.cpp | 92 +- .../src/js_file_access_ext_ability.cpp | 160 + .../observer/file_access_observer_service.cpp | 7 +- .../observer/file_access_observer_stub.cpp | 5 + .../src/observer/observer_callback_proxy.cpp | 85 +- .../src/observer/observer_callback_stub.cpp | 60 +- sa_profile/5010.xml | 2 +- sa_profile/BUILD.gn | 2 +- .../FileExtensionAbility.ts | 99 + test/unittest/external_file_access_test.cpp | 6399 +++++++-------- .../medialibrary_file_access_test.cpp | 6897 +++++++++-------- 32 files changed, 7426 insertions(+), 6701 deletions(-) rename etc/{faf_service.cfg => file_access_service.cfg} (36%) diff --git a/bundle.json b/bundle.json index fa66f61b..0d16ef3c 100644 --- a/bundle.json +++ b/bundle.json @@ -45,8 +45,8 @@ "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_access_ext_ability:fileaccessextensionability_napi", "//foundation/filemanagement/user_file_service/frameworks/js/napi/file_extension_info_module:fileextensioninfo", "//foundation/filemanagement/user_file_service/interfaces/inner_api/file_access:file_access_observer", - "//foundation/filemanagement/user_file_service/sa_profile:observer_sa_profile", - "//foundation/filemanagement/user_file_service/etc:faf_service.cfg" + "//foundation/filemanagement/user_file_service/sa_profile:file_access_service_profile", + "//foundation/filemanagement/user_file_service/etc:file_access_service.cfg" ], "base_group": [] } , diff --git a/etc/BUILD.gn b/etc/BUILD.gn index b367cee3..dac151e3 100644 --- a/etc/BUILD.gn +++ b/etc/BUILD.gn @@ -1,6 +1,6 @@ import("//build/ohos.gni") -ohos_prebuilt_etc("faf_service.cfg") { - source = "faf_service.cfg" +ohos_prebuilt_etc("file_access_service.cfg") { + source = "file_access_service.cfg" relative_install_dir = "init" subsystem_name = "filemanagement" part_name = "user_file_service" diff --git a/etc/faf_service.cfg b/etc/file_access_service.cfg similarity index 36% rename from etc/faf_service.cfg rename to etc/file_access_service.cfg index fded146f..e51a14bd 100644 --- a/etc/faf_service.cfg +++ b/etc/file_access_service.cfg @@ -1,10 +1,10 @@ { "services" : [{ - "name" : "faf_service", - "path" : ["/system/bin/sa_main", "/system/profile/faf_service.xml"], + "name" : "file_access_service", + "path" : ["/system/bin/sa_main", "/system/profile/file_access_service.xml"], "uid" : "1006", "gid" : ["1006", "shell"], - "secon" : "u:r:faf_service:s0" + "secon" : "u:r:file_access_service:s0" } ] } \ No newline at end of file diff --git a/frameworks/js/napi/file_access_module/BUILD.gn b/frameworks/js/napi/file_access_module/BUILD.gn index 1a2eca98..7ffea1ec 100644 --- a/frameworks/js/napi/file_access_module/BUILD.gn +++ b/frameworks/js/napi/file_access_module/BUILD.gn @@ -27,6 +27,7 @@ ohos_shared_library("fileaccess") { "${user_file_service_path}/frameworks/js/napi/file_access_module/root_info", "${user_file_service_path}/utils", "${user_file_service_path}/interfaces/kits/js/src/common", + "${user_file_service_path}/interfaces/inner_api/file_access/include/observer", ] sources = [ @@ -37,6 +38,7 @@ ohos_shared_library("fileaccess") { "napi_observer_callback.cpp", "napi_utils.cpp", "native_fileaccess_module.cpp", + "${user_file_service_path}/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp", "root_info/napi_root_info_exporter.cpp", "root_info/napi_root_iterator_exporter.cpp", ] @@ -59,5 +61,14 @@ ohos_shared_library("fileaccess") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "multimedia_image_framework:image", + "ability_runtime:ability_manager", + "ability_runtime:extensionkit_native", + "ability_runtime:runtime", + "access_token:libaccesstoken_sdk", + "bundle_framework:appexecfwk_core", + "hitrace_native:hitrace_meter", + "napi:ace_napi", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", ] } diff --git a/frameworks/js/napi/file_access_module/napi_observer_callback.cpp b/frameworks/js/napi/file_access_module/napi_observer_callback.cpp index 2a975d5a..ed681cb5 100644 --- a/frameworks/js/napi/file_access_module/napi_observer_callback.cpp +++ b/frameworks/js/napi/file_access_module/napi_observer_callback.cpp @@ -96,16 +96,16 @@ void NapiObserver::OnChange(std::string message) return; } -bool NapiObserverCallback::Equal(void *observer) -{ - HILOG_ERROR("cjw Equal Napi"); - auto napiObserver = static_cast(observer); - auto name = napiObserver->className_; - HILOG_ERROR("cjw Equal classname = %{public}s", name.c_str()); - if (this->observer_->cbOnRef_ != napiObserver->observer_->cbOnRef_) { - return false; - } - return true; -} +// bool NapiObserverCallback::Equal(void *observer) +// { +// HILOG_ERROR("cjw Equal Napi"); +// auto napiObserver = static_cast(observer); +// auto name = napiObserver->className_; +// HILOG_ERROR("cjw Equal classname = %{public}s", name.c_str()); +// if (this->observer_->cbOnRef_ != napiObserver->observer_->cbOnRef_) { +// return false; +// } +// return true; +// } } // namespace FileAccessFwk } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/file_access_module/napi_observer_callback.h b/frameworks/js/napi/file_access_module/napi_observer_callback.h index 911cf861..a1a217f1 100644 --- a/frameworks/js/napi/file_access_module/napi_observer_callback.h +++ b/frameworks/js/napi/file_access_module/napi_observer_callback.h @@ -53,11 +53,11 @@ public: observer_->OnChange(message); } - std::string GetClassName() override - { - return className_; - } - bool Equal(void *observer) override; + // std::string GetClassName() override + // { + // return className_; + // } + // bool Equal(void *observer) override; std::shared_ptr observer_ =nullptr; private: std::string className_ = "NapiObserverCallback"; diff --git a/interfaces/inner_api/file_access/BUILD.gn b/interfaces/inner_api/file_access/BUILD.gn index 7ef99529..cfced532 100644 --- a/interfaces/inner_api/file_access/BUILD.gn +++ b/interfaces/inner_api/file_access/BUILD.gn @@ -62,6 +62,7 @@ ohos_shared_library("file_access_extension_ability_kit") { "src/file_access_helper.cpp", "src/js_file_access_ext_ability.cpp", "src/napi_common_fileaccess.cpp", + "src/observer/observer_callback_stub.cpp", ] configs = [ ":ability_config" ] diff --git a/interfaces/inner_api/file_access/include/file_access_ext_ability.h b/interfaces/inner_api/file_access/include/file_access_ext_ability.h index 783dc138..54ee7dd7 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_ability.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_ability.h @@ -61,6 +61,9 @@ public: virtual int GetRoots(std::vector &rootInfoVec); virtual int Access(const Uri &uri, bool &isExist); static void SetCreator(const CreatorFunc& creator); + virtual int StartWatcher(const Uri &uri); + virtual int StopWatcher(const Uri &uri); + virtual int Notify(Uri &uri, std::string eventType); private: static CreatorFunc creator_; }; diff --git a/interfaces/inner_api/file_access/include/file_access_ext_proxy.h b/interfaces/inner_api/file_access/include/file_access_ext_proxy.h index fb3c6f14..9223f9e9 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_proxy.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_proxy.h @@ -56,6 +56,8 @@ public: virtual int GetFileInfoFromRelativePath(const std::string &selectFile, FileInfo &fileInfo) override; virtual int GetRoots(std::vector &rootInfoVec) override; virtual int Access(const Uri &uri, bool &isExist) override; + virtual int StartWatcher(const Uri &uri) override; + virtual int StopWatcher(const Uri &uri) override; private: static inline BrokerDelegator delegator_; }; diff --git a/interfaces/inner_api/file_access/include/file_access_ext_stub.h b/interfaces/inner_api/file_access/include/file_access_ext_stub.h index 4313a9d2..f804c1fd 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_stub.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_stub.h @@ -50,6 +50,8 @@ private: ErrCode CmdGetFileInfoFromRelativePath(MessageParcel &data, MessageParcel &reply); ErrCode CmdGetRoots(MessageParcel &data, MessageParcel &reply); ErrCode CmdAccess(MessageParcel &data, MessageParcel &reply); + ErrCode CmdStartWatcher(MessageParcel &data, MessageParcel &reply); + ErrCode CmdStopWatcher(MessageParcel &data, MessageParcel &reply); bool CheckCallingPermission(const std::string &permission); using RequestFuncType = int (FileAccessExtStub::*)(MessageParcel &data, MessageParcel &reply); std::map stubFuncMap_; diff --git a/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h b/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h index 68cbfe50..9acb2c65 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h @@ -54,6 +54,8 @@ public: int GetFileInfoFromRelativePath(const std::string &selectFile, FileInfo &fileInfo) override; int GetRoots(std::vector &rootInfoVec) override; int Access(const Uri &uri, bool &isExist) override; + int StartWatcher(const Uri &uri) override; + int StopWatcher(const Uri &uri) override; private: std::shared_ptr GetOwner(); diff --git a/interfaces/inner_api/file_access/include/file_access_helper.h b/interfaces/inner_api/file_access/include/file_access_helper.h index 835e3529..274feccf 100644 --- a/interfaces/inner_api/file_access/include/file_access_helper.h +++ b/interfaces/inner_api/file_access/include/file_access_helper.h @@ -86,6 +86,8 @@ public: int GetFileInfoFromUri(Uri &selectFile, FileInfo &fileInfo); int GetFileInfoFromRelativePath(std::string &selectFile, FileInfo &fileInfo); int GetRoots(std::vector &rootInfoVec); + int StartWatcher(Uri &uri); + int StopWatcher(Uri &uri); int RegisterNotify(Uri uri, bool notifyForDescendants, sptr &observer); int UnregisterNotify(Uri uri, sptr &observer); int Notify(); @@ -131,8 +133,8 @@ class FileAccessObserver : public ObserverCallbackStub { FileAccessObserver() {}; virtual ~FileAccessObserver() {}; void OnChange(std::string message) override; - std::string GetClassName() override; - bool Equal(void *observer) override; + // std::string GetClassName() override; + // bool Equal(void *observer) override; private: std::string className_ = "FileAccessObserver"; }; diff --git a/interfaces/inner_api/file_access/include/ifile_access_ext_base.h b/interfaces/inner_api/file_access/include/ifile_access_ext_base.h index c884566b..6e1fe22f 100644 --- a/interfaces/inner_api/file_access/include/ifile_access_ext_base.h +++ b/interfaces/inner_api/file_access/include/ifile_access_ext_base.h @@ -46,6 +46,8 @@ public: CMD_RENAME, CMD_LIST_FILE, CMD_SCAN_FILE, + CMD_START_WATCHER, + CMD_STOP_WATCHER, CMD_QUERY, CMD_GET_ROOTS, CMD_ACCESS, @@ -72,6 +74,8 @@ public: virtual int GetFileInfoFromRelativePath(const std::string &selectFile, FileInfo &fileInfo) = 0; virtual int GetRoots(std::vector &rootInfoVec) = 0; virtual int Access(const Uri &uri, bool &isExist) = 0; + virtual int StartWatcher(const Uri &uri) = 0; + virtual int StopWatcher(const Uri &uri) = 0; }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h index aa4e2a88..65543c22 100644 --- a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h +++ b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h @@ -72,14 +72,18 @@ public: int GetRoots(std::vector &rootInfoVec) override; int Access(const Uri &uri, bool &isExist) override; int Query(const Uri &uri, std::vector &columns, std::vector &results) override; + int StartWatcher(const Uri &uri) override; + int StopWatcher(const Uri &uri) override; int RegisterNotify(const Uri &uri); int UnregisterNotify(const Uri &uri); private: + void CreateWatcher(const Uri &uri); NativeValue* CallObjectMethod(const char *name, NativeValue * const *argv = nullptr, size_t argc = 0); int CallJsMethod(const std::string &funcName, JsRuntime &jsRuntime, NativeReference *jsObj, InputArgsParser argParser, ResultValueParser retParser); void GetSrcPath(std::string &srcPath); + static NativeValue* FuncCallback(NativeEngine *engine, NativeCallbackInfo *info); JsRuntime &jsRuntime_; std::shared_ptr jsObj_; diff --git a/interfaces/inner_api/file_access/include/observer/iobserver_callback.h b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h index a82a525f..b9d64f23 100644 --- a/interfaces/inner_api/file_access/include/observer/iobserver_callback.h +++ b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h @@ -26,12 +26,11 @@ public: DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.FileAccessFwk.IFileAccessObserver"); public: enum { - CMD_ONCHANGE = 0, - CMD_GETCLASSNAME + CMD_CALLBACK = 0 }; virtual void OnChange(std::string message) = 0; - virtual std::string GetClassName() = 0; - virtual bool Equal(void *observer) = 0; + // virtual std::string GetClassName() = 0; + // virtual bool Equal(void *observer) = 0; }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h index f473f42e..a7a7d736 100644 --- a/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h @@ -28,11 +28,11 @@ public: explicit ObserverCallbackProxy(const sptr& impl) : IRemoteProxy(impl) {} ~ObserverCallbackProxy() = default; void OnChange(std::string message) override; - std::string GetClassName() override; - bool Equal(void *observer) override - { HILOG_ERROR("cjw proxy Equal"); - return false; - } + // std::string GetClassName() override; + // bool Equal(void *observer) override + // { HILOG_ERROR("cjw proxy Equal"); + // return false; + // } private: static inline BrokerDelegator delegator_; }; diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h index 45954e0a..b670e31d 100644 --- a/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h @@ -29,13 +29,13 @@ namespace OHOS { namespace FileAccessFwk { class ObserverCallbackStub : public IRemoteStub { public: - // ObserverCallbackStub() = default; - // virtual ~ObserverCallbackStub() = default; + ObserverCallbackStub(); + virtual ~ObserverCallbackStub() = default; int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; - //void OnChange(std::string message) override {} + void OnChange(std::string message) override {} //std::string GetClassName() = 0; + //int32_t GetClassNameStub(MessageParcel &data, MessageParcel &reply); private: - int32_t GetClassNameStub(MessageParcel &data, MessageParcel &reply); int32_t OnChangeStub(MessageParcel &data, MessageParcel &reply); int32_t ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option); }; diff --git a/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp b/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp index 21e68af2..c209e0bd 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp @@ -18,8 +18,11 @@ #include "connection_manager.h" #include "extension_context.h" #include "file_access_framework_errno.h" +#include "file_access_observer_proxy.h" #include "hilog_wrapper.h" #include "hitrace_meter.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" #include "js_file_access_ext_ability.h" #include "runtime.h" @@ -152,5 +155,41 @@ int FileAccessExtAbility::Access(const Uri &uri, bool &isExist) HILOG_ERROR("FileAccessExtAbility::IsFileExist Undefined operation"); return EPERM; } + +int FileAccessExtAbility::StartWatcher(const Uri &uri) +{ + HILOG_ERROR("FileAccessExtAbility::IsFileExist Undefined operation"); + return EPERM; +} + +int FileAccessExtAbility::StopWatcher(const Uri &uri) +{ + HILOG_ERROR("FileAccessExtAbility::IsFileExist Undefined operation"); + return EPERM; +} + +int FileAccessExtAbility::Notify(Uri &uri, std::string eventType) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Notify"); + std::string uriString = uri.ToString(); + HILOG_ERROR("cjw notify uri = %{public}s, eventType = %{public}s", uri.ToString().c_str(), eventType.c_str()); + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (!systemAbilityManager) { + return E_GETRESULT; + } + + sptr remoteObject = systemAbilityManager->GetSystemAbility(5010); + HILOG_ERROR("cjw callback SA add = %{public}p", &remoteObject); + HILOG_ERROR("cjw callback SA add = %{public}p", (void *)remoteObject); + if (!remoteObject) { + return E_GETRESULT; + } + auto proxy = iface_cast(remoteObject); + int ret = proxy->OnChange(uriString); + HILOG_ERROR("cjw onChange ret = %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return 0; +} } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp b/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp index ae5889a1..81fa0ab1 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp @@ -938,5 +938,92 @@ int FileAccessExtProxy::Access(const Uri &uri, bool &isExist) FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } + +int FileAccessExtProxy::StartWatcher(const Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StartWatcher"); + MessageParcel data; + if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + std::string uriString = uri.ToString(); + HILOG_ERROR("cjw uristring = %{public}s", uriString.c_str()); + if (!data.WriteString(uriString)) { + HILOG_ERROR("fail to WriteParcelable uri"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_START_WATCHER, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest. err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return err; + } + + int ret = E_IPCS; + if (!reply.ReadInt32(ret)) { + HILOG_ERROR("fail to ReadInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (ret != ERR_OK) { + HILOG_ERROR("StartWatcher operation failed ret : %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +int FileAccessExtProxy::StopWatcher(const Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StopWatcher"); + MessageParcel data; + if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + std::string uriString = uri.ToString(); + if (!data.WriteString(uriString)) { + HILOG_ERROR("fail to WriteParcelable uri"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_STOP_WATCHER, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest. err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return err; + } + + int ret = E_IPCS; + if (!reply.ReadInt32(ret)) { + HILOG_ERROR("fail to ReadInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (ret != ERR_OK) { + HILOG_ERROR("StopWatcher operation failed ret : %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp b/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp index 23620687..af8926ac 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp @@ -45,6 +45,8 @@ FileAccessExtStub::FileAccessExtStub() { stubFuncMap_[CMD_OPEN_FILE] = &FileAccessExtStub::CmdOpenFile; stubFuncMap_[CMD_CREATE_FILE] = &FileAccessExtStub::CmdCreateFile; + stubFuncMap_[CMD_START_WATCHER] = &FileAccessExtStub::CmdStartWatcher; + stubFuncMap_[CMD_STOP_WATCHER] = &FileAccessExtStub::CmdStopWatcher; stubFuncMap_[CMD_MKDIR] = &FileAccessExtStub::CmdMkdir; stubFuncMap_[CMD_DELETE] = &FileAccessExtStub::CmdDelete; stubFuncMap_[CMD_MOVE] = &FileAccessExtStub::CmdMove; @@ -716,6 +718,63 @@ ErrCode FileAccessExtStub::CmdAccess(MessageParcel &data, MessageParcel &reply) return ERR_OK; } +ErrCode FileAccessExtStub::CmdStartWatcher(MessageParcel &data, MessageParcel &reply) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdStartWatcher"); + std::string uriString; + if (!data.ReadString(uriString)) { + HILOG_ERROR("Parameter StartWatcher fail to ReadParcelable uri"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + HILOG_ERROR("cjw uriString = %{public}s", uriString.c_str()); + + if (uriString.empty()) { + HILOG_ERROR("Parameter StartWatcher insideInputUri is empty"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return EINVAL; + } + + Uri uri(uriString); + int ret = StartWatcher(uri); + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("Parameter StartWatcher fail to WriteInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +ErrCode FileAccessExtStub::CmdStopWatcher(MessageParcel &data, MessageParcel &reply) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdStopWatcher"); + std::string uriString; + if (!data.ReadString(uriString)) { + HILOG_ERROR("Parameter StopWatcher fail to ReadParcelable uri"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + if (uriString.empty()) { + HILOG_ERROR("Parameter StopWatcher insideInputUri is empty"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return EINVAL; + } + + Uri uri(uriString); + int ret = StopWatcher(uri); + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("Parameter StopWatcher fail to WriteInt32 ret"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + bool FileAccessExtStub::CheckCallingPermission(const std::string &permission) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CheckCallingPermission"); diff --git a/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp b/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp index e3c498bd..5e6083ac 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp @@ -246,5 +246,33 @@ int FileAccessExtStubImpl::Access(const Uri &uri, bool &isExist) FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; } + +int FileAccessExtStubImpl::StartWatcher(const Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StartWatcher"); + if (extension_ == nullptr) { + HILOG_ERROR("StartWatcher get extension failed."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = extension_->StartWatcher(uri); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; +} + +int FileAccessExtStubImpl::StopWatcher(const Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StopWatcher"); + if (extension_ == nullptr) { + HILOG_ERROR("StopWatcher get extension failed."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = extension_->StopWatcher(uri); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; +} } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/file_access_helper.cpp b/interfaces/inner_api/file_access/src/file_access_helper.cpp index a095bc4c..9203fe49 100644 --- a/interfaces/inner_api/file_access/src/file_access_helper.cpp +++ b/interfaces/inner_api/file_access/src/file_access_helper.cpp @@ -1192,16 +1192,16 @@ void FileAccessObserver::OnChange(std::string message) { HILOG_ERROR("enter onchanged"); } -std::string FileAccessObserver::GetClassName() -{ - HILOG_ERROR("enter onchanged"); - return className_; -} -bool FileAccessObserver::Equal(void *observer) -{ - HILOG_ERROR("enter onchanged"); - return false; -} +// std::string FileAccessObserver::GetClassName() +// { +// HILOG_ERROR("enter onchanged"); +// return className_; +// } +// bool FileAccessObserver::Equal(void *observer) +// { +// HILOG_ERROR("enter onchanged"); +// return false; +// } int FileAccessHelper::RegisterNotify(Uri uri, bool notifyForDescendants, sptr &observer) { HILOG_ERROR("cjw enter RegisterNotify"); @@ -1212,11 +1212,17 @@ int FileAccessHelper::RegisterNotify(Uri uri, bool notifyForDescendants, sptr remoteObject = systemAbilityManager->GetSystemAbility(5010); + HILOG_ERROR("cjw SA add = %{public}p", (void *)remoteObject); if (!remoteObject) { return E_GETRESULT; } auto proxy = iface_cast(remoteObject); int ret = proxy->RegisterNotify(uri, observer, true); + if (ret != ERR_OK) { + HILOG_ERROR("cjw ret = %{public}d", ret); + return ret; + } + ret = StartWatcher(uri); HILOG_ERROR("cjw ret = %{public}d", ret); return ret; } @@ -1262,6 +1268,72 @@ int FileAccessHelper::Notify() } +int FileAccessHelper::StartWatcher(Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StartWatcher"); + if (!IsSystemApp()) { + HILOG_ERROR("cjw FileAccessHelper::StartWatcher check IsSystemAppByFullTokenID failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_PERMISSION_SYS; + } + + // if (!CheckUri(uri)) { + // HILOG_ERROR("Uri format check error."); + // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + // return E_URIS; + // } + + sptr fileExtProxy = GetProxyByUri(uri); + if (fileExtProxy == nullptr) { + HILOG_ERROR("failed with invalid fileAccessExtProxy"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = fileExtProxy->StartWatcher(uri); + if (ret != ERR_OK) { + HILOG_ERROR("Delete get result error, code:%{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +int FileAccessHelper::StopWatcher(Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StopWatcher"); + if (!IsSystemApp()) { + HILOG_ERROR("FileAccessHelper::StopWatcher check IsSystemAppByFullTokenID failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_PERMISSION_SYS; + } + + // if (!CheckUri(uri)) { + // HILOG_ERROR("Uri format check error."); + // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + // return E_URIS; + // } + + sptr fileExtProxy = GetProxyByUri(uri); + if (fileExtProxy == nullptr) { + HILOG_ERROR("failed with invalid fileAccessExtProxy"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = fileExtProxy->StopWatcher(uri); + if (ret != ERR_OK) { + HILOG_ERROR("Delete get result error, code:%{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + void FileAccessDeathRecipient::OnRemoteDied(const wptr &remote) { if (handler_) { diff --git a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp index a0f08abc..edb8b7fd 100644 --- a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp +++ b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp @@ -107,6 +107,75 @@ void JsFileAccessExtAbility::OnStart(const AAFwk::Want &want) FinishTrace(HITRACE_TAG_FILEMANAGEMENT); } +NativeValue* JsFileAccessExtAbility::FuncCallback(NativeEngine* engine, NativeCallbackInfo* info) +{ + HILOG_ERROR("cjw enter FuncCallback"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "FuncCallback"); + if (engine == nullptr) { + HILOG_ERROR("cjw NativeEngine pointer is null."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return nullptr; + } + + if (info == nullptr) { + HILOG_ERROR("cjw invalid param."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return engine->CreateUndefined(); + } + + if (info->argc != ARGC_TWO) { + HILOG_ERROR("cjw invalid args."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return engine->CreateUndefined(); + } + + std::string uriString = UnwrapStringFromJS(reinterpret_cast(engine), + reinterpret_cast(info->argv[ARGC_ZERO])); + HILOG_ERROR("cjw uriString = %{public}s", uriString.c_str()); + std::string notifyType = UnwrapStringFromJS(reinterpret_cast(engine), + reinterpret_cast(info->argv[ARGC_ONE])); + HILOG_ERROR("cjw notifyType = %{public}s", notifyType.c_str()); + if (info->functionInfo == nullptr || info->functionInfo->data == nullptr) { + HILOG_ERROR("cjw invalid object."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return engine->CreateUndefined(); + } + + JsFileAccessExtAbility* jsExtension = static_cast(info->functionInfo->data); + if (jsExtension == nullptr) { + HILOG_ERROR("cjw invalid JsFileAccessExtAbility."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return engine->CreateUndefined(); + } + + Uri uri(uriString); + auto ret = jsExtension->Notify(uri, notifyType); + if (ret != ERR_OK) { + HILOG_ERROR("cjw JsFileAccessExtAbility notify error, ret:%{public}d", ret); + } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return engine->CreateUndefined(); +} + +void JsFileAccessExtAbility::CreateWatcher(const Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnStart"); + HandleScope handleScope(jsRuntime_); + //napi_env env = reinterpret_cast(&jsRuntime_.GetNativeEngine()); + const std::string funcName = "FuncCallback"; + auto& nativeEngine = jsRuntime_.GetNativeEngine(); + NativeValue *nativeUri = nativeEngine.CreateString(uri.ToString().c_str(), uri.ToString().length()); + if (nativeUri == nullptr) { + HILOG_ERROR("create uri uri native js value fail."); + return; + } + NativeValue* func = nativeEngine.CreateFunction(funcName.c_str(), funcName.length(), + JsFileAccessExtAbility::FuncCallback, this); + NativeValue* argv[] = {nativeUri, func}; + CallObjectMethod("startWatcher", argv, ARGC_TWO); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +} + sptr JsFileAccessExtAbility::OnConnect(const AAFwk::Want &want) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnConnect"); @@ -1220,5 +1289,96 @@ int JsFileAccessExtAbility::UnregisterNotify(const Uri &uri) { return ERR_OK; } + +int JsFileAccessExtAbility::StartWatcher(const Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StartWatcher"); + CreateWatcher(uri); + // auto ret = std::make_shared(); + // if (ret == nullptr) { + // HILOG_ERROR("StartWatcher value is nullptr."); + // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + // return E_GETRESULT; + // } + + // auto argParser = [uri = uri](NativeEngine &engine, NativeValue *argv[], size_t &argc) -> bool { + // NativeValue *nativeUri = engine.CreateString(uri.ToString().c_str(), uri.ToString().length()); + // if (nativeUri == nullptr) { + // HILOG_ERROR("create uri uri native js value fail."); + // return false; + // } + // argv[ARGC_ZERO] = nativeUri; + // argc = ARGC_ONE; + // return true; + // }; + // auto retParser = [ret](NativeEngine &engine, NativeValue *result) -> bool { + // bool res = ConvertFromJsValue(engine, result, *ret); + // if (!res) { + // HILOG_ERROR("Convert js value fail."); + // } + // return res; + // }; + + // auto errCode = CallJsMethod("StartWatcher", jsRuntime_, jsObj_.get(), argParser, retParser); + // if (errCode != ERR_OK) { + // HILOG_ERROR("CallJsMethod error, code:%{public}d.", errCode); + // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + // return errCode; + // } + + // if (*ret != ERR_OK) { + // HILOG_ERROR("fileio fail."); + // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + // return *ret; + // } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} + +int JsFileAccessExtAbility::StopWatcher(const Uri &uri) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StopWatcher"); + auto ret = std::make_shared(); + if (ret == nullptr) { + HILOG_ERROR("StopWatcher value is nullptr."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_GETRESULT; + } + + auto argParser = [uri = uri](NativeEngine &engine, NativeValue *argv[], size_t &argc) -> bool { + NativeValue *nativeUri = engine.CreateString(uri.ToString().c_str(), uri.ToString().length()); + if (nativeUri == nullptr) { + HILOG_ERROR("create uri uri native js value fail."); + return false; + } + argv[ARGC_ZERO] = nativeUri; + argc = ARGC_ONE; + return true; + }; + auto retParser = [ret](NativeEngine &engine, NativeValue *result) -> bool { + bool res = ConvertFromJsValue(engine, result, *ret); + if (!res) { + HILOG_ERROR("Convert js value fail."); + } + return res; + }; + + auto errCode = CallJsMethod("StopWatcher", jsRuntime_, jsObj_.get(), argParser, retParser); + if (errCode != ERR_OK) { + HILOG_ERROR("CallJsMethod error, code:%{public}d.", errCode); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return errCode; + } + + if (*ret != ERR_OK) { + HILOG_ERROR("fileio fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return *ret; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp index dc74648b..d97ed9e3 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_service.cpp @@ -93,7 +93,7 @@ int32_t FileAccessObserverService::RegisterNotify(Uri uri, sptrAsObject().GetRefPtr()); - FileAccessObserverService::OnChange("123test"); + //FileAccessObserverService::OnChange("123test"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } @@ -113,7 +113,7 @@ int32_t FileAccessObserverService::UnregisterNotify(Uri uri, sptrRemoveObserver(path, 0, observer); } - FileAccessObserverService::OnChange("123test"); + FileAccessObserverService::OnChange(uri.ToString()); //RemoveObsDeathRecipient(observer->AsObject()); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; @@ -127,7 +127,7 @@ int32_t FileAccessObserverService::OnChange(std::string message) { std::lock_guard lock(nodeMutex_); path.clear(); - Uri uri("file://media/root/file"); + Uri uri(message); path.emplace_back(uri.GetScheme()); path.emplace_back(uri.GetAuthority()); uri.GetPathSegments(path); @@ -209,6 +209,7 @@ void FileAccessObserverService::ObserverNode::GetObs(const std::vector()).first->second.push_back(uri); HILOG_ERROR("cjw execute emplace uri = %{public}s", uri.ToString().c_str()); diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp index c4a0b9f4..ce1bac18 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp @@ -49,6 +49,7 @@ int32_t FileAccessObserverStub::OnRemoteRequest(uint32_t code, MessageParcel& da int32_t FileAccessObserverStub::ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { + HILOG_ERROR("cjw enter service ChooseCodeStub"); int32_t ret; switch (code) { case static_cast(IFileObserverBase::CMD_REGISTER_NOTIFY): { @@ -59,6 +60,10 @@ int32_t FileAccessObserverStub::ChooseCodeStub(uint32_t code, MessageParcel &dat ret = UnregisterNotifyStub(data, reply); break; } + case static_cast(IFileObserverBase::CMD_ONCHANGE): { + ret = OnChangeStub(data, reply); + break; + } default: { ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); break; diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp index 93d7dfa4..6ff17e72 100644 --- a/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp @@ -43,13 +43,14 @@ void ObserverCallbackProxy::OnChange(std::string message) MessageParcel reply; MessageOption option; - int err = Remote()->SendRequest(CMD_ONCHANGE, data, reply, option); + HILOG_ERROR("cjw proxy before sendRequest"); + int err = Remote()->SendRequest(CMD_CALLBACK, data, reply, option); if (err != ERR_OK) { HILOG_ERROR("fail to SendRequest. err: %{public}d", err); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return; } - + HILOG_ERROR("cjw proxy after sendRequest"); int ret = E_IPCS; if (!reply.ReadInt32(ret)) { HILOG_ERROR("fail to ReadInt32 ret"); @@ -58,7 +59,7 @@ void ObserverCallbackProxy::OnChange(std::string message) } if (ret != ERR_OK) { - HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); + HILOG_ERROR("OnChange operation failed ret : %{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return; } @@ -75,48 +76,48 @@ void ObserverCallbackProxy::OnChange(std::string message) return; } -std::string ObserverCallbackProxy::GetClassName() -{ - HILOG_ERROR("cjw proxy GetClassName"); - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetClassName"); - std::string result = "remote error"; - MessageParcel data; - if (!data.WriteInterfaceToken(ObserverCallbackProxy::GetDescriptor())) { - HILOG_ERROR("WriteInterfaceToken failed"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return result; - } +// std::string ObserverCallbackProxy::GetClassName() +// { +// HILOG_ERROR("cjw proxy GetClassName"); +// StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetClassName"); +// std::string result = "remote error"; +// MessageParcel data; +// if (!data.WriteInterfaceToken(ObserverCallbackProxy::GetDescriptor())) { +// HILOG_ERROR("WriteInterfaceToken failed"); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return result; +// } - MessageParcel reply; - MessageOption option; - int err = Remote()->SendRequest(CMD_GETCLASSNAME, data, reply, option); - if (err != ERR_OK) { - HILOG_ERROR("fail to SendRequest. err: %{public}d", err); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return result; - } +// MessageParcel reply; +// MessageOption option; +// int err = Remote()->SendRequest(CMD_GETCLASSNAME, data, reply, option); +// if (err != ERR_OK) { +// HILOG_ERROR("fail to SendRequest. err: %{public}d", err); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return result; +// } - int ret = E_IPCS; - if (!reply.ReadInt32(ret)) { - HILOG_ERROR("fail to ReadInt32 ret"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return result; - } +// int ret = E_IPCS; +// if (!reply.ReadInt32(ret)) { +// HILOG_ERROR("fail to ReadInt32 ret"); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return result; +// } - if (ret != ERR_OK) { - HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return result; - } +// if (ret != ERR_OK) { +// HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return result; +// } - if (!reply.ReadString(result)) { - HILOG_ERROR("fail to ReadString message"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return result; - } - HILOG_ERROR("cjw proxy className = %{public}s", result.c_str()); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return result; -} +// if (!reply.ReadString(result)) { +// HILOG_ERROR("fail to ReadString message"); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return result; +// } +// HILOG_ERROR("cjw proxy className = %{public}s", result.c_str()); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return result; +// } } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp index cb72a51c..3bd7c7d8 100644 --- a/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp @@ -18,7 +18,6 @@ #include #include -#include "access_token.h" #include "accesstoken_kit.h" #include "file_access_framework_errno.h" #include "hilog_wrapper.h" @@ -30,9 +29,14 @@ namespace OHOS { namespace FileAccessFwk { +ObserverCallbackStub::ObserverCallbackStub() +{ + HILOG_ERROR("cjw enter ObserverCallbackStub Constructor"); +} int ObserverCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) { + HILOG_ERROR("cjw enter OnRemoteRequest"); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnRemoteRequest"); std::u16string descriptor = ObserverCallbackStub::GetDescriptor(); std::u16string remoteDescriptor = data.ReadInterfaceToken(); @@ -48,16 +52,18 @@ int ObserverCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel& data, Me int32_t ObserverCallbackStub::ChooseCodeStub(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { + HILOG_ERROR("cjw enter ChooseCodeStub"); int32_t ret; switch (code) { - case static_cast(IFileAccessObserver::CMD_ONCHANGE): { + case static_cast(IFileAccessObserver::CMD_CALLBACK): { + HILOG_ERROR("cjw enter ChooseCodeStub OnChangeStub"); ret = OnChangeStub(data, reply); break; } - case static_cast(IFileAccessObserver::CMD_GETCLASSNAME): { - ret = GetClassNameStub(data, reply); - break; - } + // case static_cast(IFileAccessObserver::CMD_GETCLASSNAME): { + // ret = GetClassNameStub(data, reply); + // break; + // } default: { ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option); break; @@ -77,30 +83,36 @@ int32_t ObserverCallbackStub::OnChangeStub(MessageParcel &data, MessageParcel &r } HILOG_ERROR("cjw stub message = %{public}s", message.c_str()); OnChange(message); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return ERR_OK; -} - -int32_t ObserverCallbackStub::GetClassNameStub(MessageParcel &data, MessageParcel &reply) -{ - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetClassNameStub"); - std::string className; - className = GetClassName(); - int ret = ERR_OK; + int ret = 0; if (!reply.WriteInt32(ret)) { - HILOG_ERROR("Parameter GetClassName fail to WriteInt32 ret"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return E_IPCS; - } - HILOG_ERROR("cjw stub className = %{public}s", className.c_str()); - - if (!reply.WriteString(className)) { - HILOG_ERROR("fail to ReadString className"); + HILOG_ERROR("Parameter OnChangeStub fail to WriteInt32 ret"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } + +// int32_t ObserverCallbackStub::GetClassNameStub(MessageParcel &data, MessageParcel &reply) +// { +// StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetClassNameStub"); +// std::string className; +// className = GetClassName(); +// int ret = ERR_OK; +// if (!reply.WriteInt32(ret)) { +// HILOG_ERROR("Parameter GetClassName fail to WriteInt32 ret"); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return E_IPCS; +// } +// HILOG_ERROR("cjw stub className = %{public}s", className.c_str()); + +// if (!reply.WriteString(className)) { +// HILOG_ERROR("fail to ReadString className"); +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return E_IPCS; +// } +// FinishTrace(HITRACE_TAG_FILEMANAGEMENT); +// return ERR_OK; +// } } } \ No newline at end of file diff --git a/sa_profile/5010.xml b/sa_profile/5010.xml index eccc1130..76dbf1dd 100755 --- a/sa_profile/5010.xml +++ b/sa_profile/5010.xml @@ -13,7 +13,7 @@ limitations under the License. --> - faf_service + file_access_service 5010 libfile_access_observer.z.so diff --git a/sa_profile/BUILD.gn b/sa_profile/BUILD.gn index f8a27c25..15d31458 100644 --- a/sa_profile/BUILD.gn +++ b/sa_profile/BUILD.gn @@ -14,7 +14,7 @@ import("//build/ohos/sa_profile/sa_profile.gni") import("//foundation/filemanagement/user_file_service/filemanagement_aafwk.gni") -ohos_sa_profile("observer_sa_profile") { +ohos_sa_profile("file_access_service_profile") { sources = [ "5010.xml" ] part_name = "user_file_service" } \ No newline at end of file diff --git a/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts b/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts index cd02eaf7..0f76251c 100644 --- a/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts +++ b/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts @@ -15,6 +15,7 @@ // @ts-nocheck import Extension from '@ohos.application.FileAccessExtensionAbility'; import fileio from '@ohos.fileio'; +import fs from '@ohos.file.fs'; import { init, delVolumeInfo, getVolumeInfoList, path2uri } from './VolumeManager'; import { onReceiveEvent } from './Subcriber'; import fileExtensionInfo from '@ohos.file.fileExtensionInfo'; @@ -39,6 +40,37 @@ const E_EXIST = 13900015; const E_NOEXIST = 13900002; const E_URIS = 14300002; const E_GETRESULT = 14300004; +let observerMap = new Map(); + +let name2code = new Map([ + ['IN_ACCESS', 0x00000001], + ['IN_MODIFY', 0x00000002], + ['IN_ATTRIB', 0x00000004], + ['IN_CLOSE_WRITE', 0x00000008], + ['IN_CLOSE_NOWRITE', 0x00000010], + ['IN_OPE', 0x00000020], + ['IN_MOVED_FROM', 0x00000040], + ['IN_MOVED_TO', 0x00000080], + ['IN_CREATE', 0x00000100], + ['IN_DELETE', 0x00000200], + ['IN_DELETE_SELF', 0x00000400], + ['IN_MOVE_SELF', 0x00000800] +]); + +let code2name = new Map([ + ['0x00000001', 'IN_ACCESS'], + ['0x00000002', 'IN_MODIFY'], + ['0x00000004', 'IN_ATTRIB'], + ['0x00000008', 'IN_CLOSE_WRITE'], + ['0x00000010', 'IN_CLOSE_NOWRITE'], + ['0x00000020', 'IN_OPE'], + ['0x00000040', 'IN_MOVED_FROM'], + ['0x00000080', 'IN_MOVED_TO'], + ['0x00000100', 'IN_CREATE'], + ['0x00000200', 'IN_DELETE'], + ['0x00000400', 'IN_DELETE_SELF'], + ['0x00000800', 'IN_MOVE_SELF'] +]); export default class FileExtAbility extends Extension { onCreate(want): void { @@ -52,6 +84,14 @@ export default class FileExtAbility extends Extension { }); } + dec2hex(dec, len) { + let hex = dec.toString(16); + if (len) { + while (hex.length < len) hex = '0' + hex; + } + return '0x' + hex; + } + checkUri(uri): boolean { try { let uriTmp = new baseUri.URI(uri); @@ -606,4 +646,63 @@ export default class FileExtAbility extends Extension { code: ERR_OK, }; } + + startWatcher(uri, callback) { + if (!this.checkUri(uri)) { + return E_URIS; + } + let watchPath = this.getPath(uri); + console.log("cjw path =" + watchPath); + try { + // const onChange = (data) => { + // console.log("cjw onchange in "); + // console.log("cjw" + data.event); + // let eventName = code2name[dec2hex(data.event, 8)]; + // let watchUri = FILE_PREFIX_NAME + BUNDLE_NAME + watchPath; + // callback(watchUri, eventName); + // console.log("cjw1" + NotifyMessage.message); + // } + console.log("cjw aaa start create"); + //let watcher; + //let watcher = await fs.createWatcher(watchPath, 0x00000fff, onChange); + //let relative_path = "/data/service/el1/public/storage_daemon/share/public/QueryTest1/external_file_access_watcher_00001.txt"; + //let relative_path = "data/service/el1/public/storage_daemon/share/public/WatcherTest/external_file_access_watcher_00000.txt"; + //console.log(relative_path); + let watcher = fs.createWatcher(watchPath, 0x00000002, (data) => { + try { + console.log("cjw onchange in "); + console.log("cjw" + data.event); + //let eventName = code2name[this.dec2hex(data.event, 8)]; + let eventName = "2"; + let watchUri = FILE_PREFIX_NAME + BUNDLE_NAME + watchPath; + callback(watchUri, eventName); + console.log("cjw1" + eventName); + } catch (e1) { + hilog.error(DOMAIN_CODE, TAG, 'onchange error ' + e1.message); + } + }); + console.log("cjw already create"); + observerMap.set(uri, watcher); + watcher.start(); + } catch (e) { + hilog.error(DOMAIN_CODE, TAG, 'startWatcher error ' + e.message); + return E_URIS; + } + return ERR_OK; + } + + stopWatcher(uri){ + if (!this.checkUri(uri)) { + return E_URIS; + } + try { + let watcher = observerMap.get(uri); + watcher.stop(); + observerMap.delete(uri); + } catch (e) { + hilog.error(DOMAIN_CODE, TAG, 'stopWatcher error ' + e.message); + return E_URIS; + } + return ERR_OK; + } }; \ No newline at end of file diff --git a/test/unittest/external_file_access_test.cpp b/test/unittest/external_file_access_test.cpp index 2067e101..8f307a25 100644 --- a/test/unittest/external_file_access_test.cpp +++ b/test/unittest/external_file_access_test.cpp @@ -26,7 +26,7 @@ #include "iservice_registry.h" #include "nativetoken_kit.h" #include "token_setproc.h" - +#include "iobserver_callback.h" #define private public #include "file_access_helper.h" #undef private @@ -37,10 +37,10 @@ using namespace OHOS; using namespace FileAccessFwk; using json = nlohmann::json; const int ABILITY_ID = 5003; -const int INIT_THREADS_NUMBER = 4; -const int ACTUAL_SUCCESS_THREADS_NUMBER = 1; +//const int INIT_THREADS_NUMBER = 4; +//const int ACTUAL_SUCCESS_THREADS_NUMBER = 1; shared_ptr g_fah = nullptr; -int g_num = 0; +//int g_num = 0; const int UID_TRANSFORM_TMP = 20000000; const int UID_DEFAULT = 0; shared_ptr g_context = nullptr; @@ -111,3191 +111,3272 @@ public: void SetUp(){}; void TearDown(){}; }; +class MyObserver : public IRemoteStub { +public: + MyObserver() {}; + virtual ~MyObserver() {}; + void OnChange(std::string message) override; + std::string GetClassName() override; + bool Equal(void *observer) override; +}; -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0000 - * @tc.name: external_file_access_OpenFile_0000 - * @tc.desc: Test function of OpenFile interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest1(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest1, "external_file_access_OpenFile_0000.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result; - close(fd); - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0001 - * @tc.name: external_file_access_OpenFile_0001 - * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0001"; - try { - Uri uri(""); - int fd; - int result = g_fah->OpenFile(uri, WRITE_READ, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0002 - * @tc.name: external_file_access_OpenFile_0002 - * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0002"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0002.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri uri("storage/media/100/local/files/Download/external_file_access_OpenFile_0002.txt"); - int fd; - result = g_fah->OpenFile(uri, WRITE_READ, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result; - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0003 - * @tc.name: external_file_access_OpenFile_0003 - * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0003, testing::ext::TestSize.Level1) +void MyObserver::OnChange (std::string message) { - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0003"; - try { - Uri uri("~!@#$%^&*()_"); - int fd; - int result = g_fah->OpenFile(uri, WRITE_READ, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0003"; + } -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0004 - * @tc.name: external_file_access_OpenFile_0004 - * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0004, testing::ext::TestSize.Level1) +std::string MyObserver::GetClassName() { - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0004.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - int flag = -1; - result = g_fah->OpenFile(newFileUri, flag, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result; - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0004"; + return "name"; } -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0005 - * @tc.name: external_file_access_OpenFile_0005 - * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0005, testing::ext::TestSize.Level1) +bool MyObserver::Equal(void *observer) { - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0005.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result; - close(fd); - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0005"; + return true; } - /** - * @tc.number: user_file_service_external_file_access_OpenFile_0006 - * @tc.name: external_file_access_OpenFile_0006 - * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1. + * @tc.number: user_file_service_external_file_access_startWatcher_0000 + * @tc.name: external_file_access_startWatcher_0000 + * @tc.desc: Test function of startWatcher interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 * @tc.require: SR000H0386 */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0006, testing::ext::TestSize.Level1) +HWTEST_F(FileExtensionHelperTest, external_file_access_startWatcher_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0006"; + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_startWatcher_0000"; try { vector info; int result = g_fah->GetRoots(info); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0006.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, WRITE, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result; - close(fd); - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0006"; -} - -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0007 - * @tc.name: external_file_access_OpenFile_0007 - * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0007"; - try { - vector info; - int result = g_fah->GetRoots(info); + Uri parentUri(info[0].uri); + GTEST_LOG_(INFO) << parentUri.ToString(); + Uri newDirUriTest1(""); + result = g_fah->Mkdir(parentUri, "WatcherTest", newDirUriTest1); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0007.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result; - close(fd); - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0007"; -} - -static void OpenFileTdd(shared_ptr fahs, Uri uri, int flag, int fd) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFileTdd"; - int ret = fahs->OpenFile(uri, flag, fd); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "OpenFile get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK); - g_num++; - close(fd); - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFileTdd"; -} - -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0008 - * @tc.name: external_file_access_OpenFile_0008 - * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0008, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0008"; - try { - vector info; - int result = g_fah->GetRoots(info); + Uri newFileUri1(""); + std::string fileName = "external_file_access_watcher_00000.txt"; + result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - int fd; - std::string displayName = "test1.txt"; - g_num = 0; - result = g_fah->CreateFile(parentUri, displayName, newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(OpenFileTdd, g_fah, newFileUri, WRITE_READ, fd); - execthread.join(); - } - EXPECT_EQ(g_num, INIT_THREADS_NUMBER); - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0008 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0008"; -} - -static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName) -{ - Uri uri(path); - std::string scheme = uri.GetScheme(); - if (scheme == FILE_SCHEME_NAME) { - std::string curName = uri.GetAuthority(); - if (curName.empty()) { - return false; - } - path.replace(path.find(curName), curName.length(), newName); - return true; - } - - std::string tPath = uri.GetPath(); - if (tPath.empty()) { - GTEST_LOG_(INFO) << "Uri path error."; - return false; - } - - if (tPath.front() != '/') { - GTEST_LOG_(INFO) << "Uri path format error."; - return false; - } - - auto index = tPath.substr(1).find_first_of("/"); - auto bundleName = tPath.substr(1, index); - if (bundleName.empty()) { - GTEST_LOG_(INFO) << "bundleName empty."; - return false; - } - - path.replace(path.find(bundleName), bundleName.length(), newName); - return true; -} - -/** - * @tc.number: user_file_service_external_file_access_OpenFile_0009 - * @tc.name: external_file_access_OpenFile_0009 - * @tc.desc: Test function of OpenFile interface for FAILED because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0009, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0009"; - try { - vector info; - int result = g_fah->GetRoots(info); + int fd = -1; + std::string buff = "watcher test"; + result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - std::string str = info[i].uri; - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - int fd; - Uri newFileUri(str + "/NotExistFile.txt"); - result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - GTEST_LOG_(INFO) << "OpenFile_0009 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0009 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0009"; -} + sleep(1); -/** - * @tc.number: user_file_service_external_file_access_CreateFile_0000 - * @tc.name: external_file_access_CreateFile_0000 - * @tc.desc: Test function of CreateFile interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0000.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result; - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0000"; -} -/** - * @tc.number: user_file_service_external_file_access_CreateFile_0001 - * @tc.name: external_file_access_CreateFile_0001 - * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0001"; - try { - Uri newFileUri(""); - Uri parentUri(""); - int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0001.txt", newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0001"; -} -/** - * @tc.number: user_file_service_external_file_access_CreateFile_0002 - * @tc.name: external_file_access_CreateFile_0002 - * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0002"; - try { - Uri newFileUri(""); - Uri parentUri("storage/media/100/local/files/Download"); - int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0002.txt", newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0002"; -} -/** - * @tc.number: user_file_service_external_file_access_CreateFile_0003 - * @tc.name: external_file_access_CreateFile_0003 - * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0002"; - try { - Uri newFileUri(""); - Uri parentUri("~!@#$%^&*()_"); - int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0003.txt", newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0003"; -} + // result = g_fah->StartWatcher(newFileUri1); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + bool notifyForDescendants = false; + sptr myObserver = new MyObserver(); + result = g_fah->RegisterNotify(newFileUri1, notifyForDescendants, myObserver); + EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); -/** - * @tc.number: user_file_service_external_file_access_CreateFile_0004 - * @tc.name: external_file_access_CreateFile_0004 - * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - string displayName = ""; - result = g_fah->CreateFile(parentUri, displayName, newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0004"; -} -static void CreateFileTdd(shared_ptr fahs, Uri uri, std::string displayName, Uri newFile) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFileTdd"; - int ret = fahs->CreateFile(uri, displayName, newFile); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_NE(newFile.ToString(), ""); - g_num++; - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFileTdd"; -} -/** - * @tc.number: user_file_service_external_file_access_CreateFile_0005 - * @tc.name: external_file_access_CreateFile_0005 - * @tc.desc: Test function of CreateFile interface for ERROR which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); + ssize_t fileSize = write(fd, buff.c_str(), buff.size()); + EXPECT_EQ(fileSize, buff.size()); + sleep(1); + close(fd); + result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newFileUri(""); - std::string displayName = "test1.txt"; - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(CreateFileTdd, g_fah, parentUri, displayName, newFileUri); - execthread.join(); - } - EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - Uri newDelete(info[i].uri + "/" + displayName); - result = g_fah->Delete(newDelete); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } + std::string buff1 = "aaaa"; + ssize_t fileSize1 = write(fd, buff1.c_str(), buff1.size()); + EXPECT_EQ(fileSize1, buff1.size()); + close(fd); } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_CreateFile_0006 - * @tc.name: external_file_access_CreateFile_0006 - * @tc.desc: Test function of CreateFile interface for ERROR because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0006"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - std::string str = info[i].uri; - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri parentUri(str); - Uri newFileUri(""); - string displayName = "test.txt"; - result = g_fah->CreateFile(parentUri, displayName, newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - GTEST_LOG_(INFO) << "CreateFile_0006 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0006"; -} - -/** - * @tc.number: user_file_service_external_file_access_Mkdir_0000 - * @tc.name: external_file_access_Mkdir_0000 - * @tc.desc: Test function of Mkdir interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0000", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_Mkdir_0001 - * @tc.name: external_file_access_Mkdir_0001 - * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0001"; - try { - Uri newDirUriTest(""); - Uri parentUri(""); - int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0001", newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_Mkdir_0002 - * @tc.name: external_file_access_Mkdir_0002 - * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002"; - try { - Uri newDirUriTest(""); - Uri parentUri("storage/media/100/local/files/Download"); - int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0002", newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_Mkdir_0003 - * @tc.name: external_file_access_Mkdir_0003 - * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002"; - try { - Uri newDirUriTest(""); - Uri parentUri("~!@#$%^&*()_"); - int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0003", newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0003"; -} - -/** - * @tc.number: user_file_service_external_file_access_Mkdir_0004 - * @tc.name: external_file_access_Mkdir_0004 - * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - string displayName = ""; - result = g_fah->Mkdir(parentUri, displayName, newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0004"; -} - -static void MkdirTdd(shared_ptr fahs, Uri uri, std::string displayName, Uri newFile) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MkdirTdd"; - int ret = fahs->Mkdir(uri, displayName, newFile); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_NE(newFile.ToString(), ""); - g_num++; - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MkdirTdd"; -} - -/** - * @tc.number: user_file_service_external_file_access_Mkdir_0005 - * @tc.name: external_file_access_Mkdir_0005 - * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - std::string displayName = "test1"; - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(MkdirTdd, g_fah, parentUri, displayName, newDirUriTest); - execthread.join(); - } - EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - Uri newDelete(info[i].uri + "/" + displayName); - result = g_fah->Delete(newDelete); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_Mkdir_0006 - * @tc.name: external_file_access_Mkdir_0006 - * @tc.desc: Test function of Mkdir interface for ERROR because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0006"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - std::string str = info[i].uri; - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri parentUri(str); - Uri newDirUriTest(""); - string displayName = ""; - result = g_fah->Mkdir(parentUri, displayName, newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - GTEST_LOG_(INFO) << "Mkdir_0006 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0006"; -} - -/** - * @tc.number: user_file_service_external_file_access_Delete_0000 - * @tc.name: external_file_access_Delete_0000 - * @tc.desc: Test function of Delete interface for SUCCESS which delete file. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest, "external_file_access_Delete_0000.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0000 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Delete_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_Delete_0001 - * @tc.name: external_file_access_Delete_0001 - * @tc.desc: Test function of Delete interface for SUCCESS which delete folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0001"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0001 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Delete_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_Delete_0002 - * @tc.name: external_file_access_Delete_0002 - * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0002"; - try { - Uri selectFileUri(""); - int result = g_fah->Delete(selectFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Delete_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_Delete_0003 - * @tc.name: external_file_access_Delete_0003 - * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0003"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri selectFileUri("storage/media/100/local/files/Download/test"); - result = g_fah->Delete(selectFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0003 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Delete_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0003"; -} - -/** - * @tc.number: user_file_service_external_file_access_Delete_0004 - * @tc.name: external_file_access_Delete_0004 - * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0004"; - try { - Uri selectFileUri("!@#$%^&*()"); - int result = g_fah->Delete(selectFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0004 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Delete_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0004"; -} - -static void DeleteTdd(shared_ptr fahs, Uri selectFile) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_DeleteTdd"; - int ret = fahs->Delete(selectFile); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - g_num++; - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_DeleteTdd"; -} - -/** - * @tc.number: user_file_service_external_file_access_Delete_0005 - * @tc.name: external_file_access_Delete_0005 - * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - std::string displayName = "test1.txt"; - result = g_fah->CreateFile(newDirUriTest, displayName, newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(DeleteTdd, g_fah, newFileUri); - execthread.join(); - } - EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Delete_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_Delete_0006 - * @tc.name: external_file_access_Delete_0006 - * @tc.desc: Test function of Delete interface for ERROR because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0006"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - std::string str = info[i].uri; - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri selectFileUri(str); - int result = g_fah->Delete(selectFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - GTEST_LOG_(INFO) << "Delete_0006 result:" << result; - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Delete_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0006"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0000 - * @tc.name: external_file_access_Move_0000 - * @tc.desc: Test function of Move interface for SUCCESS which move file. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - result = g_fah->Move(testUri, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0000 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0001 - * @tc.name: external_file_access_Move_0001 - * @tc.desc: Test function of Move interface for SUCCESS which move folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0001"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0001 result:" << result; - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0002 - * @tc.name: external_file_access_Move_0002 - * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0002"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - Uri sourceFileUri(""); - result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0002 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0003 - * @tc.name: external_file_access_Move_0003 - * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0003"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri sourceFileUri("storage/media/100/local/files/Download/test1/test.txt"); - result = g_fah->Move(sourceFileUri, newDirUriTest2, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0003 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0003"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0004 - * @tc.name: external_file_access_Move_0004 - * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - Uri sourceFileUri("~!@#$%^&*()_"); - result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0004 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0004"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0005 - * @tc.name: external_file_access_Move_0005 - * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri targetParentUri(""); - result = g_fah->Move(testUri, targetParentUri, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0005 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0006 - * @tc.name: external_file_access_Move_0006 - * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0006"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri targetParentUri("storage/media/100/local/files/Download/test2"); - result = g_fah->Move(testUri, targetParentUri, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0006 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0006"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0007 - * @tc.name: external_file_access_Move_0007 - * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0007"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri targetParentUri("~!@#$^%&*()_"); - result = g_fah->Move(testUri, targetParentUri, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0007 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0007"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0008 - * @tc.name: external_file_access_Move_0008 - * @tc.desc: Test function of Move interface for SUCCESS which move empty folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0008, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0008"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0008 result:" << result; - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0008 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0008"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0009 - * @tc.name: external_file_access_Move_0009 - * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0009, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0009"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - size_t fileNumbers = 2000; - for (size_t j = 0; j < fileNumbers; j++) { - string fileName = "test" + ToString(j) + ".txt"; - result = g_fah->CreateFile(newDirUriTest1, fileName, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - Uri testUri2(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0009 result:" << result; - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0009 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0009"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0010 - * @tc.name: external_file_access_Move_0010 - * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0010, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0010"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->Mkdir(newDirUriTest1, "test", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - size_t directoryNumbers = 64; - for (size_t j = 0; j < directoryNumbers; j++) { - result = g_fah->Mkdir(testUri, "test", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - Uri testUri2(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0010 result:" << result; - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0010 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0010"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0011 - * @tc.name: external_file_access_Move_0011 - * @tc.desc: Test function of Move interface for SUCCESS which move other equipment file. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0011, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0011"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t j = i + 1; j < info.size(); j++) { - Uri otherUri(info[j].uri); - result = g_fah->Mkdir(otherUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Move(testUri, newDirUriTest2, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Move(testUri, newDirUriTest1, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0011 result:" << result; - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0011 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0011"; -} - -static void MoveTdd(shared_ptr fahs, Uri sourceFile, Uri targetParent, Uri newFile) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MoveTdd"; - int ret = fahs->Move(sourceFile, targetParent, newFile); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - g_num++; - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MoveTdd"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0012 - * @tc.name: external_file_access_Move_0012 - * @tc.desc: Test function of Move interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0012, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0012"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - std::string displayName = "test3.txt"; - result = g_fah->CreateFile(newDirUriTest1, displayName, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(MoveTdd, g_fah, testUri, newDirUriTest2, testUri2); - execthread.join(); - } - EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0012 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0012"; -} - -/** - * @tc.number: user_file_service_external_file_access_Move_0013 - * @tc.name: external_file_access_Move_0013 - * @tc.desc: Test function of Move interface for FAILED because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0013, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0013"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(info[0].uri); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->Mkdir(newDirUriTest1, "test", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string str = newDirUriTest1.ToString(); - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri uri(str); - Uri testUri2(""); - result = g_fah->Move(uri, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - GTEST_LOG_(INFO) << "Move_0013 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Move_0013 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0013"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0000 - * @tc.name: external_file_access_Rename_0000 - * @tc.desc: Test function of Rename interface for SUCCESS which rename file. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - result = g_fah->Rename(testUri, "test2.txt", renameUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0000 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0001 - * @tc.name: external_file_access_Rename_0001 - * @tc.desc: Test function of Rename interface for SUCCESS which rename folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0001"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - result = g_fah->Rename(newDirUriTest, "testRename", renameUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0001 result:" << result; - result = g_fah->Delete(renameUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0002 - * @tc.name: external_file_access_Rename_0002 - * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0002"; - try { - Uri renameUri(""); - Uri sourceFileUri(""); - int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0003 - * @tc.name: external_file_access_Rename_0003 - * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0003"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); - result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0003 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0003"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0004 - * @tc.name: external_file_access_Rename_0004 - * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0004"; - try { - Uri renameUri(""); - Uri sourceFileUri("~!@#$%^&*()_"); - int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0004 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0004"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0005 - * @tc.name: external_file_access_Rename_0005 - * @tc.desc: Test function of Rename interface for ERROR which displayName is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - result = g_fah->Rename(testUri, "", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0005 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0005"; -} - -static void RenameTdd(shared_ptr fahs, Uri sourceFile, std::string displayName, Uri newFile) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_RenameTdd"; - int ret = fahs->Rename(sourceFile, displayName, newFile); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "RenameTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - g_num++; - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_RenameTdd"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0006 - * @tc.name: external_file_access_Rename_0006 - * @tc.desc: Test function of Rename interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0006"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - std::string displayName1 = "test1.txt"; - std::string displayName2 = "test2.txt"; - Uri renameUri(""); - result = g_fah->CreateFile(newDirUriTest, displayName1, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(RenameTdd, g_fah, testUri, displayName2, renameUri); - execthread.join(); - } - EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0006"; -} - -/** - * @tc.number: user_file_service_external_file_access_Rename_0007 - * @tc.name: external_file_access_Rename_0007 - * @tc.desc: Test function of Rename interface for ERROR because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0007"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - std::string str = newDirUriTest.ToString(); - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri testUri(str); - Uri renameUri(""); - result = g_fah->Rename(testUri, "test.txt", renameUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - GTEST_LOG_(INFO) << "Rename_0007 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Rename_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0007"; -} - -/** - * @tc.number: user_file_service_external_file_access_ListFile_0000 - * @tc.name: external_file_access_ListFile_0000 - * @tc.desc: Test function of ListFile interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_0000.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_ListFile_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_ListFile_0001 - * @tc.name: external_file_access_ListFile_0001 - * @tc.desc: Test function of ListFile interface for ERROR which Uri is nullptr. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0001"; - try { - Uri sourceFileUri(""); - FileInfo fileInfo; - fileInfo.uri = sourceFileUri.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_ListFile_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_ListFile_0002 - * @tc.name: external_file_access_ListFile_0002 - * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0002"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); - FileInfo fileInfo; - fileInfo.uri = sourceFileUri.ToString(); - Uri sourceFile(fileInfo.uri); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_ListFile_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_ListFile_0003 - * @tc.name: external_file_access_ListFile_0003 - * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0003"; - try { - Uri sourceFileUri("~!@#$%^&*()_"); - FileInfo fileInfo; - fileInfo.uri = sourceFileUri.ToString(); - Uri sourceFile(fileInfo.uri); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_ListFile_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0003"; -} - -static void ListFileTdd(FileInfo fileInfo, int offset, int maxCount, FileFilter filter, - std::vector fileInfoVec) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFileTdd"; - int ret = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "ListFile get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - g_num++; - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFileTdd"; -} - -/** - * @tc.number: user_file_service_external_file_access_ListFile_0004 - * @tc.name: external_file_access_ListFile_0004 - * @tc.desc: Test function of ListFile interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_0004.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int offset = 0; - int maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(ListFileTdd, fileInfo, offset, maxCount, filter, fileInfoVec); - execthread.join(); - } - EXPECT_EQ(g_num, INIT_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_ListFile_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0004"; -} - -/** - * @tc.number: user_file_service_external_file_access_ListFile_0005 - * @tc.name: external_file_access_ListFile_0005 - * @tc.desc: Test function of ListFile interface for ERROR because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - std::string str = testUri.ToString(); - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - FileInfo fileInfo; - fileInfo.uri = str; - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_ListFile_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetRoots_0000 - * @tc.name: external_file_access_GetRoots_0000 - * @tc.desc: Test function of GetRoots interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0387 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetRoots_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetRoots_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "GetRoots_0000 result:" << info.size() << endl; - for (size_t i = 0; i < info.size(); i++) { - GTEST_LOG_(INFO) << info[i].uri; - GTEST_LOG_(INFO) << info[i].displayName; - GTEST_LOG_(INFO) << info[i].deviceFlags; - GTEST_LOG_(INFO) << info[i].deviceType; - } - string uri = "file://com.ohos.UserFile.ExternalFileManager/data/storage/el1/bundle/storage_daemon"; - string displayName = "shared_disk"; - EXPECT_EQ(info[0].uri, uri); - EXPECT_EQ(info[0].displayName, displayName); - EXPECT_EQ(info[0].deviceType, DEVICE_SHARED_DISK); - EXPECT_EQ(info[0].deviceFlags, DEVICE_FLAG_SUPPORTS_READ | DEVICE_FLAG_SUPPORTS_WRITE); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetRoots_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetRoots_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_Access_0000 - * @tc.name: external_file_access_Access_0000 - * @tc.desc: Test function of Access interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "test1", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest, "external_file_access_Access_0000.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - bool isExist = false; - result = g_fah->Access(newDirUriTest, isExist); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_TRUE(isExist); - result = g_fah->Access(newFileUri, isExist); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_TRUE(isExist); - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Access(newDirUriTest, isExist); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_FALSE(isExist); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Access_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_Access_0001 - * @tc.name: external_file_access_Access_0001 - * @tc.desc: Test function of Access interface FAILED because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0001"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - std::string str = info[i].uri; - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri newDirUriTest(str + "/test.txt"); - bool isExist = false; - result = g_fah->Access(newDirUriTest, isExist); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - EXPECT_FALSE(isExist); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Access_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0000 - * @tc.name: external_file_access_GetFileInfoFromUri_0000 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVecTemp; - result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0001 - * @tc.name: external_file_access_GetFileInfoFromUri_0001 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0001"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "testDir", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - FileInfo dirInfo; - result = g_fah->GetFileInfoFromUri(newDirUriTest, dirInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVec; - result = g_fah->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0002 - * @tc.name: external_file_access_GetFileInfoFromUri_0002 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the general filepath uri to fileinfo and call listfile for ERROR. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0002"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(info[i].uri); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "testDir", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest, "external_file_access_GetFileInfoFromUri_0002.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(newFileUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVecTemp; - result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0003 - * @tc.name: external_file_access_GetFileInfoFromUri_0003 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0003"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(std::string("\?\?\?\?/") + info[i].uri); - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0003"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0004 - * @tc.name: external_file_access_GetFileInfoFromUri_0004 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - std::string str = info[i].uri; - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri parentUri(str); - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - } - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0004"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0005 - * @tc.name: external_file_access_GetFileInfoFromUri_0005 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the invalid uri to fileinfo failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0005"; - try { - Uri uri("~!@#$%^&*()_"); - FileInfo fileInfo; - int result = g_fah->GetFileInfoFromUri(uri, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - uri = Uri("/"); - result = g_fah->GetFileInfoFromUri(uri, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - uri = Uri(""); - result = g_fah->GetFileInfoFromUri(uri, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0000 - * @tc.name: external_file_access_creator_0000 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0000"; - try { - setuid(UID_TRANSFORM_TMP); - std::pair, int> helper = FileAccessHelper::Creator(g_context); - setuid(UID_DEFAULT); - ASSERT_TRUE(helper.first != nullptr); - bool succ = helper.first->Release(); - EXPECT_TRUE(succ); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0001 - * @tc.name: external_file_access_creator_0001 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0001"; - try { - AAFwk::Want want; - vector wantVec; - setuid(UID_TRANSFORM_TMP); - int ret = FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(wantVec); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - bool sus = false; - for (size_t i = 0; i < wantVec.size(); i++) { - auto element = wantVec[i].GetElement(); - if (element.GetBundleName() == "com.ohos.UserFile.ExternalFileManager" && - element.GetAbilityName() == "FileExtensionAbility") { - want = wantVec[i]; - sus = true; - break; - } - } - EXPECT_TRUE(sus); - vector wants{want}; - std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); - setuid(UID_DEFAULT); - ASSERT_TRUE(helper.first != nullptr); - bool succ = helper.first->Release(); - EXPECT_TRUE(succ); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0002 - * @tc.name: external_file_access_creator_0002 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0002"; - try { - std::shared_ptr context = nullptr; - std::pair, int> helper = FileAccessHelper::Creator(context); - ASSERT_TRUE(helper.first == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0003 - * @tc.name: external_file_access_creator_0003 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0003"; - try { - std::vector wants; - std::shared_ptr context = nullptr; - std::pair, int> helper = FileAccessHelper::Creator(context, wants); - ASSERT_TRUE(helper.first == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0003"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0004 - * @tc.name: external_file_access_creator_0004 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0004"; - try { - std::vector wants; - std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); - ASSERT_TRUE(helper.first == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0004"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0005 - * @tc.name: external_file_access_creator_0005 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0005"; - try { - AAFwk::Want want; - want.SetElementName("NotExistBundleName", "NotExistAbilityName"); - std::vector wants{want}; - std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); - ASSERT_TRUE(helper.first == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0006 - * @tc.name: external_file_access_creator_0006 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0006"; - try { - std::vector wants; - std::shared_ptr context = nullptr; - std::pair, int> helper = FileAccessHelper::Creator(context, wants); - ASSERT_TRUE(helper.first == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0006"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0007 - * @tc.name: external_file_access_creator_0007 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0007"; - try { - std::vector wants; - shared_ptr helper = FileAccessHelper::Creator(g_context->GetToken(), wants); - ASSERT_TRUE(helper == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0007"; -} - -/** - * @tc.number: user_file_service_external_file_access_creator_0008 - * @tc.name: external_file_access_creator_0008 - * @tc.desc: Test function of creator interface. - * @tc.desc: create file access helper for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0008, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0008"; - try { - AAFwk::Want want; - want.SetElementName("NotExistBundleName", "NotExistAbilityName"); - std::vector wants{want}; - shared_ptr helper = FileAccessHelper::Creator(g_context->GetToken(), wants); - ASSERT_TRUE(helper == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_creator_0008 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0008"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetConnectInfo_0000 - * @tc.name: external_file_access_GetConnectInfo_0000 - * @tc.desc: Test function of GetConnectInfo interface. - * @tc.desc: helper invoke GetConnectInfo for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetConnectInfo_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetConnectInfo_0000"; - try { - std::shared_ptr connectInfo = g_fah->GetConnectInfo("NotExistBundleName"); - ASSERT_TRUE(connectInfo == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetConnectInfo_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetConnectInfo_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetKeyOfWants_0000 - * @tc.name: external_file_access_GetKeyOfWants_0000 - * @tc.desc: Test function of GetKeyOfWants interface. - * @tc.desc: helper invoke GetKeyOfWants for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetKeyOfWants_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetKeyOfWants_0000"; - try { - AAFwk::Want want; - want.SetElementName("NotExistBundleName", "NotExistAbilityName"); - std::string key = g_fah->GetKeyOfWants(want); - ASSERT_TRUE(key.empty()); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetKeyOfWants_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetKeyOfWants_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetProxyByUri_0000 - * @tc.name: external_file_access_GetProxyByUri_0000 - * @tc.desc: Test function of GetProxyByUri interface. - * @tc.desc: helper invoke GetProxyByUri for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0000"; - try { - Uri uri(""); - sptr proxy = g_fah->GetProxyByUri(uri); - ASSERT_TRUE(proxy == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_GetProxyByUri_0001 - * @tc.name: external_file_access_GetProxyByUri_0001 - * @tc.desc: Test function of GetProxyByUri interface. - * @tc.desc: helper invoke GetProxyByUri for FAILED. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0001"; - try { - Uri uri("file://com.ohos.UserFile.NotExistBundleName/data/storage/el1/bundle/storage_daemon"); - sptr proxy = g_fah->GetProxyByUri(uri); - ASSERT_TRUE(proxy == nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_Query_0000 - * @tc.name: external_file_access_Query_0000 - * @tc.desc: Test function of Query directory for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(info[0].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - std::string displayName = "QueryTest1"; - std::string relativePath = "/data/storage/el1/bundle/storage_daemon/"; - result = g_fah->Mkdir(parentUri, "QueryTest1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(newDirUriTest1, "QueryTest2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri1(""); - Uri newFileUri2(""); - std::string fileName = "external_file_access_Query_00001.txt"; - result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->CreateFile(newDirUriTest2, fileName, newFileUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd = -1; - std::string buff = "query test"; - result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - ssize_t fileSize = write(fd, buff.c_str(), buff.size()); - close(fd); - EXPECT_EQ(fileSize, buff.size()); - result = g_fah->OpenFile(newFileUri2, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - fileSize = write(fd, buff.c_str(), buff.size()); - close(fd); - EXPECT_EQ(fileSize, buff.size()); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {FILE_SIZE, " "}, - {DATE_MODIFIED, " "}, - {DATE_ADDED, " "}, - {HEIGHT, " "}, - {WIDTH, " "}, - {DURATION, " "} - }; - auto testJsonString = testJson.dump(); - result = g_fah->Query(newDirUriTest1, testJsonString); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - auto jsonObject = json::parse(testJsonString); - EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); - EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2); - EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath); - ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); - ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); - GTEST_LOG_(INFO) << " result" << testJsonString; - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Query_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0000"; -} - -/** - * @tc.number: user_file_service_external_file_access_Query_0001 - * @tc.name: external_file_access_Query_0001 - * @tc.desc: Test function of Query file for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0001"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(info[0].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "QueryTest3", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - std::string displayName = "external_file_access_Query_0001.txt"; - std::string relativePath = "/data/storage/el1/bundle/storage_daemon/QueryTest3/"; - result = g_fah->CreateFile(newDirUriTest, displayName, newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd = -1; - result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string buff = "query test"; - ssize_t fileSize = write(fd, buff.c_str(), buff.size()); - close(fd); - EXPECT_EQ(fileSize, buff.size()); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {FILE_SIZE, " "}, - {DATE_MODIFIED, " "}, - {DATE_ADDED, " "}, - {HEIGHT, " "}, - {WIDTH, " "}, - {DURATION, " "} - }; - auto testJsonString = testJson.dump(); - result = g_fah->Query(newFileUri, testJsonString); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - auto jsonObject = json::parse(testJsonString); - EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); - EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size()); - EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath); - ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); - ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); - GTEST_LOG_(INFO) << " result" << testJsonString; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Query_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0001"; -} - -/** - * @tc.number: user_file_service_external_file_access_Query_0002 - * @tc.name: external_file_access_Query_0002 - * @tc.desc: Test function of Query directory for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0002"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(info[0].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - result = g_fah->Mkdir(parentUri, "QueryTest4", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(newDirUriTest1, "QueryTest5", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri1(""); - Uri newFileUri2(""); - std::string fileName = "external_file_access_Query_00001.txt"; - result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->CreateFile(newDirUriTest2, fileName, newFileUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd = -1; - std::string buff = "query test"; - result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - ssize_t fileSize = write(fd, buff.c_str(), buff.size()); - close(fd); - EXPECT_EQ(fileSize, buff.size()); - result = g_fah->OpenFile(newFileUri2, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - fileSize = write(fd, buff.c_str(), buff.size()); - close(fd); - EXPECT_EQ(fileSize, buff.size()); - json testJson = { - {FILE_SIZE, " "} - }; - auto testJsonString = testJson.dump(); - result = g_fah->Query(newDirUriTest1, testJsonString); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - auto jsonObject = json::parse(testJsonString); - EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2); - GTEST_LOG_(INFO) << " result" << testJsonString; - result = g_fah->Delete(newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Query_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0002"; -} - -/** - * @tc.number: user_file_service_external_file_access_Query_0003 - * @tc.name: external_file_access_Query_0003 - * @tc.desc: Test function of Query interface for which is unreadable code. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0003"; - try { - Uri testUri("&*()*/?"); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "} - }; - auto testJsonString = testJson.dump(); - int result = g_fah->Query(testUri, testJsonString); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << " result" << testJsonString; - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Query_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0003"; -} - -/** - * @tc.number: user_file_service_external_file_access_Query_0004 - * @tc.name: external_file_access_Query_0004 - * @tc.desc: Test function of Query interface for which all column nonexistence. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(info[0].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "QueryTest6", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - json testJson = { - {"001", " "}, - {"#", " "}, - {"test", " "}, - {"target", " "} - }; - auto testJsonString = testJson.dump(); - result = g_fah->Query(newDirUriTest, testJsonString); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << " result" << testJsonString; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Query_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0004"; -} - -/** - * @tc.number: user_file_service_external_file_access_Query_0005 - * @tc.name: external_file_access_Query_0005 - * @tc.desc: Test function of Query interface for which part of column nonexistence. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0005"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(info[0].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "QueryTest7", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {"test", " "} - }; - auto testJsonString = testJson.dump(); - result = g_fah->Query(newDirUriTest, testJsonString); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << " result" << testJsonString; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Query_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0005"; -} - -/** - * @tc.number: user_file_service_external_file_access_Query_0006 - * @tc.name: external_file_access_Query_0006 - * @tc.desc: Test function of Query interface for which column is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0006"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(info[0].uri); - GTEST_LOG_(INFO) << parentUri.ToString(); - Uri newDirUriTest(""); - result = g_fah->Mkdir(parentUri, "QueryTest8", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - json testJson; - auto testJsonString = testJson.dump(); - result = g_fah->Query(newDirUriTest, testJsonString); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << " result" << testJsonString; - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "external_file_access_Query_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0006"; -} + GTEST_LOG_(ERROR) << "external_file_access_startWatcher_0000 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_startWatcher_0000"; +} + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0000 +// * @tc.name: external_file_access_OpenFile_0000 +// * @tc.desc: Test function of OpenFile interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest1(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "external_file_access_OpenFile_0000.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result; +// close(fd); +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0001 +// * @tc.name: external_file_access_OpenFile_0001 +// * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0001"; +// try { +// Uri uri(""); +// int fd; +// int result = g_fah->OpenFile(uri, WRITE_READ, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0002 +// * @tc.name: external_file_access_OpenFile_0002 +// * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0002"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0002.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri uri("storage/media/100/local/files/Download/external_file_access_OpenFile_0002.txt"); +// int fd; +// result = g_fah->OpenFile(uri, WRITE_READ, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result; +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0003 +// * @tc.name: external_file_access_OpenFile_0003 +// * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0003"; +// try { +// Uri uri("~!@#$%^&*()_"); +// int fd; +// int result = g_fah->OpenFile(uri, WRITE_READ, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0004 +// * @tc.name: external_file_access_OpenFile_0004 +// * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0004.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// int flag = -1; +// result = g_fah->OpenFile(newFileUri, flag, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result; +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0004"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0005 +// * @tc.name: external_file_access_OpenFile_0005 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0005.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result; +// close(fd); +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0006 +// * @tc.name: external_file_access_OpenFile_0006 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0006"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0006.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, WRITE, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result; +// close(fd); +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0006"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0007 +// * @tc.name: external_file_access_OpenFile_0007 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0007"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// result = g_fah->CreateFile(parentUri, "external_file_access_OpenFile_0007.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result; +// close(fd); +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0007"; +// } + +// static void OpenFileTdd(shared_ptr fahs, Uri uri, int flag, int fd) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFileTdd"; +// int ret = fahs->OpenFile(uri, flag, fd); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "OpenFile get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK); +// g_num++; +// close(fd); +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFileTdd"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0008 +// * @tc.name: external_file_access_OpenFile_0008 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0008, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0008"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// int fd; +// std::string displayName = "test1.txt"; +// g_num = 0; +// result = g_fah->CreateFile(parentUri, displayName, newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(OpenFileTdd, g_fah, newFileUri, WRITE_READ, fd); +// execthread.join(); +// } +// EXPECT_EQ(g_num, INIT_THREADS_NUMBER); +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0008 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0008"; +// } + +// static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName) +// { +// Uri uri(path); +// std::string scheme = uri.GetScheme(); +// if (scheme == FILE_SCHEME_NAME) { +// std::string curName = uri.GetAuthority(); +// if (curName.empty()) { +// return false; +// } +// path.replace(path.find(curName), curName.length(), newName); +// return true; +// } + +// std::string tPath = uri.GetPath(); +// if (tPath.empty()) { +// GTEST_LOG_(INFO) << "Uri path error."; +// return false; +// } + +// if (tPath.front() != '/') { +// GTEST_LOG_(INFO) << "Uri path format error."; +// return false; +// } + +// auto index = tPath.substr(1).find_first_of("/"); +// auto bundleName = tPath.substr(1, index); +// if (bundleName.empty()) { +// GTEST_LOG_(INFO) << "bundleName empty."; +// return false; +// } + +// path.replace(path.find(bundleName), bundleName.length(), newName); +// return true; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_OpenFile_0009 +// * @tc.name: external_file_access_OpenFile_0009 +// * @tc.desc: Test function of OpenFile interface for FAILED because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_OpenFile_0009, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_OpenFile_0009"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// std::string str = info[i].uri; +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// int fd; +// Uri newFileUri(str + "/NotExistFile.txt"); +// result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// GTEST_LOG_(INFO) << "OpenFile_0009 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_OpenFile_0009 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_OpenFile_0009"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_CreateFile_0000 +// * @tc.name: external_file_access_CreateFile_0000 +// * @tc.desc: Test function of CreateFile interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0000.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result; +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_CreateFile_0001 +// * @tc.name: external_file_access_CreateFile_0001 +// * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0001"; +// try { +// Uri newFileUri(""); +// Uri parentUri(""); +// int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0001.txt", newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_CreateFile_0002 +// * @tc.name: external_file_access_CreateFile_0002 +// * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0002"; +// try { +// Uri newFileUri(""); +// Uri parentUri("storage/media/100/local/files/Download"); +// int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0002.txt", newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_CreateFile_0003 +// * @tc.name: external_file_access_CreateFile_0003 +// * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0002"; +// try { +// Uri newFileUri(""); +// Uri parentUri("~!@#$%^&*()_"); +// int result = g_fah->CreateFile(parentUri, "external_file_access_CreateFile_0003.txt", newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_CreateFile_0004 +// * @tc.name: external_file_access_CreateFile_0004 +// * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// string displayName = ""; +// result = g_fah->CreateFile(parentUri, displayName, newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0004"; +// } + +// static void CreateFileTdd(shared_ptr fahs, Uri uri, std::string displayName, Uri newFile) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFileTdd"; +// int ret = fahs->CreateFile(uri, displayName, newFile); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_NE(newFile.ToString(), ""); +// g_num++; +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFileTdd"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_CreateFile_0005 +// * @tc.name: external_file_access_CreateFile_0005 +// * @tc.desc: Test function of CreateFile interface for ERROR which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newFileUri(""); +// std::string displayName = "test1.txt"; +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(CreateFileTdd, g_fah, parentUri, displayName, newFileUri); +// execthread.join(); +// } +// EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// Uri newDelete(info[i].uri + "/" + displayName); +// result = g_fah->Delete(newDelete); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_CreateFile_0006 +// * @tc.name: external_file_access_CreateFile_0006 +// * @tc.desc: Test function of CreateFile interface for ERROR because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_CreateFile_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_CreateFile_0006"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// std::string str = info[i].uri; +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri parentUri(str); +// Uri newFileUri(""); +// string displayName = "test.txt"; +// result = g_fah->CreateFile(parentUri, displayName, newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// GTEST_LOG_(INFO) << "CreateFile_0006 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_CreateFile_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_CreateFile_0006"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Mkdir_0000 +// * @tc.name: external_file_access_Mkdir_0000 +// * @tc.desc: Test function of Mkdir interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0000", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Mkdir_0001 +// * @tc.name: external_file_access_Mkdir_0001 +// * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0001"; +// try { +// Uri newDirUriTest(""); +// Uri parentUri(""); +// int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0001", newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Mkdir_0002 +// * @tc.name: external_file_access_Mkdir_0002 +// * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002"; +// try { +// Uri newDirUriTest(""); +// Uri parentUri("storage/media/100/local/files/Download"); +// int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0002", newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Mkdir_0003 +// * @tc.name: external_file_access_Mkdir_0003 +// * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0002"; +// try { +// Uri newDirUriTest(""); +// Uri parentUri("~!@#$%^&*()_"); +// int result = g_fah->Mkdir(parentUri, "external_file_access_Mkdir_0003", newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Mkdir_0004 +// * @tc.name: external_file_access_Mkdir_0004 +// * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// string displayName = ""; +// result = g_fah->Mkdir(parentUri, displayName, newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0004"; +// } + +// static void MkdirTdd(shared_ptr fahs, Uri uri, std::string displayName, Uri newFile) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MkdirTdd"; +// int ret = fahs->Mkdir(uri, displayName, newFile); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_NE(newFile.ToString(), ""); +// g_num++; +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MkdirTdd"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Mkdir_0005 +// * @tc.name: external_file_access_Mkdir_0005 +// * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// std::string displayName = "test1"; +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(MkdirTdd, g_fah, parentUri, displayName, newDirUriTest); +// execthread.join(); +// } +// EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// Uri newDelete(info[i].uri + "/" + displayName); +// result = g_fah->Delete(newDelete); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Mkdir_0006 +// * @tc.name: external_file_access_Mkdir_0006 +// * @tc.desc: Test function of Mkdir interface for ERROR because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Mkdir_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Mkdir_0006"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// std::string str = info[i].uri; +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri parentUri(str); +// Uri newDirUriTest(""); +// string displayName = ""; +// result = g_fah->Mkdir(parentUri, displayName, newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// GTEST_LOG_(INFO) << "Mkdir_0006 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Mkdir_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Mkdir_0006"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Delete_0000 +// * @tc.name: external_file_access_Delete_0000 +// * @tc.desc: Test function of Delete interface for SUCCESS which delete file. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest, "external_file_access_Delete_0000.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Delete_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Delete_0001 +// * @tc.name: external_file_access_Delete_0001 +// * @tc.desc: Test function of Delete interface for SUCCESS which delete folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0001"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0001 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Delete_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Delete_0002 +// * @tc.name: external_file_access_Delete_0002 +// * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0002"; +// try { +// Uri selectFileUri(""); +// int result = g_fah->Delete(selectFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Delete_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Delete_0003 +// * @tc.name: external_file_access_Delete_0003 +// * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0003"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri selectFileUri("storage/media/100/local/files/Download/test"); +// result = g_fah->Delete(selectFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0003 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Delete_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Delete_0004 +// * @tc.name: external_file_access_Delete_0004 +// * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0004"; +// try { +// Uri selectFileUri("!@#$%^&*()"); +// int result = g_fah->Delete(selectFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0004 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Delete_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0004"; +// } + +// static void DeleteTdd(shared_ptr fahs, Uri selectFile) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_DeleteTdd"; +// int ret = fahs->Delete(selectFile); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// g_num++; +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_DeleteTdd"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Delete_0005 +// * @tc.name: external_file_access_Delete_0005 +// * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// std::string displayName = "test1.txt"; +// result = g_fah->CreateFile(newDirUriTest, displayName, newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(DeleteTdd, g_fah, newFileUri); +// execthread.join(); +// } +// EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Delete_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Delete_0006 +// * @tc.name: external_file_access_Delete_0006 +// * @tc.desc: Test function of Delete interface for ERROR because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Delete_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Delete_0006"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// std::string str = info[i].uri; +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri selectFileUri(str); +// int result = g_fah->Delete(selectFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// GTEST_LOG_(INFO) << "Delete_0006 result:" << result; +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Delete_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Delete_0006"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0000 +// * @tc.name: external_file_access_Move_0000 +// * @tc.desc: Test function of Move interface for SUCCESS which move file. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// result = g_fah->Move(testUri, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0001 +// * @tc.name: external_file_access_Move_0001 +// * @tc.desc: Test function of Move interface for SUCCESS which move folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0001"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0001 result:" << result; +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0002 +// * @tc.name: external_file_access_Move_0002 +// * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0002"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// Uri sourceFileUri(""); +// result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0002 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0003 +// * @tc.name: external_file_access_Move_0003 +// * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0003"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri sourceFileUri("storage/media/100/local/files/Download/test1/test.txt"); +// result = g_fah->Move(sourceFileUri, newDirUriTest2, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0003 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0004 +// * @tc.name: external_file_access_Move_0004 +// * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// Uri sourceFileUri("~!@#$%^&*()_"); +// result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0004 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0004"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0005 +// * @tc.name: external_file_access_Move_0005 +// * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri targetParentUri(""); +// result = g_fah->Move(testUri, targetParentUri, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0005 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0006 +// * @tc.name: external_file_access_Move_0006 +// * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0006"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri targetParentUri("storage/media/100/local/files/Download/test2"); +// result = g_fah->Move(testUri, targetParentUri, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0006 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0006"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0007 +// * @tc.name: external_file_access_Move_0007 +// * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0007"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri targetParentUri("~!@#$^%&*()_"); +// result = g_fah->Move(testUri, targetParentUri, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0007 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0007"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0008 +// * @tc.name: external_file_access_Move_0008 +// * @tc.desc: Test function of Move interface for SUCCESS which move empty folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0008, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0008"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0008 result:" << result; +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0008 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0008"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0009 +// * @tc.name: external_file_access_Move_0009 +// * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0009, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0009"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// size_t fileNumbers = 2000; +// for (size_t j = 0; j < fileNumbers; j++) { +// string fileName = "test" + ToString(j) + ".txt"; +// result = g_fah->CreateFile(newDirUriTest1, fileName, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// Uri testUri2(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0009 result:" << result; +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0009 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0009"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0010 +// * @tc.name: external_file_access_Move_0010 +// * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0010, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0010"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->Mkdir(newDirUriTest1, "test", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// size_t directoryNumbers = 64; +// for (size_t j = 0; j < directoryNumbers; j++) { +// result = g_fah->Mkdir(testUri, "test", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// Uri testUri2(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0010 result:" << result; +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0010 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0010"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0011 +// * @tc.name: external_file_access_Move_0011 +// * @tc.desc: Test function of Move interface for SUCCESS which move other equipment file. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0011, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0011"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t j = i + 1; j < info.size(); j++) { +// Uri otherUri(info[j].uri); +// result = g_fah->Mkdir(otherUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Move(testUri, newDirUriTest2, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Move(testUri, newDirUriTest1, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0011 result:" << result; +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0011 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0011"; +// } + +// static void MoveTdd(shared_ptr fahs, Uri sourceFile, Uri targetParent, Uri newFile) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_MoveTdd"; +// int ret = fahs->Move(sourceFile, targetParent, newFile); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// g_num++; +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_MoveTdd"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0012 +// * @tc.name: external_file_access_Move_0012 +// * @tc.desc: Test function of Move interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0012, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0012"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// std::string displayName = "test3.txt"; +// result = g_fah->CreateFile(newDirUriTest1, displayName, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(MoveTdd, g_fah, testUri, newDirUriTest2, testUri2); +// execthread.join(); +// } +// EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0012 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0012"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Move_0013 +// * @tc.name: external_file_access_Move_0013 +// * @tc.desc: Test function of Move interface for FAILED because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0013, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Move_0013"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(info[0].uri); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->Mkdir(newDirUriTest1, "test", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string str = newDirUriTest1.ToString(); +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri uri(str); +// Uri testUri2(""); +// result = g_fah->Move(uri, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// GTEST_LOG_(INFO) << "Move_0013 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Move_0013 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0013"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0000 +// * @tc.name: external_file_access_Rename_0000 +// * @tc.desc: Test function of Rename interface for SUCCESS which rename file. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// result = g_fah->Rename(testUri, "test2.txt", renameUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0001 +// * @tc.name: external_file_access_Rename_0001 +// * @tc.desc: Test function of Rename interface for SUCCESS which rename folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0001"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// result = g_fah->Rename(newDirUriTest, "testRename", renameUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0001 result:" << result; +// result = g_fah->Delete(renameUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0002 +// * @tc.name: external_file_access_Rename_0002 +// * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0002"; +// try { +// Uri renameUri(""); +// Uri sourceFileUri(""); +// int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0003 +// * @tc.name: external_file_access_Rename_0003 +// * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0003"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); +// result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0003 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0004 +// * @tc.name: external_file_access_Rename_0004 +// * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0004"; +// try { +// Uri renameUri(""); +// Uri sourceFileUri("~!@#$%^&*()_"); +// int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0004 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0004"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0005 +// * @tc.name: external_file_access_Rename_0005 +// * @tc.desc: Test function of Rename interface for ERROR which displayName is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// result = g_fah->Rename(testUri, "", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0005 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0005"; +// } + +// static void RenameTdd(shared_ptr fahs, Uri sourceFile, std::string displayName, Uri newFile) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_RenameTdd"; +// int ret = fahs->Rename(sourceFile, displayName, newFile); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "RenameTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// g_num++; +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_RenameTdd"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0006 +// * @tc.name: external_file_access_Rename_0006 +// * @tc.desc: Test function of Rename interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0006"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// std::string displayName1 = "test1.txt"; +// std::string displayName2 = "test2.txt"; +// Uri renameUri(""); +// result = g_fah->CreateFile(newDirUriTest, displayName1, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(RenameTdd, g_fah, testUri, displayName2, renameUri); +// execthread.join(); +// } +// EXPECT_EQ(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0006"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Rename_0007 +// * @tc.name: external_file_access_Rename_0007 +// * @tc.desc: Test function of Rename interface for ERROR because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Rename_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Rename_0007"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// std::string str = newDirUriTest.ToString(); +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri testUri(str); +// Uri renameUri(""); +// result = g_fah->Rename(testUri, "test.txt", renameUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// GTEST_LOG_(INFO) << "Rename_0007 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Rename_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Rename_0007"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_ListFile_0000 +// * @tc.name: external_file_access_ListFile_0000 +// * @tc.desc: Test function of ListFile interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_0000.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_ListFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_ListFile_0001 +// * @tc.name: external_file_access_ListFile_0001 +// * @tc.desc: Test function of ListFile interface for ERROR which Uri is nullptr. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0001"; +// try { +// Uri sourceFileUri(""); +// FileInfo fileInfo; +// fileInfo.uri = sourceFileUri.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_ListFile_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_ListFile_0002 +// * @tc.name: external_file_access_ListFile_0002 +// * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0002"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); +// FileInfo fileInfo; +// fileInfo.uri = sourceFileUri.ToString(); +// Uri sourceFile(fileInfo.uri); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_ListFile_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_ListFile_0003 +// * @tc.name: external_file_access_ListFile_0003 +// * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0003"; +// try { +// Uri sourceFileUri("~!@#$%^&*()_"); +// FileInfo fileInfo; +// fileInfo.uri = sourceFileUri.ToString(); +// Uri sourceFile(fileInfo.uri); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_ListFile_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0003"; +// } + +// static void ListFileTdd(FileInfo fileInfo, int offset, int maxCount, FileFilter filter, +// std::vector fileInfoVec) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFileTdd"; +// int ret = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "ListFile get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// g_num++; +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFileTdd"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_ListFile_0004 +// * @tc.name: external_file_access_ListFile_0004 +// * @tc.desc: Test function of ListFile interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "external_file_access_ListFile_0004.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int offset = 0; +// int maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(ListFileTdd, fileInfo, offset, maxCount, filter, fileInfoVec); +// execthread.join(); +// } +// EXPECT_EQ(g_num, INIT_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_ListFile_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0004"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_ListFile_0005 +// * @tc.name: external_file_access_ListFile_0005 +// * @tc.desc: Test function of ListFile interface for ERROR because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_ListFile_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_ListFile_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// std::string str = testUri.ToString(); +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// FileInfo fileInfo; +// fileInfo.uri = str; +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_ListFile_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_ListFile_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetRoots_0000 +// * @tc.name: external_file_access_GetRoots_0000 +// * @tc.desc: Test function of GetRoots interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0387 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetRoots_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetRoots_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "GetRoots_0000 result:" << info.size() << endl; +// for (size_t i = 0; i < info.size(); i++) { +// GTEST_LOG_(INFO) << info[i].uri; +// GTEST_LOG_(INFO) << info[i].displayName; +// GTEST_LOG_(INFO) << info[i].deviceFlags; +// GTEST_LOG_(INFO) << info[i].deviceType; +// } +// string uri = "file://com.ohos.UserFile.ExternalFileManager/data/storage/el1/bundle/storage_daemon"; +// string displayName = "shared_disk"; +// EXPECT_EQ(info[0].uri, uri); +// EXPECT_EQ(info[0].displayName, displayName); +// EXPECT_EQ(info[0].deviceType, DEVICE_SHARED_DISK); +// EXPECT_EQ(info[0].deviceFlags, DEVICE_FLAG_SUPPORTS_READ | DEVICE_FLAG_SUPPORTS_WRITE); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetRoots_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetRoots_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Access_0000 +// * @tc.name: external_file_access_Access_0000 +// * @tc.desc: Test function of Access interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "test1", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest, "external_file_access_Access_0000.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// bool isExist = false; +// result = g_fah->Access(newDirUriTest, isExist); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_TRUE(isExist); +// result = g_fah->Access(newFileUri, isExist); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_TRUE(isExist); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Access(newDirUriTest, isExist); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_FALSE(isExist); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Access_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Access_0001 +// * @tc.name: external_file_access_Access_0001 +// * @tc.desc: Test function of Access interface FAILED because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Access_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Access_0001"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// std::string str = info[i].uri; +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri newDirUriTest(str + "/test.txt"); +// bool isExist = false; +// result = g_fah->Access(newDirUriTest, isExist); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// EXPECT_FALSE(isExist); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Access_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Access_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0000 +// * @tc.name: external_file_access_GetFileInfoFromUri_0000 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVecTemp; +// result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0001 +// * @tc.name: external_file_access_GetFileInfoFromUri_0001 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0001"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "testDir", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// FileInfo dirInfo; +// result = g_fah->GetFileInfoFromUri(newDirUriTest, dirInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVec; +// result = g_fah->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0002 +// * @tc.name: external_file_access_GetFileInfoFromUri_0002 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the general filepath uri to fileinfo and call listfile for ERROR. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0002"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(info[i].uri); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "testDir", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest, "external_file_access_GetFileInfoFromUri_0002.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(newFileUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVecTemp; +// result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0003 +// * @tc.name: external_file_access_GetFileInfoFromUri_0003 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0003"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(std::string("\?\?\?\?/") + info[i].uri); +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0004 +// * @tc.name: external_file_access_GetFileInfoFromUri_0004 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// std::string str = info[i].uri; +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri parentUri(str); +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0004"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetFileInfoFromUri_0005 +// * @tc.name: external_file_access_GetFileInfoFromUri_0005 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the invalid uri to fileinfo failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetFileInfoFromUri_0005"; +// try { +// Uri uri("~!@#$%^&*()_"); +// FileInfo fileInfo; +// int result = g_fah->GetFileInfoFromUri(uri, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// uri = Uri("/"); +// result = g_fah->GetFileInfoFromUri(uri, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// uri = Uri(""); +// result = g_fah->GetFileInfoFromUri(uri, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetFileInfoFromUri_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetFileInfoFromUri_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0000 +// * @tc.name: external_file_access_creator_0000 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0000"; +// try { +// setuid(UID_TRANSFORM_TMP); +// std::pair, int> helper = FileAccessHelper::Creator(g_context); +// setuid(UID_DEFAULT); +// ASSERT_TRUE(helper.first != nullptr); +// bool succ = helper.first->Release(); +// EXPECT_TRUE(succ); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0001 +// * @tc.name: external_file_access_creator_0001 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0001"; +// try { +// AAFwk::Want want; +// vector wantVec; +// setuid(UID_TRANSFORM_TMP); +// int ret = FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(wantVec); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// bool sus = false; +// for (size_t i = 0; i < wantVec.size(); i++) { +// auto element = wantVec[i].GetElement(); +// if (element.GetBundleName() == "com.ohos.UserFile.ExternalFileManager" && +// element.GetAbilityName() == "FileExtensionAbility") { +// want = wantVec[i]; +// sus = true; +// break; +// } +// } +// EXPECT_TRUE(sus); +// vector wants{want}; +// std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); +// setuid(UID_DEFAULT); +// ASSERT_TRUE(helper.first != nullptr); +// bool succ = helper.first->Release(); +// EXPECT_TRUE(succ); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0002 +// * @tc.name: external_file_access_creator_0002 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0002"; +// try { +// std::shared_ptr context = nullptr; +// std::pair, int> helper = FileAccessHelper::Creator(context); +// ASSERT_TRUE(helper.first == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0003 +// * @tc.name: external_file_access_creator_0003 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0003"; +// try { +// std::vector wants; +// std::shared_ptr context = nullptr; +// std::pair, int> helper = FileAccessHelper::Creator(context, wants); +// ASSERT_TRUE(helper.first == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0004 +// * @tc.name: external_file_access_creator_0004 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0004"; +// try { +// std::vector wants; +// std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); +// ASSERT_TRUE(helper.first == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0004"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0005 +// * @tc.name: external_file_access_creator_0005 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0005"; +// try { +// AAFwk::Want want; +// want.SetElementName("NotExistBundleName", "NotExistAbilityName"); +// std::vector wants{want}; +// std::pair, int> helper = FileAccessHelper::Creator(g_context, wants); +// ASSERT_TRUE(helper.first == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0006 +// * @tc.name: external_file_access_creator_0006 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0006"; +// try { +// std::vector wants; +// std::shared_ptr context = nullptr; +// std::pair, int> helper = FileAccessHelper::Creator(context, wants); +// ASSERT_TRUE(helper.first == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0006"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0007 +// * @tc.name: external_file_access_creator_0007 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0007"; +// try { +// std::vector wants; +// shared_ptr helper = FileAccessHelper::Creator(g_context->GetToken(), wants); +// ASSERT_TRUE(helper == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0007"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_creator_0008 +// * @tc.name: external_file_access_creator_0008 +// * @tc.desc: Test function of creator interface. +// * @tc.desc: create file access helper for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_creator_0008, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_creator_0008"; +// try { +// AAFwk::Want want; +// want.SetElementName("NotExistBundleName", "NotExistAbilityName"); +// std::vector wants{want}; +// shared_ptr helper = FileAccessHelper::Creator(g_context->GetToken(), wants); +// ASSERT_TRUE(helper == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_creator_0008 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_creator_0008"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetConnectInfo_0000 +// * @tc.name: external_file_access_GetConnectInfo_0000 +// * @tc.desc: Test function of GetConnectInfo interface. +// * @tc.desc: helper invoke GetConnectInfo for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetConnectInfo_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetConnectInfo_0000"; +// try { +// std::shared_ptr connectInfo = g_fah->GetConnectInfo("NotExistBundleName"); +// ASSERT_TRUE(connectInfo == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetConnectInfo_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetConnectInfo_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetKeyOfWants_0000 +// * @tc.name: external_file_access_GetKeyOfWants_0000 +// * @tc.desc: Test function of GetKeyOfWants interface. +// * @tc.desc: helper invoke GetKeyOfWants for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetKeyOfWants_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetKeyOfWants_0000"; +// try { +// AAFwk::Want want; +// want.SetElementName("NotExistBundleName", "NotExistAbilityName"); +// std::string key = g_fah->GetKeyOfWants(want); +// ASSERT_TRUE(key.empty()); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetKeyOfWants_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetKeyOfWants_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetProxyByUri_0000 +// * @tc.name: external_file_access_GetProxyByUri_0000 +// * @tc.desc: Test function of GetProxyByUri interface. +// * @tc.desc: helper invoke GetProxyByUri for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0000"; +// try { +// Uri uri(""); +// sptr proxy = g_fah->GetProxyByUri(uri); +// ASSERT_TRUE(proxy == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_GetProxyByUri_0001 +// * @tc.name: external_file_access_GetProxyByUri_0001 +// * @tc.desc: Test function of GetProxyByUri interface. +// * @tc.desc: helper invoke GetProxyByUri for FAILED. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_GetProxyByUri_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_GetProxyByUri_0001"; +// try { +// Uri uri("file://com.ohos.UserFile.NotExistBundleName/data/storage/el1/bundle/storage_daemon"); +// sptr proxy = g_fah->GetProxyByUri(uri); +// ASSERT_TRUE(proxy == nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_GetProxyByUri_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_GetProxyByUri_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Query_0000 +// * @tc.name: external_file_access_Query_0000 +// * @tc.desc: Test function of Query directory for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(info[0].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// std::string displayName = "QueryTest1"; +// std::string relativePath = "/data/storage/el1/bundle/storage_daemon/"; +// result = g_fah->Mkdir(parentUri, "QueryTest1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(newDirUriTest1, "QueryTest2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri1(""); +// Uri newFileUri2(""); +// std::string fileName = "external_file_access_Query_00001.txt"; +// result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->CreateFile(newDirUriTest2, fileName, newFileUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd = -1; +// std::string buff = "query test"; +// result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// ssize_t fileSize = write(fd, buff.c_str(), buff.size()); +// close(fd); +// EXPECT_EQ(fileSize, buff.size()); +// result = g_fah->OpenFile(newFileUri2, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// fileSize = write(fd, buff.c_str(), buff.size()); +// close(fd); +// EXPECT_EQ(fileSize, buff.size()); +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "}, +// {FILE_SIZE, " "}, +// {DATE_MODIFIED, " "}, +// {DATE_ADDED, " "}, +// {HEIGHT, " "}, +// {WIDTH, " "}, +// {DURATION, " "} +// }; +// auto testJsonString = testJson.dump(); +// result = g_fah->Query(newDirUriTest1, testJsonString); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// auto jsonObject = json::parse(testJsonString); +// EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); +// EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2); +// EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath); +// ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); +// ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); +// GTEST_LOG_(INFO) << " result" << testJsonString; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Query_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0000"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Query_0001 +// * @tc.name: external_file_access_Query_0001 +// * @tc.desc: Test function of Query file for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0001"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(info[0].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "QueryTest3", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// std::string displayName = "external_file_access_Query_0001.txt"; +// std::string relativePath = "/data/storage/el1/bundle/storage_daemon/QueryTest3/"; +// result = g_fah->CreateFile(newDirUriTest, displayName, newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd = -1; +// result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string buff = "query test"; +// ssize_t fileSize = write(fd, buff.c_str(), buff.size()); +// close(fd); +// EXPECT_EQ(fileSize, buff.size()); +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "}, +// {FILE_SIZE, " "}, +// {DATE_MODIFIED, " "}, +// {DATE_ADDED, " "}, +// {HEIGHT, " "}, +// {WIDTH, " "}, +// {DURATION, " "} +// }; +// auto testJsonString = testJson.dump(); +// result = g_fah->Query(newFileUri, testJsonString); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// auto jsonObject = json::parse(testJsonString); +// EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); +// EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size()); +// EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath); +// ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); +// ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); +// GTEST_LOG_(INFO) << " result" << testJsonString; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Query_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0001"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Query_0002 +// * @tc.name: external_file_access_Query_0002 +// * @tc.desc: Test function of Query directory for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0002"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(info[0].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// result = g_fah->Mkdir(parentUri, "QueryTest4", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(newDirUriTest1, "QueryTest5", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri1(""); +// Uri newFileUri2(""); +// std::string fileName = "external_file_access_Query_00001.txt"; +// result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->CreateFile(newDirUriTest2, fileName, newFileUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd = -1; +// std::string buff = "query test"; +// result = g_fah->OpenFile(newFileUri1, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// ssize_t fileSize = write(fd, buff.c_str(), buff.size()); +// close(fd); +// EXPECT_EQ(fileSize, buff.size()); +// result = g_fah->OpenFile(newFileUri2, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// fileSize = write(fd, buff.c_str(), buff.size()); +// close(fd); +// EXPECT_EQ(fileSize, buff.size()); +// json testJson = { +// {FILE_SIZE, " "} +// }; +// auto testJsonString = testJson.dump(); +// result = g_fah->Query(newDirUriTest1, testJsonString); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// auto jsonObject = json::parse(testJsonString); +// EXPECT_EQ(jsonObject.at(FILE_SIZE), buff.size() * 2); +// GTEST_LOG_(INFO) << " result" << testJsonString; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Query_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0002"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Query_0003 +// * @tc.name: external_file_access_Query_0003 +// * @tc.desc: Test function of Query interface for which is unreadable code. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0003"; +// try { +// Uri testUri("&*()*/?"); +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "} +// }; +// auto testJsonString = testJson.dump(); +// int result = g_fah->Query(testUri, testJsonString); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << " result" << testJsonString; +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Query_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0003"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Query_0004 +// * @tc.name: external_file_access_Query_0004 +// * @tc.desc: Test function of Query interface for which all column nonexistence. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(info[0].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "QueryTest6", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// json testJson = { +// {"001", " "}, +// {"#", " "}, +// {"test", " "}, +// {"target", " "} +// }; +// auto testJsonString = testJson.dump(); +// result = g_fah->Query(newDirUriTest, testJsonString); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << " result" << testJsonString; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Query_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0004"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Query_0005 +// * @tc.name: external_file_access_Query_0005 +// * @tc.desc: Test function of Query interface for which part of column nonexistence. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0005"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(info[0].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "QueryTest7", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "}, +// {"test", " "} +// }; +// auto testJsonString = testJson.dump(); +// result = g_fah->Query(newDirUriTest, testJsonString); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << " result" << testJsonString; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Query_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0005"; +// } + +// /** +// * @tc.number: user_file_service_external_file_access_Query_0006 +// * @tc.name: external_file_access_Query_0006 +// * @tc.desc: Test function of Query interface for which column is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Query_0006"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(info[0].uri); +// GTEST_LOG_(INFO) << parentUri.ToString(); +// Uri newDirUriTest(""); +// result = g_fah->Mkdir(parentUri, "QueryTest8", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// json testJson; +// auto testJsonString = testJson.dump(); +// result = g_fah->Query(newDirUriTest, testJsonString); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << " result" << testJsonString; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "external_file_access_Query_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0006"; +// } } // namespace \ No newline at end of file diff --git a/test/unittest/medialibrary_file_access_test.cpp b/test/unittest/medialibrary_file_access_test.cpp index a9fe9cfc..9823e37b 100644 --- a/test/unittest/medialibrary_file_access_test.cpp +++ b/test/unittest/medialibrary_file_access_test.cpp @@ -28,6 +28,7 @@ #include "image_source.h" #include "nativetoken_kit.h" #include "token_setproc.h" +#include "iobserver_callback.h" namespace { using namespace std; @@ -36,9 +37,9 @@ using namespace FileAccessFwk; using namespace OHOS::Media; using json = nlohmann::json; const int ABILITY_ID = 5003; -const int INIT_THREADS_NUMBER = 4; -const int ACTUAL_SUCCESS_THREADS_NUMBER = 1; -int g_num = 0; +//const int INIT_THREADS_NUMBER = 4; +//const int ACTUAL_SUCCESS_THREADS_NUMBER = 1; +//int g_num = 0; shared_ptr g_fah = nullptr; Uri g_newDirUri(""); const int UID_TRANSFORM_TMP = 20000000; @@ -109,17 +110,41 @@ public: void TearDown(){}; }; -static Uri GetParentUri() +// static Uri GetParentUri() +// { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri parentUri(""); +// if (info.size() > OHOS::FileAccessFwk::ERR_OK) { +// parentUri = Uri(info[0].uri + "/file"); +// GTEST_LOG_(ERROR) << parentUri.ToString(); +// } +// return parentUri; +// } + +class MyObserver : public IRemoteStub { +public: + MyObserver() {}; + virtual ~MyObserver() {}; + void OnChange(std::string message) override; + std::string GetClassName() override; + bool Equal(void *observer) override; +}; + +void MyObserver::OnChange (std::string message) { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri parentUri(""); - if (info.size() > OHOS::FileAccessFwk::ERR_OK) { - parentUri = Uri(info[0].uri + "/file"); - GTEST_LOG_(ERROR) << parentUri.ToString(); - } - return parentUri; + +} + +std::string MyObserver::GetClassName() +{ + return "name"; +} + +bool MyObserver::Equal(void *observer) +{ + return true; } /** @@ -135,3422 +160,3448 @@ HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0000, testing:: { GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0000"; try { - Uri parentUri = GetParentUri(); - bool isExist = false; - int result = g_fah->Access(g_newDirUri, isExist); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - if (!isExist) { - result = g_fah->Mkdir(parentUri, "Download", g_newDirUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - } + //Uri parentUri = GetParentUri(); + bool notifyForDescendants = false; Uri newDirUriTest("file://media/root/file"); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < fileInfoVec.size(); i++) { - if (fileInfoVec[i].fileName.compare("Download") == 0) { - g_newDirUri = Uri(fileInfoVec[i].uri); - break; - } - } - result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_OpenFile_0000.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result; - close(fd); - result = g_fah->Delete(newDirUriTest); + sptr myObserver = new MyObserver(); + int result = g_fah->RegisterNotify(newDirUriTest, notifyForDescendants, myObserver); EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); + } catch (...) { GTEST_LOG_(ERROR) << "medialibrary_file_accsess_OpenFile_0000 occurs an exception."; } GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0000"; } -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0001 - * @tc.name: medialibrary_file_access_OpenFile_0001 - * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0001"; - try { - Uri uri(""); - int fd; - int result = g_fah->OpenFile(uri, WRITE_READ, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0002 - * @tc.name: medialibrary_file_access_OpenFile_0002 - * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0002"; - try { - Uri uri("storage/media/100/local/files/Download/medialibrary_file_access_OpenFile_0002.txt"); - int fd; - int result = g_fah->OpenFile(uri, WRITE_READ, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0003 - * @tc.name: medialibrary_file_access_OpenFile_0003 - * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0003"; - try { - Uri uri("~!@#$%^&*()_"); - int fd; - int result = g_fah->OpenFile(uri, WRITE_READ, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0004 - * @tc.name: medialibrary_file_access_OpenFile_0004 - * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0004"; - try { - Uri newFileUri(""); - int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0004.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - int flag = -1; - result = g_fah->OpenFile(newFileUri, flag, fd); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result; - result = g_fah->Delete(newFileUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0005 - * @tc.name: medialibrary_file_access_OpenFile_0005 - * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0005"; - try { - Uri newFileUri(""); - int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0005.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result; - close(fd); - result = g_fah->Delete(newFileUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0006 - * @tc.name: medialibrary_file_access_OpenFile_0006 - * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0006"; - try { - Uri newFileUri(""); - int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0006.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, WRITE, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result; - close(fd); - result = g_fah->Delete(newFileUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0006"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0007 - * @tc.name: medialibrary_file_access_OpenFile_0007 - * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0007"; - try { - Uri newFileUri(""); - int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0007.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result; - close(fd); - result = g_fah->Delete(newFileUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0007"; -} - -static void OpenFileTdd(shared_ptr fahs, Uri uri, int flag, int fd) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFileTdd"; - int ret = fahs->OpenFile(uri, flag, fd); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "OpenFileTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK); - g_num++; - close(fd); - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFileTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0008 - * @tc.name: medialibrary_file_access_OpenFile_0008 - * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0008, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0008"; - try { - Uri newFileUri(""); - int fd; - g_num = 0; - std::string displayName = "test1.txt"; - int result = g_fah->CreateFile(g_newDirUri, displayName, newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(OpenFileTdd, g_fah, newFileUri, WRITE_READ, fd); - execthread.join(); - } - EXPECT_EQ(g_num, INIT_THREADS_NUMBER); - result = g_fah->Delete(newFileUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0008 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0008"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0000 - * @tc.name: medialibrary_file_access_CreateFile_0000 - * @tc.desc: Test function of CreateFile interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0000"; - try { - Uri newFileUri(""); - int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_CreateFile_0000.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result; - result = g_fah->Delete(newFileUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0001 - * @tc.name: medialibrary_file_access_CreateFile_0001 - * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0001"; - try { - Uri newFileUri(""); - Uri parentUri(""); - int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0001.txt", newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0002 - * @tc.name: medialibrary_file_access_CreateFile_0002 - * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002"; - try { - Uri newFileUri(""); - Uri parentUri("storage/media/100/local/files/Download"); - int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0002.txt", newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0003 - * @tc.name: medialibrary_file_access_CreateFile_0003 - * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002"; - try { - Uri newFileUri(""); - Uri parentUri("~!@#$%^&*()_"); - int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0003.txt", newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0004 - * @tc.name: medialibrary_file_access_CreateFile_0004 - * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0004"; - try { - Uri newFileUri(""); - string displayName = ""; - int result = g_fah->CreateFile(g_newDirUri, displayName, newFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0004"; -} - -static void CreateFileTdd(shared_ptr fahs, Uri parent, std::string displayName, Uri newDir) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFileTdd"; - int ret = fahs->CreateFile(parent, displayName, newDir); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_NE(newDir.ToString(), ""); - g_num++; - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFileTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0005 - * @tc.name: medialibrary_file_access_CreateFile_0005 - * @tc.desc: Test function of CreateFile interface for SUCCESS while Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0005"; - try { - Uri newFileUri1(""); - Uri newFileUri2(""); - Uri newFileUri3(""); - std::string displayName1 = "test1"; - std::string displayName2 = "test2"; - std::string displayName3 = "test3.txt"; - int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(CreateFileTdd, g_fah, newFileUri2, displayName3, newFileUri3); - execthread.join(); - } - EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - GTEST_LOG_(INFO) << "g_newDirUri.ToString() =" << g_newDirUri.ToString(); - result = g_fah->Delete(newFileUri1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0000 - * @tc.name: medialibrary_file_access_Mkdir_0000 - * @tc.desc: Test function of Mkdir interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0000"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "medialibrary_file_access_Mkdir_0000", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0001 - * @tc.name: medialibrary_file_access_Mkdir_0001 - * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0001"; - try { - Uri newDirUriTest(""); - Uri parentUri(""); - int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0001", newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0002 - * @tc.name: medialibrary_file_access_Mkdir_0002 - * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002"; - try { - Uri newDirUriTest(""); - Uri parentUri("storage/media/100/local/files/Download"); - int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0002", newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0003 - * @tc.name: medialibrary_file_access_Mkdir_0003 - * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002"; - try { - Uri newDirUriTest(""); - Uri parentUri("~!@#$%^&*()_"); - int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0003", newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0004 - * @tc.name: medialibrary_file_access_Mkdir_0004 - * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0004"; - try { - Uri newDirUriTest(""); - string displayName = ""; - int result = g_fah->Mkdir(g_newDirUri, displayName, newDirUriTest); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0004"; -} - -static void MkdirTdd(shared_ptr fahs, Uri parent, std::string displayName, Uri newDir) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MkdirTdd"; - int ret = fahs->Mkdir(parent, displayName, newDir); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_NE(newDir.ToString(), ""); - g_num++; - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MkdirTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0005 - * @tc.name: medialibrary_file_access_Mkdir_0005 - * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0005"; - try { - Uri newFileUri1(""); - Uri newFileUri2(""); - Uri newFileUri3(""); - std::string displayName1 = "test1"; - std::string displayName2 = "test2"; - std::string displayName3 = "test3"; - int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(MkdirTdd, g_fah, newFileUri2, displayName3, newFileUri3); - execthread.join(); - } - EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newFileUri1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Delete_0000 - * @tc.name: medialibrary_file_access_Delete_0000 - * @tc.desc: Test function of Delete interface for SUCCESS which delete file. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0000"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0000.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newFileUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0000 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Delete_0001 - * @tc.name: medialibrary_file_access_Delete_0001 - * @tc.desc: Test function of Delete interface for SUCCESS which delete folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0001"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0001 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Delete_0002 - * @tc.name: medialibrary_file_access_Delete_0002 - * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0002"; - try { - Uri selectFileUri(""); - int result = g_fah->Delete(selectFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Delete_0003 - * @tc.name: medialibrary_file_access_Delete_0003 - * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0003"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri selectFileUri("storage/media/100/local/files/Download/test"); - result = g_fah->Delete(selectFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0003 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Delete_0004 - * @tc.name: medialibrary_file_access_Delete_0004 - * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0004"; - try { - Uri selectFileUri("!@#$%^&*()"); - int result = g_fah->Delete(selectFileUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Delete_0004 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0004"; -} - -static void DeleteTdd(shared_ptr fahs, Uri selectFile) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_DeleteTdd"; - int ret = fahs->Delete(selectFile); - if (ret < OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret; - return; - } - EXPECT_GE(ret, OHOS::FileAccessFwk::ERR_OK); - g_num++; - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_DeleteTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Delete_0005 - * @tc.name: medialibrary_file_access_Delete_0005 - * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0005"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0005.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - std::string displayName = "test1.txt"; - Uri testUri2(""); - result = g_fah->CreateFile(newDirUriTest, displayName, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(DeleteTdd, g_fah, testUri); - execthread.join(); - } - EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0000 - * @tc.name: medialibrary_file_access_Move_0000 - * @tc.desc: Test function of Move interface for SUCCESS which move file. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0000"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - result = g_fah->Move(testUri, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0000 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0001 - * @tc.name: medialibrary_file_access_Move_0001 - * @tc.desc: Test function of Move interface for SUCCESS which move folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0001"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0001 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0002 - * @tc.name: medialibrary_file_access_Move_0002 - * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0002"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - Uri sourceFileUri(""); - result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0002 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0003 - * @tc.name: medialibrary_file_access_Move_0003 - * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0003"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri sourceFileUri("storage/media/100/local/files/Download/test1/test.txt"); - result = g_fah->Move(sourceFileUri, newDirUriTest2, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0003 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0004 - * @tc.name: medialibrary_file_access_Move_0004 - * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0004"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - Uri sourceFileUri("~!@#$%^&*()_"); - result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0004 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0005 - * @tc.name: medialibrary_file_access_Move_0005 - * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0005"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri targetParentUri(""); - result = g_fah->Move(testUri, targetParentUri, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0005 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0006 - * @tc.name: medialibrary_file_access_Move_0006 - * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0006"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri targetParentUri("storage/media/100/local/files/Download/test2"); - result = g_fah->Move(testUri, targetParentUri, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0006 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0006"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0007 - * @tc.name: medialibrary_file_access_Move_0007 - * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0007"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - Uri targetParentUri("~!@#$^%&*()_"); - result = g_fah->Move(testUri, targetParentUri, testUri2); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0007 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0007"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0008 - * @tc.name: medialibrary_file_access_Move_0008 - * @tc.desc: Test function of Move interface for SUCCESS which move empty folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0008, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0008"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0008 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0008 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0008"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0009 - * @tc.name: medialibrary_file_access_Move_0009 - * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0009, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0009"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - size_t fileNumbers = 2000; - for (size_t i = 0; i < fileNumbers; i++) { - string fileName = "test" + ToString(i) + ".txt"; - result = g_fah->CreateFile(newDirUriTest1, fileName, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - Uri testUri2(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0009 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0009 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0009"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0010 - * @tc.name: medialibrary_file_access_Move_0010 - * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0010, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0010"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->Mkdir(newDirUriTest1, "test", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - size_t directoryNumbers = 50; - for (size_t i = 0; i < directoryNumbers; i++) { - result = g_fah->Mkdir(testUri, "test", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } - Uri testUri2(""); - result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Move_0010 result:" << result; - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0010 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0010"; -} - -static void MoveTdd(shared_ptr fahs, Uri sourceFile, Uri targetParent, Uri newFile) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MoveTdd"; - int ret = fahs->Move(sourceFile, targetParent, newFile); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_NE(newFile.ToString(), ""); - g_num++; - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MoveTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Move_0011 - * @tc.name: medialibrary_file_access_Move_0011 - * @tc.desc: Test function of Move interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0011, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0011"; - try { - Uri newDirUriTest1(""); - Uri newDirUriTest2(""); - int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri{""}; - Uri testUri2(""); - std::string displayName = "test1.txt"; - result = g_fah->CreateFile(newDirUriTest1, displayName, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(MoveTdd, g_fah, testUri, newDirUriTest2, testUri2); - execthread.join(); - } - EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest1); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(newDirUriTest2); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0011 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0011"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0000 - * @tc.name: medialibrary_file_access_Copy_0000 - * @tc.desc: Test function of Copy interface, copy a file and argument of force is false - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0000"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0000_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri aFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0000_dest", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(aFileUri, destUri, copyResult, false); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0001 - * @tc.name: medialibrary_file_access_Copy_0001 - * @tc.desc: Test function of Copy interface, copy a directory and argument of force is false - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0001"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0001_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri aFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri bFileUri(""); - result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string bFileBuff = "Copy test content for b.txt"; - ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); - close(fd); - EXPECT_EQ(bFileSize, bFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0001_dest", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(srcUri, destUri, copyResult, false); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0002 - * @tc.name: medialibrary_file_access_Copy_0002 - * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is false - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0002"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0002_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri srcFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0002_dest_false", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destFileUri(""); - result = g_fah->CreateFile(destUri, "a.txt", destFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(srcFileUri, destUri, copyResult, false); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(copyResult.size(), 0); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0003 - * @tc.name: medialibrary_file_access_Copy_0003 - * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is true - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0003"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0003_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri srcFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0003_dest_true", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destFileUri(""); - result = g_fah->CreateFile(destUri, "a.txt", destFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(srcFileUri, destUri, copyResult, true); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0004 - * @tc.name: medialibrary_file_access_Copy_0004 - * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is false - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0004"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0004_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - Uri aFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri bFileUri(""); - result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string bFileBuff = "Copy test content for b.txt"; - ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); - close(fd); - EXPECT_EQ(bFileSize, bFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0004_dest_false", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destSrcUri(""); - result = g_fah->Mkdir(destUri, "Copy_0004_src", destSrcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destSrcAUri(""); - result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(srcUri, destUri, copyResult, false); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(copyResult.size(), 0); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0005 - * @tc.name: medialibrary_file_access_Copy_0005 - * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is true - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0005"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0005_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - Uri aFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri bFileUri(""); - result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string bFileBuff = "Copy test content for b.txt"; - ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); - close(fd); - EXPECT_EQ(bFileSize, bFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0005_dest_true", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destSrcUri(""); - result = g_fah->Mkdir(destUri, "Copy_0005_src", destSrcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destSrcAUri(""); - result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(srcUri, destUri, copyResult, true); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0006 - * @tc.name: medialibrary_file_access_Copy_0006 - * @tc.desc: Test function of Copy interface, copy a file with the same name - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0006"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0006_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri srcFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0006_dest_false", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destFileUri(""); - result = g_fah->CreateFile(destUri, "a.txt", destFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(srcFileUri, destUri, copyResult); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(copyResult.size(), 0); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0006"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Copy_0007 - * @tc.name: medialibrary_file_access_Copy_0007 - * @tc.desc: Test function of Copy interface, copy a directory with the same name - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6UI3H - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0007"; - try { - Uri srcUri(""); - int result = g_fah->Mkdir(g_newDirUri, "Copy_0007_src", srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - Uri aFileUri(""); - result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int fd; - result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string aFileBuff = "Copy test content for a.txt"; - ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); - close(fd); - EXPECT_EQ(aFileSize, aFileBuff.size()); - - Uri bFileUri(""); - result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::string bFileBuff = "Copy test content for b.txt"; - ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); - close(fd); - EXPECT_EQ(bFileSize, bFileBuff.size()); - - Uri destUri(""); - result = g_fah->Mkdir(g_newDirUri, "Copy_0007_dest_false", destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destSrcUri(""); - result = g_fah->Mkdir(destUri, "Copy_0007_src", destSrcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri destSrcAUri(""); - result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - vector copyResult; - result = g_fah->Copy(srcUri, destUri, copyResult); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(copyResult.size(), 0); - - result = g_fah->Delete(srcUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->Delete(destUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0007"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Rename_0000 - * @tc.name: medialibrary_file_access_Rename_0000 - * @tc.desc: Test function of Rename interface for SUCCESS which rename file. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0000"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - result = g_fah->Rename(testUri, "test2.txt", renameUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0000 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Rename_0001 - * @tc.name: medialibrary_file_access_Rename_0001 - * @tc.desc: Test function of Rename interface for SUCCESS which rename folder. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0001"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - result = g_fah->Rename(newDirUriTest, "testRename", renameUri); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0001 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Rename_0002 - * @tc.name: medialibrary_file_access_Rename_0002 - * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0002"; - try { - Uri renameUri(""); - Uri sourceFileUri(""); - int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0002 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Rename_0003 - * @tc.name: medialibrary_file_access_Rename_0003 - * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0003"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); - result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0003 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Rename_0004 - * @tc.name: medialibrary_file_access_Rename_0004 - * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0004"; - try { - Uri renameUri(""); - Uri sourceFileUri("~!@#$%^&*()_"); - int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0004 result:" << result; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Rename_0005 - * @tc.name: medialibrary_file_access_Rename_0005 - * @tc.desc: Test function of Rename interface for ERROR which displayName is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0005"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri renameUri(""); - result = g_fah->Rename(testUri, "", renameUri); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "Rename_0005 result:" << result; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0005"; -} - -static void RenameTdd(shared_ptr fahs, Uri sourceFile, std::string displayName, Uri newFile) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_RenameTdd"; - int ret = fahs->Rename(sourceFile, displayName, newFile); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "RenameTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_NE(newFile.ToString(), ""); - g_num++; - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_RenameTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Rename_0006 - * @tc.name: medialibrary_file_access_Rename_0006 - * @tc.desc: Test function of Rename interface for SUCCESS which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0006"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri{""}; - std::string displayName1 = "test1.txt"; - std::string displayName2 = "test2.txt"; - Uri renameUri(""); - result = g_fah->CreateFile(newDirUriTest, displayName1, testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(RenameTdd, g_fah, testUri, displayName2, renameUri); - execthread.join(); - } - EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0006"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ListFile_0000 - * @tc.name: medialibrary_file_access_ListFile_0000 - * @tc.desc: Test function of ListFile interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0000"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0000.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "ListFile_0000 result:" << fileInfoVec.size() << endl; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ListFile_0001 - * @tc.name: medialibrary_file_access_ListFile_0001 - * @tc.desc: Test function of ListFile interface for ERROR which Uri is nullptr. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0001"; - try { - Uri sourceFileUri(""); - FileInfo fileInfo; - fileInfo.uri = sourceFileUri.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - vector fileInfoVec; - FileFilter filter({}, {}, {}, 0, 0, false, false); - int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "ListFile_0001 result:" << fileInfoVec.size() << endl; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ListFile_0002 - * @tc.name: medialibrary_file_access_ListFile_0002 - * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is absolute path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0002"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); - FileInfo fileInfo; - fileInfo.uri = sourceFileUri.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - vector fileInfoVec; - FileFilter filter({}, {}, {}, 0, 0, false, false); - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "ListFile_0002 result:" << fileInfoVec.size() << endl; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ListFile_0003 - * @tc.name: medialibrary_file_access_ListFile_0003 - * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is special symbols. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0003"; - try { - Uri sourceFileUri("~!@#$%^&*()_"); - FileInfo fileInfo; - fileInfo.uri = sourceFileUri.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - vector fileInfoVec; - FileFilter filter; - int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << "ListFile_0003 result:" << fileInfoVec.size() << endl; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ListFile_0004 - * @tc.name: medialibrary_file_access_ListFile_0004 - * @tc.desc: Test function of ListFile interface for ERROR which add filter. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HB855 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0004"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri1(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.txt", testUri1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.docx", testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter({".txt"}, {}, {}, 0, 0, false, true); - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), 1); - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0004"; -} - -static void ListFileTdd(shared_ptr fahs, FileInfo fileInfo, int offset, int maxCount, - FileFilter filter, std::vector fileInfoVec) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFileTdd"; - int ret = fahs->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "ListFileTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), 1); - g_num++; - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFileTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ListFile_0005 - * @tc.name: medialibrary_file_access_ListFile_0005 - * @tc.desc: Test function of ListFile interface for ERROR which Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0005"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri1(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.txt", testUri1); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri2(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.docx", testUri2); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - g_num = 0; - FileFilter filter({".txt"}, {}, {}, 0, 0, false, true); - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(ListFileTdd, g_fah, fileInfo, offset, maxCount, filter, fileInfoVec); - execthread.join(); - } - EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0000 - * @tc.name: medialibrary_file_access_ScanFile_0000 - * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with filter. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HB866 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0000"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - FileInfo fileInfo; - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - fileInfo.uri = "file://media/root"; - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); - result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fileInfoVec.size(), 1); - GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0001 - * @tc.name: medialibrary_file_access_ScanFile_0001 - * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with no filter. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HB866 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0001"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - FileInfo fileInfo; - fileInfo.uri = "file://media/root"; - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.q1w2e3r4", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter({}, {}, {}, 0, 0, false, false); - result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fileInfoVec.size(), 2); - GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0002 - * @tc.name: medialibrary_file_access_ScanFile_0002 - * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HB866 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0002"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0002.q1w2e3r4", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.docx", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); - result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), 1); - FileFilter filter1({".q1w2e3r4", ".txt"}, {}, {}, 0, 0, false, true); - result = g_fah->ScanFile(fileInfo, offset, maxCount, filter1, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), 2); - GTEST_LOG_(INFO) << "ScanFile_0002 result:" << fileInfoVec.size() << endl; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0003 - * @tc.name: medialibrary_file_access_ScanFile_0003 - * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HB866 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0003"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0003.q1w2e3r4", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - FileInfo fileInfo; - fileInfo.uri = newDirUriTest.ToString(); - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); - result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), 1); - GTEST_LOG_(INFO) << "ScanFile_0003 result:" << fileInfoVec.size() << endl; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0003"; -} - -static void ScanFileTdd(FileInfo fileInfo, int offset, int maxCount, FileFilter filter, - std::vector fileInfoVec) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFileTdd"; - int ret = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); - if (ret != OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(ERROR) << "ScanFileTdd get result error, code:" << ret; - return; - } - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVec.size(), 1); - g_num++; - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFileTdd"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0004 - * @tc.name: medialibrary_file_access_ScanFile_0004 - * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with Concurrent. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HB866 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0004"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - FileInfo fileInfo; - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - fileInfo.uri = "file://media/root"; - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); - g_num = 0; - for (int j = 0; j < INIT_THREADS_NUMBER; j++) { - std::thread execthread(ScanFileTdd, fileInfo, offset, maxCount, filter, fileInfoVec); - execthread.join(); - } - EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0004"; -} - -static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName) -{ - std::string tPath = Uri(path).GetPath(); - if (tPath.empty()) { - GTEST_LOG_(INFO) << "Uri path error."; - return false; - } - - if (tPath.front() != '/') { - GTEST_LOG_(INFO) << "Uri path format error."; - return false; - } - - auto index = tPath.substr(1).find_first_of("/"); - auto bundleName = tPath.substr(1, index); - if (bundleName.empty()) { - GTEST_LOG_(INFO) << "bundleName empty."; - return false; - } - - path.replace(path.find(bundleName), bundleName.length(), newName); - return true; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0005 - * @tc.name: medialibrary_file_access_ScanFile_0005 - * @tc.desc: Test function of ScanFile interface for FAILED because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HB866 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0005"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0005.q1w2e3r4", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - std::string str = testUri.ToString(); - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(INFO) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - FileInfo fileInfo; - fileInfo.uri = str; - int64_t offset = 0; - int64_t maxCount = 1000; - std::vector fileInfoVec; - FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); - result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - EXPECT_EQ(fileInfoVec.size(), 0); - GTEST_LOG_(INFO) << "ScanFile_0005 result:" << fileInfoVec.size() << endl; - result = g_fah->Delete(newDirUriTest); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetRoots_0000 - * @tc.name: medialibrary_file_access_GetRoots_0000 - * @tc.desc: Test function of GetRoots interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetRoots_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetRoots_0000"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK); - if (info.size() > OHOS::FileAccessFwk::ERR_OK) { - GTEST_LOG_(INFO) << info[0].uri; - GTEST_LOG_(INFO) << info[0].displayName; - GTEST_LOG_(INFO) << info[0].deviceType; - GTEST_LOG_(INFO) << info[0].deviceFlags; - } - string uri = "file://media/root"; - string displayName = "LOCAL"; - EXPECT_EQ(info[0].uri, uri); - EXPECT_EQ(info[0].displayName, displayName); - EXPECT_EQ(info[0].deviceType, DEVICE_LOCAL_DISK); - EXPECT_EQ(info[0].deviceFlags, DEVICE_FLAG_SUPPORTS_READ | DEVICE_FLAG_SUPPORTS_WRITE); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetRoots_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetRoots_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0000 - * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0000 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0000"; - try { - vector infos; - int result = g_fah->GetRoots(infos); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < infos.size(); i++) { - Uri parentUri(infos[i].uri); - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVecTemp; - result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); - } - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0001 - * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0001 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0001"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "testDir", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - FileInfo dirInfo; - result = g_fah->GetFileInfoFromUri(newDirUriTest, dirInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVec; - result = g_fah->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0002 - * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0002 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the regular file uri to fileinfo and call listfile for ERROR. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0002"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "testDir", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri newFileUri(""); - result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_GetFileInfoFromUri_0002.txt", newFileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(newFileUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVecTemp; - result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0003 - * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0003 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0003"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - Uri parentUri(std::string("\?\?\?\?/") + info[i].uri); - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS); - } - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0004 - * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0004 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0004"; - try { - vector info; - int result = g_fah->GetRoots(info); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - for (size_t i = 0; i < info.size(); i++) { - std::string str = info[i].uri; - if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { - GTEST_LOG_(ERROR) << "replace BundleName failed."; - EXPECT_TRUE(false); - } - Uri parentUri(str); - FileInfo fileinfo; - result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); - } - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0005 - * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0005 - * @tc.desc: Test function of GetFileInfoFromUri interface. - * @tc.desc: convert the invalid uri to fileinfo failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0005"; - try { - Uri uri("~!@#$%^&*()_"); - FileInfo fileInfo; - int result = g_fah->GetFileInfoFromUri(uri, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - uri = Uri("/"); - result = g_fah->GetFileInfoFromUri(uri, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - uri = Uri(""); - result = g_fah->GetFileInfoFromUri(uri, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0000 - * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0000 - * @tc.desc: Test function of GetFileInfoFromRelativePath interface. - * @tc.desc: convert the general directory relativePath to fileinfo for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0000"; - try { - FileInfo fileInfo; - string relativePath = ""; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Audios/"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Camera/"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Documents/"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Download"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Pictures"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Videos"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0001 - * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0001 - * @tc.desc: Test function of GetFileInfoFromRelativePath interface. - * @tc.desc: convert the general directory relativePath to fileinfo for failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0001"; - try { - FileInfo fileInfo; - string relativePath = "test/"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "/"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "~!@#$%^&*()_"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "/d"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0002 - * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0002 - * @tc.desc: Test function of GetFileInfoFromRelativePath interface. - * @tc.desc: convert the general directory relativePath to fileinfo and call listfile for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0002"; - try { - FileInfo fileInfo; - string relativePath = "Download/"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - Uri parentUri(fileInfo.uri); - Uri newFile(""); - result = g_fah->CreateFile(parentUri, "GetFileInfoFromRelativePath_0002.jpg", newFile); - ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVec; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(newFile); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0003 - * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0003 - * @tc.desc: Test function of GetFileInfoFromRelativePath interface. - * @tc.desc: convert the relative file path to fileinfo and call listfile for failed. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0003"; - try { - FileInfo fileInfo; - string relativePath = "Download/"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - Uri parentUri(fileInfo.uri); - Uri newFile(""); - result = g_fah->CreateFile(parentUri, "GetFileInfoFromRelativePath_0003.jpg", newFile); - ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Download/GetFileInfoFromRelativePath_0003.jpg"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVec; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(newFile); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0004 - * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0004 - * @tc.desc: Test function of GetFileInfoFromRelativePath interface. - * @tc.desc: convert the relative directory path to fileinfo and call listfile for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000HRLBS - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0004"; - try { - FileInfo fileInfo; - string relativePath = "Download/"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - Uri parentUri(fileInfo.uri); - Uri newDir(""); - result = g_fah->Mkdir(parentUri, "DirGetFileInfoFromRelativePath_0004", newDir); - ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - Uri fileUri(""); - result = g_fah->CreateFile(newDir, "file1", fileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->CreateFile(newDir, "file2", fileUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - relativePath = "Download/DirGetFileInfoFromRelativePath_0004"; - result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - - int64_t offset = 0; - int64_t maxCount = 1000; - FileFilter filter; - std::vector fileInfoVec; - result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); - - result = g_fah->Delete(newDir); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0000 - * @tc.name: medialibrary_file_access_GetThumbnail_0000 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for SUCCESS which Uri's type is image. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0000"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Pictures/CreateImageThumbnailTest_001.jpg"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri uri(fileInfo.uri); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 256; - thumbnailSize.height = 256; - result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_NE(getPixelMap, nullptr); - EXPECT_EQ(getPixelMap->GetWidth(), thumbnailSize.width); - EXPECT_EQ(getPixelMap->GetHeight(), thumbnailSize.height); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0001 - * @tc.name: medialibrary_file_access_GetThumbnail_0001 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for SUCCESS which Uri's type is video. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0001"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Videos/CreateVideoThumbnailTest_001.mp4"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri uri(fileInfo.uri); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 300; - thumbnailSize.height = 300; - result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_NE(getPixelMap, nullptr); - EXPECT_EQ(getPixelMap->GetWidth(), thumbnailSize.width); - EXPECT_EQ(getPixelMap->GetHeight(), thumbnailSize.height); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0002 - * @tc.name: medialibrary_file_access_GetThumbnail_0002 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for SUCCESS which Uri's type is audio. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0002"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Audios/CreateAudioThumbnailTest_001.mp3"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri uri(fileInfo.uri); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 256; - thumbnailSize.height = 256; - result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_NE(getPixelMap, nullptr); - EXPECT_EQ(getPixelMap->GetWidth(), thumbnailSize.width); - EXPECT_EQ(getPixelMap->GetHeight(), thumbnailSize.height); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0003 - * @tc.name: medialibrary_file_access_GetThumbnail_0003 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0003"; - try { - Uri uri(""); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 256; - thumbnailSize.height = 256; - int result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_EQ(getPixelMap, nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0003 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0004 - * @tc.name: medialibrary_file_access_GetThumbnail_0004 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is not a local path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0004"; - try { - Uri uri("//Pictures/CreateImageThumbnailTest_001.jpg"); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 256; - thumbnailSize.height = 256; - int result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_EQ(getPixelMap, nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0005 - * @tc.name: medialibrary_file_access_GetThumbnail_0005 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is not a media path. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0005"; - try { - Uri newDirUriTest(""); - int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 256; - thumbnailSize.height = 256; - result = g_fah->GetThumbnail(testUri, thumbnailSize, getPixelMap); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_EQ(getPixelMap, nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0006 - * @tc.name: medialibrary_file_access_GetThumbnail_0006 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is unreadable code. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0006"; - try { - Uri uri("&*()*/?"); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 256; - thumbnailSize.height = 256; - int result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_EQ(getPixelMap, nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0006"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0007 - * @tc.name: medialibrary_file_access_GetThumbnail_0007 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for ERROR which size is an invalid value. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0007, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0007"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Pictures/CreateImageThumbnailTest_001.jpg"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri uri(fileInfo.uri); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = 0; - thumbnailSize.height = 0; - result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_EQ(getPixelMap, nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0007 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0007"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0008 - * @tc.name: medialibrary_file_access_GetThumbnail_0008 - * @tc.desc: Test function of GetThumbnail interface. - * @tc.desc: Test function of GetThumbnail interface for ERROR which size is an invalid value. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6HLSK - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0008, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0008"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Pictures/CreateImageThumbnailTest_001.jpg"; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri uri(fileInfo.uri); - std::shared_ptr getPixelMap = nullptr; - ThumbnailSize thumbnailSize; - thumbnailSize.width = -1; - thumbnailSize.height = -1; - result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); - EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); - ASSERT_EQ(getPixelMap, nullptr); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0008 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0008"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Query_0000 - * @tc.name: medialibrary_file_access_Query_0000 - * @tc.desc: Test function of Query directory for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0000"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Documents/"; - std::string displayName = "Documents"; - int targetSize = 46; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri dirUriTest(fileInfo.uri); - - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {FILE_SIZE, " "}, - {DATE_MODIFIED, " "}, - {DATE_ADDED, " "}, - {HEIGHT, " "}, - {WIDTH, " "}, - {DURATION, " "} - }; - auto testJsonString = testJson.dump(); - int ret = g_fah->Query(dirUriTest, testJsonString); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - auto jsonObject = json::parse(testJsonString); - EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); - EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize); - ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); - ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); - GTEST_LOG_(INFO) << testJsonString; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0000"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Query_0001 - * @tc.name: medialibrary_file_access_Query_0001 - * @tc.desc: Test function of Query file for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0001"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Documents/Test/"; - std::string displayName = "CreateQueryTest_002.txt"; - int targetSize = 23; - std::string filePath = "Documents/Test/CreateQueryTest_002.txt"; - int ret = g_fah->GetFileInfoFromRelativePath(filePath, fileInfo); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(fileInfo.uri); - - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {FILE_SIZE, " "}, - {DATE_MODIFIED, " "}, - {DATE_ADDED, " "}, - {HEIGHT, " "}, - {WIDTH, " "}, - {DURATION, " "} - }; - auto testJsonString = testJson.dump(); - ret = g_fah->Query(testUri, testJsonString); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - GTEST_LOG_(INFO) << testJsonString; - auto jsonObject = json::parse(testJsonString); - EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath); - EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); - EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize); - ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); - ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0001 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0001"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Query_0002 - * @tc.name: medialibrary_file_access_Query_0002 - * @tc.desc: Test function of Query directory size for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0002, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0002"; - try { - FileAccessFwk::FileInfo fileInfo; - std::string relativePath = "Documents/"; - std::string displayName = "Documents"; - int targetSize = 46; - int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); - EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); - Uri dirUriTest(fileInfo.uri); - - json testJson = { - {FILE_SIZE, " "} - }; - auto testJsonString = testJson.dump(); - int ret = g_fah->Query(dirUriTest, testJsonString); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - auto jsonObject = json::parse(testJsonString); - EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize); - GTEST_LOG_(INFO) << testJsonString; - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0002 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0002"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Query_0003 - * @tc.name: medialibrary_file_access_Query_0003 - * @tc.desc: Test function of Query interface for ERROR which Uri is unreadable code. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0003, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0003"; - try { - Uri testUri("&*()*/?"); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "} - }; - auto testJsonString = testJson.dump(); - int ret = g_fah->Query(testUri, testJsonString); - EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0003"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Query_0004 - * @tc.name: medialibrary_file_access_Query_0004 - * @tc.desc: Test function of Query interface for which all column nonexistence. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0004, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0004"; - try { - Uri newDirUriTest(""); - std::string fileName = "test.txt"; - int ret = g_fah->Mkdir(g_newDirUri, "Query004", newDirUriTest); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - ret = g_fah->CreateFile(newDirUriTest, fileName, testUri); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - json testJson = { - {"001", " "}, - {"#", " "}, - {"test", " "}, - {"target", " "} - }; - auto testJsonString = testJson.dump(); - ret = g_fah->Query(testUri, testJsonString); - EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); - ret = g_fah->Delete(newDirUriTest); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0004"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Query_0005 - * @tc.name: medialibrary_file_access_Query_0005 - * @tc.desc: Test function of Query interface for which part of column nonexistence. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0005, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0005"; - try { - Uri newDirUriTest(""); - std::string fileName = "test.txt"; - int ret = g_fah->Mkdir(g_newDirUri, "Query005", newDirUriTest); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - ret = g_fah->CreateFile(newDirUriTest, fileName, testUri); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - json testJson = { - {RELATIVE_PATH, " "}, - {DISPLAY_NAME, " "}, - {"test", " "} - }; - auto testJsonString = testJson.dump(); - ret = g_fah->Query(testUri, testJsonString); - EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); - ret = g_fah->Delete(newDirUriTest); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0005 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0005"; -} - -/** - * @tc.number: user_file_service_medialibrary_file_access_Query_0006 - * @tc.name: medialibrary_file_access_Query_0006 - * @tc.desc: Test function of Query interface for which column is null. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6S4VV - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0006, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0006"; - try { - Uri newDirUriTest(""); - std::string fileName = "test.txt"; - std::string relativePath = "test/test.txt"; - int ret = g_fah->Mkdir(g_newDirUri, "Query006", newDirUriTest); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - Uri testUri(""); - ret = g_fah->CreateFile(newDirUriTest, fileName, testUri); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - json testJson; - auto testJsonString = testJson.dump(); - ret = g_fah->Query(testUri, testJsonString); - EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); - ret = g_fah->Delete(newDirUriTest); - EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0006 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0006"; -} +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0000 +// * @tc.name: medialibrary_file_access_OpenFile_0000 +// * @tc.desc: Test function of OpenFile interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0000"; +// try { +// Uri parentUri = GetParentUri(); +// bool isExist = false; +// int result = g_fah->Access(g_newDirUri, isExist); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// if (!isExist) { +// result = g_fah->Mkdir(parentUri, "Download", g_newDirUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// } +// Uri newDirUriTest("file://media/root/file"); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < fileInfoVec.size(); i++) { +// if (fileInfoVec[i].fileName.compare("Download") == 0) { +// g_newDirUri = Uri(fileInfoVec[i].uri); +// break; +// } +// } +// result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_OpenFile_0000.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0000 result:" << result; +// close(fd); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_accsess_OpenFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0001 +// * @tc.name: medialibrary_file_access_OpenFile_0001 +// * @tc.desc: Test function of OpenFile interface for ERROR which Uri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0001"; +// try { +// Uri uri(""); +// int fd; +// int result = g_fah->OpenFile(uri, WRITE_READ, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0001 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0002 +// * @tc.name: medialibrary_file_access_OpenFile_0002 +// * @tc.desc: Test function of OpenFile interface for ERROR which Uri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0002"; +// try { +// Uri uri("storage/media/100/local/files/Download/medialibrary_file_access_OpenFile_0002.txt"); +// int fd; +// int result = g_fah->OpenFile(uri, WRITE_READ, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0003 +// * @tc.name: medialibrary_file_access_OpenFile_0003 +// * @tc.desc: Test function of OpenFile interface for ERROR which Uri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0003"; +// try { +// Uri uri("~!@#$%^&*()_"); +// int fd; +// int result = g_fah->OpenFile(uri, WRITE_READ, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0003 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0004 +// * @tc.name: medialibrary_file_access_OpenFile_0004 +// * @tc.desc: Test function of OpenFile interface for ERROR which flag is -1. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0004"; +// try { +// Uri newFileUri(""); +// int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0004.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// int flag = -1; +// result = g_fah->OpenFile(newFileUri, flag, fd); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0004 result:" << result; +// result = g_fah->Delete(newFileUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0005 +// * @tc.name: medialibrary_file_access_OpenFile_0005 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 0. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0005"; +// try { +// Uri newFileUri(""); +// int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0005.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0005 result:" << result; +// close(fd); +// result = g_fah->Delete(newFileUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0006 +// * @tc.name: medialibrary_file_access_OpenFile_0006 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 1. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0006"; +// try { +// Uri newFileUri(""); +// int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0006.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, WRITE, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0006 result:" << result; +// close(fd); +// result = g_fah->Delete(newFileUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0006"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0007 +// * @tc.name: medialibrary_file_access_OpenFile_0007 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which flag is 2. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0007"; +// try { +// Uri newFileUri(""); +// int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_OpenFile_0007.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(newFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "OpenFile_0007 result:" << result; +// close(fd); +// result = g_fah->Delete(newFileUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0007"; +// } + +// static void OpenFileTdd(shared_ptr fahs, Uri uri, int flag, int fd) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFileTdd"; +// int ret = fahs->OpenFile(uri, flag, fd); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "OpenFileTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fd, OHOS::FileAccessFwk::ERR_OK); +// g_num++; +// close(fd); +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFileTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0008 +// * @tc.name: medialibrary_file_access_OpenFile_0008 +// * @tc.desc: Test function of OpenFile interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0008, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0008"; +// try { +// Uri newFileUri(""); +// int fd; +// g_num = 0; +// std::string displayName = "test1.txt"; +// int result = g_fah->CreateFile(g_newDirUri, displayName, newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(OpenFileTdd, g_fah, newFileUri, WRITE_READ, fd); +// execthread.join(); +// } +// EXPECT_EQ(g_num, INIT_THREADS_NUMBER); +// result = g_fah->Delete(newFileUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_OpenFile_0008 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0008"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0000 +// * @tc.name: medialibrary_file_access_CreateFile_0000 +// * @tc.desc: Test function of CreateFile interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0000"; +// try { +// Uri newFileUri(""); +// int result = g_fah->CreateFile(g_newDirUri, "medialibrary_file_access_CreateFile_0000.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0000 result:" << result; +// result = g_fah->Delete(newFileUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0001 +// * @tc.name: medialibrary_file_access_CreateFile_0001 +// * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0001"; +// try { +// Uri newFileUri(""); +// Uri parentUri(""); +// int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0001.txt", newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0001 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0002 +// * @tc.name: medialibrary_file_access_CreateFile_0002 +// * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002"; +// try { +// Uri newFileUri(""); +// Uri parentUri("storage/media/100/local/files/Download"); +// int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0002.txt", newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0003 +// * @tc.name: medialibrary_file_access_CreateFile_0003 +// * @tc.desc: Test function of CreateFile interface for ERROR which parentUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0002"; +// try { +// Uri newFileUri(""); +// Uri parentUri("~!@#$%^&*()_"); +// int result = g_fah->CreateFile(parentUri, "medialibrary_file_access_CreateFile_0003.txt", newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0003 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0004 +// * @tc.name: medialibrary_file_access_CreateFile_0004 +// * @tc.desc: Test function of CreateFile interface for ERROR which displayName is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0004"; +// try { +// Uri newFileUri(""); +// string displayName = ""; +// int result = g_fah->CreateFile(g_newDirUri, displayName, newFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "CreateFile_0004 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0004"; +// } + +// static void CreateFileTdd(shared_ptr fahs, Uri parent, std::string displayName, Uri newDir) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFileTdd"; +// int ret = fahs->CreateFile(parent, displayName, newDir); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "CreateFileTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_NE(newDir.ToString(), ""); +// g_num++; +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFileTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_CreateFile_0005 +// * @tc.name: medialibrary_file_access_CreateFile_0005 +// * @tc.desc: Test function of CreateFile interface for SUCCESS while Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_CreateFile_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_CreateFile_0005"; +// try { +// Uri newFileUri1(""); +// Uri newFileUri2(""); +// Uri newFileUri3(""); +// std::string displayName1 = "test1"; +// std::string displayName2 = "test2"; +// std::string displayName3 = "test3.txt"; +// int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(CreateFileTdd, g_fah, newFileUri2, displayName3, newFileUri3); +// execthread.join(); +// } +// EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// GTEST_LOG_(INFO) << "g_newDirUri.ToString() =" << g_newDirUri.ToString(); +// result = g_fah->Delete(newFileUri1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_CreateFile_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_CreateFile_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0000 +// * @tc.name: medialibrary_file_access_Mkdir_0000 +// * @tc.desc: Test function of Mkdir interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0000"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "medialibrary_file_access_Mkdir_0000", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0001 +// * @tc.name: medialibrary_file_access_Mkdir_0001 +// * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0001"; +// try { +// Uri newDirUriTest(""); +// Uri parentUri(""); +// int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0001", newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0001 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0002 +// * @tc.name: medialibrary_file_access_Mkdir_0002 +// * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002"; +// try { +// Uri newDirUriTest(""); +// Uri parentUri("storage/media/100/local/files/Download"); +// int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0002", newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0003 +// * @tc.name: medialibrary_file_access_Mkdir_0003 +// * @tc.desc: Test function of Mkdir interface for ERROR which parentUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0002"; +// try { +// Uri newDirUriTest(""); +// Uri parentUri("~!@#$%^&*()_"); +// int result = g_fah->Mkdir(parentUri, "medialibrary_file_access_Mkdir_0003", newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0003 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0004 +// * @tc.name: medialibrary_file_access_Mkdir_0004 +// * @tc.desc: Test function of Mkdir interface for ERROR which displayName is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0004"; +// try { +// Uri newDirUriTest(""); +// string displayName = ""; +// int result = g_fah->Mkdir(g_newDirUri, displayName, newDirUriTest); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Mkdir_0004 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0004"; +// } + +// static void MkdirTdd(shared_ptr fahs, Uri parent, std::string displayName, Uri newDir) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MkdirTdd"; +// int ret = fahs->Mkdir(parent, displayName, newDir); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "MkdirTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_NE(newDir.ToString(), ""); +// g_num++; +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MkdirTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Mkdir_0005 +// * @tc.name: medialibrary_file_access_Mkdir_0005 +// * @tc.desc: Test function of Mkdir interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Mkdir_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Mkdir_0005"; +// try { +// Uri newFileUri1(""); +// Uri newFileUri2(""); +// Uri newFileUri3(""); +// std::string displayName1 = "test1"; +// std::string displayName2 = "test2"; +// std::string displayName3 = "test3"; +// int result = g_fah->Mkdir(g_newDirUri, displayName1, newFileUri1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(newFileUri1, displayName2, newFileUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(MkdirTdd, g_fah, newFileUri2, displayName3, newFileUri3); +// execthread.join(); +// } +// EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newFileUri1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Mkdir_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Mkdir_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Delete_0000 +// * @tc.name: medialibrary_file_access_Delete_0000 +// * @tc.desc: Test function of Delete interface for SUCCESS which delete file. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0000"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0000.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newFileUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Delete_0001 +// * @tc.name: medialibrary_file_access_Delete_0001 +// * @tc.desc: Test function of Delete interface for SUCCESS which delete folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0001"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0001 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Delete_0002 +// * @tc.name: medialibrary_file_access_Delete_0002 +// * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0002"; +// try { +// Uri selectFileUri(""); +// int result = g_fah->Delete(selectFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Delete_0003 +// * @tc.name: medialibrary_file_access_Delete_0003 +// * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0003"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri selectFileUri("storage/media/100/local/files/Download/test"); +// result = g_fah->Delete(selectFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0003 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Delete_0004 +// * @tc.name: medialibrary_file_access_Delete_0004 +// * @tc.desc: Test function of Delete interface for ERROR which selectFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0004"; +// try { +// Uri selectFileUri("!@#$%^&*()"); +// int result = g_fah->Delete(selectFileUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Delete_0004 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0004"; +// } + +// static void DeleteTdd(shared_ptr fahs, Uri selectFile) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_DeleteTdd"; +// int ret = fahs->Delete(selectFile); +// if (ret < OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "DeleteTdd get result error, code:" << ret; +// return; +// } +// EXPECT_GE(ret, OHOS::FileAccessFwk::ERR_OK); +// g_num++; +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_DeleteTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Delete_0005 +// * @tc.name: medialibrary_file_access_Delete_0005 +// * @tc.desc: Test function of Delete interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Delete_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Delete_0005"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_Delete_0005.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// std::string displayName = "test1.txt"; +// Uri testUri2(""); +// result = g_fah->CreateFile(newDirUriTest, displayName, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(DeleteTdd, g_fah, testUri); +// execthread.join(); +// } +// EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Delete_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Delete_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0000 +// * @tc.name: medialibrary_file_access_Move_0000 +// * @tc.desc: Test function of Move interface for SUCCESS which move file. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0000"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// result = g_fah->Move(testUri, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0001 +// * @tc.name: medialibrary_file_access_Move_0001 +// * @tc.desc: Test function of Move interface for SUCCESS which move folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0001"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0001 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0002 +// * @tc.name: medialibrary_file_access_Move_0002 +// * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0002"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// Uri sourceFileUri(""); +// result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0002 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0003 +// * @tc.name: medialibrary_file_access_Move_0003 +// * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0003"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri sourceFileUri("storage/media/100/local/files/Download/test1/test.txt"); +// result = g_fah->Move(sourceFileUri, newDirUriTest2, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0003 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0004 +// * @tc.name: medialibrary_file_access_Move_0004 +// * @tc.desc: Test function of Move interface for ERROR which sourceFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0004"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// Uri sourceFileUri("~!@#$%^&*()_"); +// result = g_fah->Move(sourceFileUri, newDirUriTest, testUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0004 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0005 +// * @tc.name: medialibrary_file_access_Move_0005 +// * @tc.desc: Test function of Move interface for ERROR which targetParentUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0005"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri targetParentUri(""); +// result = g_fah->Move(testUri, targetParentUri, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0005 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0006 +// * @tc.name: medialibrary_file_access_Move_0006 +// * @tc.desc: Test function of Move interface for ERROR which targetParentUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0006"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri targetParentUri("storage/media/100/local/files/Download/test2"); +// result = g_fah->Move(testUri, targetParentUri, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0006 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0006"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0007 +// * @tc.name: medialibrary_file_access_Move_0007 +// * @tc.desc: Test function of Move interface for ERROR which targetParentUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0007"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest1, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// Uri targetParentUri("~!@#$^%&*()_"); +// result = g_fah->Move(testUri, targetParentUri, testUri2); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0007 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0007"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0008 +// * @tc.name: medialibrary_file_access_Move_0008 +// * @tc.desc: Test function of Move interface for SUCCESS which move empty folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0008, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0008"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0008 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0008 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0008"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0009 +// * @tc.name: medialibrary_file_access_Move_0009 +// * @tc.desc: Test function of Move interface for SUCCESS which move more file in folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0009, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0009"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// size_t fileNumbers = 2000; +// for (size_t i = 0; i < fileNumbers; i++) { +// string fileName = "test" + ToString(i) + ".txt"; +// result = g_fah->CreateFile(newDirUriTest1, fileName, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// Uri testUri2(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0009 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0009 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0009"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0010 +// * @tc.name: medialibrary_file_access_Move_0010 +// * @tc.desc: Test function of Move interface for SUCCESS which move Multilevel directory folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0010, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0010"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->Mkdir(newDirUriTest1, "test", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// size_t directoryNumbers = 50; +// for (size_t i = 0; i < directoryNumbers; i++) { +// result = g_fah->Mkdir(testUri, "test", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } +// Uri testUri2(""); +// result = g_fah->Move(newDirUriTest1, newDirUriTest2, testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Move_0010 result:" << result; +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0010 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0010"; +// } + +// static void MoveTdd(shared_ptr fahs, Uri sourceFile, Uri targetParent, Uri newFile) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_MoveTdd"; +// int ret = fahs->Move(sourceFile, targetParent, newFile); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "MoveTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_NE(newFile.ToString(), ""); +// g_num++; +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_MoveTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Move_0011 +// * @tc.name: medialibrary_file_access_Move_0011 +// * @tc.desc: Test function of Move interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Move_0011, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Move_0011"; +// try { +// Uri newDirUriTest1(""); +// Uri newDirUriTest2(""); +// int result = g_fah->Mkdir(g_newDirUri, "test1", newDirUriTest1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Mkdir(g_newDirUri, "test2", newDirUriTest2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri{""}; +// Uri testUri2(""); +// std::string displayName = "test1.txt"; +// result = g_fah->CreateFile(newDirUriTest1, displayName, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(MoveTdd, g_fah, testUri, newDirUriTest2, testUri2); +// execthread.join(); +// } +// EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest1); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(newDirUriTest2); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Move_0011 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Move_0011"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0000 +// * @tc.name: medialibrary_file_access_Copy_0000 +// * @tc.desc: Test function of Copy interface, copy a file and argument of force is false +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0000"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0000_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri aFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0000_dest", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(aFileUri, destUri, copyResult, false); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0001 +// * @tc.name: medialibrary_file_access_Copy_0001 +// * @tc.desc: Test function of Copy interface, copy a directory and argument of force is false +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0001"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0001_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri aFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri bFileUri(""); +// result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string bFileBuff = "Copy test content for b.txt"; +// ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); +// close(fd); +// EXPECT_EQ(bFileSize, bFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0001_dest", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(srcUri, destUri, copyResult, false); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0002 +// * @tc.name: medialibrary_file_access_Copy_0002 +// * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is false +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0002"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0002_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri srcFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0002_dest_false", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destFileUri(""); +// result = g_fah->CreateFile(destUri, "a.txt", destFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(srcFileUri, destUri, copyResult, false); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(copyResult.size(), 0); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0003 +// * @tc.name: medialibrary_file_access_Copy_0003 +// * @tc.desc: Test function of Copy interface, copy a file with the same name and argument of force is true +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0003"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0003_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri srcFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0003_dest_true", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destFileUri(""); +// result = g_fah->CreateFile(destUri, "a.txt", destFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(srcFileUri, destUri, copyResult, true); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0004 +// * @tc.name: medialibrary_file_access_Copy_0004 +// * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is false +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0004"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0004_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// Uri aFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri bFileUri(""); +// result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string bFileBuff = "Copy test content for b.txt"; +// ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); +// close(fd); +// EXPECT_EQ(bFileSize, bFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0004_dest_false", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destSrcUri(""); +// result = g_fah->Mkdir(destUri, "Copy_0004_src", destSrcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destSrcAUri(""); +// result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(srcUri, destUri, copyResult, false); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(copyResult.size(), 0); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0005 +// * @tc.name: medialibrary_file_access_Copy_0005 +// * @tc.desc: Test function of Copy interface, copy a directory with the same name and argument of force is true +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0005"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0005_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// Uri aFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri bFileUri(""); +// result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string bFileBuff = "Copy test content for b.txt"; +// ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); +// close(fd); +// EXPECT_EQ(bFileSize, bFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0005_dest_true", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destSrcUri(""); +// result = g_fah->Mkdir(destUri, "Copy_0005_src", destSrcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destSrcAUri(""); +// result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(srcUri, destUri, copyResult, true); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0006 +// * @tc.name: medialibrary_file_access_Copy_0006 +// * @tc.desc: Test function of Copy interface, copy a file with the same name +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0006"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0006_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri srcFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", srcFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(srcFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0006_dest_false", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destFileUri(""); +// result = g_fah->CreateFile(destUri, "a.txt", destFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(srcFileUri, destUri, copyResult); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(copyResult.size(), 0); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0006"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Copy_0007 +// * @tc.name: medialibrary_file_access_Copy_0007 +// * @tc.desc: Test function of Copy interface, copy a directory with the same name +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6UI3H +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Copy_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Copy_0007"; +// try { +// Uri srcUri(""); +// int result = g_fah->Mkdir(g_newDirUri, "Copy_0007_src", srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// Uri aFileUri(""); +// result = g_fah->CreateFile(srcUri, "a.txt", aFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int fd; +// result = g_fah->OpenFile(aFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string aFileBuff = "Copy test content for a.txt"; +// ssize_t aFileSize = write(fd, aFileBuff.c_str(), aFileBuff.size()); +// close(fd); +// EXPECT_EQ(aFileSize, aFileBuff.size()); + +// Uri bFileUri(""); +// result = g_fah->CreateFile(srcUri, "b.txt", bFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->OpenFile(bFileUri, WRITE_READ, fd); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::string bFileBuff = "Copy test content for b.txt"; +// ssize_t bFileSize = write(fd, bFileBuff.c_str(), bFileBuff.size()); +// close(fd); +// EXPECT_EQ(bFileSize, bFileBuff.size()); + +// Uri destUri(""); +// result = g_fah->Mkdir(g_newDirUri, "Copy_0007_dest_false", destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destSrcUri(""); +// result = g_fah->Mkdir(destUri, "Copy_0007_src", destSrcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri destSrcAUri(""); +// result = g_fah->CreateFile(destSrcUri, "a.txt", destSrcAUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// vector copyResult; +// result = g_fah->Copy(srcUri, destUri, copyResult); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(copyResult.size(), 0); + +// result = g_fah->Delete(srcUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->Delete(destUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Copy_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Copy_0007"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Rename_0000 +// * @tc.name: medialibrary_file_access_Rename_0000 +// * @tc.desc: Test function of Rename interface for SUCCESS which rename file. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0000"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// result = g_fah->Rename(testUri, "test2.txt", renameUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0000 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Rename_0001 +// * @tc.name: medialibrary_file_access_Rename_0001 +// * @tc.desc: Test function of Rename interface for SUCCESS which rename folder. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0001"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// result = g_fah->Rename(newDirUriTest, "testRename", renameUri); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0001 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Rename_0002 +// * @tc.name: medialibrary_file_access_Rename_0002 +// * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0002"; +// try { +// Uri renameUri(""); +// Uri sourceFileUri(""); +// int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0002 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Rename_0003 +// * @tc.name: medialibrary_file_access_Rename_0003 +// * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0003"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); +// result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0003 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Rename_0004 +// * @tc.name: medialibrary_file_access_Rename_0004 +// * @tc.desc: Test function of Rename interface for ERROR which sourceFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0004"; +// try { +// Uri renameUri(""); +// Uri sourceFileUri("~!@#$%^&*()_"); +// int result = g_fah->Rename(sourceFileUri, "testRename.txt", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0004 result:" << result; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Rename_0005 +// * @tc.name: medialibrary_file_access_Rename_0005 +// * @tc.desc: Test function of Rename interface for ERROR which displayName is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0005"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri renameUri(""); +// result = g_fah->Rename(testUri, "", renameUri); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "Rename_0005 result:" << result; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0005"; +// } + +// static void RenameTdd(shared_ptr fahs, Uri sourceFile, std::string displayName, Uri newFile) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_RenameTdd"; +// int ret = fahs->Rename(sourceFile, displayName, newFile); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "RenameTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_NE(newFile.ToString(), ""); +// g_num++; +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_RenameTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Rename_0006 +// * @tc.name: medialibrary_file_access_Rename_0006 +// * @tc.desc: Test function of Rename interface for SUCCESS which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Rename_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Rename_0006"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri{""}; +// std::string displayName1 = "test1.txt"; +// std::string displayName2 = "test2.txt"; +// Uri renameUri(""); +// result = g_fah->CreateFile(newDirUriTest, displayName1, testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(RenameTdd, g_fah, testUri, displayName2, renameUri); +// execthread.join(); +// } +// EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Rename_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Rename_0006"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ListFile_0000 +// * @tc.name: medialibrary_file_access_ListFile_0000 +// * @tc.desc: Test function of ListFile interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0000"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0000.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "ListFile_0000 result:" << fileInfoVec.size() << endl; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ListFile_0001 +// * @tc.name: medialibrary_file_access_ListFile_0001 +// * @tc.desc: Test function of ListFile interface for ERROR which Uri is nullptr. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0001"; +// try { +// Uri sourceFileUri(""); +// FileInfo fileInfo; +// fileInfo.uri = sourceFileUri.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// vector fileInfoVec; +// FileFilter filter({}, {}, {}, 0, 0, false, false); +// int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "ListFile_0001 result:" << fileInfoVec.size() << endl; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ListFile_0002 +// * @tc.name: medialibrary_file_access_ListFile_0002 +// * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is absolute path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0002"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri sourceFileUri("storage/media/100/local/files/Download/test/test.txt"); +// FileInfo fileInfo; +// fileInfo.uri = sourceFileUri.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// vector fileInfoVec; +// FileFilter filter({}, {}, {}, 0, 0, false, false); +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "ListFile_0002 result:" << fileInfoVec.size() << endl; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ListFile_0003 +// * @tc.name: medialibrary_file_access_ListFile_0003 +// * @tc.desc: Test function of ListFile interface for ERROR which sourceFileUri is special symbols. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0003"; +// try { +// Uri sourceFileUri("~!@#$%^&*()_"); +// FileInfo fileInfo; +// fileInfo.uri = sourceFileUri.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// vector fileInfoVec; +// FileFilter filter; +// int result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << "ListFile_0003 result:" << fileInfoVec.size() << endl; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ListFile_0004 +// * @tc.name: medialibrary_file_access_ListFile_0004 +// * @tc.desc: Test function of ListFile interface for ERROR which add filter. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HB855 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0004"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri1(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.txt", testUri1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0004.docx", testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter({".txt"}, {}, {}, 0, 0, false, true); +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), 1); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0004"; +// } + +// static void ListFileTdd(shared_ptr fahs, FileInfo fileInfo, int offset, int maxCount, +// FileFilter filter, std::vector fileInfoVec) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFileTdd"; +// int ret = fahs->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "ListFileTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), 1); +// g_num++; +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFileTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ListFile_0005 +// * @tc.name: medialibrary_file_access_ListFile_0005 +// * @tc.desc: Test function of ListFile interface for ERROR which Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ListFile_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ListFile_0005"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri1(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.txt", testUri1); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri2(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ListFile_0005.docx", testUri2); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// g_num = 0; +// FileFilter filter({".txt"}, {}, {}, 0, 0, false, true); +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(ListFileTdd, g_fah, fileInfo, offset, maxCount, filter, fileInfoVec); +// execthread.join(); +// } +// EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ListFile_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ListFile_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0000 +// * @tc.name: medialibrary_file_access_ScanFile_0000 +// * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with filter. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HB866 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0000"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// FileInfo fileInfo; +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// fileInfo.uri = "file://media/root"; +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); +// result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fileInfoVec.size(), 1); +// GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0001 +// * @tc.name: medialibrary_file_access_ScanFile_0001 +// * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with no filter. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HB866 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0001"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// FileInfo fileInfo; +// fileInfo.uri = "file://media/root"; +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.q1w2e3r4", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0001.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter({}, {}, {}, 0, 0, false, false); +// result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fileInfoVec.size(), 2); +// GTEST_LOG_(INFO) << "ScanFile_0000 result:" << fileInfoVec.size() << endl; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0002 +// * @tc.name: medialibrary_file_access_ScanFile_0002 +// * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HB866 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0002"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0002.q1w2e3r4", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.docx", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); +// result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), 1); +// FileFilter filter1({".q1w2e3r4", ".txt"}, {}, {}, 0, 0, false, true); +// result = g_fah->ScanFile(fileInfo, offset, maxCount, filter1, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), 2); +// GTEST_LOG_(INFO) << "ScanFile_0002 result:" << fileInfoVec.size() << endl; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0003 +// * @tc.name: medialibrary_file_access_ScanFile_0003 +// * @tc.desc: Test function of ScanFile interface for SUCCESS which self created directory with filter. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HB866 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0003"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0003.q1w2e3r4", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// FileInfo fileInfo; +// fileInfo.uri = newDirUriTest.ToString(); +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); +// result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), 1); +// GTEST_LOG_(INFO) << "ScanFile_0003 result:" << fileInfoVec.size() << endl; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0003"; +// } + +// static void ScanFileTdd(FileInfo fileInfo, int offset, int maxCount, FileFilter filter, +// std::vector fileInfoVec) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFileTdd"; +// int ret = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// if (ret != OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(ERROR) << "ScanFileTdd get result error, code:" << ret; +// return; +// } +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVec.size(), 1); +// g_num++; +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFileTdd"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0004 +// * @tc.name: medialibrary_file_access_ScanFile_0004 +// * @tc.desc: Test function of ScanFile interface for SUCCESS which scan root directory with Concurrent. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HB866 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0004"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// FileInfo fileInfo; +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.q1w2e3r4", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0000.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// fileInfo.uri = "file://media/root"; +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); +// g_num = 0; +// for (int j = 0; j < INIT_THREADS_NUMBER; j++) { +// std::thread execthread(ScanFileTdd, fileInfo, offset, maxCount, filter, fileInfoVec); +// execthread.join(); +// } +// EXPECT_GE(g_num, ACTUAL_SUCCESS_THREADS_NUMBER); +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0004"; +// } + +// static bool ReplaceBundleNameFromPath(std::string &path, const std::string &newName) +// { +// std::string tPath = Uri(path).GetPath(); +// if (tPath.empty()) { +// GTEST_LOG_(INFO) << "Uri path error."; +// return false; +// } + +// if (tPath.front() != '/') { +// GTEST_LOG_(INFO) << "Uri path format error."; +// return false; +// } + +// auto index = tPath.substr(1).find_first_of("/"); +// auto bundleName = tPath.substr(1, index); +// if (bundleName.empty()) { +// GTEST_LOG_(INFO) << "bundleName empty."; +// return false; +// } + +// path.replace(path.find(bundleName), bundleName.length(), newName); +// return true; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_ScanFile_0005 +// * @tc.name: medialibrary_file_access_ScanFile_0005 +// * @tc.desc: Test function of ScanFile interface for FAILED because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HB866 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_ScanFile_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_ScanFile_0005"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_ScanFile_0005.q1w2e3r4", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// std::string str = testUri.ToString(); +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(INFO) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// FileInfo fileInfo; +// fileInfo.uri = str; +// int64_t offset = 0; +// int64_t maxCount = 1000; +// std::vector fileInfoVec; +// FileFilter filter({".q1w2e3r4"}, {}, {}, 0, 0, false, true); +// result = g_fah->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// EXPECT_EQ(fileInfoVec.size(), 0); +// GTEST_LOG_(INFO) << "ScanFile_0005 result:" << fileInfoVec.size() << endl; +// result = g_fah->Delete(newDirUriTest); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_ScanFile_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_ScanFile_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetRoots_0000 +// * @tc.name: medialibrary_file_access_GetRoots_0000 +// * @tc.desc: Test function of GetRoots interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetRoots_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetRoots_0000"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(info.size(), OHOS::FileAccessFwk::ERR_OK); +// if (info.size() > OHOS::FileAccessFwk::ERR_OK) { +// GTEST_LOG_(INFO) << info[0].uri; +// GTEST_LOG_(INFO) << info[0].displayName; +// GTEST_LOG_(INFO) << info[0].deviceType; +// GTEST_LOG_(INFO) << info[0].deviceFlags; +// } +// string uri = "file://media/root"; +// string displayName = "LOCAL"; +// EXPECT_EQ(info[0].uri, uri); +// EXPECT_EQ(info[0].displayName, displayName); +// EXPECT_EQ(info[0].deviceType, DEVICE_LOCAL_DISK); +// EXPECT_EQ(info[0].deviceFlags, DEVICE_FLAG_SUPPORTS_READ | DEVICE_FLAG_SUPPORTS_WRITE); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetRoots_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetRoots_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0000 +// * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0000 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the root directory uri to fileinfo and call listfile for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0000"; +// try { +// vector infos; +// int result = g_fah->GetRoots(infos); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < infos.size(); i++) { +// Uri parentUri(infos[i].uri); +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVecTemp; +// result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0001 +// * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0001 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the general directory uri to fileinfo and call listfile for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0001"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "testDir", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// FileInfo dirInfo; +// result = g_fah->GetFileInfoFromUri(newDirUriTest, dirInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVec; +// result = g_fah->ListFile(dirInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GE(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0002 +// * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0002 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the regular file uri to fileinfo and call listfile for ERROR. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0002"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "testDir", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri newFileUri(""); +// result = g_fah->CreateFile(newDirUriTest, "medialibrary_file_access_GetFileInfoFromUri_0002.txt", newFileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(newFileUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVecTemp; +// result = g_fah->ListFile(fileinfo, offset, maxCount, filter, fileInfoVecTemp); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_EQ(fileInfoVecTemp.size(), OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0003 +// * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0003 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the root directory uri to fileinfo for CheckUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0003"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// Uri parentUri(std::string("\?\?\?\?/") + info[i].uri); +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_URIS); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0004 +// * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0004 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the root directory uri to fileinfo failed because of GetProxyByUri failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0004"; +// try { +// vector info; +// int result = g_fah->GetRoots(info); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// for (size_t i = 0; i < info.size(); i++) { +// std::string str = info[i].uri; +// if (!ReplaceBundleNameFromPath(str, "ohos.com.NotExistBundleName")) { +// GTEST_LOG_(ERROR) << "replace BundleName failed."; +// EXPECT_TRUE(false); +// } +// Uri parentUri(str); +// FileInfo fileinfo; +// result = g_fah->GetFileInfoFromUri(parentUri, fileinfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::E_IPCS); +// } +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromUri_0005 +// * @tc.name: medialibrary_file_access_GetFileInfoFromUri_0005 +// * @tc.desc: Test function of GetFileInfoFromUri interface. +// * @tc.desc: convert the invalid uri to fileinfo failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromUri_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromUri_0005"; +// try { +// Uri uri("~!@#$%^&*()_"); +// FileInfo fileInfo; +// int result = g_fah->GetFileInfoFromUri(uri, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// uri = Uri("/"); +// result = g_fah->GetFileInfoFromUri(uri, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// uri = Uri(""); +// result = g_fah->GetFileInfoFromUri(uri, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromUri_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-end medialibrary_file_access_GetFileInfoFromUri_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0000 +// * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0000 +// * @tc.desc: Test function of GetFileInfoFromRelativePath interface. +// * @tc.desc: convert the general directory relativePath to fileinfo for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0000"; +// try { +// FileInfo fileInfo; +// string relativePath = ""; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Audios/"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Camera/"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Documents/"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Download"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Pictures"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Videos"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0001 +// * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0001 +// * @tc.desc: Test function of GetFileInfoFromRelativePath interface. +// * @tc.desc: convert the general directory relativePath to fileinfo for failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0001"; +// try { +// FileInfo fileInfo; +// string relativePath = "test/"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "/"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "~!@#$%^&*()_"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "/d"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0002 +// * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0002 +// * @tc.desc: Test function of GetFileInfoFromRelativePath interface. +// * @tc.desc: convert the general directory relativePath to fileinfo and call listfile for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0002"; +// try { +// FileInfo fileInfo; +// string relativePath = "Download/"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// Uri parentUri(fileInfo.uri); +// Uri newFile(""); +// result = g_fah->CreateFile(parentUri, "GetFileInfoFromRelativePath_0002.jpg", newFile); +// ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVec; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(newFile); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0003 +// * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0003 +// * @tc.desc: Test function of GetFileInfoFromRelativePath interface. +// * @tc.desc: convert the relative file path to fileinfo and call listfile for failed. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0003"; +// try { +// FileInfo fileInfo; +// string relativePath = "Download/"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// Uri parentUri(fileInfo.uri); +// Uri newFile(""); +// result = g_fah->CreateFile(parentUri, "GetFileInfoFromRelativePath_0003.jpg", newFile); +// ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Download/GetFileInfoFromRelativePath_0003.jpg"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVec; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(newFile); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetFileInfoFromRelativePath_0004 +// * @tc.name: medialibrary_file_access_GetFileInfoFromRelativePath_0004 +// * @tc.desc: Test function of GetFileInfoFromRelativePath interface. +// * @tc.desc: convert the relative directory path to fileinfo and call listfile for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000HRLBS +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetFileInfoFromRelativePath_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin medialibrary_file_access_GetFileInfoFromRelativePath_0004"; +// try { +// FileInfo fileInfo; +// string relativePath = "Download/"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// Uri parentUri(fileInfo.uri); +// Uri newDir(""); +// result = g_fah->Mkdir(parentUri, "DirGetFileInfoFromRelativePath_0004", newDir); +// ASSERT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// Uri fileUri(""); +// result = g_fah->CreateFile(newDir, "file1", fileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->CreateFile(newDir, "file2", fileUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// relativePath = "Download/DirGetFileInfoFromRelativePath_0004"; +// result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + +// int64_t offset = 0; +// int64_t maxCount = 1000; +// FileFilter filter; +// std::vector fileInfoVec; +// result = g_fah->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// EXPECT_GT(fileInfoVec.size(), OHOS::FileAccessFwk::ERR_OK); + +// result = g_fah->Delete(newDir); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetFileInfoFromRelativePath_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetFileInfoFromRelativePath_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0000 +// * @tc.name: medialibrary_file_access_GetThumbnail_0000 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for SUCCESS which Uri's type is image. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0000"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Pictures/CreateImageThumbnailTest_001.jpg"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri uri(fileInfo.uri); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 256; +// thumbnailSize.height = 256; +// result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_NE(getPixelMap, nullptr); +// EXPECT_EQ(getPixelMap->GetWidth(), thumbnailSize.width); +// EXPECT_EQ(getPixelMap->GetHeight(), thumbnailSize.height); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0001 +// * @tc.name: medialibrary_file_access_GetThumbnail_0001 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for SUCCESS which Uri's type is video. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0001"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Videos/CreateVideoThumbnailTest_001.mp4"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri uri(fileInfo.uri); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 300; +// thumbnailSize.height = 300; +// result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_NE(getPixelMap, nullptr); +// EXPECT_EQ(getPixelMap->GetWidth(), thumbnailSize.width); +// EXPECT_EQ(getPixelMap->GetHeight(), thumbnailSize.height); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0002 +// * @tc.name: medialibrary_file_access_GetThumbnail_0002 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for SUCCESS which Uri's type is audio. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0002"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Audios/CreateAudioThumbnailTest_001.mp3"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri uri(fileInfo.uri); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 256; +// thumbnailSize.height = 256; +// result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_NE(getPixelMap, nullptr); +// EXPECT_EQ(getPixelMap->GetWidth(), thumbnailSize.width); +// EXPECT_EQ(getPixelMap->GetHeight(), thumbnailSize.height); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0003 +// * @tc.name: medialibrary_file_access_GetThumbnail_0003 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0003"; +// try { +// Uri uri(""); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 256; +// thumbnailSize.height = 256; +// int result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_EQ(getPixelMap, nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0003 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0004 +// * @tc.name: medialibrary_file_access_GetThumbnail_0004 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is not a local path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0004"; +// try { +// Uri uri("//Pictures/CreateImageThumbnailTest_001.jpg"); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 256; +// thumbnailSize.height = 256; +// int result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_EQ(getPixelMap, nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0005 +// * @tc.name: medialibrary_file_access_GetThumbnail_0005 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is not a media path. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0005"; +// try { +// Uri newDirUriTest(""); +// int result = g_fah->Mkdir(g_newDirUri, "test", newDirUriTest); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// result = g_fah->CreateFile(newDirUriTest, "test.txt", testUri); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 256; +// thumbnailSize.height = 256; +// result = g_fah->GetThumbnail(testUri, thumbnailSize, getPixelMap); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_EQ(getPixelMap, nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0006 +// * @tc.name: medialibrary_file_access_GetThumbnail_0006 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for ERROR which Uri is unreadable code. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0006"; +// try { +// Uri uri("&*()*/?"); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 256; +// thumbnailSize.height = 256; +// int result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_EQ(getPixelMap, nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0006"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0007 +// * @tc.name: medialibrary_file_access_GetThumbnail_0007 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for ERROR which size is an invalid value. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0007, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0007"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Pictures/CreateImageThumbnailTest_001.jpg"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri uri(fileInfo.uri); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = 0; +// thumbnailSize.height = 0; +// result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_EQ(getPixelMap, nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0007 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0007"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_GetThumbnail_0008 +// * @tc.name: medialibrary_file_access_GetThumbnail_0008 +// * @tc.desc: Test function of GetThumbnail interface. +// * @tc.desc: Test function of GetThumbnail interface for ERROR which size is an invalid value. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6HLSK +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_GetThumbnail_0008, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_GetThumbnail_0008"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Pictures/CreateImageThumbnailTest_001.jpg"; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri uri(fileInfo.uri); +// std::shared_ptr getPixelMap = nullptr; +// ThumbnailSize thumbnailSize; +// thumbnailSize.width = -1; +// thumbnailSize.height = -1; +// result = g_fah->GetThumbnail(uri, thumbnailSize, getPixelMap); +// EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); +// ASSERT_EQ(getPixelMap, nullptr); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_GetThumbnail_0008 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_GetThumbnail_0008"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Query_0000 +// * @tc.name: medialibrary_file_access_Query_0000 +// * @tc.desc: Test function of Query directory for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0000"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Documents/"; +// std::string displayName = "Documents"; +// int targetSize = 46; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri dirUriTest(fileInfo.uri); + +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "}, +// {FILE_SIZE, " "}, +// {DATE_MODIFIED, " "}, +// {DATE_ADDED, " "}, +// {HEIGHT, " "}, +// {WIDTH, " "}, +// {DURATION, " "} +// }; +// auto testJsonString = testJson.dump(); +// int ret = g_fah->Query(dirUriTest, testJsonString); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// auto jsonObject = json::parse(testJsonString); +// EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); +// EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize); +// ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); +// ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); +// GTEST_LOG_(INFO) << testJsonString; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0000"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Query_0001 +// * @tc.name: medialibrary_file_access_Query_0001 +// * @tc.desc: Test function of Query file for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0001, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0001"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Documents/Test/"; +// std::string displayName = "CreateQueryTest_002.txt"; +// int targetSize = 23; +// std::string filePath = "Documents/Test/CreateQueryTest_002.txt"; +// int ret = g_fah->GetFileInfoFromRelativePath(filePath, fileInfo); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(fileInfo.uri); + +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "}, +// {FILE_SIZE, " "}, +// {DATE_MODIFIED, " "}, +// {DATE_ADDED, " "}, +// {HEIGHT, " "}, +// {WIDTH, " "}, +// {DURATION, " "} +// }; +// auto testJsonString = testJson.dump(); +// ret = g_fah->Query(testUri, testJsonString); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// GTEST_LOG_(INFO) << testJsonString; +// auto jsonObject = json::parse(testJsonString); +// EXPECT_EQ(jsonObject.at(RELATIVE_PATH), relativePath); +// EXPECT_EQ(jsonObject.at(DISPLAY_NAME), displayName); +// EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize); +// ASSERT_TRUE(jsonObject.at(DATE_MODIFIED) > 0); +// ASSERT_TRUE(jsonObject.at(DATE_ADDED) > 0); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0001 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0001"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Query_0002 +// * @tc.name: medialibrary_file_access_Query_0002 +// * @tc.desc: Test function of Query directory size for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0002, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0002"; +// try { +// FileAccessFwk::FileInfo fileInfo; +// std::string relativePath = "Documents/"; +// std::string displayName = "Documents"; +// int targetSize = 46; +// int result = g_fah->GetFileInfoFromRelativePath(relativePath, fileInfo); +// EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); +// Uri dirUriTest(fileInfo.uri); + +// json testJson = { +// {FILE_SIZE, " "} +// }; +// auto testJsonString = testJson.dump(); +// int ret = g_fah->Query(dirUriTest, testJsonString); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// auto jsonObject = json::parse(testJsonString); +// EXPECT_EQ(jsonObject.at(FILE_SIZE), targetSize); +// GTEST_LOG_(INFO) << testJsonString; +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0002 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0002"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Query_0003 +// * @tc.name: medialibrary_file_access_Query_0003 +// * @tc.desc: Test function of Query interface for ERROR which Uri is unreadable code. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0003, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0003"; +// try { +// Uri testUri("&*()*/?"); +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "} +// }; +// auto testJsonString = testJson.dump(); +// int ret = g_fah->Query(testUri, testJsonString); +// EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0003"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Query_0004 +// * @tc.name: medialibrary_file_access_Query_0004 +// * @tc.desc: Test function of Query interface for which all column nonexistence. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0004, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0004"; +// try { +// Uri newDirUriTest(""); +// std::string fileName = "test.txt"; +// int ret = g_fah->Mkdir(g_newDirUri, "Query004", newDirUriTest); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// ret = g_fah->CreateFile(newDirUriTest, fileName, testUri); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// json testJson = { +// {"001", " "}, +// {"#", " "}, +// {"test", " "}, +// {"target", " "} +// }; +// auto testJsonString = testJson.dump(); +// ret = g_fah->Query(testUri, testJsonString); +// EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); +// ret = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0004 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0004"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Query_0005 +// * @tc.name: medialibrary_file_access_Query_0005 +// * @tc.desc: Test function of Query interface for which part of column nonexistence. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0005, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0005"; +// try { +// Uri newDirUriTest(""); +// std::string fileName = "test.txt"; +// int ret = g_fah->Mkdir(g_newDirUri, "Query005", newDirUriTest); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// ret = g_fah->CreateFile(newDirUriTest, fileName, testUri); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// json testJson = { +// {RELATIVE_PATH, " "}, +// {DISPLAY_NAME, " "}, +// {"test", " "} +// }; +// auto testJsonString = testJson.dump(); +// ret = g_fah->Query(testUri, testJsonString); +// EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); +// ret = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0005 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0005"; +// } + +// /** +// * @tc.number: user_file_service_medialibrary_file_access_Query_0006 +// * @tc.name: medialibrary_file_access_Query_0006 +// * @tc.desc: Test function of Query interface for which column is null. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6S4VV +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_Query_0006, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_Query_0006"; +// try { +// Uri newDirUriTest(""); +// std::string fileName = "test.txt"; +// std::string relativePath = "test/test.txt"; +// int ret = g_fah->Mkdir(g_newDirUri, "Query006", newDirUriTest); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// Uri testUri(""); +// ret = g_fah->CreateFile(newDirUriTest, fileName, testUri); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// json testJson; +// auto testJsonString = testJson.dump(); +// ret = g_fah->Query(testUri, testJsonString); +// EXPECT_NE(ret, OHOS::FileAccessFwk::ERR_OK); +// ret = g_fah->Delete(newDirUriTest); +// EXPECT_EQ(ret, OHOS::FileAccessFwk::ERR_OK); +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_access_Query_0006 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_Query_0006"; +// } } // namespace -- Gitee From 20332ee5f7dc27ca8629d0f3d9a1eaf7681ab1a0 Mon Sep 17 00:00:00 2001 From: CaoChuan Date: Thu, 25 May 2023 06:18:22 +0000 Subject: [PATCH 5/5] all code Signed-off-by: CaoChuan --- .../napi_fileaccess_helper.cpp | 3 +- .../napi_observer_callback.cpp | 81 ++++++++++++----- .../napi_observer_callback.h | 18 ++-- interfaces/inner_api/file_access/BUILD.gn | 2 - .../include/file_access_ext_ability.h | 7 +- .../include/file_access_ext_proxy.h | 4 +- .../include/file_access_ext_stub.h | 4 +- .../include/file_access_ext_stub_impl.h | 4 +- .../file_access/include/file_access_helper.h | 2 +- .../include/ifile_access_ext_base.h | 8 +- .../include/js_file_access_ext_ability.h | 6 +- .../.file_access_observer_service.h.swp | Bin 0 -> 16384 bytes .../observer/file_access_observer_common.h | 6 +- .../observer/file_access_observer_proxy.h | 2 +- .../observer/file_access_observer_service.h | 7 +- .../include/observer/ifile_observer_base.h | 2 +- .../include/observer/iobserver_callback.h | 3 +- .../observer/observer_callback_proxy.h | 2 +- .../include/observer/observer_callback_stub.h | 2 +- .../src/file_access_ext_ability.cpp | 11 +-- .../file_access/src/file_access_ext_proxy.cpp | 16 ++-- .../file_access/src/file_access_ext_stub.cpp | 28 +++--- .../src/file_access_ext_stub_impl.cpp | 16 ++-- .../file_access/src/file_access_helper.cpp | 20 ++-- .../src/js_file_access_ext_ability.cpp | 71 ++++----------- .../observer/file_access_observer_proxy.cpp | 31 +++---- .../observer/file_access_observer_service.cpp | 40 +++++--- .../observer/file_access_observer_stub.cpp | 19 +++- .../src/observer/observer_callback_proxy.cpp | 22 ++--- .../src/observer/observer_callback_stub.cpp | 14 +-- .../FileExtensionAbility.ts | 28 ++---- test/unittest/BUILD.gn | 10 ++ test/unittest/external_file_access_test.cpp | 41 ++++++--- .../medialibrary_file_access_test.cpp | 86 +++++++++--------- 34 files changed, 332 insertions(+), 284 deletions(-) create mode 100644 interfaces/inner_api/file_access/include/observer/.file_access_observer_service.h.swp diff --git a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp index 59aabb9c..d66361b8 100644 --- a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp +++ b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp @@ -1325,8 +1325,9 @@ napi_value NAPI_UnregisterObserver(napi_env env, napi_callback_info info) HILOG_ERROR("Faild to get fileAccessHelper"); return nullptr; } - if (observerWrapper != nullptr) { + if (observerWrapper == nullptr) { HILOG_ERROR("CJW observerWrapper IS null"); + return nullptr; } // std::shared_ptr observer = std::make_shared(env, napiCallback); diff --git a/frameworks/js/napi/file_access_module/napi_observer_callback.cpp b/frameworks/js/napi/file_access_module/napi_observer_callback.cpp index ed681cb5..5cf80570 100644 --- a/frameworks/js/napi/file_access_module/napi_observer_callback.cpp +++ b/frameworks/js/napi/file_access_module/napi_observer_callback.cpp @@ -39,25 +39,51 @@ NapiObserver::~NapiObserver() napi_delete_reference(env_, cbOnRef_); } -void NapiObserver::OnChange(std::string message) +static napi_status SetValueArray(const napi_env& env, + const char* fieldStr, const std::vector listValue, napi_value& result) { - HILOG_ERROR("cjw napi2 message = %{public}s", message.c_str()); - uv_work_t* work = new uv_work_t(); - if (work == nullptr) { - HILOG_ERROR("failed to new uv_work_t"); - return; + napi_value value = nullptr; + napi_status status = napi_create_array_with_length(env, listValue.size(), &value); + if (status != napi_ok) { + HILOG_ERROR("Create array error! field: %{public}s", fieldStr); + return status; } - CallbackParam* param = new CallbackParam(this, message); - if (param == nullptr) { - HILOG_ERROR("failed to new param"); - delete work; - return; + int elementIndex = 0; + for (auto uri : listValue) { + napi_value uriRet = nullptr; + napi_create_string_utf8(env, uri.c_str(), NAPI_AUTO_LENGTH, &uriRet); + status = napi_set_element(env, value, elementIndex++, uriRet); + if (status != napi_ok) { + HILOG_ERROR("Set lite item failed, error: %{public}d", status); + } } - work->data = param; - int ret = uv_queue_work(loop_, work, + status = napi_set_named_property(env, result, fieldStr, value); + if (status != napi_ok) { + HILOG_ERROR("Set array named property error! field: %{public}s", fieldStr); + } + + return status; +} + +void NapiObserver::OnChange(NotifyMessage ¬ifyMessage) +{ + HILOG_ERROR("cjw napi2 message = %{public}d", notifyMessage.notifyType_); + //uv_work_t* work = new uv_work_t(); + // if (work == nullptr) { + // HILOG_ERROR("failed to new uv_work_t"); + // return; + // } + if (work_ == nullptr) { + work_ = std::make_unique(); + } + std::unique_ptr callbackParam = std::make_unique(this, notifyMessage); + work_->data = callbackParam.get(); + //work->data = param; + int ret = uv_queue_work(loop_, work_.get(), [](uv_work_t *work) {}, [](uv_work_t *work, int status) { - CallbackParam *param = reinterpret_cast(work->data); + std::unique_ptr param(reinterpret_cast(work->data)); + //CallbackParam *param = reinterpret_cast(work->data); napi_handle_scope scope = nullptr; // 打开handle scope用于管理napi_value的生命周期，否则会内存泄漏 napi_open_handle_scope(param->napiObserver_->env_, &scope); @@ -67,8 +93,9 @@ void NapiObserver::OnChange(std::string message) } NVal napiNotifyMessage = NVal::CreateObject(param->napiObserver_->env_); - napiNotifyMessage.AddProp("message", - NVal::CreateUTF8String(param->napiObserver_->env_, param->message_).val_); + napiNotifyMessage.AddProp("NotifyType", + NVal::CreateInt32(param->napiObserver_->env_, int((param->notifyMessage_).notifyType_)).val_); + SetValueArray(param->napiObserver_->env_, "uris", param->notifyMessage_.uris_, napiNotifyMessage.val_); napi_value callback = nullptr; napi_value args[ARGS_ONE] = {napiNotifyMessage.val_}; @@ -79,21 +106,25 @@ void NapiObserver::OnChange(std::string message) napi_status ret = napi_call_function(param->napiObserver_->env_, global, callback, ARGS_ONE, args, &result); if (ret != napi_ok) { HILOG_ERROR("Notify failed, status:%{public}d.", ret); + return; } // 关闭handle scope释放napi_value napi_close_handle_scope(param->napiObserver_->env_, scope); - delete param; - delete work; + // delete param; + // delete work; }); - if (ret != 0) { - delete (CallbackParam *)(work->data); - work->data = nullptr; - delete work; - work = nullptr; - return; + if (ret == 0) { + callbackParam.release(); } + // if (ret != 0) { + // delete (CallbackParam *)(work->data); + // work->data = nullptr; + // delete work; + // work = nullptr; + // return; + // } - return; + // return; } // bool NapiObserverCallback::Equal(void *observer) diff --git a/frameworks/js/napi/file_access_module/napi_observer_callback.h b/frameworks/js/napi/file_access_module/napi_observer_callback.h index a1a217f1..347576f0 100644 --- a/frameworks/js/napi/file_access_module/napi_observer_callback.h +++ b/frameworks/js/napi/file_access_module/napi_observer_callback.h @@ -23,6 +23,7 @@ #include "napi/native_node_api.h" #include "napi/native_api.h" #include "uri.h" +#include "uv.h" namespace OHOS { namespace FileAccessFwk { @@ -31,26 +32,29 @@ public: NapiObserver(napi_env env, napi_value callback); virtual ~NapiObserver(); //void OnChange(std::string message, const napi_ref cbRef); - void OnChange(std::string message); + void OnChange(NotifyMessage ¬ifyMessage); napi_ref cbOnRef_ = nullptr; private: struct CallbackParam { NapiObserver *napiObserver_; - std::string message_; - CallbackParam(NapiObserver *napiObserver, std::string message) : - napiObserver_(napiObserver), message_(message) {} + NotifyMessage notifyMessage_; + CallbackParam(NapiObserver *napiObserver, NotifyMessage notifyMessage) : + napiObserver_(napiObserver), notifyMessage_(notifyMessage) {} }; napi_env env_; uv_loop_s *loop_ = nullptr; + std::unique_ptr work_ = nullptr; }; class NapiObserverCallback : public ObserverCallbackStub { public: NapiObserverCallback(std::shared_ptr observer): observer_(observer){} - virtual ~NapiObserverCallback() {} - void OnChange(std::string message) override + ~NapiObserverCallback() { + HILOG_ERROR("cjw ~NapiObserverCallback"); + } + void OnChange(NotifyMessage ¬ifyMessage) override { - observer_->OnChange(message); + observer_->OnChange(notifyMessage); } // std::string GetClassName() override diff --git a/interfaces/inner_api/file_access/BUILD.gn b/interfaces/inner_api/file_access/BUILD.gn index cfced532..d20db26d 100644 --- a/interfaces/inner_api/file_access/BUILD.gn +++ b/interfaces/inner_api/file_access/BUILD.gn @@ -135,13 +135,11 @@ ohos_shared_library("file_access_observer") { "ability_runtime:napi_common", "ability_runtime:runtime", "access_token:libaccesstoken_sdk", - "bundle_framework:appexecfwk_core", "c_utils:utils", "hitrace_native:hitrace_meter", "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "multimedia_image_framework:image_native", - "napi:ace_napi", "safwk:system_ability_fwk", "samgr:samgr_proxy", ] diff --git a/interfaces/inner_api/file_access/include/file_access_ext_ability.h b/interfaces/inner_api/file_access/include/file_access_ext_ability.h index 54ee7dd7..ab74f6f7 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_ability.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_ability.h @@ -18,6 +18,7 @@ #include "extension_base.h" #include "file_access_extension_info.h" +#include "file_access_observer_common.h" #include "file_filter.h" #include "image_source.h" @@ -61,9 +62,9 @@ public: virtual int GetRoots(std::vector &rootInfoVec); virtual int Access(const Uri &uri, bool &isExist); static void SetCreator(const CreatorFunc& creator); - virtual int StartWatcher(const Uri &uri); - virtual int StopWatcher(const Uri &uri); - virtual int Notify(Uri &uri, std::string eventType); + virtual int RegisterNotify(const Uri &uri); + virtual int UnregisterNotify(const Uri &uri); + virtual int Notify(Uri &uri, NotifyType notifyType); private: static CreatorFunc creator_; }; diff --git a/interfaces/inner_api/file_access/include/file_access_ext_proxy.h b/interfaces/inner_api/file_access/include/file_access_ext_proxy.h index 9223f9e9..36b11c0c 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_proxy.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_proxy.h @@ -56,8 +56,8 @@ public: virtual int GetFileInfoFromRelativePath(const std::string &selectFile, FileInfo &fileInfo) override; virtual int GetRoots(std::vector &rootInfoVec) override; virtual int Access(const Uri &uri, bool &isExist) override; - virtual int StartWatcher(const Uri &uri) override; - virtual int StopWatcher(const Uri &uri) override; + virtual int RegisterNotify(const Uri &uri) override; + virtual int UnregisterNotify(const Uri &uri) override; private: static inline BrokerDelegator delegator_; }; diff --git a/interfaces/inner_api/file_access/include/file_access_ext_stub.h b/interfaces/inner_api/file_access/include/file_access_ext_stub.h index f804c1fd..5744e340 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_stub.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_stub.h @@ -50,8 +50,8 @@ private: ErrCode CmdGetFileInfoFromRelativePath(MessageParcel &data, MessageParcel &reply); ErrCode CmdGetRoots(MessageParcel &data, MessageParcel &reply); ErrCode CmdAccess(MessageParcel &data, MessageParcel &reply); - ErrCode CmdStartWatcher(MessageParcel &data, MessageParcel &reply); - ErrCode CmdStopWatcher(MessageParcel &data, MessageParcel &reply); + ErrCode CmdRegisterNotify(MessageParcel &data, MessageParcel &reply); + ErrCode CmdUnregisterNotify(MessageParcel &data, MessageParcel &reply); bool CheckCallingPermission(const std::string &permission); using RequestFuncType = int (FileAccessExtStub::*)(MessageParcel &data, MessageParcel &reply); std::map stubFuncMap_; diff --git a/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h b/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h index 9acb2c65..8178470d 100644 --- a/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h +++ b/interfaces/inner_api/file_access/include/file_access_ext_stub_impl.h @@ -54,8 +54,8 @@ public: int GetFileInfoFromRelativePath(const std::string &selectFile, FileInfo &fileInfo) override; int GetRoots(std::vector &rootInfoVec) override; int Access(const Uri &uri, bool &isExist) override; - int StartWatcher(const Uri &uri) override; - int StopWatcher(const Uri &uri) override; + int RegisterNotify(const Uri &uri) override; + int UnregisterNotify(const Uri &uri) override; private: std::shared_ptr GetOwner(); diff --git a/interfaces/inner_api/file_access/include/file_access_helper.h b/interfaces/inner_api/file_access/include/file_access_helper.h index 274feccf..55c56026 100644 --- a/interfaces/inner_api/file_access/include/file_access_helper.h +++ b/interfaces/inner_api/file_access/include/file_access_helper.h @@ -132,7 +132,7 @@ class FileAccessObserver : public ObserverCallbackStub { public: FileAccessObserver() {}; virtual ~FileAccessObserver() {}; - void OnChange(std::string message) override; + void OnChange(NotifyMessage ¬ifyMessage) override; // std::string GetClassName() override; // bool Equal(void *observer) override; private: diff --git a/interfaces/inner_api/file_access/include/ifile_access_ext_base.h b/interfaces/inner_api/file_access/include/ifile_access_ext_base.h index 6e1fe22f..d60e4c30 100644 --- a/interfaces/inner_api/file_access/include/ifile_access_ext_base.h +++ b/interfaces/inner_api/file_access/include/ifile_access_ext_base.h @@ -46,8 +46,8 @@ public: CMD_RENAME, CMD_LIST_FILE, CMD_SCAN_FILE, - CMD_START_WATCHER, - CMD_STOP_WATCHER, + CMD_REGISTER_NOTIFY, + CMD_UNREGISTER_NOTIFY, CMD_QUERY, CMD_GET_ROOTS, CMD_ACCESS, @@ -74,8 +74,8 @@ public: virtual int GetFileInfoFromRelativePath(const std::string &selectFile, FileInfo &fileInfo) = 0; virtual int GetRoots(std::vector &rootInfoVec) = 0; virtual int Access(const Uri &uri, bool &isExist) = 0; - virtual int StartWatcher(const Uri &uri) = 0; - virtual int StopWatcher(const Uri &uri) = 0; + virtual int RegisterNotify(const Uri &uri) = 0; + virtual int UnregisterNotify(const Uri &uri) = 0; }; } // namespace FileAccessFwk } // namespace OHOS diff --git a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h index 65543c22..f13ad8e0 100644 --- a/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h +++ b/interfaces/inner_api/file_access/include/js_file_access_ext_ability.h @@ -72,10 +72,8 @@ public: int GetRoots(std::vector &rootInfoVec) override; int Access(const Uri &uri, bool &isExist) override; int Query(const Uri &uri, std::vector &columns, std::vector &results) override; - int StartWatcher(const Uri &uri) override; - int StopWatcher(const Uri &uri) override; - int RegisterNotify(const Uri &uri); - int UnregisterNotify(const Uri &uri); + int RegisterNotify(const Uri &uri) override; + int UnregisterNotify(const Uri &uri) override; private: void CreateWatcher(const Uri &uri); diff --git a/interfaces/inner_api/file_access/include/observer/.file_access_observer_service.h.swp b/interfaces/inner_api/file_access/include/observer/.file_access_observer_service.h.swp new file mode 100644 index 0000000000000000000000000000000000000000..bb6ab21f979ec216cdb6446c212b556d3c769ff8 GIT binary patch literal 16384 zcmeHOO>87b6|RJzge1EJ!YL3@v3ISRmE-YxwFqqQWM}Phb`*PNGdF)H8XGg1DNX`f(xFCUm1IjHSfRNA%MO=Ujf)9mOf8+{k(ebt5?-sugcr=R~sAj^K%OX*ZqV%8#v}KoiE@2`stIzV4fk8kGi@s z>vQ|4QiR+T0xMqE3+K^iWt|yF6sd+2L$RA^?E>|8)KT-p2{~J@7T)GVl=aAn@0dgxm(c2W$Z+fM1^=fG2<} zz(wFJ@LAv_@Q?cl`7`i3@N?k1z;gftt^h5d3Y-E?0QUiZyqA#Q0=Ix40bd0?zy-E| z)4)T(yY~?CC*W1!cfd=)H-T>eUk3)jMc`534Djy92zdv%4g3`NG4LJ02I{~m;6dP1 zzyrX0ccTvQ4saXz3Gfo|9MA*Wz>1QoX8lc)%mq;*G3&*Ru~o-^Ed_ zQd++}dw>olrIv-!*nD3_XKFUyIa{jQ+@Xzn=1L zfOny1>1>%^Px@5Zyst?(rytmREaHo@Q>0HeLM=H=)aJ|_l*-ib+%QT!WzVxs+HzNz z<6L6K?yAkrlFX+4eOy%OOdzQ#Cv_ExbT#hzrS!ovXA}7e;d|iF3zjAM@!8KoZ`<9e z&QKQYgk|dCpi*F)JTGt44fu{7;=of=9)2oq1~#3E0~@|F(Vu39E<8bM`#+GW{4P0* zwdMtxF+Rx%aN1?=4$ml`SkoE!oF0~upr76^5bpC zHWrhKYPG(yUTfF&)%tpEtG=phomxlJwJW;TXg;=H@3fkw{Zoqa7}e9M2yIL2)Hn3n zrN(-rvvo){VmK@e=|s8IvRxRtNE1z|Hb8gxYTLGBM}yfk^?>S8ygkg8PQ_ieEso12 z^QskiJw58$;qn1>lR;3$7zrbszB3X(<=6axrV|2fUDEXC=7zpedx~D5=jWG5GT@TG zVvevec9@HkdB}HT$AL#C?wiY;GaSx>QaVyBiUFePVGzr)Db;s8V^`maSzsn(q!&m0 zT9u0AlDyX;;yRJuu*w}a;HC!UL(SJPkQ^R)?sBIpW+@CUZ_rSUl*$Br`VJ<7~6_rrGG=aq9C^OVQ>n0QWB=H~Rlo<_EEfNZ)%ce~a#V?H} ze3B`r9A?ZZ@(n3UbF@L6nmdvaJb~}g$ZdKno<9&{5N>_2eL}5`!HSp>;5hV)Qco+u zSC2Wd6IA)CD4xF2RLz??SxQ~xO`9CE3a9C0b;x|DB$QE$#32R}6$2#nalV#raMNZ> zWRx(PN!I$iFmjaBy4=!`K&I86l6D?W^^+E`Ay-b^S85uv~N!J)#()XDR@7 z?4B(qYJ9Cw9GK<-jk=t!<5aX8@;OmL<2;*2EiWk(`uME2FvB}|1;-$m?ua+2D|*`J zLC+3DDV4dV5c6cCbGfzIp-Y&tA5Kyw6O07*Hl}fNztZ@8rr83XOPNcjY8q{5Q}j|zYiP4Vp-tBj zq67X+Y-71Vw+EE@Xv2`>%wc`eD%%M-@*)rOIPC{^1ncmHG%6{3@+Z~b6&7hfi%HmSXoEsG`0F83v=_T(v}y~9vfhN5HZMRcv1RzvT|IrNXQ?k zqWGYpIJ}M$Fj06X_%XO23Ed1&@FU)tv=8pGQY2-nN3(p@q@HPC&(fQ<&dZo?AVRq!1Z6QNRPobHc zv=PuXc@r@Nm7P;oC@ec|*a7lCbPw1b7`3Hn6;*B55n+wV5=Ks)T6v(Hg9Id@erb6& zQlA)wc)t%vnH@z(ZLGqt9TtVp`b*A)h$h{iSpNQ+O=_h!%HE(eT`19+W;9G%%@^&0l(QsRFM8=s*G?eMBp!A3&&!yqc&GW@8wEl>{fm=lR8d$ zapXg#VPd-9lLqC4#3V46m5UgZ$Veht$Ph|jNP@0%U`*OHQNu*~Jglx((>QPvCloTJ v)8se(Mw!W!ahUsMM$0IqoM { public: explicit FileAccessObserverProxy(const sptr& impl) : IRemoteProxy(impl) {} ~FileAccessObserverProxy() = default; - int32_t OnChange(std::string message) override; + int32_t OnChange(Uri uri, NotifyType notifyType) override; int32_t RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) override; int32_t UnregisterNotify(Uri uri, sptr &observer) override; private: diff --git a/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h index ded86f19..faa51b9f 100644 --- a/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h +++ b/interfaces/inner_api/file_access/include/observer/file_access_observer_service.h @@ -87,7 +87,7 @@ class FileAccessObserverService final : public SystemAbility, public FileAccessO public: virtual void OnStart() override; virtual void OnStop() override; - int32_t OnChange(std::string message) override; + int32_t OnChange(Uri uri, NotifyType notifyType) override; int32_t RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) override; int32_t UnregisterNotify(Uri uri, sptr &observer) override; int32_t Dump(int32_t fd, const std::vector& args) override; @@ -125,8 +125,9 @@ private: ObserverNode(const std::string &nodeName): nodeName_(nodeName) {} virtual ~ObserverNode() = default; void GetObs(const std::vector &path, uint32_t index, Uri &uri, ObsMap &obsMap); - bool AddObserver(const std::vector &path, uint32_t index, const ObserverEntry &entry); - bool RemoveObserver(const std::vector &path, uint32_t index, sptr dataObserver); + bool AddObserver(const std::vector &path, uint32_t index, const ObserverEntry &entry, + bool &outIsNewNode); + bool RemoveObserver(const std::vector &path, uint32_t index, sptr dataObserver, bool &deleteNode); inline bool RemoveObserver(sptr observer); bool RemoveObserver(sptr observer); private: diff --git a/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h b/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h index 11417518..d2efe377 100644 --- a/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h +++ b/interfaces/inner_api/file_access/include/observer/ifile_observer_base.h @@ -33,7 +33,7 @@ public: CMD_UNREGISTER_NOTIFY, CMD_ONCHANGE }; - virtual int32_t OnChange(std::string message) = 0; + virtual int32_t OnChange(Uri uri, NotifyType notifyType) = 0; virtual int32_t RegisterNotify(Uri uri, sptr &observer, bool notifyForDescendants) = 0; virtual int32_t UnregisterNotify(Uri uri, sptr &observer) = 0; }; diff --git a/interfaces/inner_api/file_access/include/observer/iobserver_callback.h b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h index b9d64f23..ed983922 100644 --- a/interfaces/inner_api/file_access/include/observer/iobserver_callback.h +++ b/interfaces/inner_api/file_access/include/observer/iobserver_callback.h @@ -16,6 +16,7 @@ #ifndef I_FILE_ACCESS_OBSERVER_H #define I_FILE_ACCESS_OBSERVER_H +#include "file_access_observer_common.h" #include "iremote_broker.h" #include "iremote_object.h" @@ -28,7 +29,7 @@ public: enum { CMD_CALLBACK = 0 }; - virtual void OnChange(std::string message) = 0; + virtual void OnChange(NotifyMessage ¬ifyMessage) = 0; // virtual std::string GetClassName() = 0; // virtual bool Equal(void *observer) = 0; }; diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h index a7a7d736..5d73472e 100644 --- a/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_proxy.h @@ -27,7 +27,7 @@ class ObserverCallbackProxy : public IRemoteProxy { public: explicit ObserverCallbackProxy(const sptr& impl) : IRemoteProxy(impl) {} ~ObserverCallbackProxy() = default; - void OnChange(std::string message) override; + void OnChange(NotifyMessage ¬ifyMessage) override; // std::string GetClassName() override; // bool Equal(void *observer) override // { HILOG_ERROR("cjw proxy Equal"); diff --git a/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h index b670e31d..bddb99c2 100644 --- a/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h +++ b/interfaces/inner_api/file_access/include/observer/observer_callback_stub.h @@ -32,7 +32,7 @@ public: ObserverCallbackStub(); virtual ~ObserverCallbackStub() = default; int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; - void OnChange(std::string message) override {} + void OnChange(NotifyMessage ¬ifyMessage) override {} //std::string GetClassName() = 0; //int32_t GetClassNameStub(MessageParcel &data, MessageParcel &reply); private: diff --git a/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp b/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp index c209e0bd..2c597fa2 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_ability.cpp @@ -156,23 +156,22 @@ int FileAccessExtAbility::Access(const Uri &uri, bool &isExist) return EPERM; } -int FileAccessExtAbility::StartWatcher(const Uri &uri) +int FileAccessExtAbility::RegisterNotify(const Uri &uri) { HILOG_ERROR("FileAccessExtAbility::IsFileExist Undefined operation"); return EPERM; } -int FileAccessExtAbility::StopWatcher(const Uri &uri) +int FileAccessExtAbility::UnregisterNotify(const Uri &uri) { HILOG_ERROR("FileAccessExtAbility::IsFileExist Undefined operation"); return EPERM; } -int FileAccessExtAbility::Notify(Uri &uri, std::string eventType) +int FileAccessExtAbility::Notify(Uri &uri, NotifyType notifyType) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Notify"); - std::string uriString = uri.ToString(); - HILOG_ERROR("cjw notify uri = %{public}s, eventType = %{public}s", uri.ToString().c_str(), eventType.c_str()); + HILOG_ERROR("cjw notify uri = %{public}s, eventType = %{public}d", uri.ToString().c_str(), notifyType); sptr systemAbilityManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (!systemAbilityManager) { @@ -186,7 +185,7 @@ int FileAccessExtAbility::Notify(Uri &uri, std::string eventType) return E_GETRESULT; } auto proxy = iface_cast(remoteObject); - int ret = proxy->OnChange(uriString); + int ret = proxy->OnChange(uri, notifyType); HILOG_ERROR("cjw onChange ret = %{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return 0; diff --git a/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp b/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp index 81fa0ab1..01c87103 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_proxy.cpp @@ -939,9 +939,9 @@ int FileAccessExtProxy::Access(const Uri &uri, bool &isExist) return ERR_OK; } -int FileAccessExtProxy::StartWatcher(const Uri &uri) +int FileAccessExtProxy::RegisterNotify(const Uri &uri) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StartWatcher"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify"); MessageParcel data; if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { HILOG_ERROR("WriteInterfaceToken failed"); @@ -959,7 +959,7 @@ int FileAccessExtProxy::StartWatcher(const Uri &uri) MessageParcel reply; MessageOption option; - int err = Remote()->SendRequest(CMD_START_WATCHER, data, reply, option); + int err = Remote()->SendRequest(CMD_REGISTER_NOTIFY, data, reply, option); if (err != ERR_OK) { HILOG_ERROR("fail to SendRequest. err: %{public}d", err); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); @@ -974,7 +974,7 @@ int FileAccessExtProxy::StartWatcher(const Uri &uri) } if (ret != ERR_OK) { - HILOG_ERROR("StartWatcher operation failed ret : %{public}d", ret); + HILOG_ERROR("RegisterNotify operation failed ret : %{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; } @@ -983,9 +983,9 @@ int FileAccessExtProxy::StartWatcher(const Uri &uri) return ERR_OK; } -int FileAccessExtProxy::StopWatcher(const Uri &uri) +int FileAccessExtProxy::UnregisterNotify(const Uri &uri) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StopWatcher"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotify"); MessageParcel data; if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { HILOG_ERROR("WriteInterfaceToken failed"); @@ -1002,7 +1002,7 @@ int FileAccessExtProxy::StopWatcher(const Uri &uri) MessageParcel reply; MessageOption option; - int err = Remote()->SendRequest(CMD_STOP_WATCHER, data, reply, option); + int err = Remote()->SendRequest(CMD_UNREGISTER_NOTIFY, data, reply, option); if (err != ERR_OK) { HILOG_ERROR("fail to SendRequest. err: %{public}d", err); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); @@ -1017,7 +1017,7 @@ int FileAccessExtProxy::StopWatcher(const Uri &uri) } if (ret != ERR_OK) { - HILOG_ERROR("StopWatcher operation failed ret : %{public}d", ret); + HILOG_ERROR("UnregisterNotify operation failed ret : %{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; } diff --git a/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp b/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp index af8926ac..5229e5a5 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_stub.cpp @@ -45,8 +45,8 @@ FileAccessExtStub::FileAccessExtStub() { stubFuncMap_[CMD_OPEN_FILE] = &FileAccessExtStub::CmdOpenFile; stubFuncMap_[CMD_CREATE_FILE] = &FileAccessExtStub::CmdCreateFile; - stubFuncMap_[CMD_START_WATCHER] = &FileAccessExtStub::CmdStartWatcher; - stubFuncMap_[CMD_STOP_WATCHER] = &FileAccessExtStub::CmdStopWatcher; + stubFuncMap_[CMD_REGISTER_NOTIFY] = &FileAccessExtStub::CmdRegisterNotify; + stubFuncMap_[CMD_UNREGISTER_NOTIFY] = &FileAccessExtStub::CmdUnregisterNotify; stubFuncMap_[CMD_MKDIR] = &FileAccessExtStub::CmdMkdir; stubFuncMap_[CMD_DELETE] = &FileAccessExtStub::CmdDelete; stubFuncMap_[CMD_MOVE] = &FileAccessExtStub::CmdMove; @@ -718,27 +718,27 @@ ErrCode FileAccessExtStub::CmdAccess(MessageParcel &data, MessageParcel &reply) return ERR_OK; } -ErrCode FileAccessExtStub::CmdStartWatcher(MessageParcel &data, MessageParcel &reply) +ErrCode FileAccessExtStub::CmdRegisterNotify(MessageParcel &data, MessageParcel &reply) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdStartWatcher"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdRegisterNotify"); std::string uriString; if (!data.ReadString(uriString)) { - HILOG_ERROR("Parameter StartWatcher fail to ReadParcelable uri"); + HILOG_ERROR("Parameter CmdRegisterNotify fail to ReadParcelable uri"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } HILOG_ERROR("cjw uriString = %{public}s", uriString.c_str()); if (uriString.empty()) { - HILOG_ERROR("Parameter StartWatcher insideInputUri is empty"); + HILOG_ERROR("Parameter CmdRegisterNotify insideInputUri is empty"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return EINVAL; } Uri uri(uriString); - int ret = StartWatcher(uri); + int ret = RegisterNotify(uri); if (!reply.WriteInt32(ret)) { - HILOG_ERROR("Parameter StartWatcher fail to WriteInt32 ret"); + HILOG_ERROR("Parameter CmdRegisterNotify fail to WriteInt32 ret"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } @@ -747,26 +747,26 @@ ErrCode FileAccessExtStub::CmdStartWatcher(MessageParcel &data, MessageParcel &r return ERR_OK; } -ErrCode FileAccessExtStub::CmdStopWatcher(MessageParcel &data, MessageParcel &reply) +ErrCode FileAccessExtStub::CmdUnregisterNotify(MessageParcel &data, MessageParcel &reply) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdStopWatcher"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdUnregisterNotify"); std::string uriString; if (!data.ReadString(uriString)) { - HILOG_ERROR("Parameter StopWatcher fail to ReadParcelable uri"); + HILOG_ERROR("Parameter CmdUnregisterNotify fail to ReadParcelable uri"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } if (uriString.empty()) { - HILOG_ERROR("Parameter StopWatcher insideInputUri is empty"); + HILOG_ERROR("Parameter CmdUnregisterNotify insideInputUri is empty"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return EINVAL; } Uri uri(uriString); - int ret = StopWatcher(uri); + int ret = UnregisterNotify(uri); if (!reply.WriteInt32(ret)) { - HILOG_ERROR("Parameter StopWatcher fail to WriteInt32 ret"); + HILOG_ERROR("Parameter CmdUnregisterNotify fail to WriteInt32 ret"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } diff --git a/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp b/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp index 5e6083ac..5191a419 100644 --- a/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp +++ b/interfaces/inner_api/file_access/src/file_access_ext_stub_impl.cpp @@ -247,30 +247,30 @@ int FileAccessExtStubImpl::Access(const Uri &uri, bool &isExist) return ret; } -int FileAccessExtStubImpl::StartWatcher(const Uri &uri) +int FileAccessExtStubImpl::RegisterNotify(const Uri &uri) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StartWatcher"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "RegisterNotify"); if (extension_ == nullptr) { - HILOG_ERROR("StartWatcher get extension failed."); + HILOG_ERROR("RegisterNotify get extension failed."); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } - int ret = extension_->StartWatcher(uri); + int ret = extension_->RegisterNotify(uri); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; } -int FileAccessExtStubImpl::StopWatcher(const Uri &uri) +int FileAccessExtStubImpl::UnregisterNotify(const Uri &uri) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StopWatcher"); + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "UnregisterNotify"); if (extension_ == nullptr) { - HILOG_ERROR("StopWatcher get extension failed."); + HILOG_ERROR("UnregisterNotify get extension failed."); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } - int ret = extension_->StopWatcher(uri); + int ret = extension_->UnregisterNotify(uri); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; } diff --git a/interfaces/inner_api/file_access/src/file_access_helper.cpp b/interfaces/inner_api/file_access/src/file_access_helper.cpp index 9203fe49..a924856a 100644 --- a/interfaces/inner_api/file_access/src/file_access_helper.cpp +++ b/interfaces/inner_api/file_access/src/file_access_helper.cpp @@ -1188,7 +1188,7 @@ int FileAccessHelper::GetFileInfoFromRelativePath(std::string &selectFile, FileI return ERR_OK; } -void FileAccessObserver::OnChange(std::string message) +void FileAccessObserver::OnChange(NotifyMessage ¬ifyMessage) { HILOG_ERROR("enter onchanged"); } @@ -1205,6 +1205,7 @@ void FileAccessObserver::OnChange(std::string message) int FileAccessHelper::RegisterNotify(Uri uri, bool notifyForDescendants, sptr &observer) { HILOG_ERROR("cjw enter RegisterNotify"); + //HILOG_ERROR("cjw addr123 register observer = %{public}p", observer->AsObject()); sptr systemAbilityManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (!systemAbilityManager) { @@ -1218,18 +1219,21 @@ int FileAccessHelper::RegisterNotify(Uri uri, bool notifyForDescendants, sptr(remoteObject); int ret = proxy->RegisterNotify(uri, observer, true); - if (ret != ERR_OK) { + if (ret != ERR_OK && ret != 99) { HILOG_ERROR("cjw ret = %{public}d", ret); return ret; } - ret = StartWatcher(uri); - HILOG_ERROR("cjw ret = %{public}d", ret); + if (ret == 99) { + ret = StartWatcher(uri); + HILOG_ERROR("cjw ret = %{public}d", ret); + } return ret; } int FileAccessHelper::UnregisterNotify(Uri uri, sptr &observer) { HILOG_ERROR("cjw enter UnregisterNotify"); + //HILOG_ERROR("cjw addr123 unregister observer = %{public}p", observer->AsObject()); sptr systemAbilityManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (!systemAbilityManager) { @@ -1243,6 +1247,10 @@ int FileAccessHelper::UnregisterNotify(Uri uri, sptr &obser auto proxy = iface_cast(remoteObject); int ret = proxy->UnregisterNotify(uri, observer); HILOG_ERROR("cjw ret = %{public}d", ret); + if (ret == 99) { + ret = StopWatcher(uri); + HILOG_ERROR("cjw ret = %{public}d", ret); + } return ret; } @@ -1290,7 +1298,7 @@ int FileAccessHelper::StartWatcher(Uri &uri) return E_IPCS; } - int ret = fileExtProxy->StartWatcher(uri); + int ret = fileExtProxy->RegisterNotify(uri); if (ret != ERR_OK) { HILOG_ERROR("Delete get result error, code:%{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); @@ -1323,7 +1331,7 @@ int FileAccessHelper::StopWatcher(Uri &uri) return E_IPCS; } - int ret = fileExtProxy->StopWatcher(uri); + int ret = fileExtProxy->UnregisterNotify(uri); if (ret != ERR_OK) { HILOG_ERROR("Delete get result error, code:%{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); diff --git a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp index edb8b7fd..f5e94e64 100644 --- a/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp +++ b/interfaces/inner_api/file_access/src/js_file_access_ext_ability.cpp @@ -21,6 +21,7 @@ #include "file_access_ext_stub_impl.h" #include "file_access_extension_info.h" #include "file_access_framework_errno.h" +#include "file_access_observer_common.h" #include "hilog_wrapper.h" #include "hitrace_meter.h" #include "ipc_skeleton.h" @@ -132,9 +133,9 @@ NativeValue* JsFileAccessExtAbility::FuncCallback(NativeEngine* engine, NativeCa std::string uriString = UnwrapStringFromJS(reinterpret_cast(engine), reinterpret_cast(info->argv[ARGC_ZERO])); HILOG_ERROR("cjw uriString = %{public}s", uriString.c_str()); - std::string notifyType = UnwrapStringFromJS(reinterpret_cast(engine), + int32_t event = UnwrapInt32FromJS(reinterpret_cast(engine), reinterpret_cast(info->argv[ARGC_ONE])); - HILOG_ERROR("cjw notifyType = %{public}s", notifyType.c_str()); + // HILOG_ERROR("cjw notifyType = %{public}s", notifyType.c_str()); if (info->functionInfo == nullptr || info->functionInfo->data == nullptr) { HILOG_ERROR("cjw invalid object."); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); @@ -149,6 +150,7 @@ NativeValue* JsFileAccessExtAbility::FuncCallback(NativeEngine* engine, NativeCa } Uri uri(uriString); + NotifyType notifyType = static_cast(event); auto ret = jsExtension->Notify(uri, notifyType); if (ret != ERR_OK) { HILOG_ERROR("cjw JsFileAccessExtAbility notify error, ret:%{public}d", ret); @@ -1280,63 +1282,27 @@ int JsFileAccessExtAbility::GetFileInfoFromUri(const Uri &selectFile, FileInfo & return ERR_OK; } -int JsFileAccessExtAbility::RegisterNotify(const Uri &uri) -{ - return ERR_OK; -} -int JsFileAccessExtAbility::UnregisterNotify(const Uri &uri) -{ - return ERR_OK; -} - -int JsFileAccessExtAbility::StartWatcher(const Uri &uri) +int JsFileAccessExtAbility::RegisterNotify(const Uri &uri) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StartWatcher"); - CreateWatcher(uri); - // auto ret = std::make_shared(); - // if (ret == nullptr) { - // HILOG_ERROR("StartWatcher value is nullptr."); - // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - // return E_GETRESULT; - // } - - // auto argParser = [uri = uri](NativeEngine &engine, NativeValue *argv[], size_t &argc) -> bool { - // NativeValue *nativeUri = engine.CreateString(uri.ToString().c_str(), uri.ToString().length()); - // if (nativeUri == nullptr) { - // HILOG_ERROR("create uri uri native js value fail."); - // return false; - // } - // argv[ARGC_ZERO] = nativeUri; - // argc = ARGC_ONE; - // return true; - // }; - // auto retParser = [ret](NativeEngine &engine, NativeValue *result) -> bool { - // bool res = ConvertFromJsValue(engine, result, *ret); - // if (!res) { - // HILOG_ERROR("Convert js value fail."); - // } - // return res; - // }; - - // auto errCode = CallJsMethod("StartWatcher", jsRuntime_, jsObj_.get(), argParser, retParser); - // if (errCode != ERR_OK) { - // HILOG_ERROR("CallJsMethod error, code:%{public}d.", errCode); - // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - // return errCode; - // } - - // if (*ret != ERR_OK) { - // HILOG_ERROR("fileio fail."); - // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - // return *ret; - // } + HandleScope handleScope(jsRuntime_); + const std::string funcName = "FuncCallback"; + auto& nativeEngine = jsRuntime_.GetNativeEngine(); + NativeValue *nativeUri = nativeEngine.CreateString(uri.ToString().c_str(), uri.ToString().length()); + if (nativeUri == nullptr) { + HILOG_ERROR("create uri uri native js value fail."); + return E_URIS; + } + NativeValue* func = nativeEngine.CreateFunction(funcName.c_str(), funcName.length(), JsFileAccessExtAbility::FuncCallback, this); + NativeValue* argv[] = {nativeUri, func}; + CallObjectMethod("startWatcher", argv, ARGC_TWO); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } -int JsFileAccessExtAbility::StopWatcher(const Uri &uri) +int JsFileAccessExtAbility::UnregisterNotify(const Uri &uri) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "StopWatcher"); auto ret = std::make_shared(); @@ -1349,13 +1315,14 @@ int JsFileAccessExtAbility::StopWatcher(const Uri &uri) auto argParser = [uri = uri](NativeEngine &engine, NativeValue *argv[], size_t &argc) -> bool { NativeValue *nativeUri = engine.CreateString(uri.ToString().c_str(), uri.ToString().length()); if (nativeUri == nullptr) { - HILOG_ERROR("create uri uri native js value fail."); + HILOG_ERROR("create uri native js value fail."); return false; } argv[ARGC_ZERO] = nativeUri; argc = ARGC_ONE; return true; }; + auto retParser = [ret](NativeEngine &engine, NativeValue *result) -> bool { bool res = ConvertFromJsValue(engine, result, *ret); if (!res) { diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp index 47c1ec4a..65484ae9 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_proxy.cpp @@ -24,9 +24,9 @@ namespace OHOS { namespace FileAccessFwk { -int32_t FileAccessObserverProxy::OnChange(std::string message) +int32_t FileAccessObserverProxy::OnChange(Uri uri, NotifyType notifyType) { - HILOG_ERROR("cjw proxy OnChange = %{public}s", message.c_str()); + HILOG_ERROR("cjw proxy notifyType_ = %{public}d uri = %{public}s",notifyType, uri.ToString().c_str()); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChange"); MessageParcel data; if (!data.WriteInterfaceToken(FileAccessObserverProxy::GetDescriptor())) { @@ -35,8 +35,15 @@ int32_t FileAccessObserverProxy::OnChange(std::string message) return E_IPCS; } - if (!data.WriteString(message)) { - HILOG_ERROR("fail to WriteString message"); + if (!data.WriteParcelable(&uri)) { + HILOG_ERROR("fail to WriteParcelable uri"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + //int32_t event = static_cast(notifyType); + if (!data.WriteInt32(int(notifyType))) { + HILOG_ERROR("fail to WriteParcelable notifyType"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } @@ -63,14 +70,6 @@ int32_t FileAccessObserverProxy::OnChange(std::string message) return E_IPCS; } - std::string messageTemp; - if (!reply.ReadString(messageTemp)) { - HILOG_ERROR("fail to ReadString message"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return E_IPCS; - } - - message = messageTemp; FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } @@ -121,14 +120,14 @@ int32_t FileAccessObserverProxy::RegisterNotify(Uri uri, sptr &observer) @@ -169,14 +168,14 @@ int32_t FileAccessObserverProxy::UnregisterNotify(Uri uri, sptr +#include +#include +#include +#include #include "file_access_framework_errno.h" #include "hilog_wrapper.h" @@ -27,6 +31,7 @@ namespace FileAccessFwk { namespace { auto pms = DelayedStatsSpSingleton::GetInstance(); const bool G_REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(pms.GetRefPtr()); +constexpr int CREATE_NEW_NODE = 99; } FileAccessObserverService::FileAccessObserverService() : SystemAbility(FILE_MANAGER_SERVICE_ID, true) {} FileAccessObserverService::~FileAccessObserverService() {} @@ -86,12 +91,16 @@ int32_t FileAccessObserverService::RegisterNotify(Uri uri, sptr path = { uri.GetScheme(), uri.GetAuthority() }; uri.GetPathSegments(path); HILOG_ERROR("cjw SA RegisterNotify"); + bool outIsNewNode =false; //if (mRootNode_ != nullptr && !mRootNode_->AddObserver(path, 0, ObserverEntry(observer, deathRecipientRef, notifyForDescendants))) { - if (mRootNode_ != nullptr && !mRootNode_->AddObserver(path, 0, ObserverEntry(observer, notifyForDescendants))) { + if (mRootNode_ != nullptr && !mRootNode_->AddObserver(path, 0, ObserverEntry(observer, notifyForDescendants), outIsNewNode)) { HILOG_ERROR("The number of subscribers for this uri : %{public}s.", uri.ToString().c_str()); //RemoveObsDeathRecipient(observer->AsObject()); return E_IPCS; } + if (outIsNewNode) { + return CREATE_NEW_NODE; + } // HILOG_ERROR("cjw observer RegisterNotify add %{public}p", observer->AsObject().GetRefPtr()); //FileAccessObserverService::OnChange("123test"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); @@ -109,17 +118,21 @@ int32_t FileAccessObserverService::UnregisterNotify(Uri uri, sptr lock(nodeMutex_); std::vector path = { uri.GetScheme(), uri.GetAuthority() }; uri.GetPathSegments(path); + bool deleteNode = false; if (mRootNode_ != nullptr) { HILOG_ERROR("cjw SA UnregisterNotify"); - mRootNode_->RemoveObserver(path, 0, observer); + mRootNode_->RemoveObserver(path, 0, observer, deleteNode); + HILOG_ERROR("cjw deleteNode is true %{public}d", deleteNode); + } + if (deleteNode) { + return 99; } - FileAccessObserverService::OnChange(uri.ToString()); //RemoveObsDeathRecipient(observer->AsObject()); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } -int32_t FileAccessObserverService::OnChange(std::string message) +int32_t FileAccessObserverService::OnChange(Uri uri, NotifyType notifyType) { HILOG_ERROR("cjw Service OnChange"); ObsMap changeRes; @@ -127,7 +140,6 @@ int32_t FileAccessObserverService::OnChange(std::string message) { std::lock_guard lock(nodeMutex_); path.clear(); - Uri uri(message); path.emplace_back(uri.GetScheme()); path.emplace_back(uri.GetAuthority()); uri.GetPathSegments(path); @@ -140,10 +152,14 @@ int32_t FileAccessObserverService::OnChange(std::string message) if (changeRes.empty()) { return E_IPCS; } + NotifyMessage notifyMessage; + notifyMessage.notifyType_ = notifyType; + std::vector uris {uri.ToString()}; + notifyMessage.uris_ = uris; for (const auto &[obs, value] : changeRes) { if (obs != nullptr && !value.empty()) { //obs->OnChange({ changeInfo.changeType_, move(value), changeInfo.data_, changeInfo.size_ }); - obs->OnChange(message); + obs->OnChange(notifyMessage); } } return ERR_OK; @@ -223,7 +239,7 @@ void FileAccessObserverService::ObserverNode::GetObs(const std::vector &path, uint32_t index, const ObserverEntry &entry) +bool FileAccessObserverService::ObserverNode::AddObserver(const std::vector &path, uint32_t index, const ObserverEntry &entry, bool &outIsNewNode) { HILOG_ERROR("cjw enter ObserverNode::AddObserver NodeName = %{public}s", nodeName_.c_str()); if (path.size() == index) { @@ -247,12 +263,13 @@ bool FileAccessObserverService::ObserverNode::AddObserver(const std::vector(path[index])).first; + outIsNewNode = true; HILOG_ERROR("cjw AddObserver new ObserverNode"); - return it->second->AddObserver(path, ++index, entry); + return it->second->AddObserver(path, ++index, entry, outIsNewNode); } bool FileAccessObserverService::ObserverNode::RemoveObserver(const std::vector &path, uint32_t index, - sptr dataObserver) + sptr dataObserver, bool &deleteNode) { HILOG_ERROR("cjw enter ObserverNode::RemoveObserver"); if (index == path.size()) { @@ -266,8 +283,9 @@ bool FileAccessObserverService::ObserverNode::RemoveObserver(const std::vectorsecond->RemoveObserver(path, ++index, dataObserver)) { + if (child != childrens_.end() && child->second->RemoveObserver(path, ++index, dataObserver, deleteNode)) { childrens_.erase(child); + deleteNode = true; HILOG_ERROR("cjw execute erase"); } return observerEntry_.empty() && childrens_.empty(); diff --git a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp index ce1bac18..2f481732 100644 --- a/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp +++ b/interfaces/inner_api/file_access/src/observer/file_access_observer_stub.cpp @@ -144,14 +144,23 @@ int32_t FileAccessObserverStub::UnregisterNotifyStub(MessageParcel &data, Messag int32_t FileAccessObserverStub::OnChangeStub(MessageParcel &data, MessageParcel &reply) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChangeStub"); - std::string message; - if (!data.ReadString(message)) { - HILOG_ERROR("Parameter OnChangeStub fail to ReadString message"); + std::shared_ptr uri(data.ReadParcelable()); + if (uri == nullptr) { + HILOG_ERROR("UnregisterNotify uri is nullptr"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_URIS; + } + + NotifyType notifyType = static_cast(data.ReadInt32()); + HILOG_ERROR("cjw proxy notifyType_ = %{public}d uri = %{public}s", notifyType, (*uri).ToString().c_str()); + + int ret = OnChange(*uri, notifyType); + if (!reply.WriteInt32(ret)) { + HILOG_ERROR("Parameter OnChange fail to WriteInt32 ret"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } - HILOG_ERROR("cjw stub message = %{public}s", message.c_str()); - OnChange(message); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ERR_OK; } diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp index 6ff17e72..c043601f 100644 --- a/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_proxy.cpp @@ -24,9 +24,9 @@ namespace OHOS { namespace FileAccessFwk { -void ObserverCallbackProxy::OnChange(std::string message) +void ObserverCallbackProxy::OnChange(NotifyMessage ¬ifyMessage) { - HILOG_ERROR("cjw proxy message = %{public}s", message.c_str()); + HILOG_ERROR("cjw proxy notifyType_ = %{public}d", notifyMessage.notifyType_); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChange"); MessageParcel data; if (!data.WriteInterfaceToken(ObserverCallbackProxy::GetDescriptor())) { @@ -35,8 +35,8 @@ void ObserverCallbackProxy::OnChange(std::string message) return; } - if (!data.WriteString(message)) { - HILOG_ERROR("fail to WriteBool notifyForDescendants"); + if (!data.WriteParcelable(¬ifyMessage)) { + HILOG_ERROR("fail to WriteParcelable notifyMessage"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return; } @@ -64,14 +64,14 @@ void ObserverCallbackProxy::OnChange(std::string message) return; } - std::string messageTemp; - if (!reply.ReadString(messageTemp)) { - HILOG_ERROR("fail to ReadString message"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return; - } + // std::string messageTemp; + // if (!reply.ReadString(messageTemp)) { + // HILOG_ERROR("fail to ReadString message"); + // FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + // return; + // } - message = messageTemp; + // message = messageTemp; FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return; } diff --git a/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp index 3bd7c7d8..d38864b9 100644 --- a/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp +++ b/interfaces/inner_api/file_access/src/observer/observer_callback_stub.cpp @@ -74,15 +74,17 @@ int32_t ObserverCallbackStub::ChooseCodeStub(uint32_t code, MessageParcel &data, int32_t ObserverCallbackStub::OnChangeStub(MessageParcel &data, MessageParcel &reply) { + HILOG_ERROR("cjw enter OnChangeStub"); StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnChangeStub"); - std::string message; - if (!data.ReadString(message)) { - HILOG_ERROR("Parameter OnChangeStub fail to ReadString message"); + std::shared_ptr notifyMessage(data.ReadParcelable()); + if (notifyMessage == nullptr) { + HILOG_ERROR("OnChange uri is nullptr"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return E_IPCS; + return E_URIS; } - HILOG_ERROR("cjw stub message = %{public}s", message.c_str()); - OnChange(message); + + HILOG_ERROR("cjw OnChangeStub notifyType_ = %{public}d", (*notifyMessage).notifyType_); + OnChange(*notifyMessage); int ret = 0; if (!reply.WriteInt32(ret)) { HILOG_ERROR("Parameter OnChangeStub fail to WriteInt32 ret"); diff --git a/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts b/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts index 0f76251c..035cc969 100644 --- a/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts +++ b/services/file_extension_hap/entry/src/main/ets/FileExtensionAbility/FileExtensionAbility.ts @@ -654,29 +654,19 @@ export default class FileExtAbility extends Extension { let watchPath = this.getPath(uri); console.log("cjw path =" + watchPath); try { - // const onChange = (data) => { - // console.log("cjw onchange in "); - // console.log("cjw" + data.event); - // let eventName = code2name[dec2hex(data.event, 8)]; - // let watchUri = FILE_PREFIX_NAME + BUNDLE_NAME + watchPath; - // callback(watchUri, eventName); - // console.log("cjw1" + NotifyMessage.message); - // } console.log("cjw aaa start create"); - //let watcher; - //let watcher = await fs.createWatcher(watchPath, 0x00000fff, onChange); - //let relative_path = "/data/service/el1/public/storage_daemon/share/public/QueryTest1/external_file_access_watcher_00001.txt"; - //let relative_path = "data/service/el1/public/storage_daemon/share/public/WatcherTest/external_file_access_watcher_00000.txt"; - //console.log(relative_path); - let watcher = fs.createWatcher(watchPath, 0x00000002, (data) => { + let watcher = fs.createWatcher(watchPath, 0x00000100 | 0x00000200 | 0x00000002, (data) => { try { console.log("cjw onchange in "); - console.log("cjw" + data.event); - //let eventName = code2name[this.dec2hex(data.event, 8)]; - let eventName = "2"; + console.log("cjw asd" + data.event); + console.log("cjw asd" + (data.event).toString(16)); + console.log("cjw get hex:%s\n",(data.event).toString(16)); + let eventName = code2name[this.dec2hex(data.event, 8)]; + console.log("cjw event" + eventName); + let notifyEvent = data.event; let watchUri = FILE_PREFIX_NAME + BUNDLE_NAME + watchPath; - callback(watchUri, eventName); - console.log("cjw1" + eventName); + callback(watchUri, notifyEvent); + console.log("cjw1" + notifyEvent); } catch (e1) { hilog.error(DOMAIN_CODE, TAG, 'onchange error ' + e1.message); } diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 3db1791b..efbebe9a 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -66,6 +66,7 @@ ohos_unittest("external_file_access_test") { "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/context", "//third_party/googletest/googlemock/include/gmock", "${user_file_service_path}/interfaces/inner_api/file_access/include", + "${user_file_service_path}/interfaces/inner_api/file_access/include/observer", ] configs = [ "//build/config/compiler:exceptions" ] @@ -76,6 +77,7 @@ ohos_unittest("external_file_access_test") { "${access_token_path}/frameworks/accesstoken:accesstoken_communication_adapter_cxx", "${user_file_service_path}/interfaces/inner_api/file_access:file_access_extension_ability_kit", "//third_party/googletest:gmock_main", + "${user_file_service_path}/interfaces/inner_api/file_access:file_access_observer", ] external_deps = [ @@ -93,6 +95,14 @@ ohos_unittest("external_file_access_test") { "ipc:ipc_core", "ipc_js:rpc", "samgr:samgr_proxy", + "ability_runtime:extensionkit_native", + "ability_runtime:napi_common", + "bundle_framework:appexecfwk_core", + "hitrace_native:hitrace_meter", + "hiviewdfx_hilog_native:libhilog", + "multimedia_image_framework:image_native", + "napi:ace_napi", + "safwk:system_ability_fwk", ] } diff --git a/test/unittest/external_file_access_test.cpp b/test/unittest/external_file_access_test.cpp index 8f307a25..90768ba6 100644 --- a/test/unittest/external_file_access_test.cpp +++ b/test/unittest/external_file_access_test.cpp @@ -20,6 +20,7 @@ #include #include +#include "file_access_observer_common.h" #include "accesstoken_kit.h" #include "context_impl.h" #include "file_access_framework_errno.h" @@ -29,6 +30,7 @@ #include "iobserver_callback.h" #define private public #include "file_access_helper.h" +#include "observer_callback_stub.h" #undef private namespace { @@ -111,29 +113,29 @@ public: void SetUp(){}; void TearDown(){}; }; -class MyObserver : public IRemoteStub { +class MyObserver : public ObserverCallbackStub { public: MyObserver() {}; virtual ~MyObserver() {}; - void OnChange(std::string message) override; - std::string GetClassName() override; - bool Equal(void *observer) override; + void OnChange(NotifyMessage ¬ifyMessage) override; + // std::string GetClassName() override; + // bool Equal(void *observer) override; }; -void MyObserver::OnChange (std::string message) +void MyObserver::OnChange (NotifyMessage ¬ifyMessage) { - + GTEST_LOG_(ERROR) << "cjw what F ?."; } -std::string MyObserver::GetClassName() -{ - return "name"; -} +// std::string MyObserver::GetClassName() +// { +// return "name"; +// } -bool MyObserver::Equal(void *observer) -{ - return true; -} +// bool MyObserver::Equal(void *observer) +// { +// return true; +// } /** * @tc.number: user_file_service_external_file_access_startWatcher_0000 * @tc.name: external_file_access_startWatcher_0000 @@ -155,6 +157,11 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_startWatcher_0000, testin Uri newDirUriTest1(""); result = g_fah->Mkdir(parentUri, "WatcherTest", newDirUriTest1); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + bool notifyForDescendantsdir = true; + sptr myObserver1 = new (std::nothrow) MyObserver(); + result = g_fah->RegisterNotify(newDirUriTest1, notifyForDescendantsdir, myObserver1); + EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); + Uri newFileUri1(""); std::string fileName = "external_file_access_watcher_00000.txt"; result = g_fah->CreateFile(newDirUriTest1, fileName, newFileUri1); @@ -171,7 +178,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_startWatcher_0000, testin // result = g_fah->StartWatcher(newFileUri1); // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); bool notifyForDescendants = false; - sptr myObserver = new MyObserver(); + sptr myObserver = new (std::nothrow) MyObserver(); result = g_fah->RegisterNotify(newFileUri1, notifyForDescendants, myObserver); EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); @@ -187,6 +194,10 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_startWatcher_0000, testin ssize_t fileSize1 = write(fd, buff1.c_str(), buff1.size()); EXPECT_EQ(fileSize1, buff1.size()); close(fd); + result = g_fah->Delete(newFileUri1); + result = g_fah->UnregisterNotify(newFileUri1, myObserver); + result = g_fah->UnregisterNotify(newDirUriTest1, myObserver1); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); } catch (...) { GTEST_LOG_(ERROR) << "external_file_access_startWatcher_0000 occurs an exception."; } diff --git a/test/unittest/medialibrary_file_access_test.cpp b/test/unittest/medialibrary_file_access_test.cpp index 9823e37b..34b1f954 100644 --- a/test/unittest/medialibrary_file_access_test.cpp +++ b/test/unittest/medialibrary_file_access_test.cpp @@ -123,55 +123,55 @@ public: // return parentUri; // } -class MyObserver : public IRemoteStub { -public: - MyObserver() {}; - virtual ~MyObserver() {}; - void OnChange(std::string message) override; - std::string GetClassName() override; - bool Equal(void *observer) override; -}; +// class MyObserver : public IRemoteStub { +// public: +// MyObserver() {}; +// virtual ~MyObserver() {}; +// void OnChange(std::string message) override; +// // std::string GetClassName() override; +// // bool Equal(void *observer) override; +// }; -void MyObserver::OnChange (std::string message) -{ +// void MyObserver::OnChange (std::string message) +// { -} +// } -std::string MyObserver::GetClassName() -{ - return "name"; -} +// std::string MyObserver::GetClassName() +// { +// return "name"; +// } -bool MyObserver::Equal(void *observer) -{ - return true; -} +// bool MyObserver::Equal(void *observer) +// { +// return true; +// } -/** - * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0000 - * @tc.name: medialibrary_file_access_OpenFile_0000 - * @tc.desc: Test function of OpenFile interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H0386 - */ -HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0000, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0000"; - try { - //Uri parentUri = GetParentUri(); - bool notifyForDescendants = false; - Uri newDirUriTest("file://media/root/file"); - sptr myObserver = new MyObserver(); - int result = g_fah->RegisterNotify(newDirUriTest, notifyForDescendants, myObserver); - EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); +// /** +// * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0000 +// * @tc.name: medialibrary_file_access_OpenFile_0000 +// * @tc.desc: Test function of OpenFile interface for SUCCESS. +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: SR000H0386 +// */ +// HWTEST_F(FileAccessHelperTest, medialibrary_file_access_OpenFile_0000, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "FileAccessHelperTest-begin medialibrary_file_access_OpenFile_0000"; +// try { +// //Uri parentUri = GetParentUri(); +// bool notifyForDescendants = false; +// Uri newDirUriTest("file://media/root/file"); +// sptr myObserver = new MyObserver(); +// int result = g_fah->RegisterNotify(newDirUriTest, notifyForDescendants, myObserver); +// EXPECT_GE(result, OHOS::FileAccessFwk::ERR_OK); - } catch (...) { - GTEST_LOG_(ERROR) << "medialibrary_file_accsess_OpenFile_0000 occurs an exception."; - } - GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0000"; -} +// } catch (...) { +// GTEST_LOG_(ERROR) << "medialibrary_file_accsess_OpenFile_0000 occurs an exception."; +// } +// GTEST_LOG_(INFO) << "FileAccessHelperTest-end medialibrary_file_access_OpenFile_0000"; +// } // /** // * @tc.number: user_file_service_medialibrary_file_access_OpenFile_0000 -- Gitee