1 // Copyright 2021 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://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, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14 #include "pw_persistent_ram/persistent_buffer.h"
15
16 #include <cstddef>
17 #include <type_traits>
18
19 #include "pw_bytes/span.h"
20 #include "pw_random/xor_shift.h"
21 #include "pw_span/span.h"
22 #include "pw_unit_test/framework.h"
23
24 namespace pw::persistent_ram {
25 namespace {
26
27 class PersistentTest : public ::testing::Test {
28 protected:
29 static constexpr size_t kBufferSize = 256;
PersistentTest()30 PersistentTest() { ZeroPersistentMemory(); }
31
32 // Emulate invalidation of persistent section(s).
ZeroPersistentMemory()33 void ZeroPersistentMemory() { memset(buffer_, 0, sizeof(buffer_)); }
RandomFillMemory()34 void RandomFillMemory() {
35 random::XorShiftStarRng64 rng(0x9ad75);
36 rng.Get(buffer_);
37 }
38
GetPersistentBuffer()39 PersistentBuffer<kBufferSize>& GetPersistentBuffer() {
40 return *(new (buffer_) PersistentBuffer<kBufferSize>());
41 }
42
43 // Allocate a chunk of aligned storage that can be independently controlled.
44 alignas(PersistentBuffer<kBufferSize>)
45 std::byte buffer_[sizeof(PersistentBuffer<kBufferSize>)];
46 };
47
TEST_F(PersistentTest,DefaultConstructionAndDestruction)48 TEST_F(PersistentTest, DefaultConstructionAndDestruction) {
49 constexpr uint32_t kExpectedNumber = 0x6C2C6582;
50 {
51 // Emulate a boot where the persistent sections were invalidated.
52 // Although the fixture always does this, we do this an extra time to be
53 // 100% confident that an integrity check cannot be accidentally selected
54 // which results in reporting there is valid data when zero'd.
55 ZeroPersistentMemory();
56 auto& persistent = GetPersistentBuffer();
57 auto writer = persistent.GetWriter();
58 EXPECT_EQ(persistent.size(), 0u);
59
60 ASSERT_EQ(OkStatus(), writer.Write(as_bytes(span(&kExpectedNumber, 1))));
61 ASSERT_TRUE(persistent.has_value());
62
63 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
64 }
65
66 { // Emulate a boot where persistent memory was kept as is.
67 auto& persistent = GetPersistentBuffer();
68 ASSERT_TRUE(persistent.has_value());
69 EXPECT_EQ(persistent.size(), sizeof(kExpectedNumber));
70
71 uint32_t temp = 0;
72 memcpy(&temp, persistent.data(), sizeof(temp));
73 EXPECT_EQ(temp, kExpectedNumber);
74 }
75 }
76
TEST_F(PersistentTest,LongData)77 TEST_F(PersistentTest, LongData) {
78 constexpr std::string_view kTestString(
79 "A nice string should remain valid even if written incrementally!");
80 constexpr size_t kWriteSize = 5;
81
82 { // Initialize the buffer.
83 RandomFillMemory();
84 auto& persistent = GetPersistentBuffer();
85 ASSERT_FALSE(persistent.has_value());
86
87 auto writer = persistent.GetWriter();
88 for (size_t i = 0; i < kTestString.length(); i += kWriteSize) {
89 ASSERT_EQ(OkStatus(),
90 writer.Write(kTestString.data() + i,
91 std::min(kWriteSize, kTestString.length() - i)));
92 }
93 // Need to manually write a null terminator since std::string_view doesn't
94 // include one in the string length.
95 ASSERT_EQ(OkStatus(), writer.Write(std::byte(0)));
96
97 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
98 }
99
100 { // Ensure data is valid.
101 auto& persistent = GetPersistentBuffer();
102 ASSERT_TRUE(persistent.has_value());
103 ASSERT_STREQ(kTestString.data(),
104 reinterpret_cast<const char*>(persistent.data()));
105 }
106 }
107
TEST_F(PersistentTest,MostlyFilled)108 TEST_F(PersistentTest, MostlyFilled) {
109 std::array<std::byte, kBufferSize - 3> test_data;
110 constexpr size_t kWriteSize = 11;
111 random::XorShiftStarRng64 test_data_generator(0xDA960FD9);
112 test_data_generator.Get(test_data);
113
114 static_assert(test_data.size() < kBufferSize);
115
116 { // Initialize the buffer.
117 RandomFillMemory();
118 auto& persistent = GetPersistentBuffer();
119 EXPECT_FALSE(persistent.has_value());
120
121 auto writer = persistent.GetWriter();
122 for (size_t i = 0; i < test_data.size(); i += kWriteSize) {
123 EXPECT_EQ(OkStatus(),
124 writer.Write(test_data.data() + i,
125 std::min(kWriteSize, test_data.size() - i)));
126 }
127 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
128 }
129
130 { // Ensure data is valid.
131 auto& persistent = GetPersistentBuffer();
132 EXPECT_TRUE(persistent.has_value());
133 EXPECT_EQ(persistent.size(), test_data.size());
134 EXPECT_EQ(
135 std::memcmp(test_data.data(), persistent.data(), persistent.size()), 0);
136 }
137 }
138
TEST_F(PersistentTest,AttemptOversizedWrite)139 TEST_F(PersistentTest, AttemptOversizedWrite) {
140 std::array<std::byte, kBufferSize - 3> test_data;
141 constexpr size_t kWriteSize = 11;
142 random::XorShiftStarRng64 test_data_generator(0xDA960FD9);
143 test_data_generator.Get(test_data);
144
145 static_assert(test_data.size() < kBufferSize);
146
147 { // Initialize the buffer.
148 RandomFillMemory();
149 auto& persistent = GetPersistentBuffer();
150 EXPECT_FALSE(persistent.has_value());
151
152 auto writer = persistent.GetWriter();
153 for (size_t i = 0; i < test_data.size(); i += kWriteSize) {
154 EXPECT_EQ(OkStatus(),
155 writer.Write(test_data.data() + i,
156 std::min(kWriteSize, test_data.size() - i)));
157 }
158
159 // This final write is guaranteed to be too big, but shouldn't corrupt the
160 // final contents of the buffer.
161 constexpr size_t kFinalWriteSize = 21;
162 EXPECT_GT(writer.ConservativeWriteLimit(), 0u);
163 EXPECT_GT(kFinalWriteSize, writer.ConservativeWriteLimit());
164 EXPECT_EQ(Status::ResourceExhausted(),
165 writer.Write(test_data.data(), kFinalWriteSize));
166
167 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
168 }
169
170 { // Ensure data is valid.
171 auto& persistent = GetPersistentBuffer();
172 EXPECT_TRUE(persistent.has_value());
173 EXPECT_EQ(persistent.size(), test_data.size());
174 EXPECT_EQ(
175 std::memcmp(test_data.data(), persistent.data(), persistent.size()), 0);
176 }
177 }
178
TEST_F(PersistentTest,Filled)179 TEST_F(PersistentTest, Filled) {
180 std::array<std::byte, kBufferSize> test_data;
181 constexpr size_t kWriteSize = 5;
182 random::XorShiftStarRng64 test_data_generator(0x4BEDED8F);
183 test_data_generator.Get(test_data);
184
185 static_assert(test_data.size() == kBufferSize);
186
187 { // Initialize the buffer.
188 RandomFillMemory();
189 auto& persistent = GetPersistentBuffer();
190 EXPECT_FALSE(persistent.has_value());
191
192 auto writer = persistent.GetWriter();
193 for (size_t i = 0; i < test_data.size(); i += kWriteSize) {
194 EXPECT_EQ(OkStatus(),
195 writer.Write(test_data.data() + i,
196 std::min(kWriteSize, test_data.size() - i)));
197 }
198 EXPECT_EQ(writer.ConservativeWriteLimit(), 0u);
199 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
200 }
201
202 { // Ensure data is valid.
203 auto& persistent = GetPersistentBuffer();
204 EXPECT_TRUE(persistent.has_value());
205 EXPECT_EQ(persistent.size(), kBufferSize);
206 EXPECT_EQ(
207 std::memcmp(test_data.data(), persistent.data(), test_data.size()), 0);
208 }
209 }
210
TEST_F(PersistentTest,VariableSizedWrites)211 TEST_F(PersistentTest, VariableSizedWrites) {
212 std::array<std::byte, kBufferSize> test_data;
213 constexpr size_t kMaxWriteSize = 11;
214 random::XorShiftStarRng64 test_data_generator(0x63CAA44A);
215 test_data_generator.Get(test_data);
216
217 static_assert(test_data.size() == kBufferSize);
218
219 { // Initialize the buffer.
220 RandomFillMemory();
221 auto& persistent = GetPersistentBuffer();
222 EXPECT_FALSE(persistent.has_value());
223
224 auto writer = persistent.GetWriter();
225
226 size_t count = 0;
227 size_t write_size = 1;
228 while (count < kBufferSize) {
229 const size_t remaining_space = writer.ConservativeWriteLimit();
230
231 EXPECT_EQ(OkStatus(),
232 writer.Write(test_data.data() + count,
233 std::min(write_size, remaining_space)));
234
235 count += write_size;
236 write_size = (write_size % kMaxWriteSize) + 1;
237 ASSERT_NE(write_size, 12u);
238 ASSERT_NE(write_size, 0u);
239 }
240 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
241 }
242
243 { // Ensure data is valid.
244 auto& persistent = GetPersistentBuffer();
245 EXPECT_TRUE(persistent.has_value());
246 EXPECT_EQ(persistent.size(), test_data.size());
247 EXPECT_EQ(
248 std::memcmp(test_data.data(), persistent.data(), persistent.size()), 0);
249 }
250 }
251
TEST_F(PersistentTest,ZeroDataIsNoValue)252 TEST_F(PersistentTest, ZeroDataIsNoValue) {
253 ZeroPersistentMemory();
254 auto& persistent = GetPersistentBuffer();
255 EXPECT_FALSE(persistent.has_value());
256 }
257
TEST_F(PersistentTest,RandomDataIsInvalid)258 TEST_F(PersistentTest, RandomDataIsInvalid) {
259 RandomFillMemory();
260 auto& persistent = GetPersistentBuffer();
261 ASSERT_FALSE(persistent.has_value());
262 }
263
TEST_F(PersistentTest,AppendingData)264 TEST_F(PersistentTest, AppendingData) {
265 constexpr std::string_view kTestString("Test string one!");
266 constexpr uint32_t kTestNumber = 42;
267
268 { // Initialize the buffer.
269 RandomFillMemory();
270 auto& persistent = GetPersistentBuffer();
271 auto writer = persistent.GetWriter();
272 EXPECT_EQ(persistent.size(), 0u);
273
274 // Write an integer.
275 ASSERT_EQ(OkStatus(), writer.Write(as_bytes(span(&kTestNumber, 1))));
276 ASSERT_TRUE(persistent.has_value());
277
278 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
279 }
280
281 { // Get a pointer to the buffer and validate the contents.
282 auto& persistent = GetPersistentBuffer();
283 ASSERT_TRUE(persistent.has_value());
284 EXPECT_EQ(persistent.size(), sizeof(kTestNumber));
285
286 // Write more data.
287 auto writer = persistent.GetWriter();
288 EXPECT_EQ(persistent.size(), sizeof(kTestNumber));
289 ASSERT_EQ(OkStatus(),
290 writer.Write(as_bytes(span<const char>(kTestString))));
291
292 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
293 }
294 { // Ensure data was appended.
295 auto& persistent = GetPersistentBuffer();
296 ASSERT_TRUE(persistent.has_value());
297 EXPECT_EQ(persistent.size(), sizeof(kTestNumber) + kTestString.length());
298 }
299 }
300
301 } // namespace
302 } // namespace pw::persistent_ram
303