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
16 #include <gtest/gtest.h>
17
18 #include "file_entity.h"
19 #include "fs_randomaccessfile.h"
20
21 namespace OHOS::FileManagement::ModuleFileIO::Test {
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace std;
25
26 class FsRandomAccessFileTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 protected:
33 unique_ptr<RandomAccessFileEntity> rafEntity;
34 unique_ptr<FsRandomAccessFile> raf;
35 };
36
SetUpTestCase(void)37 void FsRandomAccessFileTest::SetUpTestCase(void)
38 {
39 GTEST_LOG_(INFO) << "SetUpTestCase";
40 }
41
TearDownTestCase(void)42 void FsRandomAccessFileTest::TearDownTestCase(void)
43 {
44 GTEST_LOG_(INFO) << "TearDownTestCase";
45 }
46
SetUp(void)47 void FsRandomAccessFileTest::SetUp(void)
48 {
49 GTEST_LOG_(INFO) << "SetUp";
50 rafEntity = make_unique<RandomAccessFileEntity>();
51 const int fdValue = 3;
52 const bool isClosed = false;
53 rafEntity->fd = make_unique<DistributedFS::FDGuard>(fdValue, isClosed);
54 rafEntity->filePointer = 0;
55 raf = make_unique<FsRandomAccessFile>(move(rafEntity));
56 }
57
TearDown(void)58 void FsRandomAccessFileTest::TearDown(void)
59 {
60 GTEST_LOG_(INFO) << "TearDown";
61 }
62
63 /**
64 * @tc.name: FsRandomAccessFileTest_Constructor_001
65 * @tc.desc: Test function of Constructor() interface for SUCCESS.
66 * @tc.size: MEDIUM
67 * @tc.type: FUNC
68 * @tc.level Level 1
69 */
70 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_Constructor_001, testing::ext::TestSize.Level1)
71 {
72 GTEST_LOG_(INFO) << "FsRandomAccessFileTest-begin FsRandomAccessFileTest_Constructor_001";
73
74 auto result = FsRandomAccessFile::Constructor();
75 EXPECT_EQ(result.IsSuccess(), true);
76
77 GTEST_LOG_(INFO) << "FsRandomAccessFileTest-end FsRandomAccessFileTest_Constructor_001";
78 }
79
80 /**
81 * @tc.name: FsRandomAccessFileTest_GetFD_002
82 * @tc.desc: Test function of GetFD() interface for SUCCESS.
83 * @tc.size: MEDIUM
84 * @tc.type: FUNC
85 * @tc.level Level 1
86 */
87 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_GetFD_002, testing::ext::TestSize.Level1)
88 {
89 GTEST_LOG_(INFO) << "FsRandomAccessFileTest-begin FsRandomAccessFileTest_GetFD_002";
90
91 auto result = raf->GetFD();
92 EXPECT_EQ(result.IsSuccess(), true);
93
94 GTEST_LOG_(INFO) << "FsRandomAccessFileTest-end FsRandomAccessFileTest_GetFD_002";
95 }
96
97 /**
98 * @tc.name: FsRandomAccessFileTest_GetFD_003
99 * @tc.desc: Test function of GetFD() interface for is failed for FsRandomAccessFile is nullopt.
100 * @tc.size: MEDIUM
101 * @tc.type: FUNC
102 * @tc.level Level 1
103
104 */
105 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_GetFD_003, testing::ext::TestSize.Level1)
106 {
107 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_GetFD_003";
108
109 raf = make_unique<FsRandomAccessFile>(nullptr);
110 auto result = raf->GetFD();
111 EXPECT_EQ(result.IsSuccess(), false);
112
113 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_GetFD_003";
114 }
115
116 // GetFPointer
117 /**
118 * @tc.name: FsRandomAccessFileTest_GetFPointer_004
119 * @tc.desc: Test function of GetFPointer() interface for SUCCESS.
120 * @tc.size: MEDIUM
121 * @tc.type: FUNC
122 * @tc.level Level 1
123
124 */
125 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_GetFPointer_004, testing::ext::TestSize.Level1)
126 {
127 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_GetFPointer_004";
128
129 raf->rafEntity->filePointer = 100;
130 auto result = raf->GetFPointer();
131 EXPECT_EQ(result.IsSuccess(), true);
132
133 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_GetFPointer_004";
134 }
135
136 /**
137 * @tc.name: FsRandomAccessFileTest_GetFPointer_005
138 * @tc.desc: Test function of GetFPointer() interface for ERROR.
139 * @tc.size: MEDIUM
140 * @tc.type: FUNC
141 * @tc.level Level 1
142
143 */
144 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_GetFPointer_005, testing::ext::TestSize.Level1)
145 {
146 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_GetFPointer_005";
147
148 raf = make_unique<FsRandomAccessFile>(nullptr);
149 auto result = raf->GetFPointer();
150 EXPECT_EQ(result.IsSuccess(), false);
151
152 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_GetFPointer_005";
153 }
154
155 /**
156 * @tc.name: FsRandomAccessFileTest_SetFilePointerSync_006
157 * @tc.desc: Test function of SetFilePointerSync() interface for SUCCESS.
158 * @tc.size: MEDIUM
159 * @tc.type: FUNC
160 * @tc.level Level 1
161
162 */
163 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_SetFilePointerSync_006, testing::ext::TestSize.Level1)
164 {
165 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_SetFilePointerSync_006";
166
167 auto result = raf->SetFilePointerSync(50);
168 EXPECT_EQ(result.IsSuccess(), true);
169 EXPECT_EQ(raf->rafEntity->filePointer, 50);
170
171 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_SetFilePointerSync_006";
172 }
173
174 /**
175 * @tc.name: FsRandomAccessFileTest_SetFilePointerSync_007
176 * @tc.desc: Test function of SetFilePointerSync() interface for ERROR.
177 * @tc.size: MEDIUM
178 * @tc.type: FUNC
179 * @tc.level Level 1
180
181 */
182 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_SetFilePointerSync_007, testing::ext::TestSize.Level1)
183 {
184 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_SetFilePointerSync_007";
185
186 raf = make_unique<FsRandomAccessFile>(nullptr);
187 auto result = raf->SetFilePointerSync(50);
188 EXPECT_EQ(result.IsSuccess(), false);
189
190 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_SetFilePointerSync_007";
191 }
192
193 // ReadSync
194 /**
195 * @tc.name: FsRandomAccessFileTest_ReadSync_008
196 * @tc.desc: Test function of ReadSync() interface for ERROR.
197 * @tc.size: MEDIUM
198 * @tc.type: FUNC
199 * @tc.level Level 1
200
201 */
202 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_ReadSync_008, testing::ext::TestSize.Level1)
203 {
204 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_ReadSync_008";
205
206 raf = make_unique<FsRandomAccessFile>(nullptr);
207 ArrayBuffer buffer(malloc(100), 100);
208
209 auto result = raf->ReadSync(buffer, nullopt);
210 EXPECT_EQ(result.IsSuccess(), false);
211 free(buffer.buf);
212
213 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_ReadSync_008";
214 }
215
216 /**
217 * @tc.name: FsRandomAccessFileTest_ReadSync_009
218 * @tc.desc: Test function of ReadSync() interface for ERROR.
219 * @tc.size: MEDIUM
220 * @tc.type: FUNC
221 * @tc.level Level 1
222
223 */
224 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_ReadSync_009, testing::ext::TestSize.Level1)
225 {
226 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_ReadSync_009";
227
228 ArrayBuffer buffer(malloc(100), 100);
229 ReadOptions options;
230 options.offset = -5;
231
232 auto result = raf->ReadSync(buffer, options);
233 EXPECT_EQ(result.IsSuccess(), false);
234 free(buffer.buf);
235
236 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_ReadSync_009";
237 }
238
239 /**
240 * @tc.name: FsRandomAccessFileTest_ReadSync_010
241 * @tc.desc: Test function of ReadSync() interface for ERROR.
242 * @tc.size: MEDIUM
243 * @tc.type: FUNC
244 * @tc.level Level 1
245
246 */
247 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_ReadSync_010, testing::ext::TestSize.Level1)
248 {
249 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_ReadSync_010";
250
251 ArrayBuffer buffer(malloc(100), 100);
252 ReadOptions options;
253 options.length = -1;
254
255 auto result = raf->ReadSync(buffer, options);
256 EXPECT_EQ(result.IsSuccess(), false);
257 free(buffer.buf);
258
259 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_ReadSync_010";
260 }
261
262 // WriteSync
263 /**
264 * @tc.name: FsRandomAccessFileTest_WriteSync_011
265 * @tc.desc: Test function of WriteSync() interface for ERROR.
266 * @tc.size: MEDIUM
267 * @tc.type: FUNC
268 * @tc.level Level 1
269
270 */
271 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_WriteSync_011, testing::ext::TestSize.Level1)
272 {
273 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_WriteSync_011";
274
275 raf = make_unique<FsRandomAccessFile>(nullptr);
276 string data = "test data";
277 auto result = raf->WriteSync(data, nullopt);
278 EXPECT_EQ(result.IsSuccess(), false);
279
280 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_WriteSync_011";
281 }
282
283 /**
284 * @tc.name: FsRandomAccessFileTest_WriteSync_012
285 * @tc.desc: Test function of WriteSync() interface for ERROR.
286 * @tc.size: MEDIUM
287 * @tc.type: FUNC
288 * @tc.level Level 1
289
290 */
291 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_WriteSync_012, testing::ext::TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_WriteSync_012";
294
295 raf = make_unique<FsRandomAccessFile>(nullptr);
296 ArrayBuffer buffer(malloc(100), 100);
297 auto result = raf->WriteSync(buffer, nullopt);
298 EXPECT_EQ(result.IsSuccess(), false);
299 free(buffer.buf);
300
301 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_WriteSync_012";
302 }
303
304 /**
305 * @tc.name: FsRandomAccessFileTest_WriteSync_013
306 * @tc.desc: Test function of WriteSync() interface for ERROR.
307 * @tc.size: MEDIUM
308 * @tc.type: FUNC
309 * @tc.level Level 1
310
311 */
312 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_WriteSync_013, testing::ext::TestSize.Level1)
313 {
314 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_WriteSync_013";
315
316 string data = "test data";
317 WriteOptions options;
318 options.offset = -5;
319
320 auto result = raf->WriteSync(data, options);
321 EXPECT_EQ(result.IsSuccess(), false);
322
323 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_WriteSync_013";
324 }
325
326 /**
327 * @tc.name: FsRandomAccessFileTest_WriteSync_014
328 * @tc.desc: Test function of WriteSync() interface for ERROR.
329 * @tc.size: MEDIUM
330 * @tc.type: FUNC
331 * @tc.level Level 1
332
333 */
334 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_WriteSync_014, testing::ext::TestSize.Level1)
335 {
336 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_WriteSync_014";
337
338 ArrayBuffer buffer(malloc(100), 100);
339 WriteOptions options;
340 options.offset = -5;
341
342 auto result = raf->WriteSync(buffer, options);
343 EXPECT_EQ(result.IsSuccess(), false);
344 free(buffer.buf);
345
346 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_WriteSync_014";
347 }
348
349 /**
350 * @tc.name: FsRandomAccessFileTest_WriteSync_015
351 * @tc.desc: Test function of WriteSync() interface for ERROR.
352 * @tc.size: MEDIUM
353 * @tc.type: FUNC
354 * @tc.level Level 1
355
356 */
357 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_WriteSync_015, testing::ext::TestSize.Level1)
358 {
359 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_WriteSync_015";
360
361 string data = "test data";
362 WriteOptions options;
363 options.length = -5;
364
365 auto result = raf->WriteSync(data, options);
366 EXPECT_EQ(result.IsSuccess(), false);
367
368 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_WriteSync_015";
369 }
370
371 /**
372 * @tc.name: FsRandomAccessFileTest_WriteSync_016
373 * @tc.desc: Test function of WriteSync() interface for ERROR.
374 * @tc.size: MEDIUM
375 * @tc.type: FUNC
376 * @tc.level Level 1
377
378 */
379 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_WriteSync_016, testing::ext::TestSize.Level1)
380 {
381 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_WriteSync_016";
382
383 ArrayBuffer buffer(malloc(100), 100);
384 WriteOptions options;
385 options.length = -5;
386
387 auto result = raf->WriteSync(buffer, options);
388 EXPECT_EQ(result.IsSuccess(), false);
389 free(buffer.buf);
390
391 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_WriteSync_016";
392 }
393
394 // CloseSync
395 /**
396 * @tc.name: FsRandomAccessFileTest_CloseSync_017
397 * @tc.desc: Test function of CloseSync() interface for ERROR.
398 * @tc.size: MEDIUM
399 * @tc.type: FUNC
400 * @tc.level Level 1
401
402 */
403 HWTEST_F(FsRandomAccessFileTest, FsRandomAccessFileTest_CloseSync_017, testing::ext::TestSize.Level1)
404 {
405 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-begin FsRandomAccessFileTest_CloseSync_017";
406
407 raf = make_unique<FsRandomAccessFile>(nullptr);
408 auto result = raf->CloseSync();
409 EXPECT_EQ(result.IsSuccess(), false);
410
411 GTEST_LOG_(INFO) << "FsRandomAccessFileMockTest-end FsRandomAccessFileTest_CloseSync_017";
412 }
413
414 }