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 <span>
18 #include <type_traits>
19
20 #include "gtest/gtest.h"
21 #include "pw_bytes/span.h"
22 #include "pw_random/xor_shift.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 StatusWithSize sws = rng.Get(buffer_);
37 ASSERT_TRUE(sws.ok());
38 ASSERT_EQ(sws.size(), sizeof(buffer_));
39 }
40
GetPersistentBuffer()41 PersistentBuffer<kBufferSize>& GetPersistentBuffer() {
42 return *(new (buffer_) PersistentBuffer<kBufferSize>());
43 }
44
45 // Allocate a chunk of aligned storage that can be independently controlled.
46 alignas(PersistentBuffer<kBufferSize>)
47 std::byte buffer_[sizeof(PersistentBuffer<kBufferSize>)];
48 };
49
TEST_F(PersistentTest,DefaultConstructionAndDestruction)50 TEST_F(PersistentTest, DefaultConstructionAndDestruction) {
51 constexpr uint32_t kExpectedNumber = 0x6C2C6582;
52 {
53 // Emulate a boot where the persistent sections were invalidated.
54 // Although the fixture always does this, we do this an extra time to be
55 // 100% confident that an integrity check cannot be accidentally selected
56 // which results in reporting there is valid data when zero'd.
57 ZeroPersistentMemory();
58 auto& persistent = GetPersistentBuffer();
59 auto writer = persistent.GetWriter();
60 EXPECT_EQ(persistent.size(), 0u);
61
62 writer.Write(std::as_bytes(std::span(&kExpectedNumber, 1)))
63 .IgnoreError(); // TODO(pwbug/387): Handle Status properly
64 ASSERT_TRUE(persistent.has_value());
65
66 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
67 }
68
69 { // Emulate a boot where persistent memory was kept as is.
70 auto& persistent = GetPersistentBuffer();
71 ASSERT_TRUE(persistent.has_value());
72 EXPECT_EQ(persistent.size(), sizeof(kExpectedNumber));
73
74 uint32_t temp = 0;
75 memcpy(&temp, persistent.data(), sizeof(temp));
76 EXPECT_EQ(temp, kExpectedNumber);
77 }
78 }
79
TEST_F(PersistentTest,LongData)80 TEST_F(PersistentTest, LongData) {
81 constexpr std::string_view kTestString(
82 "A nice string should remain valid even if written incrementally!");
83 constexpr size_t kWriteSize = 5;
84
85 { // Initialize the buffer.
86 RandomFillMemory();
87 auto& persistent = GetPersistentBuffer();
88 ASSERT_FALSE(persistent.has_value());
89
90 auto writer = persistent.GetWriter();
91 for (size_t i = 0; i < kTestString.length(); i += kWriteSize) {
92 writer
93 .Write(kTestString.data() + i,
94 std::min(kWriteSize, kTestString.length() - i))
95 .IgnoreError(); // TODO(pwbug/387): Handle Status properly
96 }
97 // Need to manually write a null terminator since std::string_view doesn't
98 // include one in the string length.
99 writer.Write(std::byte(0))
100 .IgnoreError(); // TODO(pwbug/387): Handle Status properly
101
102 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
103 }
104
105 { // Ensure data is valid.
106 auto& persistent = GetPersistentBuffer();
107 ASSERT_TRUE(persistent.has_value());
108 ASSERT_STREQ(kTestString.data(),
109 reinterpret_cast<const char*>(persistent.data()));
110 }
111 }
112
TEST_F(PersistentTest,ZeroDataIsNoValue)113 TEST_F(PersistentTest, ZeroDataIsNoValue) {
114 ZeroPersistentMemory();
115 auto& persistent = GetPersistentBuffer();
116 EXPECT_FALSE(persistent.has_value());
117 }
118
TEST_F(PersistentTest,RandomDataIsInvalid)119 TEST_F(PersistentTest, RandomDataIsInvalid) {
120 RandomFillMemory();
121 auto& persistent = GetPersistentBuffer();
122 ASSERT_FALSE(persistent.has_value());
123 }
124
TEST_F(PersistentTest,AppendingData)125 TEST_F(PersistentTest, AppendingData) {
126 constexpr std::string_view kTestString("Test string one!");
127 constexpr uint32_t kTestNumber = 42;
128
129 { // Initialize the buffer.
130 RandomFillMemory();
131 auto& persistent = GetPersistentBuffer();
132 auto writer = persistent.GetWriter();
133 EXPECT_EQ(persistent.size(), 0u);
134
135 // Write an integer.
136 writer.Write(std::as_bytes(std::span(&kTestNumber, 1)))
137 .IgnoreError(); // TODO(pwbug/387): Handle Status properly
138 ASSERT_TRUE(persistent.has_value());
139
140 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
141 }
142
143 { // Get a pointer to the buffer and validate the contents.
144 auto& persistent = GetPersistentBuffer();
145 ASSERT_TRUE(persistent.has_value());
146 EXPECT_EQ(persistent.size(), sizeof(kTestNumber));
147
148 // Write more data.
149 auto writer = persistent.GetWriter();
150 EXPECT_EQ(persistent.size(), sizeof(kTestNumber));
151 writer.Write(std::as_bytes(std::span<const char>(kTestString)))
152 .IgnoreError(); // TODO(pwbug/387): Handle Status properly
153
154 persistent.~PersistentBuffer(); // Emulate shutdown / global destructors.
155 }
156 { // Ensure data was appended.
157 auto& persistent = GetPersistentBuffer();
158 ASSERT_TRUE(persistent.has_value());
159 EXPECT_EQ(persistent.size(), sizeof(kTestNumber) + kTestString.length());
160 }
161 }
162
163 } // namespace
164 } // namespace pw::persistent_ram
165