1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "copy/ipc_wrapper.h"
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "dfs_error.h"
20 #include "i_daemon_mock.h"
21 #include "message_parcel_mock.h"
22
23 #include "directory_ex.h"
24
25 namespace OHOS::Storage::DistributedFile::Test {
26 using namespace OHOS::FileManagement;
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace std;
30
31 constexpr size_t MAX_IPC_RAW_DATA_SIZE = 128 * 1024 * 1024;
32 class IpcWrapperTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38
39 static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
40 };
41
SetUpTestCase(void)42 void IpcWrapperTest::SetUpTestCase(void)
43 {
44 GTEST_LOG_(INFO) << "SetUpTestCase";
45 messageParcelMock_ = make_shared<MessageParcelMock>();
46 MessageParcelMock::messageParcel = messageParcelMock_;
47 }
48
TearDownTestCase(void)49 void IpcWrapperTest::TearDownTestCase(void)
50 {
51 GTEST_LOG_(INFO) << "TearDownTestCase";
52 messageParcelMock_ = nullptr;
53 MessageParcelMock::messageParcel = nullptr;
54 }
55
SetUp(void)56 void IpcWrapperTest::SetUp(void)
57 {
58 GTEST_LOG_(INFO) << "SetUp";
59 }
60
TearDown(void)61 void IpcWrapperTest::TearDown(void)
62 {
63 GTEST_LOG_(INFO) << "TearDown";
64 }
65
66 /**
67 * @tc.name: WriteUriByRawData
68 * @tc.desc: The execution of the GetSize failed.
69 * @tc.type: FUNC
70 * @tc.require: I7TDJK
71 */
72 HWTEST_F(IpcWrapperTest, WriteUriByRawData, TestSize.Level0)
73 {
74 GTEST_LOG_(INFO) << "WriteUriByRawData Start";
75 MessageParcel data;
76 std::vector<std::string> uriVec = {"test_uri1", "test_uri2"};
77 // Test case 1: WriteStringVector fails
78 EXPECT_CALL(*messageParcelMock_, WriteStringVector(uriVec)).WillOnce(Return(false));
79 bool result = IpcWrapper::WriteUriByRawData(data, uriVec);
80 EXPECT_FALSE(result);
81
82 // Test case 2: WriteInt32 fails (data size)
83 EXPECT_CALL(*messageParcelMock_, WriteStringVector(uriVec)).WillOnce(Return(true));
84 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
85 result = IpcWrapper::WriteUriByRawData(data, uriVec);
86 EXPECT_FALSE(result);
87
88 // Test case 3: WriteRawData fails
89 EXPECT_CALL(*messageParcelMock_, WriteStringVector(uriVec)).WillOnce(Return(true));
90 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
91 EXPECT_CALL(*messageParcelMock_, WriteRawData(_, _)).WillOnce(Return(false));
92 result = IpcWrapper::WriteUriByRawData(data, uriVec);
93 EXPECT_FALSE(result);
94
95 // Test case 4: Successful write
96 EXPECT_CALL(*messageParcelMock_, WriteStringVector(uriVec)).WillOnce(Return(true));
97 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
98 EXPECT_CALL(*messageParcelMock_, WriteRawData(_, _)).WillOnce(Return(true));
99 result = IpcWrapper::WriteUriByRawData(data, uriVec);
100 EXPECT_TRUE(result);
101 GTEST_LOG_(INFO) << "WriteUriByRawData End";
102 }
103
104 /**
105 * @tc.name: WriteBatchUris
106 * @tc.desc: The execution of the GetSize failed.
107 * @tc.type: FUNC
108 * @tc.require: I7TDJK
109 */
110 HWTEST_F(IpcWrapperTest, WriteBatchUris, TestSize.Level0)
111 {
112 GTEST_LOG_(INFO) << "WriteBatchUris Start";
113 MessageParcel data;
114 std::vector<std::string> uriVec = {"test_uri1", "test_uri2"};
115
116 // Test case 1: WriteUint32 fails
117 EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(false));
118 bool result = IpcWrapper::WriteBatchUris(data, uriVec);
119 EXPECT_FALSE(result);
120
121 // Test case 2: WriteUriByRawData fails
122 EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
123 EXPECT_CALL(*messageParcelMock_, WriteStringVector(_)).WillOnce(Return(false));
124 result = IpcWrapper::WriteBatchUris(data, uriVec);
125 EXPECT_FALSE(result);
126
127 // Test case 3: Successful write
128 EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
129 EXPECT_CALL(*messageParcelMock_, WriteStringVector(_)).WillOnce(Return(true));
130 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
131 EXPECT_CALL(*messageParcelMock_, WriteRawData(_, _)).WillOnce(Return(true));
132 result = IpcWrapper::WriteBatchUris(data, uriVec);
133 EXPECT_TRUE(result);
134 GTEST_LOG_(INFO) << "WriteBatchUris End";
135 }
136
137 /**
138 * @tc.name: GetData
139 * @tc.desc: Test GetData function under different conditions.
140 * @tc.type: FUNC
141 * @tc.require: I7TDJK
142 */
143 HWTEST_F(IpcWrapperTest, GetData, TestSize.Level0)
144 {
145 GTEST_LOG_(INFO) << "GetData Start";
146
147 // Test case 1: Null input data
148 void* buffer = nullptr;
149 bool result = IpcWrapper::GetData(buffer, 1, nullptr);
150 EXPECT_FALSE(result);
151 EXPECT_EQ(buffer, nullptr);
152
153 // Test case 2: Zero size
154 const char* validData = "test";
155 result = IpcWrapper::GetData(buffer, 0, validData);
156 EXPECT_FALSE(result);
157 EXPECT_EQ(buffer, nullptr);
158
159 // Test case 3: Size exceeds maximum limit
160 result = IpcWrapper::GetData(buffer, MAX_IPC_RAW_DATA_SIZE + 1, validData);
161 EXPECT_FALSE(result);
162 EXPECT_EQ(buffer, nullptr);
163
164 // Test case 4: Successful memory copy
165 size_t validSize = 5; // 5: "test" + null terminator
166 result = IpcWrapper::GetData(buffer, validSize, validData);
167 EXPECT_TRUE(result);
168 ASSERT_NE(buffer, nullptr);
169 EXPECT_EQ(memcmp(buffer, validData, validSize), 0);
170 if (buffer != nullptr) {
171 free(buffer); // Cleanup allocated memory
172 buffer = nullptr;
173 }
174 GTEST_LOG_(INFO) << "GetData End";
175 }
176
177 /**
178 * @tc.name: ReadBatchUriByRawData
179 * @tc.desc: Test ReadBatchUriByRawData function under different conditions.
180 * @tc.type: FUNC
181 * @tc.require: I7TDJK
182 */
183 HWTEST_F(IpcWrapperTest, ReadBatchUriByRawData, TestSize.Level0)
184 {
185 GTEST_LOG_(INFO) << "ReadBatchUriByRawData Start";
186 MessageParcel data;
187 std::vector<std::string> uriVec;
188
189 // Test case 1: ReadInt32 returns zero data size
190 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(0));
191 bool result = IpcWrapper::ReadBatchUriByRawData(data, uriVec);
192 EXPECT_FALSE(result);
193
194 // Test case 2: GetData fails (null raw data)
195 size_t dataSize = 5; // 5: test size
196 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(dataSize));
197 EXPECT_CALL(*messageParcelMock_, ReadRawData(_)).WillOnce(Return(nullptr));
198 result = IpcWrapper::ReadBatchUriByRawData(data, uriVec);
199 EXPECT_FALSE(result);
200
201 // Test case 3: Successful
202 const char* validData = "test";
203 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(dataSize));
204 EXPECT_CALL(*messageParcelMock_, ReadRawData(_)).WillOnce(Return(validData));
205 EXPECT_CALL(*messageParcelMock_, ReadStringVector(_)).WillOnce(Return(true));
206 result = IpcWrapper::ReadBatchUriByRawData(data, uriVec);
207 EXPECT_TRUE(result);
208 GTEST_LOG_(INFO) << "ReadBatchUriByRawData End";
209 }
210
211 /**
212 * @tc.name: ReadBatchUris
213 * @tc.desc: Test ReadBatchUris function under different conditions.
214 * @tc.type: FUNC
215 * @tc.require: I7TDJK
216 */
217 HWTEST_F(IpcWrapperTest, ReadBatchUris, TestSize.Level0)
218 {
219 GTEST_LOG_(INFO) << "ReadBatchUris Start";
220 MessageParcel data;
221 std::vector<std::string> uriVec;
222
223 // Test case 1: ReadUint32 returns zero
224 EXPECT_CALL(*messageParcelMock_, ReadUint32()).WillOnce(Return(0));
225 int32_t result = IpcWrapper::ReadBatchUris(data, uriVec);
226 EXPECT_EQ(result, OHOS::FileManagement::E_INVAL_ARG);
227
228 // Test case 2: ReadBatchUriByRawData fails
229 EXPECT_CALL(*messageParcelMock_, ReadUint32()).WillOnce(Return(1)); // 1: test size
230 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(0)); // Causes failure
231 result = IpcWrapper::ReadBatchUris(data, uriVec);
232 EXPECT_EQ(result, OHOS::FileManagement::E_IPC_READ_FAILED);
233
234 // Test case 3: Successful read
235 const char* validData = "test";
236 size_t dataSize = 5; // 5: test size
237 std::vector<std::string> testVec;
238 testVec.emplace_back("test");
239 testVec.emplace_back("test");
240 EXPECT_CALL(*messageParcelMock_, ReadUint32()).WillOnce(Return(1)); // 1: test size
241 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(dataSize));
242 EXPECT_CALL(*messageParcelMock_, ReadRawData(_)).WillOnce(Return(validData));
243 EXPECT_CALL(*messageParcelMock_, ReadStringVector(_)).WillOnce(Return(true));
244 result = IpcWrapper::ReadBatchUris(data, uriVec);
245 EXPECT_EQ(result, OHOS::FileManagement::E_IPC_READ_FAILED);
246 GTEST_LOG_(INFO) << "ReadBatchUris End";
247 }
248 }
249