1 /*
2 * Copyright (C) 2024 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 <cstdint>
18 #include <cstdlib>
19 #include <ctime>
20 #include <fstream>
21 #include <iostream>
22 #include <memory>
23 #include <sstream>
24 #include <string>
25 #include <unordered_map>
26
27 #include <csetjmp>
28 #include <csignal>
29 #include <cstring>
30 #include <dirent.h>
31 #include <execinfo.h>
32 #include <fcntl.h>
33 #include <pwd.h>
34 #include <sys/stat.h>
35 #include <unistd.h>
36
37 #include <gmock/gmock-actions.h>
38 #include <gmock/gmock-cardinalities.h>
39 #include <gmock/gmock-spec-builders.h>
40 #include <gmock/gmock.h>
41 #include <gtest/gtest.h>
42
43 #include "metadata_stream.h"
44 #include "buffer_metadata_stream.h"
45 #include "file_metadata_stream.h"
46 #include "data_buf.h"
47
48 using namespace testing::ext;
49 using namespace testing;
50 using namespace OHOS::Media;
51
52 namespace OHOS {
53 namespace Media {
54 const int SIZE_1024 = 1024;
55 const int SIZE_512 = 512;
56 const int SIZE_255 = 255;
57 const int SIZE_20 = 20;
58 const int SIZE_10 = 10;
59 const int TEST_DIR_PERMISSIONS = 0777;
60
61 class MemoryCheck {
62 public:
Start()63 void Start()
64 {
65 startVmSize = GetVmSize();
66 startVmRSS = GetVmRSS();
67 startFdCount = CountOpenFileDescriptors();
68 }
69
End()70 void End()
71 {
72 endVmSize = GetVmSize();
73 endVmRSS = GetVmRSS();
74 endFdCount = CountOpenFileDescriptors();
75 }
76
77 bool check = true;
78
Compare() const79 bool Compare() const
80 {
81 if (check) {
82 if (startVmSize != endVmSize || startVmRSS != endVmRSS || startFdCount != endFdCount) {
83 std::cout << "Difference in VmSize: " << endVmSize - startVmSize << std::endl;
84 std::cout << "Difference in VmRSS: " << endVmRSS - startVmRSS << std::endl;
85 std::cout << "Difference in File Descriptors: " << endFdCount - startFdCount << std::endl;
86 return false;
87 }
88 }
89 return true;
90 }
91
92 private:
GetVmSize() const93 long GetVmSize() const
94 {
95 return GetMemoryInfo("VmSize:");
96 }
97
GetVmRSS() const98 long GetVmRSS() const
99 {
100 return GetMemoryInfo("VmRSS:");
101 }
102
CountOpenFileDescriptors() const103 int CountOpenFileDescriptors() const
104 {
105 DIR *dir;
106 int fdCount = 0;
107 std::string dirPath = "/proc/" + std::to_string(getpid()) + "/fd/";
108 if ((dir = opendir(dirPath.c_str())) != nullptr) {
109 while (readdir(dir) != nullptr) {
110 fdCount++;
111 }
112 closedir(dir);
113 } else {
114 std::cerr << "Could not open " << dirPath << std::endl;
115 }
116
117 return fdCount;
118 }
119
GetMemoryInfo(const std::string & name) const120 long GetMemoryInfo(const std::string &name) const
121 {
122 std::string line;
123 std::ifstream statusFile("/proc/self/status");
124
125 while (std::getline(statusFile, line)) {
126 if (line.find(name) != std::string::npos) {
127 return std::stol(line.substr(name.length()));
128 }
129 }
130
131 return 0;
132 }
133
134 long startVmSize = 0;
135 long startVmRSS = 0;
136 long endVmSize = 0;
137 long endVmRSS = 0;
138 int startFdCount = 0;
139 int endFdCount = 0;
140 };
141
CountOpenFileDescriptors()142 int CountOpenFileDescriptors()
143 {
144 DIR *dir;
145 int fdCount = 0;
146 std::string dirPath = "/proc/" + std::to_string(getpid()) + "/fd/";
147 if ((dir = opendir(dirPath.c_str())) != nullptr) {
148 while (readdir(dir) != nullptr) {
149 fdCount++;
150 }
151 closedir(dir);
152 } else {
153 std::cerr << "Could not open " << dirPath << std::endl;
154 }
155
156 return fdCount;
157 }
158
159
RemoveFile(const std::string & filePath)160 void RemoveFile(const std::string &filePath)
161 {
162 int result = remove(filePath.c_str());
163 if (result != 0) {
164 char errstr[METADATA_STREAM_ERROR_BUFFER_SIZE];
165 strerror_r(errno, errstr, sizeof(errstr));
166 }
167 }
168
CreateIfNotExit(const std::string & filePath)169 std::string CreateIfNotExit(const std::string &filePath)
170 {
171 struct stat buffer;
172 if (stat(filePath.c_str(), &buffer) != 0) { // 文件不存在
173 std::ofstream file(filePath);
174 if (!file) {
175 std::cerr << "Failed to create file: " << filePath << std::endl;
176 } else {
177 file.close();
178 }
179 }
180 return filePath;
181 }
182
183 class MetadataStreamTest : public testing::Test {
184 public:
MetadataStreamTest()185 MetadataStreamTest() {}
~MetadataStreamTest()186 ~MetadataStreamTest() override {}
187 std::string filePath = "/data/local/tmp/image/testfile.txt";
188 std::string filePathSource = "/data/local/tmp/image/test_exif_test.jpg";
189 std::string filePathDest = "/data/local/tmp/image/testfile_dest.png";
190 std::string backupFilePathSource = "/data/local/tmp/image/test_exif.jpg";
191 const ssize_t testSize[4] = {
192 1,
193 METADATA_STREAM_PAGE_SIZE + 1,
194 METADATA_STREAM_PAGE_SIZE,
195 METADATA_STREAM_PAGE_SIZE - 1
196 };
197 MemoryCheck memoryCheck;
198
SetUp()199 void SetUp() override
200 {
201 // Create the directory
202 std::string dirPath = "/data/local/tmp/image";
203 if (access(dirPath.c_str(), F_OK) != 0) {
204 int ret = mkdir(dirPath.c_str(), TEST_DIR_PERMISSIONS);
205 if (ret != 0) {
206 char buf[METADATA_STREAM_ERROR_BUFFER_SIZE];
207 strerror_r(errno, buf, sizeof(buf));
208 GTEST_LOG_(ERROR) << "Failed to create directory: " << dirPath << ", error: " << buf;
209 }
210 }
211
212 // Backup the files
213 std::filesystem::copy(backupFilePathSource, filePathSource, std::filesystem::copy_options::overwrite_existing);
214 memoryCheck.check = true;
215 memoryCheck.Start();
216 }
217
218 const static std::string tmpDirectory;
219 static bool alreadyExist;
220
TearDown()221 void TearDown() override
222 {
223 memoryCheck.End();
224 memoryCheck.check = false;
225 if (!memoryCheck.Compare()) {
226 GTEST_LOG_(INFO) << "Memory leak detected";
227 }
228 RemoveFile(filePath.c_str());
229 RemoveFile(filePathDest.c_str());
230 }
231
SetUpTestCase()232 static void SetUpTestCase()
233 {
234 // Create the directory
235 if (access(tmpDirectory.c_str(), F_OK) != 0) {
236 int ret = mkdir(tmpDirectory.c_str(), TEST_DIR_PERMISSIONS);
237 if (ret != 0) {
238 char buf[METADATA_STREAM_ERROR_BUFFER_SIZE];
239 strerror_r(errno, buf, sizeof(buf));
240 GTEST_LOG_(ERROR) << "Failed to create directory: " << tmpDirectory << ", error: " << buf;
241 }
242 alreadyExist = false;
243 } else {
244 alreadyExist = true;
245 }
246 }
TearDownTestCase()247 static void TearDownTestCase()
248 {
249 if (!alreadyExist) {
250 rmdir(tmpDirectory.c_str());
251 }
252 }
253 };
254
255 bool MetadataStreamTest::alreadyExist = false;
256 const std::string MetadataStreamTest::tmpDirectory = "/data/local/tmp/image";
257
258 class MockFileWrapper : public FileWrapper {
259 public:
260 MOCK_METHOD(ssize_t, FWrite, (const void *src, size_t size, ssize_t nmemb, FILE *file), (override));
261 MOCK_METHOD(ssize_t, FRead, (void *destv, size_t size, ssize_t nmemb, FILE *file), (override));
262
MockFileWrapper()263 MockFileWrapper()
264 {
265 // Set the default behavior of write to call the system's write function
266 ON_CALL(*this, FWrite(_, _, _, _))
267 .WillByDefault(Invoke([](const void *src, size_t size, ssize_t nmemb, FILE *file) {
268 size_t result = ::fwrite(src, size, nmemb, file);
269 if (result != static_cast<size_t>(nmemb)) {
270 char errstr[METADATA_STREAM_ERROR_BUFFER_SIZE];
271 strerror_r(errno, errstr, sizeof(errstr));
272 std::cerr << "Failed to write to the file: " << errstr << std::endl;
273 }
274 return result;
275 }));
276 // Set the default behavior of read to call the system's read function
277 ON_CALL(*this, FRead(_, _, _, _)).WillByDefault(Invoke([](void *destv, size_t size, ssize_t nmemb, FILE *file) {
278 size_t result = ::fread(destv, size, nmemb, file);
279 if (result != static_cast<size_t>(nmemb)) {
280 char errstr[METADATA_STREAM_ERROR_BUFFER_SIZE];
281 strerror_r(errno, errstr, sizeof(errstr));
282 std::cerr << "Failed to read from the file: " << errstr << std::endl;
283 }
284 return result;
285 }));
286 }
287 };
288
289 /**
290 * @tc.name: FileMetadataStream_Write001
291 * @tc.desc: Test the Write function of FileMetadataStream, whether it can write
292 * normally and verify the written data
293 * @tc.type: FUNC
294 */
295 HWTEST_F(MetadataStreamTest, FileMetadataStream_Write001, TestSize.Level3)
296 {
297 // Create a FileMetadataStream object
298 FileMetadataStream stream(CreateIfNotExit(filePath));
299
300 // Open the file
301 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
302
303 // Create some data to write
304 byte data[SIZE_10] = {0};
305
306 ASSERT_EQ(stream.Tell(), 0);
307
308 // Write the data to the file
309 size_t bytesWritten = stream.Write(data, sizeof(data));
310
311 // Check that the correct number of bytes were written
312 ASSERT_EQ(bytesWritten, sizeof(data));
313
314 // Flush the file
315 stream.Flush();
316
317 // Open the file again
318 int fileDescriptor = open(filePath.c_str(), O_RDONLY);
319 ASSERT_NE(fileDescriptor, -1);
320
321 // Read the data from the file
322 byte buffer[SIZE_10];
323 ssize_t bytesRead = read(fileDescriptor, buffer, sizeof(buffer));
324
325 // Check that the correct number of bytes were read
326 ASSERT_EQ(bytesRead, sizeof(data));
327
328 // Check that the data read is the same as the data written
329 ASSERT_EQ(memcmp(data, buffer, sizeof(data)), 0);
330
331 // Close the file
332 close(fileDescriptor);
333 }
334
335 /**
336 * @tc.name: FileMetadataStream_Write002
337 * @tc.desc: Test the Write function of FileMetadataStream when the file is not
338 * open
339 * @tc.type: FUNC
340 */
341 HWTEST_F(MetadataStreamTest, FileMetadataStream_Write002, TestSize.Level3)
342 {
343 FileMetadataStream stream(filePath);
344 byte data[SIZE_10] = {0};
345 ASSERT_EQ(stream.Write(data, sizeof(data)), -1);
346 }
347
348 /**
349 * @tc.name: FileMetadataStream_Write003
350 * @tc.desc: Test the Write function of FileMetadataStream when the amount of data
351 * written exceeds the remaining space in the file system
352 * @tc.type: FUNC
353 */
354 HWTEST_F(MetadataStreamTest, FileMetadataStream_Write003, TestSize.Level3)
355 {
356 // This test case requires an MetadataStream object that can simulate a read
357 // failure, so mock technology may be needed in actual testing
358 auto mockFileWrapper = std::make_unique<MockFileWrapper>();
359 // Set the behavior of the write function to always return -1, simulating a
360 // write failure
361 EXPECT_CALL(*mockFileWrapper.get(), FWrite(_, _, _, _)).WillOnce(Return(-1));
362
363 FileMetadataStream stream(CreateIfNotExit(filePath), std::move(mockFileWrapper));
364
365 // Test the Write function
366 byte buffer[SIZE_1024];
367 stream.Open(OpenMode::ReadWrite);
368 EXPECT_EQ(stream.Write(buffer, sizeof(buffer)), -1);
369 }
370
371 /**
372 * @tc.name: FileMetadataStream_Write004
373 * @tc.desc: Test the Write function of FileMetadataStream when all data from the
374 * source image stream has been read
375 * @tc.type: FUNC
376 */
377 HWTEST_F(MetadataStreamTest, FileMetadataStream_Write004, TestSize.Level3)
378 {
379 FileMetadataStream stream1(filePathSource);
380 FileMetadataStream stream2(CreateIfNotExit(filePathDest));
381 ASSERT_TRUE(stream1.Open(OpenMode::ReadWrite));
382 ASSERT_TRUE(stream2.Open(OpenMode::ReadWrite));
383 // Read all data from stream1
384 byte buffer[METADATA_STREAM_PAGE_SIZE];
385 while (stream1.Read(buffer, sizeof(buffer)) > 0) {
386 }
387 // At this point, all data from stream1 has been read, so the write should
388 // return 0
389 byte *buf = new byte[stream1.GetSize()];
390 stream1.Read(buf, stream1.GetSize());
391 ASSERT_EQ(stream2.Write(buf, stream1.GetSize()), stream1.GetSize());
392 stream1.Flush();
393 stream2.Flush();
394 delete[] buf;
395 }
396
397 /**
398 * @tc.name: FileMetadataStream_Write005
399 * @tc.desc: Test the Write function of FileMetadataStream when reading data from
400 * the source image stream fails
401 * @tc.type: FUNC
402 */
403 HWTEST_F(MetadataStreamTest, FileMetadataStream_Write005, TestSize.Level3)
404 {
405 // This test case requires an MetadataStream object that can simulate a read
406 // failure, so mock technology may be needed in actual testing
407 auto mockSourceFileWrapper = std::make_unique<MockFileWrapper>();
408 auto mockDestFileWrapper = std::make_unique<MockFileWrapper>();
409
410 // Set the behavior of the write function to always return -1, simulating a
411 // write failure
412 EXPECT_CALL(*mockDestFileWrapper.get(), FWrite(_, _, _, _)).Times(Exactly(0));
413 EXPECT_CALL(*mockSourceFileWrapper.get(), FRead(_, _, _, _)).WillOnce(Return(-1));
414
415 FileMetadataStream sourceStream(filePathSource, std::move(mockSourceFileWrapper));
416 FileMetadataStream destStream(filePath, std::move(mockDestFileWrapper));
417
418 // Test the Write function
419 sourceStream.Open();
420 destStream.Open();
421 byte *buf = new byte[sourceStream.GetSize()];
422 EXPECT_EQ(sourceStream.Read(buf, sourceStream.GetSize()), -1);
423 delete[] buf;
424 }
425
426 /**
427 * @tc.name: FileMetadataStream_Write001
428 * @tc.desc: Test the Write function of FileMetadataStream, whether it can write
429 * normally and verify the written data
430 * @tc.type: FUNC
431 */
432 HWTEST_F(MetadataStreamTest, FileMetadataStream_Write007, TestSize.Level3)
433 {
434 // Create a FileMetadataStream object
435 FileMetadataStream stream(CreateIfNotExit(filePath));
436
437 // Open the file
438 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
439
440 // Create some data to write
441 std::string data = "1Hello, world!";
442
443 ASSERT_EQ(stream.Seek(0, SeekPos::BEGIN), 0);
444 ASSERT_EQ(stream.Tell(), 0);
445 // Write the data to the file
446 ASSERT_EQ(stream.Write((byte *)data.c_str(), data.size()), data.size());
447 ASSERT_EQ(stream.Tell(), data.size());
448 // Flush the file
449 stream.Flush();
450
451 // Open the file again
452 int fileDescriptor = open(filePath.c_str(), O_RDONLY);
453 ASSERT_NE(fileDescriptor, -1);
454
455 // Read the data from the file
456 byte buffer[SIZE_20];
457 read(fileDescriptor, buffer, sizeof(buffer));
458
459 // Check that the data read is the same as the data written
460 ASSERT_EQ(memcmp(data.c_str(), buffer, data.size()), 0);
461
462 // Close the file
463 close(fileDescriptor);
464 }
465
466 HWTEST_F(MetadataStreamTest, FileMetadataStream_Write008, TestSize.Level3)
467 {
468 for (ssize_t size : testSize) {
469 RemoveFile(filePath);
470 FileMetadataStream stream(CreateIfNotExit(filePath));
471 ASSERT_TRUE(stream.Open());
472 byte *buf = new byte[size](); // Dynamically allocate the buffer with the current test size
473 ASSERT_EQ(stream.Write(buf, size), size);
474 ASSERT_EQ(stream.Flush(), true);
475 ASSERT_EQ(stream.GetSize(), size);
476
477 // Open the file in binary mode and move the file pointer to the end to get the file size
478 std::ifstream file(filePath, std::ios::binary | std::ios::ate);
479 ASSERT_TRUE(file.is_open());
480
481 // Get the file size
482 std::streamsize fileSize = file.tellg();
483 file.close();
484
485 // Compare the file size with the current test size
486 ASSERT_EQ(fileSize, size);
487
488 delete[] buf; // Don't forget to delete the dynamically allocated buffer
489 }
490 }
491
492 /**
493 * @tc.name: FileMetadataStream_Open001
494 * @tc.desc: Test the Open function of FileMetadataStream when the file path does
495 * not exist
496 * @tc.type: FUNC
497 */
498 HWTEST_F(MetadataStreamTest, FileMetadataStream_Open001, TestSize.Level3)
499 {
500 // Test the case where the file path does not exist
501 std::string nonExistFilePath = "/data/local/tmp/image/non_exist_file.txt";
502 RemoveFile(nonExistFilePath.c_str());
503 FileMetadataStream stream1(CreateIfNotExit(nonExistFilePath));
504 ASSERT_TRUE(stream1.Open());
505 std::string sourceData = "Hello, world!";
506 stream1.Write((byte *)sourceData.c_str(), sourceData.size());
507 // Read data from stream1
508 byte buffer[SIZE_255];
509 stream1.Seek(0, SeekPos::BEGIN);
510 ssize_t bytesRead = stream1.Read(buffer, sourceData.size());
511 ASSERT_EQ(bytesRead, sourceData.size());
512 buffer[bytesRead] = '\0'; // Add string termination character
513 // Check if the read data is the same as the written data
514 ASSERT_STREQ((char *)buffer, sourceData.c_str());
515 ASSERT_TRUE(stream1.Flush());
516 RemoveFile(nonExistFilePath.c_str());
517 }
518
519 /**
520 * @tc.name: FileMetadataStream_Open002
521 * @tc.desc: Test the Open function of FileMetadataStream when the file path exists
522 * but is not writable
523 * @tc.type: FUNC
524 */
525 HWTEST_F(MetadataStreamTest, FileMetadataStream_Open002, TestSize.Level3)
526 {
527 // Get the username of the current user
528 uid_t uid = getuid();
529 struct passwd *passwordEntry = getpwuid(uid);
530 if (passwordEntry == nullptr) {
531 perror("getpwuid");
532 return;
533 }
534 std::string username(passwordEntry->pw_name);
535
536 // Test the case where the file path exists but is not writable
537 std::string nonWritableFilePath = "/data/local/tmp/image/non_writable_file.txt";
538 close(open(nonWritableFilePath.c_str(), O_CREAT, S_IRUSR));
539 FileMetadataStream stream2(nonWritableFilePath);
540 if (username == "root") {
541 // If the current user is root, then it can be opened successfully
542 ASSERT_TRUE(stream2.Open());
543 } else {
544 // If the current user is not root, then it cannot be opened
545 ASSERT_FALSE(stream2.Open());
546 }
547 RemoveFile(nonWritableFilePath.c_str());
548 }
549
550 /**
551 * @tc.name: FileMetadataStream_Open003
552 * @tc.desc: Test the Open function of FileMetadataStream when the file is already
553 * open
554 * @tc.type: FUNC
555 */
556 HWTEST_F(MetadataStreamTest, FileMetadataStream_Open003, TestSize.Level3)
557 {
558 // Test the case where the file is already open
559 FileMetadataStream stream3(CreateIfNotExit(filePath));
560 ASSERT_TRUE(stream3.Open());
561 ASSERT_TRUE(stream3.Open());
562 ASSERT_TRUE(stream3.Flush());
563 }
564
565 /**
566 * @tc.name: FileMetadataStream_Open004
567 * @tc.desc: Test the Open function of FileMetadataStream when the file does not
568 * exist
569 * @tc.type: FUNC
570 */
571 HWTEST_F(MetadataStreamTest, FileMetadataStream_Open004, TestSize.Level3)
572 {
573 // Test the case where the file does not exist
574 const char *nonExistentFilePath = "/path/to/nonexistent/file";
575 FileMetadataStream stream(nonExistentFilePath);
576 ASSERT_FALSE(stream.Open(OpenMode::Read));
577 }
578
579 /**
580 * @tc.name: FileMetadataStream_Open005
581 * @tc.desc: Test the Open twice
582 * @tc.type: FUNC
583 */
584 HWTEST_F(MetadataStreamTest, FileMetadataStream_Open005, TestSize.Level3)
585 {
586 FileMetadataStream stream(filePathSource);
587 ASSERT_TRUE(stream.Open(OpenMode::Read));
588 ASSERT_TRUE(stream.Open(OpenMode::Read));
589 }
590
591 /**
592 * @tc.name: FileMetadataStream_Read001
593 * @tc.desc: Test the Read function of FileMetadataStream, reading 512 bytes
594 * @tc.type: FUNC
595 */
596 HWTEST_F(MetadataStreamTest, FileMetadataStream_Read001, TestSize.Level3)
597 {
598 FileMetadataStream stream(filePathSource);
599 byte buffer[SIZE_1024];
600 stream.Open(OpenMode::ReadWrite);
601 // Simulate reading 512 bytes
602 ssize_t bytesRead = stream.Read(buffer, SIZE_512);
603 EXPECT_EQ(SIZE_512, bytesRead);
604 }
605
606 /**
607 * @tc.name: FileMetadataStream_Read002
608 * @tc.desc: Test the Read function of FileMetadataStream, trying to read from a
609 * file that has not been opened
610 * @tc.type: FUNC
611 */
612 HWTEST_F(MetadataStreamTest, FileMetadataStream_Read002, TestSize.Level3)
613 {
614 FileMetadataStream stream(filePathSource);
615 byte buffer[SIZE_1024];
616 // Flush the stream to simulate an unopened file
617 ASSERT_FALSE(stream.Flush());
618 ssize_t bytesRead = stream.Read(buffer, SIZE_512);
619 EXPECT_EQ(-1, bytesRead);
620 }
621
622 /**
623 * @tc.name: FileMetadataStream_MMap001
624 * @tc.desc: Test the MMap function of FileMetadataStream, trying to write to a
625 * memory-mapped file that is not writable
626 * @tc.type: FUNC
627 */
628 HWTEST_F(MetadataStreamTest, FileMetadataStream_MMap001, TestSize.Level3)
629 {
630 memoryCheck.check = false; // This test is expected to crash, so memory leak
631 // check is not needed
632 // Assume there is an appropriate way to create or obtain the resources
633 // needed for the test YourResource test_resource; Test the behavior of the
634 // MMap function when isWriteable is false
635 FileMetadataStream stream(filePathSource);
636 byte *result = stream.GetAddr(false);
637 // Assume that checking whether result is not nullptr, or there is another
638 // appropriate verification method
639 ASSERT_EQ(result, nullptr);
640 stream.Open(OpenMode::ReadWrite);
641 result = stream.GetAddr(false);
642 ASSERT_NE(result, nullptr);
643 }
644
645 /**
646 * @tc.name: FileMetadataStream_MMap002
647 * @tc.desc: Test the MMap function of FileMetadataStream, trying to write to a
648 * memory-mapped file that is writable
649 * @tc.type: FUNC
650 */
651 HWTEST_F(MetadataStreamTest, FileMetadataStream_MMap002, TestSize.Level3)
652 {
653 // Test the behavior of the MMap function when isWriteable is true
654 FileMetadataStream stream(filePathSource);
655 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
656 byte *result = stream.GetAddr(true);
657 ASSERT_NE(result, nullptr);
658 // Try to write data
659 result[0] = 123;
660
661 // Read the data and check if it is the same as the written data
662 ASSERT_EQ(result[0], 123);
663 }
664
665 /**
666 * @tc.name: FileMetadataStream_MMap003
667 * @tc.desc: Test whether the MMap function of FileMetadataStream can actually
668 * modify the content of the file
669 * @tc.type: FUNC
670 */
671 HWTEST_F(MetadataStreamTest, FileMetadataStream_MMap003, TestSize.Level3)
672 {
673 // Test whether MMap can actually modify the content of the file
674 FileMetadataStream stream(filePathSource);
675 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
676 byte *result = stream.GetAddr(true);
677 ASSERT_NE(result, nullptr);
678
679 // Try to write data
680 result[0] = 123;
681
682 stream.Seek(0, SeekPos::BEGIN);
683 byte buffer[1];
684 ASSERT_EQ(stream.Read(buffer, 1), 1);
685 ASSERT_EQ(buffer[0], 123);
686
687 // Flush stream
688 ASSERT_TRUE(stream.Flush());
689 FileMetadataStream checkStream(filePathSource);
690 checkStream.Open(OpenMode::ReadWrite);
691 byte checkBuffer[1];
692 ASSERT_EQ(checkStream.Read(checkBuffer, 1), 1);
693
694 // Check if the data in the file is the same as the data written
695 ASSERT_EQ(checkBuffer[0], 123);
696 }
697
698 /**
699 * @tc.name: FileMetadataStream_CopyFrom001
700 * @tc.desc: Test the CopyFrom function of FileMetadataStream, copying data from
701 * one stream to another
702 * @tc.type: FUNC
703 */
704 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom001, TestSize.Level3)
705 {
706 FileMetadataStream src(filePathSource);
707 FileMetadataStream dest(CreateIfNotExit(filePathDest));
708
709 src.Open();
710 // Write some known data to src
711 std::string data = "Hello, world!";
712 ASSERT_EQ(src.Tell(), 0);
713 ASSERT_GE(src.Write((byte *)data.c_str(), data.size()), 0);
714 ASSERT_TRUE(src.Flush());
715 // Call the Transfer function to transfer data from src to dest
716 dest.Open();
717 ASSERT_TRUE(dest.CopyFrom(src));
718 // Read data from dest and verify that it is the same as the data written to
719 // src
720 byte buffer[SIZE_255] = {0};
721
722 ASSERT_EQ(dest.Seek(0, SeekPos::BEGIN), 0);
723 ASSERT_EQ(dest.Read(buffer, data.size()), data.size());
724 ASSERT_EQ(std::string(buffer, buffer + data.size()), data);
725
726 // Verify that src is empty
727 ASSERT_EQ(dest.GetSize(), src.GetSize());
728 }
729
730 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom002, TestSize.Level3)
731 {
732 BufferMetadataStream src;
733 FileMetadataStream dest(CreateIfNotExit(filePathDest));
734 ASSERT_TRUE(src.Open());
735 ASSERT_EQ(dest.Open(), true);
736 src.Write((byte *)"Hello, world!", 13);
737 char bufSrc[14] = {0};
738 src.Seek(0, SeekPos::BEGIN);
739 src.Read((byte *)bufSrc, 13);
740 ASSERT_STREQ(bufSrc, "Hello, world!");
741 ASSERT_TRUE(dest.CopyFrom(src));
742 dest.Seek(0, SeekPos::BEGIN);
743 char buf[14] = {0};
744 dest.Read((byte *)buf, 13);
745 ASSERT_STREQ(buf, "Hello, world!");
746 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), 13), 0);
747 }
748
749 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom003, TestSize.Level3)
750 {
751 BufferMetadataStream src;
752 FileMetadataStream dest(CreateIfNotExit(filePathDest));
753 src.Open();
754 dest.Open();
755 char buff[METADATA_STREAM_PAGE_SIZE + 1] = {0};
756 src.Write((byte *)buff, sizeof(buff));
757 ASSERT_TRUE(dest.CopyFrom(src));
758 ASSERT_EQ(src.GetSize(), dest.GetSize());
759 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), 4097), 0);
760 }
761
762 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom004, TestSize.Level3)
763 {
764 BufferMetadataStream src;
765 FileMetadataStream dest(CreateIfNotExit(filePathDest));
766 src.Open();
767 dest.Open();
768 char buff[METADATA_STREAM_PAGE_SIZE - 1] = {0};
769 src.Write((byte *)buff, sizeof(buff));
770 ASSERT_TRUE(dest.CopyFrom(src));
771 ASSERT_EQ(src.GetSize(), dest.GetSize());
772 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
773 }
774
775 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom005, TestSize.Level3)
776 {
777 RemoveFile(filePath.c_str());
778 FileMetadataStream src(CreateIfNotExit(filePathDest));
779 BufferMetadataStream dest;
780 src.Open();
781 dest.Open();
782 char buff[METADATA_STREAM_PAGE_SIZE - 1] = {0};
783 ASSERT_EQ(src.Write((byte *)buff, sizeof(buff)), sizeof(buff));
784 ASSERT_TRUE(src.Flush());
785 ASSERT_EQ(src.Tell(), sizeof(buff));
786 ASSERT_EQ(src.GetSize(), sizeof(buff));
787 ASSERT_TRUE(dest.CopyFrom(src));
788 ASSERT_EQ(src.GetSize(), dest.GetSize());
789 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
790 }
791
792 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom006, TestSize.Level3)
793 {
794 for (ssize_t size : testSize) {
795 RemoveFile(filePathDest.c_str());
796 FileMetadataStream src(CreateIfNotExit(filePathDest));
797 BufferMetadataStream dest;
798 src.Open();
799 dest.Open();
800 byte *buf = new byte[size]();
801 ASSERT_EQ(src.Write(buf, size), size);
802 ASSERT_TRUE(src.Flush());
803 ASSERT_EQ(src.Tell(), size);
804 ASSERT_EQ(src.GetSize(), size);
805 ASSERT_TRUE(dest.CopyFrom(src));
806 ASSERT_EQ(src.GetSize(), dest.GetSize());
807 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
808 delete[] buf;
809 }
810 }
811
812 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom007, TestSize.Level3)
813 {
814 for (ssize_t size : testSize) {
815 RemoveFile(filePath.c_str());
816 FileMetadataStream dest(CreateIfNotExit(filePathDest));
817 BufferMetadataStream src;
818 src.Open();
819 dest.Open();
820 byte *buf = new byte[size]();
821 ASSERT_EQ(src.Write(buf, size), size);
822 ASSERT_TRUE(src.Flush());
823 ASSERT_EQ(src.Tell(), size);
824 ASSERT_EQ(src.GetSize(), size);
825 ASSERT_TRUE(dest.CopyFrom(src));
826 ASSERT_EQ(src.GetSize(), dest.GetSize());
827 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
828 delete[] buf;
829 }
830 }
831
832 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom008, TestSize.Level3)
833 {
834 for (ssize_t size : testSize) {
835 RemoveFile(filePathDest.c_str());
836 RemoveFile(filePathSource.c_str());
837 FileMetadataStream src(CreateIfNotExit(filePathSource));
838 FileMetadataStream dest(CreateIfNotExit(filePathDest));
839 src.Open();
840 dest.Open();
841 byte *buf = new byte[size]();
842 ASSERT_EQ(src.Write(buf, size), size);
843 ASSERT_TRUE(src.Flush());
844 ASSERT_EQ(src.Tell(), size);
845 ASSERT_EQ(src.GetSize(), size);
846 ASSERT_TRUE(dest.CopyFrom(src));
847 ASSERT_EQ(src.GetSize(), dest.GetSize());
848 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
849 delete[] buf;
850 }
851 }
852
853 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom009, TestSize.Level3)
854 {
855 for (ssize_t size : testSize) {
856 RemoveFile(filePath.c_str());
857 BufferMetadataStream src;
858 BufferMetadataStream dest;
859 src.Open();
860 dest.Open();
861 byte *buf = new byte[size]();
862 ASSERT_EQ(src.Write(buf, size), size);
863 ASSERT_TRUE(src.Flush());
864 ASSERT_EQ(src.Tell(), size);
865 ASSERT_EQ(src.GetSize(), size);
866 ASSERT_TRUE(dest.CopyFrom(src));
867 ASSERT_EQ(src.GetSize(), dest.GetSize());
868 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
869 delete[] buf;
870 }
871 }
872
873 HWTEST_F(MetadataStreamTest, FileMetadataStream_CopyFrom010, TestSize.Level3)
874 {
875 for (ssize_t size : testSize) {
876 RemoveFile(filePathDest.c_str());
877 std::filesystem::copy(backupFilePathSource, filePathSource, std::filesystem::copy_options::overwrite_existing);
878 FileMetadataStream src(CreateIfNotExit(filePathDest));
879 FileMetadataStream dest(CreateIfNotExit(filePathSource));
880 src.Open();
881 dest.Open();
882 byte *buf = new byte[size]();
883 ASSERT_EQ(src.Write(buf, size), size);
884 ASSERT_TRUE(src.Flush());
885 ASSERT_EQ(src.Tell(), size);
886 ASSERT_EQ(src.GetSize(), size);
887 ASSERT_TRUE(dest.CopyFrom(src));
888 ASSERT_EQ(src.GetSize(), dest.GetSize());
889 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
890 delete[] buf;
891 }
892 }
893
894 HWTEST_F(MetadataStreamTest, FileMetadataStream_IsEof001, TestSize.Level3)
895 {
896 FileMetadataStream src(filePathSource);
897 src.Open();
898 byte buffer[1];
899 ASSERT_EQ(src.Seek(0, SeekPos::BEGIN), 0);
900 src.Read(buffer, sizeof(buffer));
901 ASSERT_FALSE(src.IsEof());
902 ASSERT_EQ(src.Seek(0, SeekPos::END), src.GetSize());
903 src.Read(buffer, sizeof(buffer));
904 ASSERT_TRUE(src.IsEof());
905 }
906
907 /**
908 * @tc.name: FileMetadataStream_ReadByte001
909 * @tc.desc: Test the ReadByte function of FileMetadataStream, comparing its output
910 * with the Read function
911 * @tc.type: FUNC
912 */
913 HWTEST_F(MetadataStreamTest, FileMetadataStream_ReadByte001, TestSize.Level3)
914 {
915 FileMetadataStream stream(filePathSource);
916 stream.Open(OpenMode::ReadWrite);
917
918 // Read 10 bytes using Read function
919 byte buffer[SIZE_10];
920 stream.Read(buffer, SIZE_10);
921
922 // Reset the file offset
923 stream.Seek(0, SeekPos::BEGIN);
924
925 // Read 10 bytes using ReadByte function
926 byte byteBuffer[SIZE_10];
927 for (int i = 0; i < SIZE_10; i++) {
928 byteBuffer[i] = stream.ReadByte();
929 }
930
931 // Compare the results
932 for (int i = 0; i < SIZE_10; i++) {
933 EXPECT_EQ(buffer[i], byteBuffer[i]);
934 }
935 }
936
937 /**
938 * @tc.name: FileMetadataStream_ReadByte002
939 * @tc.desc: Test the ReadByte function of FileMetadataStream, trying to read
940 * beyond the end of the file
941 * @tc.type: FUNC
942 */
943 HWTEST_F(MetadataStreamTest, FileMetadataStream_ReadByte002, TestSize.Level3)
944 {
945 FileMetadataStream stream(filePathSource);
946 stream.Open(OpenMode::ReadWrite);
947
948 // Set the file offset to the end of the file
949 EXPECT_EQ(stream.Seek(0, SeekPos::END), stream.GetSize());
950
951 // Try to read one more byte
952 int result = stream.ReadByte();
953
954 // Check if the result is -1
955 EXPECT_EQ(result, -1);
956 }
957
958 /**
959 * @tc.name: FileMetadataStream_CONSTRUCTOR001
960 * @tc.desc: Test the constructor of FileMetadataStream, checking if it can
961 * correctly initialize a stream from an existing file pointer
962 * @tc.type: FUNC
963 */
964 HWTEST_F(MetadataStreamTest, FileMetadataStream_CONSTRUCTOR001, TestSize.Level3)
965 {
966 FileMetadataStream stream(CreateIfNotExit(filePath));
967 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
968 std::string sourceData = "Hello, world!";
969 ASSERT_EQ(stream.Seek(5, SeekPos::BEGIN), 5);
970 ASSERT_EQ(stream.Write((byte *)sourceData.c_str(), sourceData.size()), sourceData.size());
971
972 FileMetadataStream cloneStream(fileno(stream.fp_));
973 ASSERT_TRUE(stream.Flush());
974 ASSERT_TRUE(cloneStream.Open(OpenMode::ReadWrite));
975 // Read the data from cloneStream
976 byte buffer[SIZE_255];
977 cloneStream.Seek(5, SeekPos::BEGIN);
978 ssize_t bytesRead = cloneStream.Read(buffer, sourceData.size());
979 ASSERT_EQ(bytesRead, sourceData.size());
980 buffer[bytesRead] = '\0'; // Add string termination character
981
982 // Check if the read data is the same as the data in the source file
983 ASSERT_STREQ((char *)buffer, sourceData.c_str());
984
985 // Write some new data to cloneStream
986 std::string newData = "New data";
987 cloneStream.Write((byte *)newData.c_str(), newData.size());
988
989 // Read the data from cloneStream again
990 cloneStream.Seek(0, SeekPos::BEGIN);
991 bytesRead = cloneStream.Read(buffer, sizeof(buffer) - 1);
992 buffer[bytesRead] = '\0'; // Add string termination character
993
994 // Check if the read data contains the new data
995 ASSERT_STRNE((char *)buffer, newData.c_str());
996 }
997
998 /**
999 * @tc.name: FileMetadataStream_CONSTRUCTOR002
1000 * @tc.desc: Test the constructor of FileMetadataStream, checking if it can
1001 * correctly initialize a stream from an existing file descriptor
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(MetadataStreamTest, FileMetadataStream_CONSTRUCTOR002, TestSize.Level3)
1005 {
1006 // Create and open a temporary file
1007 std::string tempFile = tmpDirectory + "/testfile";
1008 int fileDescription = open(tempFile.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
1009 ASSERT_NE(fileDescription, -1);
1010
1011 // Use the file descriptor to create a new FileMetadataStream object
1012 FileMetadataStream stream(fileDescription);
1013 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
1014 ASSERT_NE(stream.dupFD_, -1);
1015 // Check the state of the FileMetadataStream object
1016 ASSERT_TRUE(stream.fp_ != nullptr);
1017 ASSERT_EQ(stream.mappedMemory_, nullptr);
1018 ASSERT_EQ(stream.Tell(), 0);
1019
1020 // Write data
1021 byte writeData[SIZE_10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1022 ssize_t bytesWritten = stream.Write(writeData, sizeof(writeData));
1023 ASSERT_EQ(bytesWritten, sizeof(writeData));
1024
1025 // Reset the file pointer to the beginning of the file
1026 stream.Seek(0, SeekPos::BEGIN);
1027
1028 // Read data
1029 byte readData[SIZE_10] = {0};
1030 ssize_t bytesRead = stream.Read(readData, sizeof(readData));
1031 ASSERT_EQ(bytesRead, sizeof(readData));
1032
1033 // Check if the read data is the same as the written data
1034 for (size_t i = 0; i < sizeof(writeData); ++i) {
1035 ASSERT_EQ(writeData[i], readData[i]);
1036 }
1037
1038 // Close the file
1039 close(fileDescription);
1040 RemoveFile(tempFile.c_str());
1041 }
1042
1043 /**
1044 * @tc.name: FileMetadataStream_CONSTRUCTOR003
1045 * @tc.desc: Test the constructor of FileMetadataStream, checking if it can
1046 * correctly initialize a stream from an existing file descriptor and handle
1047 * file operations
1048 * @tc.type: FUNC
1049 */
1050 HWTEST_F(MetadataStreamTest, FileMetadataStream_CONSTRUCTOR003, TestSize.Level3)
1051 {
1052 int fdCount = CountOpenFileDescriptors();
1053 std::string tempFile = tmpDirectory + "/testfile";
1054 int fileDescriptor = open(tempFile.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
1055 ASSERT_EQ(fdCount + 1, CountOpenFileDescriptors());
1056 int dupFD = dup(fileDescriptor);
1057 ASSERT_EQ(fdCount + 2, CountOpenFileDescriptors());
1058 ASSERT_NE(fileDescriptor, -1);
1059 FILE *fileStream = fdopen(dupFD, "r+"); // Change "rb" to "wb" for writing in binary mode
1060 ASSERT_EQ(fdCount + 2, CountOpenFileDescriptors());
1061 ;
1062 ASSERT_NE(fileStream, nullptr);
1063 std::string text = "Hello, world!";
1064 ssize_t result = fwrite(text.c_str(), sizeof(char), text.size(),
1065 fileStream); // Use sizeof(char) as the second argument
1066 ASSERT_EQ(ferror(fileStream), 0);
1067 ASSERT_EQ(result, text.size());
1068
1069 // Reset the file pointer to the beginning of the file
1070 rewind(fileStream);
1071
1072 ASSERT_EQ(fdCount + 2, CountOpenFileDescriptors());
1073 fileno(fileStream);
1074 ASSERT_EQ(fdCount + 2, CountOpenFileDescriptors());
1075
1076 // Read and verify the data
1077 char buffer[SIZE_255];
1078 result = fread(buffer, sizeof(char), text.size(), fileStream);
1079 ASSERT_EQ(result, text.size());
1080 buffer[result] = '\0'; // Add string termination character
1081 ASSERT_STREQ(buffer, text.c_str());
1082
1083 fclose(fileStream);
1084 ASSERT_EQ(fdCount + 1, CountOpenFileDescriptors());
1085 close(fileDescriptor);
1086 ASSERT_EQ(fdCount, CountOpenFileDescriptors());
1087 }
1088
1089 /**
1090 * @tc.name: FileMetadataStream_CONSTRUCTOR004
1091 * @tc.desc: Test the constructor of FileMetadataStream, checking if it can
1092 * correctly initialize a stream from an existing file descriptor and handle
1093 * file operations using the stream's file pointer
1094 * @tc.type: FUNC
1095 */
1096 HWTEST_F(MetadataStreamTest, FileMetadataStream_CONSTRUCTOR004, TestSize.Level3)
1097 {
1098 std::string tempFile = tmpDirectory + "/testfile";
1099 int fileDescriptor = open(tempFile.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
1100 FileMetadataStream stream(fileDescriptor);
1101 int dupFD = stream.dupFD_;
1102 ASSERT_NE(fileDescriptor, -1);
1103 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
1104 FILE *fileStream = stream.fp_; // Change "rb" to "wb" for writing in binary mode
1105 // binary mode
1106 ASSERT_NE(fileStream, nullptr);
1107 std::string text = "Hello, world!";
1108 ssize_t result = fwrite(text.c_str(), sizeof(char), text.size(),
1109 fileStream); // Use sizeof(char) as the second argument
1110 ASSERT_EQ(ferror(fileStream), 0);
1111 ASSERT_EQ(result, text.size());
1112
1113 // Reset the file pointer to the beginning of the file
1114 rewind(fileStream);
1115
1116 // Read and verify the data
1117 char buffer[SIZE_255];
1118 result = fread(buffer, sizeof(char), text.size(), fileStream);
1119 ASSERT_EQ(result, text.size());
1120 buffer[result] = '\0'; // Add string termination character
1121 ASSERT_STREQ(buffer, text.c_str());
1122
1123 fclose(fileStream);
1124 close(dupFD);
1125 close(fileDescriptor);
1126 }
1127
1128 HWTEST_F(MetadataStreamTest, FileMetadataStream_CONSTRUCTOR005, TestSize.Level3)
1129 {
1130 int fileDescriptor = open(filePathSource.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
1131 FileMetadataStream *stream = new FileMetadataStream(fileDescriptor);
1132 ASSERT_FALSE(stream->IsOpen());
1133 ASSERT_TRUE(stream->Open());
1134 delete stream;
1135 stream = new FileMetadataStream(fileDescriptor);
1136 ASSERT_TRUE(stream->Open());
1137 delete stream;
1138 }
1139
1140 /**
1141 * @tc.name: FileMetadataStream_DESTRUCTOR001
1142 * @tc.desc: Test the destructor of FileMetadataStream, checking if it can
1143 * correctly handle the deletion of a non-existing file
1144 * @tc.type: FUNC
1145 */
1146 HWTEST_F(MetadataStreamTest, FileMetadataStream_DESTRUCTOR001, TestSize.Level3)
1147 {
1148 FileMetadataStream *stream = new FileMetadataStream("/data/fileNotExist");
1149 ASSERT_FALSE(stream->Open());
1150 ASSERT_EQ(stream->Write((byte *)"Hello, the world", 16), -1);
1151 stream->GetAddr();
1152 ASSERT_FALSE(stream->Flush());
1153 delete stream;
1154 }
1155
1156 /**
1157 * @tc.name: FileMetadataStream_Seek001
1158 * @tc.desc: Test the Seek function of FileMetadataStream, checking if it can
1159 * correctly change the position of the file pointer
1160 * @tc.type: FUNC
1161 */
1162 HWTEST_F(MetadataStreamTest, FileMetadataStream_Seek001, TestSize.Level3)
1163 {
1164 RemoveFile(filePath.c_str());
1165 FileMetadataStream stream(CreateIfNotExit(filePath));
1166 stream.Open(OpenMode::ReadWrite);
1167 std::string sourceData = "Hello, world!";
1168 ASSERT_EQ(stream.Tell(), 0);
1169 stream.Write((byte *)sourceData.c_str(), sourceData.size());
1170 ASSERT_EQ(stream.Tell(), sourceData.size());
1171 stream.Seek(2, SeekPos::BEGIN);
1172 ASSERT_EQ(stream.Tell(), 2);
1173 byte buffer[SIZE_255];
1174 ssize_t bytesRead = stream.Read(buffer, 1);
1175 buffer[bytesRead] = '\0'; // Add string termination character
1176 ASSERT_STREQ((char *)buffer, "l");
1177 ASSERT_EQ(stream.Tell(), 3);
1178 stream.Seek(3, SeekPos::CURRENT);
1179 ASSERT_EQ(stream.Tell(), 6);
1180 bytesRead = stream.Read(buffer, 1);
1181 buffer[bytesRead] = '\0'; // Add string termination character
1182 ASSERT_STREQ((char *)buffer, " ");
1183 stream.Seek(0, SeekPos::END);
1184 ASSERT_EQ(stream.Tell(), sourceData.size());
1185 }
1186
1187 /**
1188 * @tc.name: BufferMetadataStream_Open001
1189 * @tc.desc: Test the Open function of BufferMetadataStream, checking if it can
1190 * correctly open a stream
1191 * @tc.type: FUNC
1192 */
1193 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Open001, TestSize.Level3)
1194 {
1195 BufferMetadataStream stream;
1196 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
1197 }
1198
1199 /**
1200 * @tc.name: BufferMetadataStream_Read001
1201 * @tc.desc: Test the Read function of BufferMetadataStream, checking if it can
1202 * correctly read data from the stream
1203 * @tc.type: FUNC
1204 */
1205 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Read001, TestSize.Level3)
1206 {
1207 BufferMetadataStream stream;
1208 ASSERT_TRUE(stream.Open(OpenMode::ReadWrite));
1209
1210 // Write a string
1211 std::string sourceData = "Hello, world!";
1212 ASSERT_EQ(stream.Tell(), 0);
1213 stream.Write((byte *)sourceData.c_str(), sourceData.size());
1214
1215 // Read the string
1216 byte buffer[SIZE_255];
1217 stream.Seek(0, SeekPos::BEGIN);
1218 size_t bytesRead = stream.Read(buffer, sourceData.size());
1219 buffer[bytesRead] = '\0'; // Add string termination character
1220
1221 // Compare the read string with the written string
1222 ASSERT_STREQ((char *)buffer, sourceData.c_str());
1223 }
1224
1225 /**
1226 * @tc.name: BufferMetadataStream_Write001
1227 * @tc.desc: Test the Write function of BufferMetadataStream, checking if it can
1228 * correctly write data to the stream
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Write001, TestSize.Level3)
1232 {
1233 BufferMetadataStream stream;
1234 byte data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1235 stream.Open(OpenMode::ReadWrite);
1236 size_t size = sizeof(data) / sizeof(data[0]);
1237 int offset = 0;
1238 stream.Seek(0, SeekPos::BEGIN);
1239 ssize_t bytesWritten = stream.Write(data, size);
1240 ASSERT_EQ(bytesWritten, size);
1241 offset = stream.Tell();
1242 ASSERT_EQ(stream.Tell(), size);
1243 ASSERT_NE(offset, 0);
1244 byte readData[10] = {0};
1245 stream.Seek(0, SeekPos::BEGIN);
1246 ASSERT_EQ(stream.Tell(), 0);
1247 ssize_t bytesRead = stream.Read(readData, size);
1248 ASSERT_EQ(bytesRead, size);
1249
1250 for (size_t i = 0; i < size; ++i) {
1251 ASSERT_EQ(data[i], readData[i]);
1252 }
1253 }
1254
1255 /**
1256 * @tc.name: BufferMetadataStream_Write002
1257 * @tc.desc: Test the Write function of BufferMetadataStream, checking if it can
1258 * correctly write a string to the stream
1259 * @tc.type: FUNC
1260 */
1261 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Write002, TestSize.Level3)
1262 {
1263 BufferMetadataStream stream;
1264 stream.Open(OpenMode::ReadWrite);
1265 stream.Write((byte *)"Hello, world!", 13);
1266 ASSERT_EQ(stream.capacity_, METADATA_STREAM_PAGE_SIZE);
1267 ASSERT_EQ(stream.Tell(), 13);
1268 }
1269
1270 /**
1271 * @tc.name: BufferMetadataStream_Write003
1272 * @tc.desc: Test the Write function of BufferMetadataStream, checking if it can
1273 * correctly handle large data
1274 * @tc.type: FUNC
1275 */
1276 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Write003, TestSize.Level3)
1277 {
1278 BufferMetadataStream stream;
1279 stream.Open(OpenMode::ReadWrite);
1280 byte data[METADATA_STREAM_PAGE_SIZE + 1] = {0}; // Create a 4097-byte data
1281 stream.Write(data, METADATA_STREAM_PAGE_SIZE + 1); // Write 4097 bytes of data
1282 ASSERT_GE(stream.capacity_,
1283 METADATA_STREAM_PAGE_SIZE + 1); // Check if the buffer capacity is at least 4097
1284 ASSERT_EQ(stream.Tell(), METADATA_STREAM_PAGE_SIZE + 1); // Check if the write position is correct
1285 }
1286
1287 /**
1288 * @tc.name: BufferImageStream_Write004
1289 * @tc.desc: Test the Write function of BufferImageStream, checking if it can
1290 * correctly handle data of the exact buffer capacity
1291 * @tc.type: FUNC
1292 */
1293 HWTEST_F(MetadataStreamTest, BufferImageStream_Write004, TestSize.Level3)
1294 {
1295 BufferMetadataStream stream;
1296 stream.Open();
1297
1298 byte data[METADATA_STREAM_PAGE_SIZE] = {0}; // Create a 4096-byte data
1299 stream.Write(data, METADATA_STREAM_PAGE_SIZE); // Write 4096 bytes of data
1300 ASSERT_EQ(stream.capacity_,
1301 METADATA_STREAM_PAGE_SIZE); // Check if the buffer capacity is 4096
1302 ASSERT_EQ(stream.Tell(),
1303 METADATA_STREAM_PAGE_SIZE); // Check if the write position is correct
1304 }
1305
1306 /**
1307 * @tc.name: BufferImageStream_Write005
1308 * @tc.desc: Test the Write function of BufferImageStream, checking if it can
1309 * correctly handle fixed buffer size
1310 * @tc.type: FUNC
1311 */
1312 HWTEST_F(MetadataStreamTest, BufferImageStream_Write005, TestSize.Level3)
1313 {
1314 char text[] = "Hello, world!";
1315 BufferMetadataStream stream((byte *)text, sizeof(text), BufferMetadataStream::Fix);
1316 ASSERT_TRUE(stream.Open());
1317 ASSERT_EQ(stream.Write((byte *)"Hi", 2), 2);
1318 ASSERT_EQ(stream.Tell(), 2);
1319 ASSERT_STREQ(text, "Hillo, world!");
1320 ASSERT_EQ(stream.Write((byte *)"this is a very long text", 24), -1);
1321 ASSERT_STREQ(text, "Hillo, world!");
1322 }
1323
1324 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Write006, TestSize.Level3)
1325 {
1326 for (ssize_t size : testSize) {
1327 BufferMetadataStream stream;
1328 ASSERT_TRUE(stream.Open());
1329 byte *buf = new byte[size](); // Dynamically allocate the buffer with the current test size
1330 ASSERT_EQ(stream.Write(buf, size), size);
1331 ASSERT_EQ(stream.GetSize(), size);
1332
1333 delete[] buf; // Don't forget to delete the dynamically allocated buffer
1334 }
1335 }
1336
1337 /**
1338 * @tc.name: BufferImageStream_Write006
1339 * @tc.desc: Test the Write function of BufferImageStream, checking if it can
1340 * correctly handle dynamic buffer size
1341 * @tc.type: FUNC
1342 */
1343 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Write007, TestSize.Level3)
1344 {
1345 char text[] = "Hello, world!";
1346 BufferMetadataStream stream((byte *)text, sizeof(text), BufferMetadataStream::Dynamic);
1347 ASSERT_TRUE(stream.Open());
1348 ASSERT_EQ(stream.Write((byte *)"Hi", 2), 2);
1349 ASSERT_EQ(stream.Tell(), 2);
1350 ASSERT_STREQ(text, "Hillo, world!");
1351 stream.Seek(0, SeekPos::BEGIN);
1352 ASSERT_EQ(stream.Write((byte *)"this is a very long text", 25), 25);
1353 ASSERT_STREQ((char *)stream.GetAddr(false), "this is a very long text");
1354 }
1355
1356 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Write008, TestSize.Level3)
1357 {
1358 BufferMetadataStream stream;
1359 byte *buf = new byte[14];
1360 ASSERT_TRUE(stream.Open());
1361 stream.Write((uint8_t *)"Hello, world!\0", 14);
1362 stream.Seek(4, SeekPos::BEGIN);
1363 stream.Write((uint8_t *)"a", 1);
1364 stream.Write((uint8_t *)"b", 1);
1365 stream.Seek(0, SeekPos::BEGIN);
1366 stream.Read(buf, 14);
1367 ASSERT_STREQ((char *)buf, "Hellab world!");
1368 delete[] buf;
1369 }
1370
1371 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Write009, TestSize.Level3)
1372 {
1373 BufferMetadataStream stream;
1374 byte *buf = new byte[2000];
1375 byte *buf2 = new byte[500];
1376 ASSERT_TRUE(stream.Open());
1377 stream.Write(buf, 2000);
1378 stream.Write(buf2, 500);
1379 stream.Write(buf2, 500);
1380 ASSERT_EQ(stream.GetSize(), 3000);
1381 ASSERT_EQ(stream.capacity_, 32768);
1382 delete[] buf;
1383 delete[] buf2;
1384 }
1385
1386 /**
1387 * @tc.name: BufferMetadataStream_Close002
1388 * @tc.desc: Test the Close function of BufferMetadataStream after writing to the
1389 * stream
1390 * @tc.type: FUNC
1391 */
1392 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Close002, TestSize.Level3)
1393 {
1394 BufferMetadataStream stream;
1395 stream.Write((byte *)"Hello, world!", 13);
1396 ASSERT_NE(stream.buffer_, nullptr);
1397 }
1398
1399 /**
1400 * @tc.name: BufferImageStream_Close003
1401 * @tc.desc: Test the Close function of BufferImageStream after releasing the
1402 * stream
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(MetadataStreamTest, BufferImageStream_Close003, TestSize.Level3)
1406 {
1407 BufferMetadataStream stream;
1408 stream.Write((byte *)"Hello, world!", 13);
1409 delete[] stream.Release();
1410 ASSERT_EQ(stream.buffer_, nullptr);
1411 }
1412
1413 /**
1414 * @tc.name: BufferMetadataStream_Close004
1415 * @tc.desc: Test the Close function of BufferMetadataStream after closing the
1416 * stream
1417 * @tc.type: FUNC
1418 */
1419 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Close004, TestSize.Level3)
1420 {
1421 BufferMetadataStream stream;
1422 stream.Write((byte *)"Hello, world!", 13);
1423 stream.Close();
1424 ASSERT_EQ(stream.buffer_, nullptr);
1425 }
1426
1427 /**
1428 * @tc.name: BufferImageStream_Close006
1429 * @tc.desc: Test the Close function of BufferImageStream with a fixed size
1430 * buffer after releasing the stream
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(MetadataStreamTest, BufferImageStream_Close006, TestSize.Level3)
1434 {
1435 char text[] = "Hello, world!";
1436 BufferMetadataStream stream((byte *)text, sizeof(text), BufferMetadataStream::Fix);
1437 stream.Release();
1438 ASSERT_EQ(stream.buffer_, nullptr);
1439 }
1440
1441 /**
1442 * @tc.name: BufferImageStream_Close007
1443 * @tc.desc: Test the Close function of BufferImageStream with a dynamic size
1444 * buffer after writing and releasing the stream
1445 * @tc.type: FUNC
1446 */
1447 HWTEST_F(MetadataStreamTest, BufferImageStream_Close007, TestSize.Level3)
1448 {
1449 char text[] = "Hello, world!";
1450 BufferMetadataStream stream((byte *)text, sizeof(text), BufferMetadataStream::Dynamic);
1451 stream.Write((byte *)"this is a very very long text", 28);
1452 delete[] stream.Release();
1453
1454 DataBuf dataBuf(10);
1455 dataBuf.WriteUInt8(0, 123);
1456 EXPECT_EQ(dataBuf.ReadUInt8(0), 123);
1457 }
1458
1459 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CopyFrom001, TestSize.Level3)
1460 {
1461 FileMetadataStream src(filePathSource);
1462 BufferMetadataStream dest;
1463 src.Open();
1464 dest.Open();
1465 ASSERT_TRUE(dest.CopyFrom(src));
1466 ASSERT_EQ(src.GetSize(), dest.GetSize());
1467 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
1468 }
1469
1470 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CopyFrom002, TestSize.Level3)
1471 {
1472 BufferMetadataStream src;
1473 BufferMetadataStream dest;
1474 src.Open();
1475 dest.Open();
1476 src.Write((byte *)"Hello, world!", 13);
1477 ASSERT_TRUE(dest.CopyFrom(src));
1478 ASSERT_EQ(src.GetSize(), dest.GetSize());
1479 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
1480 }
1481
1482 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CopyFrom003, TestSize.Level3)
1483 {
1484 BufferMetadataStream src;
1485 BufferMetadataStream dest;
1486 src.Open();
1487 dest.Open();
1488 char buff[METADATA_STREAM_PAGE_SIZE + 1] = {0};
1489 src.Write((byte *)buff, METADATA_STREAM_PAGE_SIZE + 1);
1490 ASSERT_TRUE(dest.CopyFrom(src));
1491 ASSERT_EQ(src.GetSize(), dest.GetSize());
1492 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
1493 }
1494
1495 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CopyFrom004, TestSize.Level3)
1496 {
1497 BufferMetadataStream src;
1498 BufferMetadataStream dest;
1499 src.Open();
1500 dest.Open();
1501 char buff[METADATA_STREAM_PAGE_SIZE - 1] = {0};
1502 src.Write((byte *)buff, METADATA_STREAM_PAGE_SIZE - 1);
1503 ASSERT_TRUE(dest.CopyFrom(src));
1504 ASSERT_EQ(src.GetSize(), dest.GetSize());
1505 ASSERT_EQ(memcmp(src.GetAddr(), dest.GetAddr(), src.GetSize()), 0);
1506 }
1507
1508 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CopyFrom005, TestSize.Level3)
1509 {
1510 BufferMetadataStream temp;
1511 temp.Open();
1512 temp.Write((uint8_t*)"Hello, world", 13);
1513 BufferMetadataStream src(temp.GetAddr(), temp.GetSize(), BufferMetadataStream::Dynamic);
1514 FileMetadataStream dest(filePathSource);
1515 src.Open();
1516 dest.Open();
1517 bool ret = src.CopyFrom(dest);
1518 ASSERT_EQ(ret, true);
1519 }
1520
1521 /**
1522 * @tc.name: BufferMetadataStream_ReadByte001
1523 * @tc.desc: test the ReadByte function of BufferMetadataStream
1524 * @tc.type: FUNC
1525 */
1526 HWTEST_F(MetadataStreamTest, BufferMetadataStream_ReadByte001, TestSize.Level3)
1527 {
1528 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_ReadByte001 start";
1529 byte *originData = nullptr;
1530 size_t size = 4;
1531 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Dynamic;
1532 int originalFd = 0;
1533 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1534 BufferMetadataStream stream = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1535 int ret = stream.ReadByte();
1536 ASSERT_EQ(ret, -1);
1537 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_ReadByte001 end";
1538 }
1539
1540 /**
1541 * @tc.name: BufferMetadataStream_ReadByte002
1542 * @tc.desc: test the ReadByte function of BufferMetadataStream
1543 * @tc.type: FUNC
1544 */
1545 HWTEST_F(MetadataStreamTest, BufferMetadataStream_ReadByte002, TestSize.Level3)
1546 {
1547 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_ReadByte002 start";
1548 byte originData[4] = {1, 2, 3, 4};
1549 size_t size = 4;
1550 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Dynamic;
1551 int originalFd = 0;
1552 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1553 BufferMetadataStream stream = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1554 stream.currentOffset_ = 128;
1555 int ret = stream.ReadByte();
1556 ASSERT_EQ(ret, -1);
1557 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_ReadByte002 end";
1558 }
1559
1560 /**
1561 * @tc.name: BufferMetadataStream_Seek001
1562 * @tc.desc: test the Seek function of BufferMetadataStream
1563 * @tc.type: FUNC
1564 */
1565 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Seek001, TestSize.Level3)
1566 {
1567 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Seek001 start";
1568 byte originData[4] = {1, 2, 3, 4};
1569 size_t size = 4;
1570 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Dynamic;
1571 int originalFd = 0;
1572 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1573 BufferMetadataStream stream = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1574 long offset = 0;
1575 SeekPos pos = SeekPos::END;
1576 long ret = stream.Seek(offset, pos);
1577 ASSERT_EQ(ret, 4);
1578 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Seek001 end";
1579 }
1580
1581 /**
1582 * @tc.name: BufferMetadataStream_Seek002
1583 * @tc.desc: test the Seek function of BufferMetadataStream
1584 * @tc.type: FUNC
1585 */
1586 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Seek002, TestSize.Level3)
1587 {
1588 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Seek002 start";
1589 byte originData[4] = {1, 2, 3, 4};
1590 size_t size = 4;
1591 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Dynamic;
1592 int originalFd = 0;
1593 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1594 BufferMetadataStream stream = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1595 long offset = 128;
1596 SeekPos pos = SeekPos::BEGIN;
1597 long ret = stream.Seek(offset, pos);
1598 ASSERT_EQ(ret, 4);
1599 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Seek002 end";
1600 }
1601
1602 /**
1603 * @tc.name: BufferMetadataStream_Read002
1604 * @tc.desc: test the Read function of BufferMetadataStream
1605 * @tc.type: FUNC
1606 */
1607 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Read002, TestSize.Level3)
1608 {
1609 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Read002 start";
1610 byte originData[4] = {1, 2, 3, 4};
1611 size_t size = 4;
1612 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Dynamic;
1613 int originalFd = 0;
1614 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1615 BufferMetadataStream stream = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1616 stream.currentOffset_ = 128;
1617 auto buf = static_cast<uint8_t *>(malloc(size));
1618 ssize_t ret = stream.Read(buf, size);
1619 ASSERT_EQ(ret, -1);
1620 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Read002 end";
1621 }
1622
1623 /**
1624 * @tc.name: BufferMetadataStream_Read003
1625 * @tc.desc: test the Read function of BufferMetadataStream
1626 * @tc.type: FUNC
1627 */
1628 HWTEST_F(MetadataStreamTest, BufferMetadataStream_Read003, TestSize.Level3)
1629 {
1630 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Read003 start";
1631 byte originData[4] = {1, 2, 3, 4};
1632 size_t size = 4;
1633 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Dynamic;
1634 int originalFd = 0;
1635 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1636 BufferMetadataStream stream = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1637 auto buf = static_cast<uint8_t *>(malloc(size));
1638 ssize_t ret = stream.Read(buf, size);
1639 ASSERT_EQ(ret, -1);
1640 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_Read003 end";
1641 }
1642
1643 /**
1644 * @tc.name: BufferMetadataStream_CopyFrom006
1645 * @tc.desc: test the CopyFrom function of BufferMetadataStream
1646 * @tc.type: FUNC
1647 */
1648 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CopyFrom006, TestSize.Level3)
1649 {
1650 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_CopyFrom006 start";
1651 BufferMetadataStream src;
1652 BufferMetadataStream dest;
1653 bool ret = dest.CopyFrom(src);
1654 ASSERT_EQ(ret, true);
1655 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_CopyFrom006 end";
1656 }
1657
1658 /**
1659 * @tc.name: BufferMetadataStream_CopyFrom007
1660 * @tc.desc: test the CopyFrom function of BufferMetadataStream
1661 * @tc.type: FUNC
1662 */
1663 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CopyFrom007, TestSize.Level3)
1664 {
1665 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_CopyFrom007 start";
1666 BufferMetadataStream src;
1667 byte originData[4] = {1, 2, 3, 4};
1668 size_t size = 4;
1669 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Fix;
1670 int originalFd = 0;
1671 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1672 BufferMetadataStream dest = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1673 dest.capacity_ = 0;
1674 src.bufferSize_ = 8;
1675 bool ret = dest.CopyFrom(src);
1676 ASSERT_EQ(ret, false);
1677 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_CopyFrom007 end";
1678 }
1679
1680 /**
1681 * @tc.name: BufferMetadataStream_CalculateNewCapacity001
1682 * @tc.desc: test the CalculateNewCapacity function of BufferMetadataStream
1683 * @tc.type: FUNC
1684 */
1685 HWTEST_F(MetadataStreamTest, BufferMetadataStream_CalculateNewCapacity001, TestSize.Level3)
1686 {
1687 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_CalculateNewCapacity001 start";
1688 BufferMetadataStream src;
1689 byte originData[4] = {1, 2, 3, 4};
1690 size_t size = 4;
1691 BufferMetadataStream::MemoryMode mode = BufferMetadataStream::MemoryMode::Fix;
1692 int originalFd = 0;
1693 const std::string &originalPath = "/data/local/tmp/image/test.txt";
1694 BufferMetadataStream stream = BufferMetadataStream(originData, size, mode, originalFd, originalPath);
1695 long currentOffset = 0;
1696 stream.expandCount_ = 5;
1697 long ret = stream.CalculateNewCapacity(currentOffset, size);
1698 ASSERT_EQ(ret, BufferMetadataStream::METADATA_STREAM_CAPACITY_30MB);
1699 GTEST_LOG_(INFO) << "MetadataStreamTest: BufferMetadataStream_CalculateNewCapacity001 end";
1700 }
1701
1702 /**
1703 * @tc.name: FileMetadataStream_Read003
1704 * @tc.desc: Test the Read function of FileMetadataStream
1705 * @tc.type: FUNC
1706 */
1707 HWTEST_F(MetadataStreamTest, FileMetadataStream_Read003, TestSize.Level3)
1708 {
1709 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Read003 start";
1710 const std::string &filePath = "";
1711 FileMetadataStream stream = FileMetadataStream(filePath);
1712 stream.fp_ = fopen("/data/local/tmp/image/test_exif.jpg", "rb");
1713 byte buffer[SIZE_1024];
1714 ssize_t ret = stream.Read(buffer, 0);
1715 ASSERT_EQ(ret, 0);
1716 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Read003 end";
1717 }
1718
1719 /**
1720 * @tc.name: FileMetadataStream_ReadByte003
1721 * @tc.desc: Test the ReadByte function of FileMetadataStream
1722 * @tc.type: FUNC
1723 */
1724 HWTEST_F(MetadataStreamTest, FileMetadataStream_ReadByte003, TestSize.Level3)
1725 {
1726 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_ReadByte003 start";
1727 const std::string &filePath = "/data/local/tmp/image/not_exist.jpg";
1728 FileMetadataStream stream = FileMetadataStream(filePath);
1729 int ret = stream.ReadByte();
1730 ASSERT_EQ(ret, -1);
1731 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_ReadByte003 end";
1732 }
1733
1734 /**
1735 * @tc.name: FileMetadataStream_Seek002
1736 * @tc.desc: Test the Seek function of FileMetadataStream
1737 * @tc.type: FUNC
1738 */
1739 HWTEST_F(MetadataStreamTest, FileMetadataStream_Seek002, TestSize.Level3)
1740 {
1741 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Seek002 start";
1742 const std::string &filePath = "/data/local/tmp/image/not_exist.jpg";
1743 FileMetadataStream stream = FileMetadataStream(filePath);
1744 long offset = 0;
1745 SeekPos pos = SeekPos::BEGIN;
1746 long ret = stream.Seek(offset, pos);
1747 ASSERT_EQ(ret, -1);
1748 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Seek002 end";
1749 }
1750
1751 /**
1752 * @tc.name: FileMetadataStream_Tell001
1753 * @tc.desc: Test the Tell function of FileMetadataStream
1754 * @tc.type: FUNC
1755 */
1756 HWTEST_F(MetadataStreamTest, FileMetadataStream_Tell001, TestSize.Level3)
1757 {
1758 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Tell001 start";
1759 const std::string &filePath = "/data/local/tmp/image/not_exist.jpg";
1760 FileMetadataStream stream = FileMetadataStream(filePath);
1761 long ret = 0;
1762 ret = stream.Tell();
1763 ASSERT_EQ(ret, -1);
1764 stream.initPath_ = FileMetadataStream::INIT_FROM_FD;
1765 ret = stream.Tell();
1766 ASSERT_EQ(ret, -1);
1767 stream.initPath_ = FileMetadataStream::INIT_FROM_UNKNOWN;
1768 ret = stream.Tell();
1769 ASSERT_EQ(ret, -1);
1770 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Tell001 end";
1771 }
1772
1773 /**
1774 * @tc.name: FileMetadataStream_OpenFromFD001
1775 * @tc.desc: Test the OpenFromFD function of FileMetadataStream
1776 * @tc.type: FUNC
1777 */
1778 HWTEST_F(MetadataStreamTest, FileMetadataStream_OpenFromFD001, TestSize.Level3)
1779 {
1780 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_OpenFromFD001 start";
1781 const std::string &filePath = "/data/local/tmp/image/not_exist.jpg";
1782 FileMetadataStream stream = FileMetadataStream(filePath);
1783 const char *modeStr = "rb";
1784 bool ret = stream.OpenFromFD(modeStr);
1785 ASSERT_EQ(ret, false);
1786 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_OpenFromFD001 end";
1787 }
1788
1789 /**
1790 * @tc.name: FileMetadataStream_Open006
1791 * @tc.desc: Test the Open function of FileMetadataStream
1792 * @tc.type: FUNC
1793 */
1794 HWTEST_F(MetadataStreamTest, FileMetadataStream_Open006, TestSize.Level3)
1795 {
1796 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Open006 start";
1797 const std::string &filePath = "/data/local/tmp/image/not_exist.jpg";
1798 FileMetadataStream stream = FileMetadataStream(filePath);
1799 stream.initPath_ = FileMetadataStream::INIT_FROM_UNKNOWN;
1800 OpenMode mode = OpenMode::Read;
1801 bool ret = stream.Open(mode);
1802 ASSERT_EQ(ret, false);
1803 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_Open006 end";
1804 }
1805
1806 /**
1807 * @tc.name: FileMetadataStream_GetSize001
1808 * @tc.desc: Test the GetSize function of FileMetadataStream
1809 * @tc.type: FUNC
1810 */
1811 HWTEST_F(MetadataStreamTest, FileMetadataStream_GetSize001, TestSize.Level3)
1812 {
1813 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_GetSize001 start";
1814 const std::string &filePath = "/data/local/tmp/image/not_exist.jpg";
1815 FileMetadataStream stream = FileMetadataStream(filePath);
1816 ssize_t ret = stream.GetSize();
1817 ASSERT_EQ(ret, -1);
1818 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_GetSize001 end";
1819 }
1820
1821 /**
1822 * @tc.name: FileMetadataStream_IsEof002
1823 * @tc.desc: Test the IsEof function of FileMetadataStream
1824 * @tc.type: FUNC
1825 */
1826 HWTEST_F(MetadataStreamTest, FileMetadataStream_IsEof002, TestSize.Level3)
1827 {
1828 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_IsEof002 start";
1829 const std::string &filePath = "/data/local/tmp/image/not_exist.jpg";
1830 FileMetadataStream stream = FileMetadataStream(filePath);
1831 bool ret = stream.IsEof();
1832 ASSERT_EQ(ret, true);
1833 GTEST_LOG_(INFO) << "MetadataStreamTest: FileMetadataStream_IsEof002 end";
1834 }
1835 } // namespace Media
1836 } // namespace OHOS
