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 3097ee4a4706ebd4fcf417733cb1eaa3eca8695c..f3f8a3c40dbb505a92628b383eacc9878dd7ffcc 100644 --- a/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp +++ b/frameworks/js/napi/file_access_module/napi_fileaccess_helper.cpp @@ -46,6 +46,8 @@ namespace { static napi_ref g_constructorRef = nullptr; constexpr uint32_t INITIAL_REFCOUNT = 1; constexpr int COPY_EXCEPTION = -1; + using CallbackExec = std::function; + using CallbackComplete = std::function; } std::list> g_fileAccessHelperList; @@ -678,7 +680,7 @@ static napi_value CreateObjectArray(napi_env env, std::vector result return copyResultArray; } -std::tuple GetCopyArguments(napi_env env, NFuncArg &funcArg) +static std::tuple GetCopyArguments(napi_env env, NFuncArg &funcArg) { bool retStatus = false; std::unique_ptr srcPath; @@ -717,6 +719,35 @@ std::tuple GetCopyArguments(napi_env env, return std::make_tuple(true, srcPathStr, destPathStr, force); } +static napi_value AddNAsyncWork(napi_env env, NFuncArg &funcArg, CallbackExec cbExec, CallbackComplete cbComplete) +{ + const std::string procedureName = "copy"; + NVal thisVar(env, funcArg.GetThisVar()); + + if (funcArg.GetArgc() == NARG_CNT::TWO) { + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; + } + + if (funcArg.GetArgc() == NARG_CNT::THREE) { + NVal thirdArg(env, funcArg[NARG_POS::THIRD]); + if (thirdArg.TypeIs(napi_boolean)) { + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; + } + if (thirdArg.TypeIs(napi_function)) { + return NAsyncWorkCallback(env, thisVar, thirdArg).Schedule(procedureName, cbExec, cbComplete).val_; + } + NError(EINVAL).ThrowErr(env); + return nullptr; + } + + NVal cb(env, funcArg[NARG_POS::FOURTH]); + if (!cb.TypeIs(napi_function)) { + NError(EINVAL).ThrowErr(env); + return nullptr; + } + return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; +} + napi_value NAPI_Copy(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); @@ -745,7 +776,6 @@ napi_value NAPI_Copy(napi_env env, napi_callback_info info) NError(E_GETRESULT).ThrowErr(env); return nullptr; } - int ret = ERR_OK; auto cbExec = [srcPathStr, destPathStr, force, result, &ret, fileAccessHelper]() -> NError { OHOS::Uri srcUri(srcPathStr); @@ -763,31 +793,7 @@ napi_value NAPI_Copy(napi_env env, napi_callback_info info) return { env, CreateObjectArray(env, *result) }; }; - const std::string procedureName = "copy"; - NVal thisVar(env, funcArg.GetThisVar()); - - if (funcArg.GetArgc() == NARG_CNT::TWO) { - return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; - } - - if (funcArg.GetArgc() == NARG_CNT::THREE) { - NVal thirdArg(env, funcArg[NARG_POS::THIRD]); - if (thirdArg.TypeIs(napi_boolean) || thirdArg.TypeIs(napi_undefined)) { - return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_; - } - if (thirdArg.TypeIs(napi_function)) { - return NAsyncWorkCallback(env, thisVar, thirdArg).Schedule(procedureName, cbExec, cbComplete).val_; - } - NError(EINVAL).ThrowErr(env); - return nullptr; - } - - NVal cb(env, funcArg[NARG_POS::FOURTH]); - if (!cb.TypeIs(napi_function)) { - NError(EINVAL).ThrowErr(env); - return nullptr; - } - return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_; + return AddNAsyncWork(env, funcArg, cbExec, cbComplete); } napi_value NAPI_Rename(napi_env env, napi_callback_info info) 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 80fe58d6e9313ae73faeed0fa64205aa6109288c..e08c07b4138a752ebcd7a4a54e17c76e56bb9dfc 100644 --- a/interfaces/inner_api/file_access/include/file_access_helper.h +++ b/interfaces/inner_api/file_access/include/file_access_helper.h @@ -105,6 +105,12 @@ private: std::shared_ptr GetConnectInfo(const std::string &bundleName); int CopyInsideService(Uri &sourceUri, Uri &destUri, std::vector ©Result, bool force = false); + int GetCopyResult(const std::string &sourceUri, const std::string &destUri, int errCode, const std::string &errMsg, + std::vector ©Result); + int TranslateCopyResult(int errCode, CopyResult ©Result); + int IsDirectory(Uri &uri, bool &isDir); + bool IsExternalUri(Uri &uri); + bool IsMediaUri(Uri &uri); sptr token_ = nullptr; std::unordered_map> cMap_; 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 79e0eb1e40bdac2a16c507b1763a1d8db8af20be..fdedf002f2dc260390d6364650c50f1339485b3f 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 @@ -65,6 +65,7 @@ public: int Mkdir(const Uri &parent, const std::string &displayName, Uri &newFile) override; int Delete(const Uri &sourceFile) override; int Move(const Uri &sourceFile, const Uri &targetParent, Uri &newFile) override; + int Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, bool force = false) override; int Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile) override; int ListFile(const FileInfo &fileInfo, const int64_t offset, const int64_t maxCount, const FileFilter &filter, std::vector &fileInfoVec) override; 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 130b4ab3469d0f722dc31f5d0f9240876e996561..87708f0db1000225209c672a68f0d52b0a3bab65 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 @@ -318,17 +318,9 @@ int FileAccessExtProxy::Move(const Uri &sourceFile, const Uri &targetParent, Uri return ERR_OK; } -int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, - bool force) +static int WriteCopyFuncArguments(OHOS::MessageParcel &data, const Uri &sourceUri, const Uri &destUri, bool force) { - StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); - MessageParcel data; - if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { - HILOG_ERROR("WriteInterfaceToken failed"); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return E_IPCS; - } - + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "WriteCopyFuncArguments"); std::string insideInputSourceUri = sourceUri.ToString(); if (!data.WriteString(insideInputSourceUri)) { HILOG_ERROR("fail to WriteParcelable insideInputSourceUri"); @@ -348,16 +340,13 @@ int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vect FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return E_IPCS; } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ERR_OK; +} - MessageParcel reply; - MessageOption option; - int err = Remote()->SendRequest(CMD_COPY, data, reply, option); - if (err != ERR_OK) { - HILOG_ERROR("fail to SendRequest. err: %{public}d", err); - FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return err; - } - +static int ReadCopyFuncResults(OHOS::MessageParcel &reply, std::vector ©Result) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ReadCopyFuncResults"); int ret = E_IPCS; if (!reply.ReadInt32(ret)) { HILOG_ERROR("fail to ReadInt32 ret"); @@ -367,7 +356,7 @@ int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vect if (ret == ERR_OK) { HILOG_ERROR("Copy operation success"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - return ERR_OK; + return ret; } uint32_t count = 0; @@ -392,6 +381,43 @@ int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vect copyResult.push_back(*copyResultPtr); } } + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; +} + +int FileAccessExtProxy::Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, + bool force) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); + MessageParcel data; + if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) { + HILOG_ERROR("WriteInterfaceToken failed"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return E_IPCS; + } + + int ret = WriteCopyFuncArguments(data, sourceUri, destUri, force); + if (ret != ERR_OK) { + HILOG_ERROR("Write copy function arguments error, code: %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + MessageParcel reply; + MessageOption option; + int err = Remote()->SendRequest(CMD_COPY, data, reply, option); + if (err != ERR_OK) { + HILOG_ERROR("fail to SendRequest, err: %{public}d", err); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return err; + } + + ret = ReadCopyFuncResults(reply, copyResult); + if (ret != ERR_OK) { + HILOG_ERROR("Read copy function result error, code: %{public}d", ret); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } 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 df45fb58f25f88bcbd84a871c604c26afcf02477..5ca6efd5f4c07dfa9cee22e177d1b60416143da4 100644 --- a/interfaces/inner_api/file_access/src/file_access_helper.cpp +++ b/interfaces/inner_api/file_access/src/file_access_helper.cpp @@ -646,7 +646,7 @@ int FileAccessHelper::Move(Uri &sourceFile, Uri &targetParent, Uri &newFile) return ERR_OK; } -static bool IsMediaUri(Uri &uri) +bool FileAccessHelper::IsMediaUri(Uri &uri) { string scheme = uri.GetScheme(); if (scheme == FILE_SCHEME_NAME) { @@ -655,7 +655,34 @@ static bool IsMediaUri(Uri &uri) return false; } -static int ThrowExceptionByErrorCode(int errCode, CopyResult ©Result) +bool FileAccessHelper::IsExternalUri(Uri &uri) +{ + string scheme = uri.GetScheme(); + if (scheme == FILE_SCHEME_NAME) { + return uri.GetAuthority() == EXTERNAL_BNUDLE_NAME; + } + return false; +} + +int FileAccessHelper::IsDirectory(Uri &uri, bool &isDir) +{ + sptr proxy = FileAccessHelper::GetProxyByUri(uri); + if (proxy == nullptr) { + HILOG_ERROR("failed with invalid fileAccessExtProxy"); + return E_IPCS; + } + + FileInfo fileInfo; + int ret = proxy->GetFileInfoFromUri(uri, fileInfo); + if (ret != ERR_OK) { + HILOG_ERROR("get FileInfo from uri error, code:%{public}d", ret); + return ret; + } + isDir = (fileInfo.mode & DOCUMENT_FLAG_REPRESENTS_DIR) != 0; + return ret; +} + +int FileAccessHelper::TranslateCopyResult(int errCode, CopyResult &result) { if (errCode == COPY_EXCEPTION || errCode == ERR_OK) { return errCode; @@ -666,6 +693,7 @@ static int ThrowExceptionByErrorCode(int errCode, CopyResult ©Result) case E_IPCS: case E_URIS: case ERR_NOMEM: + case E_PERMISSION_SYS: case ERR_PERM: { HILOG_ERROR("Copy exception, terminate copy"); ret = COPY_EXCEPTION; @@ -679,12 +707,22 @@ static int ThrowExceptionByErrorCode(int errCode, CopyResult ©Result) } if (OHOS::FileManagement::LibN::errCodeTable.find(errCode) != OHOS::FileManagement::LibN::errCodeTable.end()) { - copyResult.errCode = OHOS::FileManagement::LibN::errCodeTable.at(errCode).first; - copyResult.errMsg = OHOS::FileManagement::LibN::errCodeTable.at(errCode).second; + result.errCode = OHOS::FileManagement::LibN::errCodeTable.at(errCode).first; + result.errMsg = OHOS::FileManagement::LibN::errCodeTable.at(errCode).second; } return ret; } +int FileAccessHelper::GetCopyResult(const std::string &sourceUri, const std::string &destUri, int errCode, + const std::string &errMsg, std::vector ©Result) +{ + CopyResult result { sourceUri, destUri, errCode, errMsg }; + int ret = TranslateCopyResult(errCode, result); + copyResult.clear(); + copyResult.push_back(result); + return ret; +} + int FileAccessHelper::CopyInsideService(Uri &sourceUri, Uri &destUri, std::vector ©Result, bool force) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CopyInsideService"); @@ -694,23 +732,24 @@ int FileAccessHelper::CopyInsideService(Uri &sourceUri, Uri &destUri, std::vecto HILOG_ERROR("Failed with invalid fileAccessExtProxy"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); CopyResult result; - ret = ThrowExceptionByErrorCode(E_IPCS, result); + ret = TranslateCopyResult(E_IPCS, result); copyResult.push_back(result); return ret; } ret = proxy->Copy(sourceUri, destUri, copyResult, force); if (ret != ERR_OK) { - HILOG_ERROR("Copy error, code:%{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); if ((ret == COPY_EXCEPTION) || (ret == COPY_NOEXCEPTION)) { HILOG_ERROR("Copy exception, code:%{public}d", ret); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; } - CopyResult result { "", "", ret, ""}; + HILOG_ERROR("Copy error, code:%{public}d", ret); + CopyResult result { "", "", ret, "" }; + ret = TranslateCopyResult(ret, result); copyResult.push_back(result); - return COPY_EXCEPTION; + return ret; } FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; @@ -720,29 +759,38 @@ int FileAccessHelper::Copy(Uri &sourceUri, Uri &destUri, std::vector { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); if (!IsSystemApp()) { - HILOG_ERROR("FileAccessHelper::Copy check IsSystemAppByFullTokenID failed"); + HILOG_ERROR("Copy check IsSystemAppByFullTokenID failed"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - CopyResult result { sourceUri.ToString(), destUri.ToString(), E_PERMISSION_SYS, "" }; - copyResult.push_back(result); - return COPY_EXCEPTION; + return GetCopyResult("", "", E_PERMISSION_SYS, "", copyResult); } if (!CheckUri(sourceUri) || !CheckUri(destUri)) { HILOG_ERROR("Uri format check error"); FinishTrace(HITRACE_TAG_FILEMANAGEMENT); - CopyResult result { sourceUri.ToString(), destUri.ToString(), E_URIS, "" }; - copyResult.push_back(result); + return GetCopyResult("", "", E_URIS, "", copyResult); + } + + bool isDir = false; + int ret = IsDirectory(destUri, isDir); + if (ret != ERR_OK) { + HILOG_ERROR("Get uri type error"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + GetCopyResult("", "", ret, "", copyResult); return COPY_EXCEPTION; } + if (!isDir) { + HILOG_ERROR("Destination uri is not directory"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return GetCopyResult("", "", E_URIS, "", copyResult); + } - int ret = COPY_EXCEPTION; - if (IsMediaUri(sourceUri) && IsMediaUri(destUri)) { + ret = COPY_EXCEPTION; + if ((IsMediaUri(sourceUri) && IsMediaUri(destUri)) + || (IsExternalUri(sourceUri) && IsExternalUri(destUri))) { ret = CopyInsideService(sourceUri, destUri, copyResult, force); } else { - HILOG_ERROR("External storage copy is not supported."); - CopyResult result { sourceUri.ToString(), destUri.ToString(), EPERM, "" }; - copyResult.push_back(result); - return COPY_NOEXCEPTION; + HILOG_ERROR("Unsupported copy service, invalid uri"); + return GetCopyResult("", "", E_URIS, "", copyResult); } FinishTrace(HITRACE_TAG_FILEMANAGEMENT); return ret; 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 694d86b05e2248520aee5a06cecde5e523fa0342..9adef443850a330361fd09b66e366126943fb1e8 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 @@ -32,6 +32,7 @@ #include "napi_common_util.h" #include "napi_common_want.h" #include "napi_remote_object.h" +#include "n_error.h" namespace OHOS { namespace FileAccessFwk { @@ -42,10 +43,13 @@ namespace { constexpr size_t ARGC_THREE = 3; constexpr size_t ARGC_FOUR = 4; constexpr size_t MAX_ARG_COUNT = 5; + constexpr int COPY_EXCEPTION = -1; + constexpr int COPY_NOEXCEPTION = -2; } using namespace OHOS::AppExecFwk; using namespace OHOS::AbilityRuntime; +using namespace OHOS::FileManagement::LibN; using OHOS::Security::AccessToken::AccessTokenKit; struct FilterParam { @@ -590,6 +594,126 @@ int JsFileAccessExtAbility::Move(const Uri &sourceFile, const Uri &targetParent, return ERR_OK; } +static void TranslateCopyResult(CopyResult ©Result) +{ + if (errCodeTable.find(copyResult.errCode) != errCodeTable.end()) { + copyResult.errCode = errCodeTable.at(copyResult.errCode).first; + if (copyResult.errMsg.empty()) { + copyResult.errMsg = errCodeTable.at(copyResult.errCode).second; + } + } +} + +static bool ParserGetJsCopyResult(NativeEngine &engine, NativeValue *nativeValue, + std::vector ©Result, int ©Ret) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ParserGetJsCopyResult"); + if (nativeValue == nullptr) { + HILOG_ERROR("---------------- nativeValue is nullptr ---------------- "); + } + NativeObject *obj = ConvertNativeValueTo(nativeValue); + if (obj == nullptr) { + HILOG_ERROR("Convert js object fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + + bool ret = ConvertFromJsValue(engine, obj->GetProperty("code"), copyRet); + if (!ret) { + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + HILOG_ERROR("Convert js value fail."); + return false; + } + HILOG_ERROR("copyRet == %{public}d", copyRet); + if (copyRet == ERR_OK) { + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + HILOG_ERROR("copyRet == ERR_OK"); + return true; + } + + NativeArray *nativeArray = ConvertNativeValueTo(obj->GetProperty("results")); + if (nativeArray == nullptr) { + HILOG_ERROR("nativeArray is nullptr"); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + + for (uint32_t i = 0; i < nativeArray->GetLength(); i++) { + NativeValue *nativeCopyResult = nativeArray->GetElement(i); + if (nativeCopyResult == nullptr) { + HILOG_ERROR("get native FileInfo fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + + obj = ConvertNativeValueTo(nativeCopyResult); + if (obj == nullptr) { + HILOG_ERROR("Convert js object fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return false; + } + + CopyResult result; + if (copyRet == COPY_NOEXCEPTION) { + ret = ret && ConvertFromJsValue(engine, obj->GetProperty("sourceUri"), result.sourceUri); + ret = ret && ConvertFromJsValue(engine, obj->GetProperty("destUri"), result.destUri); + } + if ((copyRet == COPY_NOEXCEPTION) || (copyRet == COPY_EXCEPTION)) { + ret = ret && ConvertFromJsValue(engine, obj->GetProperty("errCode"), result.errCode); + } + if (!ret) { + HILOG_ERROR("Convert js value fail."); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return ret; + } + + TranslateCopyResult(result); + copyResult.push_back(result); + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return true; +} + +int JsFileAccessExtAbility::Copy(const Uri &sourceUri, const Uri &destUri, std::vector ©Result, + bool force) +{ + StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Copy"); + auto argParser = [sourceUri, destUri, force](NativeEngine &engine, NativeValue* argv[], size_t &argc) -> bool { + NativeValue *srcNativeUri = engine.CreateString(sourceUri.ToString().c_str(), + sourceUri.ToString().length()); + NativeValue *dstNativeUri = engine.CreateString(destUri.ToString().c_str(), destUri.ToString().length()); + NativeValue *forceCopy = engine.CreateBoolean(force); + if (srcNativeUri == nullptr || dstNativeUri == nullptr || forceCopy == nullptr) { + HILOG_ERROR("create arguments native js value fail."); + return false; + } + argv[ARGC_ZERO] = srcNativeUri; + argv[ARGC_ONE] = dstNativeUri; + argv[ARGC_TWO] = forceCopy; + argc = ARGC_THREE; + return true; + }; + + int copyRet = COPY_EXCEPTION; + auto retParser = [©Result, ©Ret](NativeEngine &engine, NativeValue *result) -> bool { + return ParserGetJsCopyResult(engine, result, copyResult, copyRet); + }; + + auto errCode = CallJsMethod("copy", jsRuntime_, jsObj_.get(), argParser, retParser); + if (errCode != ERR_OK) { + HILOG_ERROR("CallJsMethod error, code:%{public}d.", errCode); + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + CopyResult result { "", "", errCode, ""}; + TranslateCopyResult(result); + copyResult.push_back(result); + return COPY_EXCEPTION; + } + + FinishTrace(HITRACE_TAG_FILEMANAGEMENT); + return copyRet; +} + int JsFileAccessExtAbility::Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile) { StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Rename"); 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 b4cb8deaa1eae4ce6873d349483759cbd272864d..edbe9641384b3611dce4ad795217aac26a77ef63 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 @@ -29,9 +29,13 @@ const FILE_PREFIX_NAME = 'file://'; const TAG = 'ExternalFileManager'; const ERR_OK = 0; const ERR_ERROR = -1; -const E_EXIST = 13900015; -const ERR_PERM = 13900001; +const COPY_EXCEPTION = -1; +const COPY_NOEXCEPTION = -2; +const E_PERM = 13900001; const E_NOEXIST = 13900002; +const E_FAULT = 13900013; +const E_EXIST = 13900015; +const E_INVAL = 13900020; const E_URIS = 14300002; const E_GETRESULT = 14300004; const CREATE_EVENT_CODE = 0x00000100; @@ -379,7 +383,7 @@ export default class FileExtAbility extends Extension { //Cross device move not currently supported return { uri: '', - code: ERR_PERM, + code: E_PERM, }; } catch (e) { hilog.error(DOMAIN_CODE, TAG, 'move error ' + e.message); @@ -424,6 +428,199 @@ export default class FileExtAbility extends Extension { } } + getCopyReturnValue(sourceUri, destUri, errCode, errMsg, ret) { + let copyResult = [ + { + sourceUri: sourceUri, + destUri: destUri, + errCode: errCode, + errMsg: errMsg, + }, + ]; + return { + results: copyResult, + code: ret, + }; + } + + checkCopyArguments(sourceFileUri, targetParentUri) { + if (!this.checkUri(sourceFileUri) || !this.checkUri(targetParentUri)) { + hilog.error(DOMAIN_CODE, TAG, 'check arguments error, invalid arguments'); + return this.getCopyReturnValue('', '', E_URIS, '', COPY_EXCEPTION); + } + + let displayName = this.getFileName(sourceFileUri); + let newFileOrDirUri = this.genNewFileUri(targetParentUri, displayName); + let oldPath = getPath(sourceFileUri); + let newPath = getPath(newFileOrDirUri); + if (oldPath === newPath) { + hilog.error(DOMAIN_CODE, TAG, 'the source and target files are the same file'); + return this.getCopyReturnValue(sourceFileUri, targetParentUri, E_INVAL, '', COPY_NOEXCEPTION); + } else if (newPath.indexOf(oldPath) === 0) { + hilog.error(DOMAIN_CODE, TAG, 'copy to a subdirectory of the source directory'); + return this.getCopyReturnValue('', '', E_FAULT, '', COPY_EXCEPTION); + } + + try { + let isExist = fs.accessSync(oldPath); + if (!isExist) { + hilog.error(DOMAIN_CODE, TAG, 'source uri is not exist, invalid arguments'); + return this.getCopyReturnValue(sourceFileUri, '', E_INVAL, '', COPY_NOEXCEPTION); + } + + let stat = fs.statSync(getPath(targetParentUri)); + if (!stat || !stat.isDirectory()) { + hilog.error(DOMAIN_CODE, TAG, 'target is not directory, invalid arguments'); + return this.getCopyReturnValue('', targetParentUri, E_INVAL, '', COPY_NOEXCEPTION); + } + } catch (e) { + hilog.error(DOMAIN_CODE, TAG, 'copy error ' + e.message); + return this.getCopyReturnValue('', '', e.code, '', COPY_EXCEPTION); + } + return { + results: [], + code: ERR_OK, + } + } + + processCopyReturnValue(ret, copyRet) + { + if (ret.code == COPY_EXCEPTION) { + copyRet = ret; + } + if (ret.code == COPY_NOEXCEPTION) { + for (let index in ret.results) { + copyRet.results.push(ret.results[index]); + } + copyRet.code = ret.code; + } + } + + copyFile(sourceFilePath, newFilePath): {[], number} { + let copyRet = { + results: [], + code: ERR_OK, + }; + // open 获取两个fd + let srcFile = fs.openSync(sourceFilePath, fs.OpenMode.READ_ONLY); + let newFile = fs.openSync(newFilePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); + try { + hilog.error(DOMAIN_CODE, TAG, "copyFileSync begin"); + hilog.error(DOMAIN_CODE, TAG, 'srcFd: ' + srcFile.fd + ', newFd: ' + newFile.fd); + //fs.copyFileSync(sourceFilePath, newFilePath); + fs.copyFileSync(srcFile.fd, newFile.fd); + hilog.error(DOMAIN_CODE, TAG, "copyFileSync end"); + fs.closeSync(srcFile); + fs.closeSync(newFile); + } catch (err) { + hilog.error(DOMAIN_CODE, TAG, 'copyFileSync failed with error message: ' + err.message + ', error code: ' + err.code); + fs.closeSync(srcFile); + fs.closeSync(newFIle); + return this.getCopyReturnValue(sourceFileUri, '', err.code, err.message, COPY_EXCEPTION); + } + hilog.error(DOMAIN_CODE, TAG, "copyFile copyRet.code: " + copyRet.code); + return copyRet; + } + + copyDirectory(sourceFilePath, targetFilePath, mode): {[], number} { + let copyRet = { + results: [], + code: ERR_OK, + }; + try { + hilog.error(DOMAIN_CODE, TAG, "--------------copyDir begin--------------"); + //await fs.copyDir(sourceFilePath, targetFilePath, mode); + fs.copyDirSync(sourceFilePath, targetFilePath, mode); + hilog.error(DOMAIN_CODE, TAG, "--------------copyDir end--------------"); + } catch (err) { + if (err.code === E_EXIST) { + for (let i = 0; i < err.data.length; i++) { + hilog.error(DOMAIN_CODE, TAG, "copy directory failed with conflicting files: " + err.data[i].srcFile + " " + err.data[i].destFile); + let ret = this.getCopyReturnValue(err.data[i].srcFile, err.data[i].destFile, err.code, err.message, COPY_NOEXCEPTION); + this.processCopyReturnValue(ret, copyRet); + } + return copyRet; + } + hilog.error(DOMAIN_CODE, TAG, 'copy directory failed with error message: ' + err.message + ', error code: ' + err.code); + return this.getCopyReturnValue(sourceFileUri, '', err.code, err.message, COPY_EXCEPTION); + } + hilog.error(DOMAIN_CODE, TAG, "copyDir copyRet.code: " + copyRet.code); + return copyRet; + // fs.copyDir(sourceFilePath, targetFilePath, mode).then(() => { + // hilog.error(DOMAIN_CODE, TAG, "copy directory succeed"); + // hilog.error(DOMAIN_CODE, TAG, "copyRet.code: " + copyRet.code); + // return copyRet; + // }).catch((err) => { + // if (err.code === E_EXIST) { + // hilog.error(DOMAIN_CODE, TAG, "copyDir err.code: E_EXIST"); + // for (let i = 0; i < err.data.length; i++) { + // hilog.error(DOMAIN_CODE, TAG, "copy directory failed with conflicting files: " + err.data[i].srcFile + " " + err.data[i].destFile); + // let ret = this.getCopyReturnValue(err.data[i].srcFile, err.data[i].destFile, err.code, err.message, COPY_NOEXCEPTION); + // this.processCopyReturnValue(ret, copyRet); + // } + // return copyRet; + // } else { + // hilog.error(DOMAIN_CODE, TAG, 'copy directory failed with error message: ' + err.message + ', error code: ' + err.code); + // return this.getCopyReturnValue(sourceFileUri, '', err.code, err.message, COPY_EXCEPTION); + // } + // }); + } + + copy(sourceFileUri, targetParentUri, force) { + hilog.error(DOMAIN_CODE, TAG, 'sourceFileUri: ' + sourceFileUri + ' targetParentUri: ' + targetParentUri); + let checkRet= this.checkCopyArguments(sourceFileUri, targetParentUri); + if (checkRet.code != ERR_OK) { + return checkRet; + } + + hilog.error(DOMAIN_CODE, TAG, 'copy enter'); + let sourceFilePath = getPath(sourceFileUri); + let targetFilePath = getPath(targetParentUri); + let displayName = this.getFileName(sourceFileUri); + let newFileOrDirUri = this.genNewFileUri(targetParentUri, displayName); + let newFilePath = getPath(newFileOrDirUri); + hilog.error(DOMAIN_CODE, TAG, 'newFilePath: ' + newFilePath); + let isExist = fs.accessSync(newFilePath); + if (isExist && force === false) { + return this.getCopyReturnValue(sourceFileUri, '', E_EXIST, '', COPY_NOEXCEPTION); + } + + hilog.error(DOMAIN_CODE, TAG, 'sourceFilePath: ' + sourceFilePath + ' targetFilePath: ' + targetFilePath); + let stat = fs.statSync(sourceFilePath); + if (stat.isFile()) { // 源是文件 + return this.copyFile(sourceFilePath, newFilePath); + } else if (stat.isDirectory()) { // 源是目录 + let mode = force ? 1 : 0; + let copyRet = this.copyDirectory(sourceFilePath, targetFilePath, mode); + hilog.error(DOMAIN_CODE, TAG, "--------------this.copyDir end--------------"); + return copyRet; + + // let mode = force ? 1 : 0; + // fs.copyDir(sourceFilePath, targetFilePath, mode, (err) => { + // hilog.error(DOMAIN_CODE, TAG, "--------------copyDir end--------------"); + // if (err && err.code === E_EXIST) { + // hilog.error(DOMAIN_CODE, TAG, "copyDir err.code: E_EXIST"); + // for (let i = 0; i < err.data.length; i++) { + // hilog.error(DOMAIN_CODE, TAG, "copy directory failed with conflicting files: " + err.data[i].srcFile + " " + err.data[i].destFile); + // let ret = this.getCopyReturnValue(err.data[i].srcFile, err.data[i].destFile, err.code, err.message, COPY_NOEXCEPTION); + // this.processCopyReturnValue(ret, copyRet); + // } + // return copyRet; + // } else if (err) { + // hilog.error(DOMAIN_CODE, TAG, 'copy directory failed with error message: ' + err.message + ', error code: ' + err.code); + // return this.getCopyReturnValue(sourceFileUri, '', err.code, err.message, COPY_EXCEPTION); + // } else { + // hilog.error(DOMAIN_CODE, TAG, "copy directory succeed"); + // hilog.error(DOMAIN_CODE, TAG, "copyRet.code: " + copyRet.code);// 没有输出 + // return copyRet; + // } + // }); + } else { + hilog.error(DOMAIN_CODE, TAG, "the copy operation is not permitted"); + return this.getCopyReturnValue(sourceFileUri, targetFilePath, E_PERM, '', COPY_EXCEPTION); + } + } + access(sourceFileUri): {boolean, number} { sourceFileUri = this.decode(sourceFileUri); if (sourceFileUri === '') { @@ -732,4 +929,4 @@ export default class FileExtAbility extends Extension { } return ERR_OK; } -}; \ No newline at end of file +}; diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index abea929a5b10b92b91e86deca923d64da02354ca..8deeb4fb1a9c9c12d2744c8df10b06371fd0fdc9 100755 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -94,6 +94,8 @@ ohos_unittest("external_file_access_test") { "ipc_js:rpc", "samgr:samgr_proxy", ] + resource_config_file = + "${user_file_service_path}/test/unittest/resources/ohos_test.xml" } ohos_unittest("abnormal_file_access_test") { diff --git a/test/unittest/external_file_access_test.cpp b/test/unittest/external_file_access_test.cpp index 43b1ef943d053548ff6f7cfefde96168fc71dbb5..ff56b206d1632a58ed5c0574556067c440a9d196 100644 --- a/test/unittest/external_file_access_test.cpp +++ b/test/unittest/external_file_access_test.cpp @@ -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,7 +111,7 @@ public: void SetUp(){}; void TearDown(){}; }; - +#if 0 /** * @tc.number: user_file_service_external_file_access_OpenFile_0000 * @tc.name: external_file_access_OpenFile_0000 @@ -1689,7 +1689,7 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0009, testing::ext:: result = g_fah->Mkdir(parentUri, "test2", newDirUriTest2); EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); Uri testUri(""); - size_t fileNumbers = 2000; + size_t fileNumbers = 2; for (size_t j = 0; j < fileNumbers; j++) { string fileName = "test" + ToString(j) + ".txt"; result = g_fah->CreateFile(newDirUriTest1, fileName, testUri); @@ -2025,7 +2025,530 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Move_0016, testing::ext:: } GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Move_0016"; } +#endif + +/** + * @tc.number: user_file_service_external_file_access_Copy_0000 + * @tc.name: external_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: TODO: 换成Issue编号 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0000_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0000_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult, false); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + Uri destFileUri(destDir.ToString() + "/" + "a.txt"); + GTEST_LOG_(ERROR) << "-------------------- destFileUri : " << destFileUri.ToString(); + result = g_fah->OpenFile(destFileUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, destFileSize); + close(fd); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0000 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0000"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0001 + * @tc.name: external_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: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_0001"; + try { + vector info; + int result = g_fah->GetRoots(info); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + GTEST_LOG_(ERROR) << "-------------------- RootInfo.size(): " << info.size(); + for (size_t i = 0; i < info.size(); i++) { + GTEST_LOG_(ERROR) << "-------------------- RootInfo uri: " << info[i].uri; + Uri parentUri(info[i].uri); + Uri srcDir(""); + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0001_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd = -1; + result = g_fah->OpenFile(aUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t aFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(aFileSize, sizeof(buff)); + close(fd); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->Mkdir(parentUri, "Copy_0001_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, false); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0001 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0001"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0002 + * @tc.name: external_file_access_Copy_0002 + * @tc.desc: Test function of Copy interface, copy a empty directory + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0002, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0002_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0002_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, false); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0002 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0002"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0003 + * @tc.name: external_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: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0003, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0003_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0003_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri existFile(""); + result = g_fah->CreateFile(destDir, "a.txt", existFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult, true); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + result = g_fah->OpenFile(existFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, destFileSize); + close(fd); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0003 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0003"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0004 + * @tc.name: external_file_access_Copy_0004 + * @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: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0004, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0004_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0004_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri existFile(""); + result = g_fah->CreateFile(destDir, "a.txt", existFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult, false); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 1); + + result = g_fah->OpenFile(existFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(destFileSize, 0); + close(fd); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0004 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0004"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0005 + * @tc.name: external_file_access_Copy_0005 + * @tc.desc: Test function of Copy interface, copy a file with the same name and no force argument + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0005, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0005_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri srcFile(""); + result = g_fah->CreateFile(srcDir, "a.txt", srcFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(srcFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for a.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0005_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri existFile(""); + result = g_fah->CreateFile(destDir, "a.txt", existFile); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcFile, destDir, copyResult); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_GT(copyResult.size(), 0); + + result = g_fah->OpenFile(existFile, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + ssize_t destFileSize = read(fd, buff, sizeof(buff)); + EXPECT_EQ(destFileSize, 0); + close(fd); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0005 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0005"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0006 + * @tc.name: external_file_access_Copy_0006 + * @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: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0006, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0006_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + int fd; + result = g_fah->OpenFile(bUri, WRITE_READ, fd); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + char buff[] = "Copy test content for b.txt"; + ssize_t srcFileSize = write(fd, buff, sizeof(buff)); + EXPECT_EQ(srcFileSize, sizeof(buff)); + close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0006_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destSrcDir(""); + result = g_fah->Mkdir(destDir, "Copy_0006_src", destSrcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->CreateFile(destSrcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, true); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 0); + + // result = g_fah->OpenFile(bUri, WRITE_READ, fd); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // ssize_t destFileSize = read(fd, buff, sizeof(buff)); + // EXPECT_EQ(destFileSize, srcFileSize); + // close(fd); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0006 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0006"; +} + +#if 0 +/** + * @tc.number: user_file_service_external_file_access_Copy_0007 + * @tc.name: external_file_access_Copy_0007 + * @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: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0007, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0007_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // int fd; + // result = g_fah->OpenFile(bUri, WRITE_READ, fd); + // EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + // char buff[] = "Copy test content for b.txt"; + // ssize_t bFileSize = write(fd, buff, sizeof(buff)); + // EXPECT_EQ(bFileSize, sizeof(buff)); + // close(fd); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0007_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destSrcDir(""); + result = g_fah->Mkdir(destDir, "Copy_0007_src", destSrcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->CreateFile(destSrcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult, false); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 1); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0007 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0007"; +} + +/** + * @tc.number: user_file_service_external_file_access_Copy_0008 + * @tc.name: external_file_access_Copy_0008 + * @tc.desc: Test function of Copy interface, copy a directory with the same name and no force argument + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0387 + */ +HWTEST_F(FileExtensionHelperTest, external_file_access_Copy_0008, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileExtensionHelperTest-begin external_file_access_Copy_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 srcDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0008_src", srcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri aUri(""); + result = g_fah->CreateFile(srcDir, "a.txt", aUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri bUri(""); + result = g_fah->CreateFile(srcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + Uri destDir(""); + result = g_fah->Mkdir(parentUri, "Copy_0008_dest", destDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + Uri destSrcDir(""); + result = g_fah->Mkdir(destDir, "Copy_0008_src", destSrcDir); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + result = g_fah->CreateFile(destSrcDir, "b.txt", bUri); + EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + + std::vector copyResult; + result = g_fah->Copy(srcDir, destDir, copyResult); + EXPECT_NE(result, OHOS::FileAccessFwk::ERR_OK); + EXPECT_EQ(copyResult.size(), 1); + + //result = g_fah->Delete(srcDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + //result = g_fah->Delete(destDir); + //EXPECT_EQ(result, OHOS::FileAccessFwk::ERR_OK); + } + } catch (...) { + GTEST_LOG_(ERROR) << "external_file_access_Copy_0008 occurs an exception."; + } + GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Copy_0008"; +} +#endif +#if 0 /** * @tc.number: user_file_service_external_file_access_Rename_0000 * @tc.name: external_file_access_Rename_0000 @@ -3901,4 +4424,5 @@ HWTEST_F(FileExtensionHelperTest, external_file_access_Query_0007, testing::ext: } GTEST_LOG_(INFO) << "FileExtensionHelperTest-end external_file_access_Query_0007"; } -} // namespace \ No newline at end of file +#endif +} // namespace diff --git a/test/unittest/resources/ohos_test.xml b/test/unittest/resources/ohos_test.xml index ba2271adff50c7cbff6e6e9281c241d490b3f7aa..9f60bc56f56897f5838e967ac35d7617338b5ae7 100644 --- a/test/unittest/resources/ohos_test.xml +++ b/test/unittest/resources/ohos_test.xml @@ -34,4 +34,11 @@