• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "create_stream_core.h"
18 #include "fs_utils.h"
19 
20 namespace OHOS {
21 namespace FileManagement {
22 namespace ModuleFileIO {
23 using namespace std;
24 
25 static const string streamFilePath = "/data/test/FsStreamCoreTest.txt";
26 
27 class FsStreamTest : public testing::Test {
28 public:
SetUpTestCase(void)29     static void SetUpTestCase(void)
30     {
31         int32_t fd = open(streamFilePath.c_str(), CREATE | O_RDWR, 0644);
32         if (fd <= 0) {
33             ASSERT_TRUE(false);
34         }
35         close(fd);
36     };
TearDownTestCase()37     static void TearDownTestCase()
38     {
39         rmdir(streamFilePath.c_str());
40     };
SetUp()41     void SetUp() {};
TearDown()42     void TearDown() {};
43 };
44 
45 /**
46  * @tc.name: FsStreamCloseTest_0001
47  * @tc.desc: Test function of Close() interface for close success.
48  * @tc.size: MEDIUM
49  * @tc.type: FUNC
50  * @tc.level Level 1
51  */
52 HWTEST_F(FsStreamTest, FsStreamCloseTest_0001, testing::ext::TestSize.Level1)
53 {
54     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamCloseTest_0001";
55     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
56     ASSERT_TRUE(ret.IsSuccess());
57     auto result = ret.GetData().value();
58 
59     auto retCs = result->Close();
60     ASSERT_TRUE(retCs.IsSuccess());
61 
62     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamCloseTest_0001";
63 }
64 
65 /**
66  * @tc.name: FsStreamCloseTest_0002
67  * @tc.desc: Test function of Close() interface for close fail.
68  * @tc.size: MEDIUM
69  * @tc.type: FUNC
70  * @tc.level Level 1
71  */
72 HWTEST_F(FsStreamTest, FsStreamCloseTest_0002, testing::ext::TestSize.Level1)
73 {
74     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamCloseTest_0002";
75     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
76     ASSERT_TRUE(ret.IsSuccess());
77     auto result = ret.GetData().value();
78 
79     auto retCs = result->Close();
80     ASSERT_TRUE(retCs.IsSuccess());
81 
82     retCs = result->Close();
83     EXPECT_FALSE(retCs.IsSuccess());
84     auto err = retCs.GetError();
85     EXPECT_EQ(err.GetErrNo(), 13900005);
86 
87     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamCloseTest_0002";
88 }
89 
90 /**
91  * @tc.name: FsStreamFlushTest_0001
92  * @tc.desc: Test function of Flush() interface for null fp.
93  * @tc.size: MEDIUM
94  * @tc.type: FUNC
95  * @tc.level Level 1
96  */
97 HWTEST_F(FsStreamTest, FsStreamFlushTest_0001, testing::ext::TestSize.Level1)
98 {
99     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamFlushTest_0001";
100     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
101     ASSERT_TRUE(ret.IsSuccess());
102     auto result = ret.GetData().value();
103 
104     auto retCs = result->Close();
105     ASSERT_TRUE(retCs.IsSuccess());
106 
107     auto retFl = result->Flush();
108     EXPECT_FALSE(retFl.IsSuccess());
109     auto err = retFl.GetError();
110     EXPECT_EQ(err.GetErrNo(), 13900005);
111 
112     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamFlushTest_0001";
113 }
114 
115 /**
116  * @tc.name: FsStreamFlushTest_0002
117  * @tc.desc: Test function of Flush() interface for success.
118  * @tc.size: MEDIUM
119  * @tc.type: FUNC
120  * @tc.level Level 1
121  */
122 HWTEST_F(FsStreamTest, FsStreamFlushTest_0002, testing::ext::TestSize.Level1)
123 {
124     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamFlushTest_0002";
125     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
126     ASSERT_TRUE(ret.IsSuccess());
127     auto result = ret.GetData().value();
128 
129     auto retFl = result->Flush();
130     ASSERT_TRUE(retFl.IsSuccess());
131 
132     auto retCs = result->Close();
133     ASSERT_TRUE(retCs.IsSuccess());
134 
135     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamFlushTest_0002";
136 }
137 
138 /**
139  * @tc.name: FsStreamSeekTest_0001
140  * @tc.desc: Test function of Seek() interface for null fp.
141  * @tc.size: MEDIUM
142  * @tc.type: FUNC
143  * @tc.level Level 1
144  */
145 HWTEST_F(FsStreamTest, FsStreamSeekTest_0001, testing::ext::TestSize.Level1)
146 {
147     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0001";
148     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
149     ASSERT_TRUE(ret.IsSuccess());
150     auto result = ret.GetData().value();
151 
152     auto retCs = result->Close();
153     ASSERT_TRUE(retCs.IsSuccess());
154 
155     auto retSk = result->Seek(0);
156     EXPECT_FALSE(retSk.IsSuccess());
157     auto err = retSk.GetError();
158     EXPECT_EQ(err.GetErrNo(), 13900002);
159 
160     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0001";
161 }
162 
163 /**
164  * @tc.name: FsStreamSeekTest_0002
165  * @tc.desc: Test function of Seek() interface for error whence < SEEK_SET (0).
166  * @tc.size: MEDIUM
167  * @tc.type: FUNC
168  * @tc.level Level 1
169  */
170 HWTEST_F(FsStreamTest, FsStreamSeekTest_0002, testing::ext::TestSize.Level1)
171 {
172     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0002";
173     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
174     ASSERT_TRUE(ret.IsSuccess());
175     auto result = ret.GetData().value();
176 
177     optional<int32_t> opt = -1;
178     auto retSk = result->Seek(0, opt);
179     EXPECT_FALSE(retSk.IsSuccess());
180     auto err = retSk.GetError();
181     EXPECT_EQ(err.GetErrNo(), 13900020);
182 
183     auto retCs = result->Close();
184     ASSERT_TRUE(retCs.IsSuccess());
185 
186     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0002";
187 }
188 
189 /**
190  * @tc.name: FsStreamSeekTest_0003
191  * @tc.desc: Test function of Seek() interface for error whence > SEEK_END (2).
192  * @tc.size: MEDIUM
193  * @tc.type: FUNC
194  * @tc.level Level 1
195  */
196 HWTEST_F(FsStreamTest, FsStreamSeekTest_0003, testing::ext::TestSize.Level1)
197 {
198     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0003";
199     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
200     ASSERT_TRUE(ret.IsSuccess());
201     auto result = ret.GetData().value();
202 
203     optional<int32_t> opt = 3;
204     auto retSk = result->Seek(0, opt);
205     EXPECT_FALSE(retSk.IsSuccess());
206     auto err = retSk.GetError();
207     EXPECT_EQ(err.GetErrNo(), 13900020);
208 
209     auto retCs = result->Close();
210     ASSERT_TRUE(retCs.IsSuccess());
211 
212     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0003";
213 }
214 
215 /**
216  * @tc.name: FsStreamSeekTest_0004
217  * @tc.desc: Test function of Seek() interface for success.
218  * @tc.size: MEDIUM
219  * @tc.type: FUNC
220  * @tc.level Level 1
221  */
222 HWTEST_F(FsStreamTest, FsStreamSeekTest_0004, testing::ext::TestSize.Level1)
223 {
224     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamSeekTest_0004";
225     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
226     ASSERT_TRUE(ret.IsSuccess());
227     auto result = ret.GetData().value();
228 
229     auto retSk = result->Seek(1);
230     ASSERT_TRUE(retSk.IsSuccess());
231 
232     auto retCs = result->Close();
233     ASSERT_TRUE(retCs.IsSuccess());
234 
235     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamSeekTest_0004";
236 }
237 
238 /**
239  * @tc.name: FsStreamWriteTest_0001
240  * @tc.desc: Test function of Write() interface for string single argument fail null fp.
241  * @tc.size: MEDIUM
242  * @tc.type: FUNC
243  * @tc.level Level 1
244  */
245 HWTEST_F(FsStreamTest, FsStreamWriteTest_0001, testing::ext::TestSize.Level1)
246 {
247     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0001";
248     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
249     ASSERT_TRUE(ret.IsSuccess());
250     auto result = ret.GetData().value();
251 
252     auto retCs = result->Close();
253     ASSERT_TRUE(retCs.IsSuccess());
254 
255     auto retWr = result->Write("FsStreamWriteTest_0001");
256     EXPECT_FALSE(retWr.IsSuccess());
257     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
258 
259     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0001";
260 }
261 
262 /**
263  * @tc.name: FsStreamWriteTest_0002
264  * @tc.desc: Test function of Write() interface for ArrayBuffer single argument fail null fp.
265  * @tc.size: MEDIUM
266  * @tc.type: FUNC
267  * @tc.level Level 1
268  */
269 HWTEST_F(FsStreamTest, FsStreamWriteTest_0002, testing::ext::TestSize.Level1)
270 {
271     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0002";
272     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
273     ASSERT_TRUE(ret.IsSuccess());
274     auto result = ret.GetData().value();
275 
276     auto retCs = result->Close();
277     ASSERT_TRUE(retCs.IsSuccess());
278 
279     string buf = "FsStreamWriteTest_0001";
280     auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22));
281     EXPECT_FALSE(retWr.IsSuccess());
282     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
283 
284     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0002";
285 }
286 
287 /**
288  * @tc.name: FsStreamWriteTest_0003
289  * @tc.desc: Test function of Write() interface for string error offset.
290  * @tc.size: MEDIUM
291  * @tc.type: FUNC
292  * @tc.level Level 1
293  */
294 HWTEST_F(FsStreamTest, FsStreamWriteTest_0003, testing::ext::TestSize.Level1)
295 {
296     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0003";
297     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
298     ASSERT_TRUE(ret.IsSuccess());
299     auto result = ret.GetData().value();
300 
301     WriteOptions opt;
302     opt.offset = -1;
303 
304     auto retWr = result->Write("FsStreamWriteTest_0003", opt);
305     EXPECT_FALSE(retWr.IsSuccess());
306     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
307 
308     auto retCs = result->Close();
309     ASSERT_TRUE(retCs.IsSuccess());
310 
311     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0003";
312 }
313 
314 /**
315  * @tc.name: FsStreamWriteTest_0004
316  * @tc.desc: Test function of Write() interface for ArrayBuffer error offset.
317  * @tc.size: MEDIUM
318  * @tc.type: FUNC
319  * @tc.level Level 1
320  */
321 HWTEST_F(FsStreamTest, FsStreamWriteTest_0004, testing::ext::TestSize.Level1)
322 {
323     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0004";
324     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
325     ASSERT_TRUE(ret.IsSuccess());
326     auto result = ret.GetData().value();
327 
328     WriteOptions opt;
329     opt.offset = -1;
330 
331     string buf = "FsStreamWriteTest_0004";
332     auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
333     EXPECT_FALSE(retWr.IsSuccess());
334     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
335 
336     auto retCs = result->Close();
337     ASSERT_TRUE(retCs.IsSuccess());
338 
339     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0004";
340 }
341 
342 /**
343  * @tc.name: FsStreamWriteTest_0005
344  * @tc.desc: Test function of Write() interface for string error encoding.
345  * @tc.size: MEDIUM
346  * @tc.type: FUNC
347  * @tc.level Level 1
348  */
349 HWTEST_F(FsStreamTest, FsStreamWriteTest_0005, testing::ext::TestSize.Level1)
350 {
351     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0005";
352     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
353     ASSERT_TRUE(ret.IsSuccess());
354     auto result = ret.GetData().value();
355 
356     WriteOptions opt;
357     opt.encoding = "utf-16";
358 
359     auto retWr = result->Write("FsStreamWriteTest_0005", opt);
360     EXPECT_FALSE(retWr.IsSuccess());
361     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
362 
363     auto retCs = result->Close();
364     ASSERT_TRUE(retCs.IsSuccess());
365 
366     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0005";
367 }
368 
369 /**
370  * @tc.name: FsStreamWriteTest_0006
371  * @tc.desc: Test function of Write() interface for ArrayBuffer error encoding.
372  * @tc.size: MEDIUM
373  * @tc.type: FUNC
374  * @tc.level Level 1
375  */
376 HWTEST_F(FsStreamTest, FsStreamWriteTest_0006, testing::ext::TestSize.Level1)
377 {
378     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0006";
379     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
380     ASSERT_TRUE(ret.IsSuccess());
381     auto result = ret.GetData().value();
382 
383     WriteOptions opt;
384     opt.encoding = "utf-16";
385 
386     string buf = "FsStreamWriteTest_0006";
387     auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
388     EXPECT_FALSE(retWr.IsSuccess());
389     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
390 
391     auto retCs = result->Close();
392     ASSERT_TRUE(retCs.IsSuccess());
393 
394     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0004";
395 }
396 
397 #if defined(_WIN64) || defined(__x86_64__) || defined(__ppc64__) || defined(__LP64__)
398 /**
399  * @tc.name: FsStreamWriteTest_0007
400  * @tc.desc: Test function of Write() interface for string > UINT_MAX.
401  * @tc.size: MEDIUM
402  * @tc.type: FUNC
403  * @tc.level Level 1
404  */
405 HWTEST_F(FsStreamTest, FsStreamWriteTest_0007, testing::ext::TestSize.Level1)
406 {
407     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0007";
408     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
409     ASSERT_TRUE(ret.IsSuccess());
410     auto result = ret.GetData().value();
411 
412     size_t largeLength = static_cast<size_t>(UINT_MAX) + 1;
413     string largeString(largeLength, 'a');
414 
415     auto retWr = result->Write(largeString);
416     EXPECT_FALSE(retWr.IsSuccess());
417     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
418 
419     auto retCs = result->Close();
420     ASSERT_TRUE(retCs.IsSuccess());
421 
422     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0005";
423 }
424 
425 /**
426  * @tc.name: FsStreamWriteTest_0008
427  * @tc.desc: Test function of Write() interface for ArrayBuffer > UINT_MAX.
428  * @tc.size: MEDIUM
429  * @tc.type: FUNC
430  * @tc.level Level 1
431  */
432 HWTEST_F(FsStreamTest, FsStreamWriteTest_0008, testing::ext::TestSize.Level1)
433 {
434     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0008";
435     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
436     ASSERT_TRUE(ret.IsSuccess());
437     auto result = ret.GetData().value();
438 
439     size_t largeLength = static_cast<size_t>(UINT_MAX) + 1;
440     string largeString(largeLength, 'a');
441 
442     auto retWr = result->Write(ArrayBuffer(static_cast<void *>(largeString.data()), largeLength));
443     EXPECT_FALSE(retWr.IsSuccess());
444     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
445 
446     auto retCs = result->Close();
447     ASSERT_TRUE(retCs.IsSuccess());
448 
449     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0008";
450 }
451 #endif
452 
453 /**
454  * @tc.name: FsStreamWriteTest_0009
455  * @tc.desc: Test function of Write() interface for string length < 0.
456  * @tc.size: MEDIUM
457  * @tc.type: FUNC
458  * @tc.level Level 1
459  */
460 HWTEST_F(FsStreamTest, FsStreamWriteTest_0009, testing::ext::TestSize.Level1)
461 {
462     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0009";
463     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
464     ASSERT_TRUE(ret.IsSuccess());
465     auto result = ret.GetData().value();
466 
467     WriteOptions opt;
468     opt.length = -1;
469 
470     auto retWr = result->Write("FsStreamWriteTest_0009", opt);
471     EXPECT_FALSE(retWr.IsSuccess());
472     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
473 
474     auto retCs = result->Close();
475     ASSERT_TRUE(retCs.IsSuccess());
476 
477     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0009";
478 }
479 
480 /**
481  * @tc.name: FsStreamWriteTest_0010
482  * @tc.desc: Test function of Write() interface for ArrayBuffer length < 0.
483  * @tc.size: MEDIUM
484  * @tc.type: FUNC
485  * @tc.level Level 1
486  */
487 HWTEST_F(FsStreamTest, FsStreamWriteTest_0010, testing::ext::TestSize.Level1)
488 {
489     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0010";
490     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
491     ASSERT_TRUE(ret.IsSuccess());
492     auto result = ret.GetData().value();
493 
494     WriteOptions opt;
495     opt.length = -1;
496 
497     string buf = "FsStreamWriteTest_0010";
498     auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
499     EXPECT_FALSE(retWr.IsSuccess());
500     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900020);
501 
502     auto retCs = result->Close();
503     ASSERT_TRUE(retCs.IsSuccess());
504 
505     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0010";
506 }
507 
508 /**
509  * @tc.name: FsStreamWriteTest_0013
510  * @tc.desc: Test function of Write() interface for string no permission.
511  * @tc.size: MEDIUM
512  * @tc.type: FUNC
513  * @tc.level Level 1
514  */
515 HWTEST_F(FsStreamTest, FsStreamWriteTest_0013, testing::ext::TestSize.Level1)
516 {
517     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0013";
518     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
519     ASSERT_TRUE(ret.IsSuccess());
520     auto result = ret.GetData().value();
521 
522     auto retWr = result->Write("FsStreamWriteTest_0013");
523     EXPECT_FALSE(retWr.IsSuccess());
524     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
525 
526     auto retCs = result->Close();
527     ASSERT_TRUE(retCs.IsSuccess());
528 
529     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0013";
530 }
531 
532 /**
533  * @tc.name: FsStreamWriteTest_0014
534  * @tc.desc: Test function of Write() interface for ArrayBuffer no permission.
535  * @tc.size: MEDIUM
536  * @tc.type: FUNC
537  * @tc.level Level 1
538  */
539 HWTEST_F(FsStreamTest, FsStreamWriteTest_0014, testing::ext::TestSize.Level1)
540 {
541     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0014";
542     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r");
543     ASSERT_TRUE(ret.IsSuccess());
544     auto result = ret.GetData().value();
545 
546     string buf = "FsStreamWriteTest_0014";
547     auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22));
548     EXPECT_FALSE(retWr.IsSuccess());
549     EXPECT_EQ(retWr.GetError().GetErrNo(), 13900005);
550 
551     auto retCs = result->Close();
552     ASSERT_TRUE(retCs.IsSuccess());
553 
554     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0014";
555 }
556 
557 /**
558  * @tc.name: FsStreamWriteTest_0015
559  * @tc.desc: Test function of Write() interface for string success.
560  * @tc.size: MEDIUM
561  * @tc.type: FUNC
562  * @tc.level Level 1
563  */
564 HWTEST_F(FsStreamTest, FsStreamWriteTest_0015, testing::ext::TestSize.Level1)
565 {
566     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0015";
567     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
568     ASSERT_TRUE(ret.IsSuccess());
569     auto result = ret.GetData().value();
570 
571     WriteOptions opt;
572     opt.offset = 0;
573     opt.encoding = "utf-8";
574     opt.length = 5;
575 
576     auto retWr = result->Write("FsStreamWriteTest_0015", opt);
577     ASSERT_TRUE(retWr.IsSuccess());
578 
579     size_t retLen = retWr.GetData().value();
580     EXPECT_EQ(retLen, 5);
581 
582     auto retCs = result->Close();
583     ASSERT_TRUE(retCs.IsSuccess());
584 
585     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0015";
586 }
587 
588 /**
589  * @tc.name: FsStreamWriteTest_0016
590  * @tc.desc: Test function of Write() interface for ArrayBuffer success.
591  * @tc.size: MEDIUM
592  * @tc.type: FUNC
593  * @tc.level Level 1
594  */
595 HWTEST_F(FsStreamTest, FsStreamWriteTest_0016, testing::ext::TestSize.Level1)
596 {
597     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamWriteTest_0016";
598     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w+");
599     ASSERT_TRUE(ret.IsSuccess());
600     auto result = ret.GetData().value();
601 
602     WriteOptions opt;
603     opt.offset = 0;
604     opt.encoding = "utf-8";
605     opt.length = 5;
606 
607     string buf = "FsStreamWriteTest_0016";
608     auto retWr = result->Write(ArrayBuffer(static_cast<void *>(buf.data()), 22), opt);
609     ASSERT_TRUE(retWr.IsSuccess());
610 
611     size_t retLen = retWr.GetData().value();
612     EXPECT_EQ(retLen, 5);
613 
614     auto retCs = result->Close();
615     ASSERT_TRUE(retCs.IsSuccess());
616 
617     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamWriteTest_0016";
618 }
619 
620 /**
621  * @tc.name: FsStreamReadTest_0001
622  * @tc.desc: Test function of Read() interface for single argument null fp.
623  * @tc.size: MEDIUM
624  * @tc.type: FUNC
625  * @tc.level Level 1
626  */
627 HWTEST_F(FsStreamTest, FsStreamReadTest_0001, testing::ext::TestSize.Level1)
628 {
629     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0001";
630     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
631     ASSERT_TRUE(ret.IsSuccess());
632     auto result = ret.GetData().value();
633 
634     auto retCs = result->Close();
635     ASSERT_TRUE(retCs.IsSuccess());
636 
637     void *buffer = std::malloc(4096);
638     ArrayBuffer arrayBuffer(buffer, 4096);
639     auto retRd = result->Read(arrayBuffer);
640     EXPECT_FALSE(retRd.IsSuccess());
641     EXPECT_EQ(retRd.GetError().GetErrNo(), 13900005);
642 
643     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0001";
644 }
645 
646 /**
647  * @tc.name: FsStreamReadTest_0002
648  * @tc.desc: Test function of Read() interface for error offset.
649  * @tc.size: MEDIUM
650  * @tc.type: FUNC
651  * @tc.level Level 1
652  */
653 HWTEST_F(FsStreamTest, FsStreamReadTest_0002, testing::ext::TestSize.Level1)
654 {
655     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0002";
656     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
657     ASSERT_TRUE(ret.IsSuccess());
658     auto result = ret.GetData().value();
659 
660     ReadOptions opt;
661     opt.offset = -1;
662 
663     void *buffer = std::malloc(4096);
664     ArrayBuffer arrayBuffer(buffer, 4096);
665     auto retRd = result->Read(arrayBuffer, opt);
666     EXPECT_FALSE(retRd.IsSuccess());
667     EXPECT_EQ(retRd.GetError().GetErrNo(), 13900020);
668 
669     auto retCs = result->Close();
670     ASSERT_TRUE(retCs.IsSuccess());
671 
672     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0002";
673 }
674 
675 #if defined(_WIN64) || defined(__x86_64__) || defined(__ppc64__) || defined(__LP64__)
676 /**
677  * @tc.name: FsStreamReadTest_0003
678  * @tc.desc: Test function of Read() interface for bufLen > UINT_MAX.
679  * @tc.size: MEDIUM
680  * @tc.type: FUNC
681  * @tc.level Level 1
682  */
683 HWTEST_F(FsStreamTest, FsStreamReadTest_0003, testing::ext::TestSize.Level1)
684 {
685     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0003";
686     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
687     ASSERT_TRUE(ret.IsSuccess());
688     auto result = ret.GetData().value();
689 
690     size_t largeLength = static_cast<size_t>(UINT_MAX) + 1;
691 
692     void *buffer = std::malloc(largeLength);
693     ArrayBuffer arrayBuffer(buffer, largeLength);
694     auto retRd = result->Read(arrayBuffer);
695     EXPECT_FALSE(retRd.IsSuccess());
696     EXPECT_EQ(retRd.GetError().GetErrNo(), 13900020);
697 
698     auto retCs = result->Close();
699     ASSERT_TRUE(retCs.IsSuccess());
700 
701     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0003";
702 }
703 #endif
704 
705 /**
706  * @tc.name: FsStreamReadTest_0004
707  * @tc.desc: Test function of Read() interface for error length.
708  * @tc.size: MEDIUM
709  * @tc.type: FUNC
710  * @tc.level Level 1
711  */
712 HWTEST_F(FsStreamTest, FsStreamReadTest_0004, testing::ext::TestSize.Level1)
713 {
714     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0004";
715     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
716     ASSERT_TRUE(ret.IsSuccess());
717     auto result = ret.GetData().value();
718 
719     ReadOptions opt;
720     opt.length = -1;
721 
722     void *buffer = std::malloc(4096);
723     ArrayBuffer arrayBuffer(buffer, 4096);
724     auto retRd = result->Read(arrayBuffer, opt);
725     EXPECT_FALSE(retRd.IsSuccess());
726     EXPECT_EQ(retRd.GetError().GetErrNo(), 13900020);
727 
728     auto retCs = result->Close();
729     ASSERT_TRUE(retCs.IsSuccess());
730 
731     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0004";
732 }
733 
734 /**
735  * @tc.name: FsStreamReadTest_0005
736  * @tc.desc: Test function of Read() interface for no permission.
737  * @tc.size: MEDIUM
738  * @tc.type: FUNC
739  * @tc.level Level 1
740  */
741 HWTEST_F(FsStreamTest, FsStreamReadTest_0005, testing::ext::TestSize.Level1)
742 {
743     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0005";
744     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "w");
745     ASSERT_TRUE(ret.IsSuccess());
746     auto result = ret.GetData().value();
747 
748     void *buffer = std::malloc(4096);
749     ArrayBuffer arrayBuffer(buffer, 4096);
750     auto retRd = result->Read(arrayBuffer);
751     EXPECT_FALSE(retRd.IsSuccess());
752     EXPECT_EQ(retRd.GetError().GetErrNo(), 13900005);
753 
754     auto retCs = result->Close();
755     ASSERT_TRUE(retCs.IsSuccess());
756 
757     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0005";
758 }
759 
760 /**
761  * @tc.name: FsStreamReadTest_0006
762  * @tc.desc: Test function of Read() interface for success.
763  * @tc.size: MEDIUM
764  * @tc.type: FUNC
765  * @tc.level Level 1
766  */
767 HWTEST_F(FsStreamTest, FsStreamReadTest_0006, testing::ext::TestSize.Level1)
768 {
769     GTEST_LOG_(INFO) << "FsStreamTest-begin FsStreamReadTest_0006";
770     auto ret = CreateStreamCore::DoCreateStream(streamFilePath, "r+");
771     ASSERT_TRUE(ret.IsSuccess());
772     auto result = ret.GetData().value();
773 
774     ReadOptions opt;
775     opt.offset = 0;
776     opt.length = 5;
777     void *buffer = std::malloc(4096);
778     ArrayBuffer arrayBuffer(buffer, 4096);
779 
780     auto retRd = result->Read(arrayBuffer, opt);
781     ASSERT_TRUE(retRd.IsSuccess());
782 
783     size_t retLen = retRd.GetData().value();
784     EXPECT_EQ(retLen, 0);
785 
786     auto retCs = result->Close();
787     ASSERT_TRUE(retCs.IsSuccess());
788 
789     GTEST_LOG_(INFO) << "FsStreamTest-end FsStreamReadTest_0006";
790 }
791 
792 } // namespace ModuleFileIO
793 } // namespace FileManagement
794 } // namespace OHOS