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