1 #include "estoraged_conf.hpp"
2 #include "pattern.hpp"
3 
4 #include <fcntl.h>
5 #include <unistd.h>
6 
7 #include <stdplus/fd/create.hpp>
8 #include <stdplus/fd/gmock.hpp>
9 #include <stdplus/fd/managed.hpp>
10 #include <xyz/openbmc_project/Common/error.hpp>
11 
12 #include <fstream>
13 #include <span>
14 #include <system_error>
15 
16 #include <gmock/gmock-matchers.h>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 
20 namespace estoraged_test
21 {
22 
23 using estoraged::Pattern;
24 using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
25 using testing::_;
26 using testing::Invoke;
27 using testing::Return;
28 
TEST(pattern,patternPass)29 TEST(pattern, patternPass)
30 {
31     std::string testFileName = "patternPass";
32     uint64_t size = 4096;
33     std::ofstream testFile;
34     testFile.open(testFileName,
35                   std::ios::out | std::ios::binary | std::ios::trunc);
36     testFile.close();
37 
38     stdplus::fd::Fd&& writeFd =
39         stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::WriteOnly);
40 
41     Pattern pass(testFileName);
42     EXPECT_NO_THROW(pass.writePattern(size, writeFd));
43 
44     stdplus::fd::Fd&& readFd =
45         stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadOnly);
46 
47     EXPECT_NO_THROW(pass.verifyPattern(size, readFd));
48 }
49 
50 /* This test that pattern writes the correct number of bytes even if
51  * size of the drive is not divisible by the block size
52  */
53 
TEST(pattern,patternNotDivisible)54 TEST(pattern, patternNotDivisible)
55 {
56     std::string testFileName = "notDivisible";
57     uint64_t size = 4097;
58     // 4097 is not divisible by the block size, and we expect no errors
59     std::ofstream testFile;
60     testFile.open(testFileName,
61                   std::ios::out | std::ios::binary | std::ios::trunc);
62     testFile.close();
63 
64     stdplus::fd::Fd&& writeFd =
65         stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::WriteOnly);
66     Pattern pass(testFileName);
67     EXPECT_NO_THROW(pass.writePattern(size, writeFd));
68 
69     stdplus::fd::Fd&& readFd =
70         stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadOnly);
71     EXPECT_NO_THROW(pass.verifyPattern(size, readFd));
72 }
73 
TEST(pattern,patternsDontMatch)74 TEST(pattern, patternsDontMatch)
75 {
76     std::string testFileName = "patternsDontMatch";
77     uint64_t size = 4096;
78     std::ofstream testFile;
79 
80     Pattern pass(testFileName);
81 
82     int dummyValue = 88;
83     testFile.open(testFileName, std::ios::binary | std::ios::out);
84     testFile.write((reinterpret_cast<const char*>(&dummyValue)),
85                    sizeof(dummyValue));
86     testFile.close();
87 
88     stdplus::fd::Fd&& writeFd =
89         stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::WriteOnly);
90 
91     EXPECT_NO_THROW(pass.writePattern(size - sizeof(dummyValue), writeFd));
92 
93     stdplus::fd::Fd&& readFd =
94         stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadOnly);
95 
96     EXPECT_THROW(pass.verifyPattern(size, readFd), InternalFailure);
97 }
98 
TEST(pattern,shortReadWritePass)99 TEST(pattern, shortReadWritePass)
100 {
101     std::string testFileName = "testfile_shortRead";
102     uint64_t size = 4096;
103     size_t shortSize = 128;
104     static auto shortData1 = std::vector<std::byte>(shortSize);
105     static auto shortData2 = std::vector<std::byte>(shortSize);
106     static auto restOfData = std::vector<std::byte>(size - shortSize * 2);
107     Pattern pass(testFileName);
108     stdplus::fd::FdMock mock;
109 
110     testing::Sequence s;
111 
112     // test write pattern with short blocks
113     EXPECT_CALL(mock, write(_))
114         .WillOnce(Invoke([](std::span<const std::byte> x) {
115             std::copy_n(x.begin(), shortData1.size(), shortData1.begin());
116             return shortData1;
117         }))
118         .RetiresOnSaturation();
119     EXPECT_CALL(mock, write(_))
120         .WillOnce(Invoke([](std::span<const std::byte> x) {
121             std::copy_n(x.begin(), restOfData.size(), restOfData.begin());
122             return restOfData;
123         }))
124         .RetiresOnSaturation();
125     EXPECT_CALL(mock, write(_))
126         .WillOnce(Invoke([](std::span<const std::byte> x) {
127             std::copy_n(x.begin(), shortData2.size(), shortData2.begin());
128             return shortData2;
129         }))
130         .RetiresOnSaturation();
131 
132     // test read pattern
133     EXPECT_CALL(mock, read(_))
134         .WillOnce(Invoke([](std::span<std::byte> x) {
135             std::copy_n(shortData1.begin(), shortData1.size(), x.data());
136             std::span ret(shortData1);
137             return ret;
138         }))
139         .RetiresOnSaturation();
140 
141     EXPECT_CALL(mock, read(_))
142         .WillOnce(Invoke([](std::span<std::byte> x) {
143             std::copy_n(restOfData.begin(), restOfData.size(), x.data());
144             std::span ret(restOfData);
145             return ret;
146         }))
147         .RetiresOnSaturation();
148 
149     EXPECT_CALL(mock, read(_))
150         .WillOnce(Invoke([](std::span<std::byte> x) {
151             std::copy_n(shortData2.begin(), shortData2.size(), x.data());
152             std::span ret(shortData2);
153             return ret;
154         }))
155         .RetiresOnSaturation();
156 
157     EXPECT_NO_THROW(pass.writePattern(size, mock));
158     EXPECT_NO_THROW(pass.verifyPattern(size, mock));
159 }
160 
TEST(Zeros,shortReadWriteFail)161 TEST(Zeros, shortReadWriteFail)
162 {
163     std::string testFileName = "testfile_shortRead";
164 
165     uint64_t size = 4096;
166     size_t shortSize = 128;
167     Pattern tryPattern(testFileName);
168     auto shortData = std::vector<std::byte>(shortSize, std::byte{0});
169     auto restOfData =
170         std::vector<std::byte>(size - shortSize * 3, std::byte{0});
171     std::span shortDataSpan{shortData};
172     std::span restOfDataSpan{restOfData};
173     // open the file and write none to it
174 
175     stdplus::fd::FdMock mock;
176 
177     // test writes
178     EXPECT_CALL(mock, write(_))
179         .WillOnce(Return(shortDataSpan))
180         .WillOnce(Return(shortDataSpan))
181         .WillOnce(Return(restOfDataSpan))
182         .WillOnce(Return(restOfDataSpan)); // return too much data!
183 
184     EXPECT_THROW(tryPattern.writePattern(size, mock), InternalFailure);
185 
186     // test reads
187     EXPECT_CALL(mock, read(_))
188         .WillOnce(Return(shortDataSpan))
189         .WillOnce(Return(shortDataSpan))
190         .WillOnce(Return(restOfDataSpan))
191         .WillOnce(Return(restOfDataSpan)); // return too much data!
192 
193     EXPECT_THROW(tryPattern.verifyPattern(size, mock), InternalFailure);
194 }
195 
TEST(pattern,driveIsSmaller)196 TEST(pattern, driveIsSmaller)
197 {
198     std::string testFileName = "testfile_driveIsSmaller";
199 
200     uint64_t size = 4096;
201     Pattern tryPattern(testFileName);
202 
203     stdplus::fd::FdMock mocks;
204     testing::InSequence s;
205 
206     // test writes
207     EXPECT_CALL(mocks, write(_))
208         .Times(33)
209         .WillRepeatedly(Return(std::span<std::byte>{}))
210         .RetiresOnSaturation();
211 
212     EXPECT_THROW(tryPattern.writePattern(size, mocks), InternalFailure);
213 
214     // test reads
215     EXPECT_CALL(mocks, read(_))
216         .Times(33)
217         .WillRepeatedly(Return(std::span<std::byte>{}))
218         .RetiresOnSaturation();
219 
220     EXPECT_THROW(tryPattern.verifyPattern(size, mocks), InternalFailure);
221 }
222 
223 } // namespace estoraged_test
224