1 #include "file_handler.hpp" 2 3 #include <cstdint> 4 #include <cstdio> 5 #include <fstream> 6 #include <vector> 7 8 #include <gtest/gtest.h> 9 10 namespace ipmi_flash 11 { 12 13 static constexpr auto TESTPATH = "test.output"; 14 15 class FileHandlerOpenTest : public ::testing::Test 16 { 17 protected: 18 void TearDown() override 19 { 20 (void)std::remove(TESTPATH); 21 } 22 }; 23 24 TEST_F(FileHandlerOpenTest, VerifyDefaultOpenIsHappy) 25 { 26 /* Opening a fail may create it? */ 27 28 FileHandler handler(TESTPATH); 29 EXPECT_TRUE(handler.open("")); 30 EXPECT_TRUE(handler.open("")); 31 } 32 33 TEST_F(FileHandlerOpenTest, VerifyOpenForReadFailsWithNoFile) 34 { 35 FileHandler handler(TESTPATH); 36 EXPECT_EQ(handler.getSize(), 0); 37 EXPECT_FALSE(handler.open("", std::ios::in)); 38 EXPECT_EQ(handler.getSize(), 0); 39 } 40 41 TEST_F(FileHandlerOpenTest, VerifyOpenForReadSucceedsWithFile) 42 { 43 std::ofstream testfile; 44 testfile.open(TESTPATH, std::ios::out); 45 testfile << "Hello world"; 46 FileHandler handler(TESTPATH); 47 EXPECT_TRUE(handler.open("", std::ios::in)); 48 } 49 50 TEST_F(FileHandlerOpenTest, VerifyWriteDataWrites) 51 { 52 /* Verify writing bytes writes them... flushing data can be an issue here, 53 * so we close first. 54 */ 55 FileHandler handler(TESTPATH); 56 EXPECT_TRUE(handler.open("")); 57 58 std::vector<std::uint8_t> bytes = {0x01, 0x02}; 59 std::uint32_t offset = 0; 60 61 EXPECT_TRUE(handler.write(offset, bytes)); 62 handler.close(); 63 64 std::ifstream data; 65 data.open(TESTPATH, std::ios::binary); 66 char expectedBytes[2]; 67 data.read(&expectedBytes[0], sizeof(expectedBytes)); 68 EXPECT_EQ(expectedBytes[0], bytes[0]); 69 EXPECT_EQ(expectedBytes[1], bytes[1]); 70 /* annoyingly the memcmp was failing... but it's the same data. */ 71 } 72 73 TEST_F(FileHandlerOpenTest, VerifySimpleRead) 74 { 75 std::ofstream testfile; 76 testfile.open(TESTPATH, std::ios::out); 77 std::vector<std::uint8_t> testPattern = {0x0, 0x1, 0x2, 0x3, 0x4, 78 0x5, 0x6, 0x7, 0x8, 0x9}; 79 testfile.write(reinterpret_cast<const char*>(testPattern.data()), 80 testPattern.size()); 81 testfile.close(); 82 FileHandler handler(TESTPATH); 83 EXPECT_EQ(handler.getSize(), testPattern.size()); 84 EXPECT_TRUE(handler.open("", std::ios::in)); 85 auto result = handler.read(0, 10); 86 EXPECT_EQ(handler.getSize(), testPattern.size()); 87 ASSERT_TRUE(result); 88 EXPECT_EQ(result->size(), 10); 89 EXPECT_EQ(*result, testPattern); 90 } 91 92 TEST_F(FileHandlerOpenTest, VerifyTruncatedAndOffsetReads) 93 { 94 std::ofstream testfile; 95 testfile.open(TESTPATH, std::ios::out); 96 std::vector<std::uint8_t> testPattern = {0x0, 0x1, 0x2, 0x3, 0x4, 97 0x5, 0x6, 0x7, 0x8, 0x9}; 98 std::vector<std::uint8_t> expectedResult(testPattern.begin() + 3, 99 testPattern.end()); 100 101 testfile.write(reinterpret_cast<const char*>(testPattern.data()), 102 testPattern.size()); 103 testfile.close(); 104 FileHandler handler(TESTPATH); 105 EXPECT_TRUE(handler.open("", std::ios::in)); 106 auto result = handler.read(3, 10); 107 ASSERT_TRUE(result); 108 EXPECT_EQ(*result, expectedResult); 109 } 110 111 TEST_F(FileHandlerOpenTest, VerifyBadOffsetReadsFail) 112 { 113 std::ofstream testfile; 114 testfile.open(TESTPATH, std::ios::out); 115 std::vector<std::uint8_t> testPattern = {0x0, 0x1, 0x2, 0x3, 0x4, 116 0x5, 0x6, 0x7, 0x8, 0x9}; 117 testfile.write(reinterpret_cast<const char*>(testPattern.data()), 118 testPattern.size()); 119 testfile.close(); 120 FileHandler handler(TESTPATH); 121 EXPECT_TRUE(handler.open("", std::ios::in)); 122 auto result = handler.read(11, 10); 123 EXPECT_FALSE(result); 124 } 125 126 } // namespace ipmi_flash 127