From 295fe4b57bd9189c556dbba386c4a13cf74e0fe3 Mon Sep 17 00:00:00 2001 From: onexiaomin Date: Fri, 9 Dec 2022 02:24:49 +0800 Subject: [PATCH] add unit test Description: add unit test Sig:OpenHarmony/filemanagement_user_file_service Feature or Bugfix:Feature Binary Source: No Signed-off-by: onexiaomin --- .../test/mock/mock_i_remote_object.h | 82 + .../test/mock/mock_message_parcel.cpp | 318 +++ .../file_access/test/mock/parcel_assist.h | 243 ++ .../file_access/test/mock/utils_log.h | 51 + .../file_access/test/unittest/BUILD.gn | 1 + .../unittest/file_access_unit_test/BUILD.gn | 56 + .../file_access_ext_proxy_test.cpp | 2124 +++++++++++++++++ 7 files changed, 2875 insertions(+) create mode 100644 frameworks/innerkits/file_access/test/mock/mock_i_remote_object.h create mode 100644 frameworks/innerkits/file_access/test/mock/mock_message_parcel.cpp create mode 100644 frameworks/innerkits/file_access/test/mock/parcel_assist.h create mode 100644 frameworks/innerkits/file_access/test/mock/utils_log.h create mode 100644 frameworks/innerkits/file_access/test/unittest/file_access_unit_test/BUILD.gn create mode 100644 frameworks/innerkits/file_access/test/unittest/file_access_unit_test/file_access_ext_proxy_test.cpp diff --git a/frameworks/innerkits/file_access/test/mock/mock_i_remote_object.h b/frameworks/innerkits/file_access/test/mock/mock_i_remote_object.h new file mode 100644 index 00000000..7d247e6f --- /dev/null +++ b/frameworks/innerkits/file_access/test/mock/mock_i_remote_object.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FILE_ACCESS_MOCK_I_REMOTE_OBJECT_H +#define FILE_ACCESS_MOCK_I_REMOTE_OBJECT_H + +#include "gmock/gmock.h" + +#include "iremote_broker.h" +#include "iremote_object.h" + +namespace OHOS { +namespace FileAccessFwk { +class MockIRemoteObject : public IRemoteObject { +public: + MockIRemoteObject() : IRemoteObject(u"mock_i_remote_object") {} + + ~MockIRemoteObject() {} + + int32_t GetObjectRefCount() override + { + return 0; + } + + MOCK_METHOD4(SendRequest, int(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)); + + bool IsProxyObject() const override + { + return true; + } + + bool CheckObjectLegality() const override + { + return true; + } + + bool AddDeathRecipient(const sptr &recipient) override + { + return true; + } + + bool RemoveDeathRecipient(const sptr &recipient) override + { + return true; + } + + bool Marshalling(Parcel &parcel) const override + { + return true; + } + + sptr AsInterface() override + { + return nullptr; + } + + int Dump(int fd, const std::vector &args) override + { + return 0; + } + + std::u16string GetObjectDescriptor() const + { + std::u16string descriptor = std::u16string(); + return descriptor; + } +}; +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_ACCESS_MOCK_I_REMOTE_OBJECT_H diff --git a/frameworks/innerkits/file_access/test/mock/mock_message_parcel.cpp b/frameworks/innerkits/file_access/test/mock/mock_message_parcel.cpp new file mode 100644 index 00000000..be6ad5af --- /dev/null +++ b/frameworks/innerkits/file_access/test/mock/mock_message_parcel.cpp @@ -0,0 +1,318 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "file_access_framework_errno.h" +#include "iremote_object.h" +#include "message_parcel.h" +#include "parcel_assist.h" +#include "utils_log.h" + +namespace OHOS { + +using namespace FileAccessFwk; + +static const size_t DEFAULT_CPACITY = 204800; // 200K + +std::queue g_queue; + +std::queue& FileAccessFwk::GetParamQueue() +{ + return g_queue; +} + +Parcelable::Parcelable() : Parcelable(false) {} + +Parcelable::Parcelable(bool asRemote) +{ + asRemote_ = asRemote; + behavior_ = 0; +} + +Parcel::Parcel(Allocator *allocator) +{ + if (allocator != nullptr) { + allocator_ = allocator; + } else { + allocator_ = new DefaultAllocator(); + } + + writeCursor_ = 0; + readCursor_ = 0; + + data_ = nullptr; + dataSize_ = 0; + dataCapacity_ = 0; + + maxDataCapacity_ = DEFAULT_CPACITY; + objectOffsets_ = nullptr; + objectCursor_ = 0; + objectsCapacity_ = 0; +} + +Parcel::Parcel() : Parcel(new DefaultAllocator()) {} + +Parcel::~Parcel() +{ + FlushBuffer(); + delete allocator_; +} + +void *DefaultAllocator::Alloc(size_t size) +{ + return malloc(size); +} + +void DefaultAllocator::Dealloc(void *data) +{ + if (data != nullptr) { + free(data); + } +} + +void *DefaultAllocator::Realloc(void *data, size_t newSize) +{ + return realloc(data, newSize); +} + +void Parcel::FlushBuffer() +{ + if (allocator_ == nullptr) { + return; + } + + if (data_ != nullptr) { + allocator_->Dealloc(data_); + dataSize_ = 0; + writeCursor_ = 0; + readCursor_ = 0; + dataCapacity_ = 0; + data_ = nullptr; + } + + if (objectOffsets_) { + objectHolder_.clear(); + free(objectOffsets_); + objectCursor_ = 0; + objectOffsets_ = nullptr; + objectsCapacity_ = 0; + } +} + +bool Parcel::EnsureWritableCapacity(size_t desireCapacity) +{ + if (!writable_) { + UTILS_LOGW("this parcel data is alloc by driver, which is can not be writen"); + return false; + } + if (desireCapacity <= GetWritableBytes()) { + return true; + } + + size_t minNewCapacity = desireCapacity + writeCursor_; + size_t newCapacity = CalcNewCapacity(minNewCapacity); + if ((newCapacity <= dataCapacity_) || (newCapacity < minNewCapacity)) { + UTILS_LOGW( + "Failed to ensure parcel capacity, newCapacity = %{public}zu, dataCapacity_ = %{public}zu, " + "minNewCapacity = %{public}zu", + newCapacity, dataCapacity_, minNewCapacity); + return false; + } + + if (allocator_ != nullptr) { + void *newData = allocator_->Realloc(data_, newCapacity); + if (newData != nullptr) { + data_ = reinterpret_cast(newData); + dataCapacity_ = newCapacity; + return true; + } + UTILS_LOGW("Failed to realloc parcel capacity, newCapacity = %{public}zu, dataCapacity_ = %{public}zu", + newCapacity, dataCapacity_); + } + + return false; +} + +size_t Parcel::GetWritableBytes() const +{ + if (dataCapacity_ > writeCursor_) { + return dataCapacity_ - writeCursor_; + } + + return 0; +} + +size_t Parcel::GetReadableBytes() const +{ + if (dataSize_ > readCursor_) { + return dataSize_ - readCursor_; + } + + return 0; +} + +template +bool Parcel::Write(T value) +{ + size_t desireCapacity = sizeof(T); + if (EnsureWritableCapacity(desireCapacity)) { + *reinterpret_cast(data_ + writeCursor_) = value; + writeCursor_ += desireCapacity; + dataSize_ += desireCapacity; + return true; + } + + return false; +} + +bool Parcel::ReadInt32(int32_t &value) +{ + if (g_queue.empty()) { + return false; + } + + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + value = parcelAssist.GetInt32(); + void *tVal = parcelAssist.ReturnT(); + if (!tVal) { + return parcelAssist.ReturnBool(); + } + + Parcelable *object = reinterpret_cast(tVal); + if (!object->asRemote_ && !Write(1)) { + return parcelAssist.ReturnBool(); + } + if (!Write(1)) { + return parcelAssist.ReturnBool(); + } + if (!WriteRemoteObject(object)) { + return parcelAssist.ReturnBool(); + } + return parcelAssist.ReturnBool(); +} + +bool Parcel::WriteInt32(int32_t value) +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnBool(); + } + return false; +} + +bool Parcel::WriteString(const std::string &value) +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnBool(); + } + return false; +} + +bool Parcel::WriteUint32(uint32_t value) +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnBool(); + } + return false; +} + +int32_t Parcel::ReadInt32() +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnInt32(); + } + return -1; +} + +bool Parcel::WriteParcelable(const Parcelable *) +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnBool(); + } + return false; +} + +uint64_t Parcel::ReadUint64() +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnUInt64(); + } + return -1; +} + +int64_t Parcel::ReadInt64() +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnInt64(); + } + return -1; +} + +bool Parcel::ReadInt64(int64_t &value) +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnBool(); + } + return false; +} + +bool Parcel::WriteInt64(int64_t value) +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnBool(); + } + return false; +} + +int MessageParcel::ReadFileDescriptor() +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnFileDescriptor(); + } + return -1; +} + +bool MessageParcel::WriteInterfaceToken(std::u16string name) +{ + if (g_queue.size()) { + ParcelAssist parcelAssist = g_queue.front(); + g_queue.pop(); + return parcelAssist.ReturnBool(); + } + return false; +} + +} // namespace OHOS diff --git a/frameworks/innerkits/file_access/test/mock/parcel_assist.h b/frameworks/innerkits/file_access/test/mock/parcel_assist.h new file mode 100644 index 00000000..138973af --- /dev/null +++ b/frameworks/innerkits/file_access/test/mock/parcel_assist.h @@ -0,0 +1,243 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FILE_ACCESS_PARCEL_ASSIST_H +#define FILE_ACCESS_PARCEL_ASSIST_H + +#include "gmock/gmock.h" +#include + +namespace OHOS { +namespace FileAccessFwk { + +class ParcelAssist { +public: + bool ReturnBool() + { + return retVal.vBool; + } + int8_t ReturnInt8() + { + return retVal.vInt8; + } + int16_t ReturnInt16() + { + return retVal.vInt16; + } + int32_t ReturnInt32() + { + return retVal.vInt32; + } + int64_t ReturnInt64() + { + return retVal.vInt64; + } + uint8_t ReturnUInt8() + { + return retVal.vUInt8; + } + uint16_t ReturnUInt16() + { + return retVal.vUInt16; + } + uint32_t ReturnUInt32() + { + return retVal.vUInt32; + } + uint64_t ReturnUInt64() + { + return retVal.vUInt64; + } + ParcelAssist &ReturnBool(bool value) + { + retVal.vBool = value; + return *this; + } + ParcelAssist &ReturnInt8(int8_t value) + { + retVal.vInt8 = value; + return *this; + } + ParcelAssist &ReturnInt16(int16_t value) + { + retVal.vInt16 = value; + return *this; + } + ParcelAssist &ReturnInt32(int32_t value) + { + retVal.vInt32 = value; + return *this; + } + ParcelAssist &ReturnInt64(int64_t value) + { + retVal.vInt64 = value; + return *this; + } + ParcelAssist &ReturnUInt8(uint8_t value) + { + retVal.vUInt8 = value; + return *this; + } + ParcelAssist &ReturnUInt16(uint16_t value) + { + retVal.vUInt16 = value; + return *this; + } + ParcelAssist &ReturnUInt32(uint32_t value) + { + retVal.vUInt32 = value; + return *this; + } + ParcelAssist &ReturnUInt64(uint64_t value) + { + retVal.vUInt64 = value; + return *this; + } + + bool GetBool() + { + return param.vBool; + } + int8_t GetInt8() + { + return param.vInt8; + } + int16_t GetInt16() + { + return param.vInt16; + } + int32_t GetInt32() + { + return param.vInt32; + } + int64_t GetInt64() + { + return param.vInt64; + } + uint8_t GetUInt8() + { + return param.vUInt8; + } + uint16_t GetUInt16() + { + return param.vUInt16; + } + uint32_t GetUInt32() + { + return param.vUInt32; + } + uint64_t GetUInt64() + { + return param.vUInt64; + } + ParcelAssist &GetBool(bool value) + { + param.vBool = value; + return *this; + } + ParcelAssist &GetInt8(int8_t value) + { + param.vInt8 = value; + return *this; + } + ParcelAssist &GetInt16(int16_t value) + { + param.vInt16 = value; + return *this; + } + ParcelAssist &GetInt32(int32_t value) + { + param.vInt32 = value; + return *this; + } + ParcelAssist &GetInt64(int64_t value) + { + param.vInt64 = value; + return *this; + } + ParcelAssist &GetUInt8(uint8_t value) + { + param.vUInt8 = value; + return *this; + } + ParcelAssist &GetUInt16(uint16_t value) + { + param.vUInt16 = value; + return *this; + } + ParcelAssist &GetUInt32(uint32_t value) + { + param.vUInt32 = value; + return *this; + } + ParcelAssist &GetUInt64(uint64_t value) + { + param.vUInt64 = value; + return *this; + } + + std::string GetString() + { + return str; + } + ParcelAssist &GetString(const std::string &value) + { + str = value; + return *this; + } + void *ReturnT() + { + return tVal; + } + ParcelAssist &WriteT(void *value) + { + tVal = value; + return *this; + } + ParcelAssist &ReturnFileDescriptor(int value) + { + retVal.vInt32 = value; + return *this; + } + int ReturnFileDescriptor() + { + return retVal.vInt32; + } + +private: + union UValue { + bool vBool; + int8_t vInt8; + int16_t vInt16; + int32_t vInt32; + int64_t vInt64; + uint8_t vUInt8; + uint16_t vUInt16; + uint32_t vUInt32; + uint64_t vUInt64; + }; + +private: + UValue retVal; + UValue param; + std::string str; + void *tVal = nullptr; +}; + +std::queue& GetParamQueue(); + +} // namespace FileAccessFwk +} // namespace OHOS +#endif // FILE_ACCESS_PARCEL_ASSIST_H diff --git a/frameworks/innerkits/file_access/test/mock/utils_log.h b/frameworks/innerkits/file_access/test/mock/utils_log.h new file mode 100644 index 00000000..c108918d --- /dev/null +++ b/frameworks/innerkits/file_access/test/mock/utils_log.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef UTILS_BASE_LOG_H +#define UTILS_BASE_LOG_H + +#ifdef CONFIG_HILOG +#include "hilog_base/log_base.h" +constexpr LogType UTILS_LOG_TYPE = LOG_CORE; +constexpr unsigned int UTILS_LOG_DOMAIN = 0xD003D00; +constexpr const char *UTILS_LOG_TAG = "utils_base"; +#define UTILS_LOGF(...) (void)HiLogBasePrint(UTILS_LOG_TYPE, LOG_FATAL, UTILS_LOG_DOMAIN, UTILS_LOG_TAG, __VA_ARGS__) +#define UTILS_LOGE(...) (void)HiLogBasePrint(UTILS_LOG_TYPE, LOG_ERROR, UTILS_LOG_DOMAIN, UTILS_LOG_TAG, __VA_ARGS__) +#define UTILS_LOGW(...) (void)HiLogBasePrint(UTILS_LOG_TYPE, LOG_WARN, UTILS_LOG_DOMAIN, UTILS_LOG_TAG, __VA_ARGS__) +#define UTILS_LOGI(...) (void)HiLogBasePrint(UTILS_LOG_TYPE, LOG_INFO, UTILS_LOG_DOMAIN, UTILS_LOG_TAG, __VA_ARGS__) +#else +#define UTILS_LOGF(...) +#define UTILS_LOGE(...) +#define UTILS_LOGW(...) +#define UTILS_LOGI(...) +#endif // CONFIG_HILOG + +#if (defined CONFIG_HILOG) && (defined CONFIG_PARCEL_DEBUG) +constexpr LogType PARCEL_LOG_TYPE = LOG_CORE; +constexpr unsigned int PARCEL_LOG_DOMAIN = 0xD003D01; +constexpr const char *PARCEL_LOG_TAG = "parcel"; +#define PARCEL_LOGF(...) \ + (void)HiLogBasePrint(PARCEL_LOG_TYPE, LOG_FATAL, PARCEL_LOG_DOMAIN, PARCEL_LOG_TAG, __VA_ARGS__) +#define PARCEL_LOGE(...) \ + (void)HiLogBasePrint(PARCEL_LOG_TYPE, LOG_ERROR, PARCEL_LOG_DOMAIN, PARCEL_LOG_TAG, __VA_ARGS__) +#define PARCEL_LOGW(...) (void)HiLogBasePrint(PARCEL_LOG_TYPE, LOG_WARN, PARCEL_LOG_DOMAIN, PARCEL_LOG_TAG, __VA_ARGS__) +#define PARCEL_LOGI(...) (void)HiLogBasePrint(PARCEL_LOG_TYPE, LOG_INFO, PARCEL_LOG_DOMAIN, PARCEL_LOG_TAG, __VA_ARGS__) +#else +#define PARCEL_LOGF(...) +#define PARCEL_LOGE(...) +#define PARCEL_LOGW(...) +#define PARCEL_LOGI(...) +#endif // (defined CONFIG_HILOG) && (defined CONFIG_PARCEL_DEBUG) + +#endif // UTILS_BASE_LOG_H diff --git a/frameworks/innerkits/file_access/test/unittest/BUILD.gn b/frameworks/innerkits/file_access/test/unittest/BUILD.gn index 3d03347d..44733a7b 100644 --- a/frameworks/innerkits/file_access/test/unittest/BUILD.gn +++ b/frameworks/innerkits/file_access/test/unittest/BUILD.gn @@ -102,5 +102,6 @@ group("user_file_service_unit_test") { deps = [ ":external_file_access_test", ":medialibrary_file_access_test", + "file_access_unit_test:unittest", ] } diff --git a/frameworks/innerkits/file_access/test/unittest/file_access_unit_test/BUILD.gn b/frameworks/innerkits/file_access/test/unittest/file_access_unit_test/BUILD.gn new file mode 100644 index 00000000..4a4bb550 --- /dev/null +++ b/frameworks/innerkits/file_access/test/unittest/file_access_unit_test/BUILD.gn @@ -0,0 +1,56 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("//foundation/filemanagement/user_file_service/filemanagement_aafwk.gni") + +BASE_DIR = "//foundation/filemanagement/user_file_service" + +ohos_unittest("file_access_unit_test") { + module_out_path = "filemanagement/user_file_service" + include_dirs = [ + "//foundation/distributeddatamgr/distributedfile/interfaces/kits/js/src/common", + "//foundation/filemanagement/user_file_service/frameworks/innerkits/file_access/include", + "//foundation/filemanagement/user_file_service/frameworks/innerkits/file_access/include/notify", + "../../mock", + "${BASE_DIR}/utils", + ] + + sources = [ + "../../mock/mock_message_parcel.cpp", + "file_access_ext_proxy_test.cpp", + ] + + deps = [ + "//foundation/filemanagement/user_file_service/frameworks/innerkits/file_access:file_access_extension_ability_kit", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:wantagent_innerkits", + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + +group("unittest") { + testonly = true + deps = [] + + deps += [ ":file_access_unit_test" ] +} diff --git a/frameworks/innerkits/file_access/test/unittest/file_access_unit_test/file_access_ext_proxy_test.cpp b/frameworks/innerkits/file_access/test/unittest/file_access_unit_test/file_access_ext_proxy_test.cpp new file mode 100644 index 00000000..d38a22a2 --- /dev/null +++ b/frameworks/innerkits/file_access/test/unittest/file_access_unit_test/file_access_ext_proxy_test.cpp @@ -0,0 +1,2124 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "file_access_ext_proxy.h" +#include "file_access_framework_errno.h" +#include "message_parcel.h" +#include "mock_i_remote_object.h" +#include "parcel_assist.h" + +namespace OHOS { + +using namespace testing; +using namespace testing::ext; +using namespace OHOS::FileAccessFwk; + +constexpr int32_t WRITE_READ = 2; +constexpr int32_t INVALID_FILEDESCRIPTOR = -1; + +std::shared_ptr g_proxy = nullptr; +sptr g_remoteObject = nullptr; + +#define EXPECT(value) FileAccessFwk::GetParamQueue().push(value) + +class FileAccessExtProxyUnitTest : public testing::Test { +public: + FileAccessExtProxyUnitTest() {} + + virtual ~FileAccessExtProxyUnitTest() {} + + static void SetUpTestCase(); + + static void TearDownTestCase(); + + void SetUp(); + + void TearDown(); +}; + +void FileAccessExtProxyUnitTest::SetUpTestCase() +{ + if (!g_remoteObject) { + g_remoteObject = new (std::nothrow) MockIRemoteObject(); + } + ASSERT_NE(nullptr, g_remoteObject); + if (!g_proxy) { + g_proxy = std::make_shared(g_remoteObject); + } +} + +void FileAccessExtProxyUnitTest::TearDownTestCase() {} + +void FileAccessExtProxyUnitTest::SetUp() +{ + GetParamQueue() = std::queue(); +} + +void FileAccessExtProxyUnitTest::TearDown() {} + +/* + * @tc.number: user_file_service_external_file_access_OpenFileTest_0100 + * @tc.name: OpenFileTest_0100 + * @tc.desc: test if FileAccessExtProxy's OpenFile function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, OpenFileTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, OpenFileTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("testfile"); + int flags = WRITE_READ; + int fd = -1; + ErrCode res = g_proxy->OpenFile(uri, flags, fd); + EXPECT_EQ(OHOS::FileAccessFwk::ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_OpenFileTest_0200 + * @tc.name: OpenFileTest_0200 + * @tc.desc: test if FileAccessExtProxy's OpenFile function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, OpenFileTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, OpenFileTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("testfile"); + int flags = WRITE_READ; + int fd = -1; + ErrCode res = g_proxy->OpenFile(uri, flags, fd); + EXPECT_EQ(OHOS::FileAccessFwk::ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_OpenFileTest_0300 + * @tc.name: OpenFileTest_0300 + * @tc.desc: test if FileAccessExtProxy's OpenFile function executed as expected in WriteInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, OpenFileTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, OpenFileTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("testfile"); + int flags = WRITE_READ; + int fd = -1; + ErrCode res = g_proxy->OpenFile(uri, flags, fd); + EXPECT_EQ(OHOS::FileAccessFwk::ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_OpenFileTest_0400 + * @tc.name: OpenFileTest_0400 + * @tc.desc: test if FileAccessExtProxy's OpenFile function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, OpenFileTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, OpenFileTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri uri("testfile"); + int flags = WRITE_READ; + int fd = -1; + ErrCode res = g_proxy->OpenFile(uri, flags, fd); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_OpenFileTest_0500 + * @tc.name: OpenFileTest_0500 + * @tc.desc: test if FileAccessExtProxy's OpenFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, OpenFileTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, OpenFileTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("testfile"); + int flags = WRITE_READ; + int fd = -1; + ErrCode res = g_proxy->OpenFile(uri, flags, fd); + EXPECT_EQ(OHOS::FileAccessFwk::ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_OpenFileTest_0600 + * @tc.name: OpenFileTest_0600 + * @tc.desc: test if FileAccessExtProxy's OpenFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, OpenFileTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, OpenFileTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri uri("testfile"); + int flags = WRITE_READ; + int fd = -1; + ErrCode res = g_proxy->OpenFile(uri, flags, fd); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_OpenFileTest_0700 + * @tc.name: OpenFileTest_0700 + * @tc.desc: test if AnsManagerProxy's InnerTransact function executed as expected in ReadFileDescriptor error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, OpenFileTest_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, OpenFileTest_0700, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnFileDescriptor(INVALID_FILEDESCRIPTOR)); + + Uri uri("testfile"); + int flags = WRITE_READ; + int fd = -1; + ErrCode res = g_proxy->OpenFile(uri, flags, fd); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0100 + * @tc.name: CreateFileTest_0100 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0200 + * @tc.name: CreateFileTest_0200 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0300 + * @tc.name: CreateFileTest_0300 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in WriteString error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0400 + * @tc.name: CreateFileTest_0400 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0500 + * @tc.name: CreateFileTest_0500 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0600 + * @tc.name: CreateFileTest_0600 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0700 + * @tc.name: CreateFileTest_0700 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in uri nullptr case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0700, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnInt32(OHOS::FileAccessFwk::ERR_OK)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_CreateFileTest_0800 + * @tc.name: CreateFileTest_0800 + * @tc.desc: test if FileAccessExtProxy's CreateFile function executed as expected in uri empty case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, CreateFileTest_0800, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, CreateFileTest_0800, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + Uri uri(""); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK) + .WriteT(reinterpret_cast(&uri))); + + Uri parent("datashare:///data/test"); + std::string displayName = "testfile"; + Uri retFile(""); + ErrCode res = g_proxy->CreateFile(parent, displayName, retFile); + EXPECT_EQ(ERR_INVALID_RESULT, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0100 + * @tc.name: MkdirTest_0100 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0200 + * @tc.name: MkdirTest_0200 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0300 + * @tc.name: MkdirTest_0300 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in WriteString error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0400 + * @tc.name: MkdirTest_0400 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0500 + * @tc.name: MkdirTest_0500 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0600 + * @tc.name: MkdirTest_0600 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0700 + * @tc.name: MkdirTest_0700 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in uri nullptr case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0700, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnInt32(OHOS::FileAccessFwk::ERR_OK)); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MkdirTest_0800 + * @tc.name: MkdirTest_0800 + * @tc.desc: test if FileAccessExtProxy's Mkdir function executed as expected in uri empty case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MkdirTest_0800, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MkdirTest_0800, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + Uri uri(""); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK) + .WriteT(reinterpret_cast(&uri))); + + Uri parent("datashare:///data/test"); + std::string displayName = "testDir"; + Uri newFile(""); + ErrCode res = g_proxy->Mkdir(parent, displayName, newFile); + EXPECT_EQ(ERR_INVALID_RESULT, res); +} + +/* + * @tc.number: user_file_service_external_file_access_DeleteTest_0100 + * @tc.name: DeleteTest_0100 + * @tc.desc: test if FileAccessExtProxy's Delete function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, DeleteTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, DeleteTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + ErrCode res = g_proxy->Delete(sourceFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_DeleteTest_0200 + * @tc.name: DeleteTest_0200 + * @tc.desc: test if FileAccessExtProxy's Delete function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, DeleteTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, DeleteTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + ErrCode res = g_proxy->Delete(sourceFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_DeleteTest_0300 + * @tc.name: DeleteTest_0300 + * @tc.desc: test if FileAccessExtProxy's Delete function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, DeleteTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, DeleteTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri sourceFile("datashare:///data/test/testfile"); + ErrCode res = g_proxy->Delete(sourceFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_DeleteTest_0400 + * @tc.name: DeleteTest_0400 + * @tc.desc: test if FileAccessExtProxy's Delete function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, DeleteTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, DeleteTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + ErrCode res = g_proxy->Delete(sourceFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_DeleteTest_0500 + * @tc.name: DeleteTest_0500 + * @tc.desc: test if FileAccessExtProxy's Delete function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, DeleteTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, DeleteTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri sourceFile("datashare:///data/test/testfile"); + ErrCode res = g_proxy->Delete(sourceFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0100 + * @tc.name: MoveTest_0100 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0200 + * @tc.name: MoveTest_0200 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0300 + * @tc.name: MoveTest_0300 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0400 + * @tc.name: MoveTest_0400 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0500 + * @tc.name: MoveTest_0500 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0600 + * @tc.name: MoveTest_0600 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0700 + * @tc.name: MoveTest_0700 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in uri nullptr case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0700, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnInt32(OHOS::FileAccessFwk::ERR_OK)); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_MoveTest_0800 + * @tc.name: MoveTest_0800 + * @tc.desc: test if FileAccessExtProxy's Move function executed as expected in uri empty case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, MoveTest_0800, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, MoveTest_0800, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + Uri uri(""); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK) + .WriteT(reinterpret_cast(&uri))); + + Uri sourceFile("datashare:///data/test/testfile"); + Uri targetParent("datashare:///data/test/testDir"); + Uri retFile(""); + ErrCode res = g_proxy->Move(sourceFile, targetParent, retFile); + EXPECT_EQ(ERR_INVALID_RESULT, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0100 + * @tc.name: RenameTest_0100 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0200 + * @tc.name: RenameTest_0200 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0300 + * @tc.name: RenameTest_0300 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in WriteString error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0400 + * @tc.name: RenameTest_0400 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0500 + * @tc.name: RenameTest_0500 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0600 + * @tc.name: RenameTest_0600 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0700 + * @tc.name: RenameTest_0700 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in uri nullptr case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0700, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnInt32(OHOS::FileAccessFwk::ERR_OK)); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_RenameTest_0800 + * @tc.name: RenameTest_0800 + * @tc.desc: test if FileAccessExtProxy's Rename function executed as expected in uri empty case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, RenameTest_0800, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, RenameTest_0800, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + Uri uri(""); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK) + .WriteT(reinterpret_cast(&uri))); + + Uri sourceFile("datashare:///data/test/testfile"); + std::string displayName("testfile2"); + Uri retFile(""); + ErrCode res = g_proxy->Rename(sourceFile, displayName, retFile); + EXPECT_EQ(ERR_INVALID_RESULT, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0100 + * @tc.name: ListFileTest_0100 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0200 + * @tc.name: ListFileTest_0200 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0300 + * @tc.name: ListFileTest_0300 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in WriteInt64 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0400 + * @tc.name: ListFileTest_0400 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in WriteInt64 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0500 + * @tc.name: ListFileTest_0500 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0600 + * @tc.name: ListFileTest_0600 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0700 + * @tc.name: ListFileTest_0700 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0700, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0800 + * @tc.name: ListFileTest_0800 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0800, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0800, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ListFileTest_0900 + * @tc.name: ListFileTest_0900 + * @tc.desc: test if FileAccessExtProxy's ListFile function executed as expected in ReadInt64 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ListFileTest_0900, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ListFileTest_0900, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ListFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_INVALID_RESULT, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0100 + * @tc.name: ScanFileTest_0100 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0200 + * @tc.name: ScanFileTest_0200 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0300 + * @tc.name: ScanFileTest_0300 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in WriteInt64 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0400 + * @tc.name: ScanFileTest_0400 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in WriteInt64 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0500 + * @tc.name: ScanFileTest_0500 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0600 + * @tc.name: ScanFileTest_0600 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0700 + * @tc.name: ScanFileTest_0700 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0700, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0800 + * @tc.name: ScanFileTest_0800 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0800, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0800, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_ScanFileTest_0900 + * @tc.name: ScanFileTest_0900 + * @tc.desc: test if FileAccessExtProxy's ScanFile function executed as expected in ReadInt64 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, ScanFileTest_0900, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, ScanFileTest_0900, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + const FileInfo fileInfo; + const int64_t offset = 0; + const int64_t maxCount = 10; + const FileFilter filter; + std::vector fileInfoVec; + ErrCode res = g_proxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec); + EXPECT_EQ(ERR_INVALID_RESULT, res); +} + +/* + * @tc.number: user_file_service_external_file_access_GetRootsTest_0100 + * @tc.name: GetRootsTest_0100 + * @tc.desc: test if FileAccessExtProxy's GetRoots function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, GetRootsTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, GetRootsTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + std::vector rootInfoVec; + ErrCode res = g_proxy->GetRoots(rootInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_GetRootsTest_0200 + * @tc.name: GetRootsTest_0200 + * @tc.desc: test if FileAccessExtProxy's GetRoots function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, GetRootsTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, GetRootsTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + std::vector rootInfoVec; + ErrCode res = g_proxy->GetRoots(rootInfoVec); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_GetRootsTest_0300 + * @tc.name: GetRootsTest_0300 + * @tc.desc: test if FileAccessExtProxy's GetRoots function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, GetRootsTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, GetRootsTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + std::vector rootInfoVec; + ErrCode res = g_proxy->GetRoots(rootInfoVec); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_GetRootsTest_0400 + * @tc.name: GetRootsTest_0400 + * @tc.desc: test if FileAccessExtProxy's GetRoots function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, GetRootsTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, GetRootsTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + std::vector rootInfoVec; + ErrCode res = g_proxy->GetRoots(rootInfoVec); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_GetRootsTest_0500 + * @tc.name: GetRootsTest_0500 + * @tc.desc: test if FileAccessExtProxy's GetRoots function executed as expected in ReadUint64 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, GetRootsTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, GetRootsTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + std::vector rootInfoVec; + ErrCode res = g_proxy->GetRoots(rootInfoVec); + EXPECT_EQ(ERR_INVALID_RESULT, res); +} + +/* + * @tc.number: user_file_service_external_file_access_UriToFileInfoTest_0100 + * @tc.name: UriToFileInfoTest_0100 + * @tc.desc: test if FileAccessExtProxy's UriToFileInfo function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, UriToFileInfoTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, UriToFileInfoTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri selectFile("datashare:///data/test/testfile"); + FileInfo fileInfo; + ErrCode res = g_proxy->UriToFileInfo(selectFile, fileInfo); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_UriToFileInfoTest_0200 + * @tc.name: UriToFileInfoTest_0200 + * @tc.desc: test if FileAccessExtProxy's UriToFileInfo function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, UriToFileInfoTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, UriToFileInfoTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri selectFile("datashare:///data/test/testfile"); + FileInfo fileInfo; + ErrCode res = g_proxy->UriToFileInfo(selectFile, fileInfo); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_UriToFileInfoTest_0300 + * @tc.name: UriToFileInfoTest_0300 + * @tc.desc: test if FileAccessExtProxy's UriToFileInfo function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, UriToFileInfoTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, UriToFileInfoTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri selectFile("datashare:///data/test/testfile"); + FileInfo fileInfo; + ErrCode res = g_proxy->UriToFileInfo(selectFile, fileInfo); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_UriToFileInfoTest_0400 + * @tc.name: UriToFileInfoTest_0400 + * @tc.desc: test if FileAccessExtProxy's UriToFileInfo function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, UriToFileInfoTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, UriToFileInfoTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri selectFile("datashare:///data/test/testfile"); + FileInfo fileInfo; + ErrCode res = g_proxy->UriToFileInfo(selectFile, fileInfo); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_UriToFileInfoTest_0500 + * @tc.name: UriToFileInfoTest_0500 + * @tc.desc: test if FileAccessExtProxy's UriToFileInfo function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, UriToFileInfoTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, UriToFileInfoTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri selectFile("datashare:///data/test/testfile"); + FileInfo fileInfo; + ErrCode res = g_proxy->UriToFileInfo(selectFile, fileInfo); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_UriToFileInfoTest_0600 + * @tc.name: UriToFileInfoTest_0600 + * @tc.desc: test if FileAccessExtProxy's UriToFileInfo function executed as expected in fileInfo nullptr case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, UriToFileInfoTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, UriToFileInfoTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnInt32(OHOS::FileAccessFwk::ERR_OK)); + + Uri selectFile("datashare:///data/test/testfile"); + FileInfo fileInfo; + ErrCode res = g_proxy->UriToFileInfo(selectFile, fileInfo); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_AccessTest_0100 + * @tc.name: AccessTest_0100 + * @tc.desc: test if FileAccessExtProxy's Access function executed as expected in WriteInterfaceToken error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, AccessTest_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, AccessTest_0100, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("datashare:///data/test/testfile"); + bool isExist = false; + ErrCode res = g_proxy->Access(uri, isExist); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_AccessTest_0200 + * @tc.name: AccessTest_0200 + * @tc.desc: test if FileAccessExtProxy's Access function executed as expected in WriteParcelable error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, AccessTest_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, AccessTest_0200, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("datashare:///data/test/testfile"); + bool isExist = false; + ErrCode res = g_proxy->Access(uri, isExist); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_AccessTest_0300 + * @tc.name: AccessTest_0300 + * @tc.desc: test if FileAccessExtProxy's Access function executed as expected in SendRequest error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, AccessTest_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, AccessTest_0300, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(FileAccessFwk::ERR_PERMISSION_DENIED))); + + Uri uri("datashare:///data/test/testfile"); + bool isExist = false; + ErrCode res = g_proxy->Access(uri, isExist); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_AccessTest_0400 + * @tc.name: AccessTest_0400 + * @tc.desc: test if FileAccessExtProxy's Access function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, AccessTest_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, AccessTest_0400, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("datashare:///data/test/testfile"); + bool isExist = false; + ErrCode res = g_proxy->Access(uri, isExist); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} + +/* + * @tc.number: user_file_service_external_file_access_AccessTest_0500 + * @tc.name: AccessTest_0500 + * @tc.desc: test if FileAccessExtProxy's Access function executed as expected in ReadInt32 error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, AccessTest_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, AccessTest_0500, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(FileAccessFwk::ERR_PERMISSION_DENIED)); + + Uri uri("datashare:///data/test/testfile"); + bool isExist = false; + ErrCode res = g_proxy->Access(uri, isExist); + EXPECT_EQ(FileAccessFwk::ERR_PERMISSION_DENIED, res); +} + +/* + * @tc.number: user_file_service_external_file_access_AccessTest_0600 + * @tc.name: AccessTest_0600 + * @tc.desc: test if FileAccessExtProxy's Access function executed as expected in ReadBool error case. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H0386 + */ +HWTEST_F(FileAccessExtProxyUnitTest, AccessTest_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "FileAccessExtProxyUnitTest, AccessTest_0600, TestSize.Level1"; + ASSERT_NE(nullptr, g_proxy); + + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true)); + EXPECT_CALL(*g_remoteObject, SendRequest(_, _, _, _)).WillOnce(DoAll(Return(OHOS::FileAccessFwk::ERR_OK))); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(true).GetInt32(OHOS::FileAccessFwk::ERR_OK)); + EXPECT(FileAccessFwk::ParcelAssist().ReturnBool(false)); + + Uri uri("datashare:///data/test/testfile"); + bool isExist = false; + ErrCode res = g_proxy->Access(uri, isExist); + EXPECT_EQ(ERR_PARCEL_FAIL, res); +} +} // namespace OHOS -- Gitee