Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 1 | // Copyright 2020 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 | |
Wyatt Hepler | bdd8e5a | 2020-02-20 19:27:26 -0800 | [diff] [blame] | 15 | #include "pw_kvs/internal/entry.h" |
Wyatt Hepler | d31d970 | 2020-02-14 08:46:36 -0800 | [diff] [blame] | 16 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 17 | #include <span> |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 18 | #include <string_view> |
| 19 | |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 20 | #include "gtest/gtest.h" |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 21 | #include "pw_bytes/array.h" |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 22 | #include "pw_kvs/alignment.h" |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 23 | #include "pw_kvs/checksum.h" |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 24 | #include "pw_kvs/crc16_checksum.h" |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 25 | #include "pw_kvs/fake_flash_memory.h" |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 26 | #include "pw_kvs/flash_memory.h" |
Wyatt Hepler | 88adfe8 | 2020-02-20 19:33:27 -0800 | [diff] [blame] | 27 | #include "pw_kvs/format.h" |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 28 | |
Wyatt Hepler | 1fc1104 | 2020-02-19 17:17:51 -0800 | [diff] [blame] | 29 | namespace pw::kvs::internal { |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 30 | namespace { |
| 31 | |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 32 | using std::byte; |
| 33 | using std::string_view; |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 34 | |
David Rogers | 436b3aa | 2020-08-03 08:44:10 -0700 | [diff] [blame] | 35 | // For magic value always use a random 32 bit integer rather than a human |
| 36 | // readable 4 bytes. See pw_kvs/format.h for more information. |
| 37 | constexpr EntryFormat kFormat{0x961c2ff9, nullptr}; |
Wyatt Hepler | 88adfe8 | 2020-02-20 19:33:27 -0800 | [diff] [blame] | 38 | |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 39 | TEST(Entry, Size_RoundsUpToAlignment) { |
David Rogers | a149d64 | 2020-07-08 09:25:41 -0700 | [diff] [blame] | 40 | // Use FakeFlashMemory, rather than FakeFlashMemoryBuffer, so the class gets |
| 41 | // tested/used directly. |
| 42 | std::array<std::byte, 64 * 2> buffer; |
David Rogers | 02892d2 | 2020-07-30 00:33:00 -0700 | [diff] [blame] | 43 | |
| 44 | // Flash alignment needs to be 1 due to how the partition is used in this |
| 45 | // test. |
| 46 | FakeFlashMemory flash(buffer, 64, 2, 1); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 47 | |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 48 | for (size_t alignment_bytes = 1; alignment_bytes <= 4096; ++alignment_bytes) { |
Wyatt Hepler | 7465be3 | 2020-02-21 15:30:53 -0800 | [diff] [blame] | 49 | FlashPartition partition(&flash, 0, flash.sector_count(), alignment_bytes); |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 50 | const size_t align = AlignUp(alignment_bytes, Entry::kMinAlignmentBytes); |
| 51 | |
| 52 | for (size_t value : {size_t(0), align - 1, align, align + 1, 2 * align}) { |
Wyatt Hepler | 7465be3 | 2020-02-21 15:30:53 -0800 | [diff] [blame] | 53 | Entry entry = |
| 54 | Entry::Valid(partition, 0, kFormat, "k", {nullptr, value}, 0); |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 55 | |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 56 | ASSERT_EQ(AlignUp(sizeof(EntryHeader) + 1 /* key */ + value, align), |
| 57 | entry.size()); |
| 58 | } |
| 59 | |
Wyatt Hepler | 7465be3 | 2020-02-21 15:30:53 -0800 | [diff] [blame] | 60 | Entry entry = Entry::Tombstone(partition, 0, kFormat, "k", 0); |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 61 | ASSERT_EQ(AlignUp(sizeof(EntryHeader) + 1 /* key */, align), entry.size()); |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 62 | } |
| 63 | } |
| 64 | |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 65 | TEST(Entry, Construct_ValidEntry) { |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 66 | FakeFlashMemoryBuffer<64, 2> flash(16); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 67 | FlashPartition partition(&flash, 0, flash.sector_count()); |
| 68 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 69 | auto entry = Entry::Valid( |
| 70 | partition, 1, kFormat, "k", std::as_bytes(std::span("123")), 9876); |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 71 | |
| 72 | EXPECT_FALSE(entry.deleted()); |
Wyatt Hepler | 88adfe8 | 2020-02-20 19:33:27 -0800 | [diff] [blame] | 73 | EXPECT_EQ(entry.magic(), kFormat.magic); |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 74 | EXPECT_EQ(entry.value_size(), sizeof("123")); |
Wyatt Hepler | 1fc1104 | 2020-02-19 17:17:51 -0800 | [diff] [blame] | 75 | EXPECT_EQ(entry.transaction_id(), 9876u); |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 76 | } |
| 77 | |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 78 | TEST(Entry, Construct_Tombstone) { |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 79 | FakeFlashMemoryBuffer<64, 2> flash(16); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 80 | FlashPartition partition(&flash, 0, flash.sector_count()); |
| 81 | |
Wyatt Hepler | 7465be3 | 2020-02-21 15:30:53 -0800 | [diff] [blame] | 82 | auto entry = Entry::Tombstone(partition, 1, kFormat, "key", 123); |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 83 | |
| 84 | EXPECT_TRUE(entry.deleted()); |
Wyatt Hepler | 88adfe8 | 2020-02-20 19:33:27 -0800 | [diff] [blame] | 85 | EXPECT_EQ(entry.magic(), kFormat.magic); |
Wyatt Hepler | e541e07 | 2020-02-14 09:10:53 -0800 | [diff] [blame] | 86 | EXPECT_EQ(entry.value_size(), 0u); |
Wyatt Hepler | 1fc1104 | 2020-02-19 17:17:51 -0800 | [diff] [blame] | 87 | EXPECT_EQ(entry.transaction_id(), 123u); |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 88 | } |
| 89 | |
David Rogers | 436b3aa | 2020-08-03 08:44:10 -0700 | [diff] [blame] | 90 | // For magic value always use a unique random 32 bit integer rather than a human |
| 91 | // readable 4 bytes. See pw_kvs/format.h for more information. |
| 92 | constexpr uint32_t kMagicWithChecksum = 0xad165142; |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 93 | constexpr uint32_t kTransactionId1 = 0x96979899; |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 94 | |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 95 | constexpr auto kKey1 = bytes::String("key45"); |
| 96 | constexpr auto kValue1 = bytes::String("VALUE!"); |
| 97 | constexpr auto kPadding1 = bytes::String("\0\0\0\0\0"); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 98 | |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 99 | constexpr auto kHeader1 = bytes::Concat(kMagicWithChecksum, |
| 100 | uint32_t(0x23aa), // checksum (CRC16) |
| 101 | uint8_t(1), // alignment (32 B) |
| 102 | uint8_t(kKey1.size()), // key length |
| 103 | uint16_t(kValue1.size()), // value size |
| 104 | kTransactionId1 // transaction ID |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 105 | ); |
| 106 | |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 107 | constexpr auto kEntryWithoutPadding1 = bytes::Concat(kHeader1, kKey1, kValue1); |
| 108 | constexpr auto kEntry1 = bytes::Concat(kEntryWithoutPadding1, kPadding1); |
Wyatt Hepler | 7465be3 | 2020-02-21 15:30:53 -0800 | [diff] [blame] | 109 | static_assert(kEntry1.size() == 32); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 110 | |
Armando Montanez | 888370d | 2020-05-01 18:29:22 -0700 | [diff] [blame] | 111 | ChecksumCrc16 default_checksum; |
| 112 | constexpr EntryFormat kFormatWithChecksum{kMagicWithChecksum, |
| 113 | &default_checksum}; |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 114 | constexpr internal::EntryFormats kFormats(kFormatWithChecksum); |
| 115 | |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 116 | class ValidEntryInFlash : public ::testing::Test { |
| 117 | protected: |
| 118 | ValidEntryInFlash() : flash_(kEntry1), partition_(&flash_) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 119 | EXPECT_EQ(OkStatus(), Entry::Read(partition_, 0, kFormats, &entry_)); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 120 | } |
| 121 | |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 122 | FakeFlashMemoryBuffer<1024, 4> flash_; |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 123 | FlashPartition partition_; |
| 124 | Entry entry_; |
| 125 | }; |
| 126 | |
| 127 | TEST_F(ValidEntryInFlash, PassesChecksumVerification) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 128 | EXPECT_EQ(OkStatus(), entry_.VerifyChecksumInFlash()); |
| 129 | EXPECT_EQ(OkStatus(), entry_.VerifyChecksum("key45", kValue1)); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | TEST_F(ValidEntryInFlash, HeaderContents) { |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 133 | EXPECT_EQ(entry_.magic(), kMagicWithChecksum); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 134 | EXPECT_EQ(entry_.key_length(), 5u); |
| 135 | EXPECT_EQ(entry_.value_size(), 6u); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 136 | EXPECT_EQ(entry_.transaction_id(), kTransactionId1); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 137 | EXPECT_FALSE(entry_.deleted()); |
| 138 | } |
| 139 | |
| 140 | TEST_F(ValidEntryInFlash, ReadKey) { |
| 141 | Entry::KeyBuffer key = {}; |
| 142 | auto result = entry_.ReadKey(key); |
| 143 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 144 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 145 | EXPECT_EQ(result.size(), entry_.key_length()); |
| 146 | EXPECT_STREQ(key.data(), "key45"); |
| 147 | } |
| 148 | |
| 149 | TEST_F(ValidEntryInFlash, ReadValue) { |
| 150 | char value[32] = {}; |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 151 | auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value))); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 152 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 153 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 154 | EXPECT_EQ(result.size(), entry_.value_size()); |
| 155 | EXPECT_STREQ(value, "VALUE!"); |
| 156 | } |
| 157 | |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 158 | TEST_F(ValidEntryInFlash, ReadValue_BufferTooSmall) { |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 159 | char value[3] = {}; |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 160 | auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value))); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 161 | |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 162 | ASSERT_EQ(Status::ResourceExhausted(), result.status()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 163 | EXPECT_EQ(3u, result.size()); |
| 164 | EXPECT_EQ(value[0], 'V'); |
| 165 | EXPECT_EQ(value[1], 'A'); |
| 166 | EXPECT_EQ(value[2], 'L'); |
| 167 | } |
| 168 | |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 169 | TEST_F(ValidEntryInFlash, ReadValue_WithOffset) { |
| 170 | char value[3] = {}; |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 171 | auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 3); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 172 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 173 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 174 | EXPECT_EQ(3u, result.size()); |
| 175 | EXPECT_EQ(value[0], 'U'); |
| 176 | EXPECT_EQ(value[1], 'E'); |
| 177 | EXPECT_EQ(value[2], '!'); |
| 178 | } |
| 179 | |
| 180 | TEST_F(ValidEntryInFlash, ReadValue_WithOffset_BufferTooSmall) { |
| 181 | char value[1] = {}; |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 182 | auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 4); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 183 | |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 184 | ASSERT_EQ(Status::ResourceExhausted(), result.status()); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 185 | EXPECT_EQ(1u, result.size()); |
| 186 | EXPECT_EQ(value[0], 'E'); |
| 187 | } |
| 188 | |
| 189 | TEST_F(ValidEntryInFlash, ReadValue_WithOffset_EmptyRead) { |
| 190 | char value[16] = {'?'}; |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 191 | auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 6); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 192 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 193 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 194 | EXPECT_EQ(0u, result.size()); |
| 195 | EXPECT_EQ(value[0], '?'); |
| 196 | } |
| 197 | |
| 198 | TEST_F(ValidEntryInFlash, ReadValue_WithOffset_PastEnd) { |
| 199 | char value[16] = {}; |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 200 | auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 7); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 201 | |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 202 | EXPECT_EQ(Status::OutOfRange(), result.status()); |
Wyatt Hepler | 5f6efc0 | 2020-02-18 16:54:31 -0800 | [diff] [blame] | 203 | EXPECT_EQ(0u, result.size()); |
| 204 | } |
| 205 | |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 206 | TEST(ValidEntry, Write) { |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 207 | FakeFlashMemoryBuffer<1024, 4> flash; |
Wyatt Hepler | 7465be3 | 2020-02-21 15:30:53 -0800 | [diff] [blame] | 208 | FlashPartition partition(&flash, 0, flash.sector_count(), 32); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 209 | |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 210 | Entry entry = Entry::Valid( |
David Rogers | 907570b | 2020-08-06 12:44:27 -0700 | [diff] [blame] | 211 | partition, 64, kFormatWithChecksum, "key45", kValue1, kTransactionId1); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 212 | |
| 213 | auto result = entry.Write("key45", kValue1); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 214 | EXPECT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 215 | EXPECT_EQ(32u, result.size()); |
David Rogers | 907570b | 2020-08-06 12:44:27 -0700 | [diff] [blame] | 216 | EXPECT_EQ(std::memcmp(&flash.buffer()[64], kEntry1.data(), kEntry1.size()), |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 217 | 0); |
| 218 | } |
| 219 | |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 220 | constexpr auto kHeader2 = bytes::String( |
David Rogers | 436b3aa | 2020-08-03 08:44:10 -0700 | [diff] [blame] | 221 | "\x42\x51\x16\xad" // magic |
| 222 | "\xba\xb3\x00\x00" // checksum (CRC16) |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 223 | "\x00" // alignment |
| 224 | "\x01" // key length |
| 225 | "\xff\xff" // value size |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 226 | "\x00\x01\x02\x03" // transaction ID |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 227 | ); |
| 228 | |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 229 | constexpr auto kKeyAndPadding2 = |
| 230 | bytes::String("K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 231 | |
| 232 | class TombstoneEntryInFlash : public ::testing::Test { |
| 233 | protected: |
| 234 | TombstoneEntryInFlash() |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 235 | : flash_(bytes::Concat(kHeader2, kKeyAndPadding2)), partition_(&flash_) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 236 | EXPECT_EQ(OkStatus(), Entry::Read(partition_, 0, kFormats, &entry_)); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 237 | } |
| 238 | |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 239 | FakeFlashMemoryBuffer<1024, 4> flash_; |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 240 | FlashPartition partition_; |
| 241 | Entry entry_; |
| 242 | }; |
| 243 | |
| 244 | TEST_F(TombstoneEntryInFlash, PassesChecksumVerification) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 245 | EXPECT_EQ(OkStatus(), entry_.VerifyChecksumInFlash()); |
| 246 | EXPECT_EQ(OkStatus(), entry_.VerifyChecksum("K", {})); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | TEST_F(TombstoneEntryInFlash, HeaderContents) { |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 250 | EXPECT_EQ(entry_.magic(), kMagicWithChecksum); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 251 | EXPECT_EQ(entry_.key_length(), 1u); |
| 252 | EXPECT_EQ(entry_.value_size(), 0u); |
Wyatt Hepler | 1fc1104 | 2020-02-19 17:17:51 -0800 | [diff] [blame] | 253 | EXPECT_EQ(entry_.transaction_id(), 0x03020100u); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 254 | EXPECT_TRUE(entry_.deleted()); |
| 255 | } |
| 256 | |
| 257 | TEST_F(TombstoneEntryInFlash, ReadKey) { |
| 258 | Entry::KeyBuffer key = {}; |
| 259 | auto result = entry_.ReadKey(key); |
| 260 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 261 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 262 | EXPECT_EQ(result.size(), entry_.key_length()); |
| 263 | EXPECT_STREQ(key.data(), "K"); |
| 264 | } |
| 265 | |
| 266 | TEST_F(TombstoneEntryInFlash, ReadValue) { |
| 267 | char value[32] = {}; |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 268 | auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value))); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 269 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 270 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 271 | EXPECT_EQ(0u, result.size()); |
| 272 | } |
| 273 | |
| 274 | TEST(TombstoneEntry, Write) { |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 275 | FakeFlashMemoryBuffer<1024, 4> flash; |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 276 | FlashPartition partition(&flash); |
| 277 | ChecksumCrc16 checksum; |
| 278 | |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 279 | Entry entry = |
| 280 | Entry::Tombstone(partition, 16, kFormatWithChecksum, "K", 0x03020100); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 281 | |
| 282 | auto result = entry.Write("K", {}); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 283 | EXPECT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 284 | EXPECT_EQ(32u, result.size()); |
| 285 | EXPECT_EQ(std::memcmp(&flash.buffer()[16], |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 286 | bytes::Concat(kHeader2, kKeyAndPadding2).data(), |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 287 | kEntry1.size()), |
| 288 | 0); |
| 289 | } |
| 290 | |
| 291 | TEST(Entry, Checksum_NoChecksumRequiresZero) { |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 292 | FakeFlashMemoryBuffer<1024, 4> flash(kEntry1); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 293 | FlashPartition partition(&flash); |
| 294 | Entry entry; |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 295 | |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 296 | const EntryFormat format{kMagicWithChecksum, nullptr}; |
| 297 | const internal::EntryFormats formats(format); |
| 298 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 299 | ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, formats, &entry)); |
Wyatt Hepler | 22d0d9f | 2020-03-05 14:57:11 -0800 | [diff] [blame] | 300 | |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 301 | EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash()); |
| 302 | EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksum({}, {})); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 303 | |
| 304 | std::memset(&flash.buffer()[4], 0, 4); // set the checksum field to 0 |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 305 | ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, formats, &entry)); |
| 306 | EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash()); |
| 307 | EXPECT_EQ(OkStatus(), entry.VerifyChecksum({}, {})); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 308 | } |
| 309 | |
| 310 | TEST(Entry, Checksum_ChecksPadding) { |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 311 | FakeFlashMemoryBuffer<1024, 4> flash( |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 312 | bytes::Concat(kHeader1, kKey1, kValue1, bytes::String("\0\0\0\0\1"))); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 313 | FlashPartition partition(&flash); |
| 314 | Entry entry; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 315 | ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry)); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 316 | |
| 317 | // Last byte in padding is a 1; should fail. |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 318 | EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 319 | |
| 320 | // The in-memory verification fills in 0s for the padding. |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 321 | EXPECT_EQ(OkStatus(), entry.VerifyChecksum("key45", kValue1)); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 322 | |
| 323 | flash.buffer()[kEntry1.size() - 1] = byte{0}; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 324 | EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash()); |
Wyatt Hepler | a00d1ef | 2020-02-14 14:31:26 -0800 | [diff] [blame] | 325 | } |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 326 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 327 | TEST_F(ValidEntryInFlash, Update_SameFormat_TransactionIdIsUpdated) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 328 | ASSERT_EQ(OkStatus(), |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 329 | entry_.Update(kFormatWithChecksum, kTransactionId1 + 3)); |
| 330 | |
| 331 | EXPECT_EQ(kFormatWithChecksum.magic, entry_.magic()); |
| 332 | EXPECT_EQ(0u, entry_.address()); |
| 333 | EXPECT_EQ(kTransactionId1 + 3, entry_.transaction_id()); |
| 334 | EXPECT_FALSE(entry_.deleted()); |
| 335 | } |
| 336 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 337 | TEST_F(ValidEntryInFlash, |
| 338 | Update_DifferentFormat_MagicAndTransactionIdAreUpdated) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 339 | ASSERT_EQ(OkStatus(), entry_.Update(kFormat, kTransactionId1 + 6)); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 340 | |
| 341 | EXPECT_EQ(kFormat.magic, entry_.magic()); |
| 342 | EXPECT_EQ(0u, entry_.address()); |
| 343 | EXPECT_EQ(kTransactionId1 + 6, entry_.transaction_id()); |
| 344 | EXPECT_FALSE(entry_.deleted()); |
| 345 | } |
| 346 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 347 | TEST_F(ValidEntryInFlash, Update_ReadError_WithChecksumIsError) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 348 | flash_.InjectReadError(FlashError::Unconditional(Status::Aborted())); |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 349 | |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 350 | EXPECT_EQ(Status::Aborted(), |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 351 | entry_.Update(kFormatWithChecksum, kTransactionId1 + 1)); |
| 352 | } |
| 353 | |
David Rogers | 436b3aa | 2020-08-03 08:44:10 -0700 | [diff] [blame] | 354 | // For magic value always use a random 32 bit integer rather than a human |
| 355 | // readable 4 bytes. See pw_kvs/format.h for more information. |
| 356 | constexpr EntryFormat kNoChecksumFormat{.magic = 0x721bad24, |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 357 | .checksum = nullptr}; |
| 358 | |
| 359 | TEST_F(ValidEntryInFlash, Update_ReadError_NoChecksumIsOkay) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 360 | flash_.InjectReadError(FlashError::Unconditional(Status::Aborted())); |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 361 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 362 | EXPECT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1)); |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 363 | } |
| 364 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 365 | TEST_F(ValidEntryInFlash, Copy) { |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 366 | auto result = entry_.Copy(123); |
| 367 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 368 | EXPECT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 369 | EXPECT_EQ(entry_.size(), result.size()); |
| 370 | EXPECT_EQ(0, |
| 371 | std::memcmp( |
| 372 | &flash_.buffer().data()[123], kEntry1.data(), kEntry1.size())); |
| 373 | } |
| 374 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 375 | TEST_F(ValidEntryInFlash, Copy_ReadError) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 376 | flash_.InjectReadError(FlashError::Unconditional(Status::Unimplemented())); |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 377 | auto result = entry_.Copy(kEntry1.size()); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 378 | EXPECT_EQ(Status::Unimplemented(), result.status()); |
Wyatt Hepler | 486ac57 | 2020-03-12 15:15:22 -0700 | [diff] [blame] | 379 | EXPECT_EQ(0u, result.size()); |
| 380 | } |
| 381 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 382 | constexpr uint32_t ByteSum(std::span<const byte> bytes, uint32_t value = 0) { |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 383 | for (byte b : bytes) { |
| 384 | value += unsigned(b); |
| 385 | } |
| 386 | return value; |
| 387 | } |
| 388 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 389 | // Sums the bytes, adding one to each byte so that zeroes change the checksum. |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 390 | class ChecksumSummation final : public ChecksumAlgorithm { |
| 391 | public: |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 392 | ChecksumSummation() |
| 393 | : ChecksumAlgorithm(std::as_bytes(std::span(&sum_, 1))), sum_(0) {} |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 394 | |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 395 | void Reset() override { sum_ = 0; } |
| 396 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 397 | void Update(std::span<const byte> data) override { |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 398 | for (byte b : data) { |
| 399 | sum_ += unsigned(b) + 1; // Add 1 so zero-value bytes affect checksum. |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 400 | } |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 401 | } |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 402 | |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 403 | private: |
| 404 | uint32_t sum_; |
| 405 | } sum_checksum; |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 406 | |
David Rogers | 436b3aa | 2020-08-03 08:44:10 -0700 | [diff] [blame] | 407 | // For magic value always use a random 32 bit integer rather than a human |
| 408 | // readable 4 bytes. See pw_kvs/format.h for more information. |
| 409 | constexpr uint32_t kMagicWithSum = 0x6093aadb; |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 410 | constexpr EntryFormat kFormatWithSum{kMagicWithSum, &sum_checksum}; |
| 411 | constexpr internal::EntryFormats kFormatsWithSum(kFormatWithSum); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 412 | |
Wyatt Hepler | b8c67ac | 2021-08-12 09:44:21 -0700 | [diff] [blame^] | 413 | template <size_t kAlignment> |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 414 | constexpr auto MakeNewFormatWithSumEntry() { |
Wyatt Hepler | b8c67ac | 2021-08-12 09:44:21 -0700 | [diff] [blame^] | 415 | constexpr uint8_t alignment_units = (kAlignment + 15) / 16 - 1; |
| 416 | constexpr size_t size = AlignUp(kEntryWithoutPadding1.size(), kAlignment); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 417 | |
| 418 | constexpr uint32_t checksum = |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 419 | ByteSum(bytes::Concat(kFormatWithSum.magic)) + 0 /* checksum */ + |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 420 | alignment_units + kKey1.size() + kValue1.size() + |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 421 | ByteSum(bytes::Concat(kTransactionId1 + 1)) + ByteSum(kKey1) + |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 422 | ByteSum(kValue1) + size /* +1 for each byte in the checksum */; |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 423 | |
| 424 | constexpr auto kNewHeader1 = |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 425 | bytes::Concat(kFormatWithSum.magic, // magic |
| 426 | checksum, // checksum (byte sum) |
| 427 | alignment_units, // alignment (in 16 B units) |
| 428 | uint8_t(kKey1.size()), // key length |
| 429 | uint16_t(kValue1.size()), // value size |
| 430 | kTransactionId1 + 1); // transaction ID |
Wyatt Hepler | b8c67ac | 2021-08-12 09:44:21 -0700 | [diff] [blame^] | 431 | constexpr size_t padding = Padding(kEntryWithoutPadding1.size(), kAlignment); |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 432 | return bytes::Concat( |
| 433 | kNewHeader1, kKey1, kValue1, bytes::Initialized<padding>(0)); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 434 | } |
| 435 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 436 | TEST_F(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSmallerAlignment) { |
| 437 | // Uses 16-bit alignment, smaller than the original entry's alignment. |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 438 | ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 1)); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 439 | |
| 440 | StatusWithSize result = entry_.Copy(kEntry1.size()); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 441 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 442 | EXPECT_EQ(kEntry1.size(), result.size()); |
| 443 | |
| 444 | constexpr auto new_data = MakeNewFormatWithSumEntry<16>(); |
| 445 | static_assert(new_data.size() == 32); |
| 446 | |
| 447 | EXPECT_EQ( |
| 448 | 0, |
| 449 | std::memcmp( |
| 450 | &flash_.buffer()[kEntry1.size()], new_data.data(), new_data.size())); |
| 451 | Entry new_entry; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 452 | ASSERT_EQ(OkStatus(), |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 453 | Entry::Read(partition_, 32, kFormatsWithSum, &new_entry)); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 454 | EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash()); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 455 | EXPECT_EQ(kFormatWithSum.magic, new_entry.magic()); |
| 456 | EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id()); |
| 457 | } |
| 458 | |
| 459 | TEST(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSameAlignment) { |
| 460 | // Use 32-bit alignment, the same as the original entry's alignment. |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 461 | FakeFlashMemoryBuffer<1024, 4> flash(kEntry1); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 462 | FlashPartition partition(&flash, 0, 4, 32); |
| 463 | Entry entry; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 464 | ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry)); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 465 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 466 | ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1)); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 467 | |
| 468 | StatusWithSize result = entry.Copy(32); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 469 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 470 | EXPECT_EQ(AlignUp(kEntry1.size(), 32), result.size()); |
| 471 | |
| 472 | constexpr auto new_data = MakeNewFormatWithSumEntry<32>(); |
| 473 | static_assert(new_data.size() == 32); |
| 474 | |
| 475 | EXPECT_EQ(0, |
| 476 | std::memcmp(&flash.buffer()[32], new_data.data(), new_data.size())); |
| 477 | |
| 478 | Entry new_entry; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 479 | ASSERT_EQ(OkStatus(), |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 480 | Entry::Read(partition, 32, kFormatsWithSum, &new_entry)); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 481 | EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash()); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 482 | EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id()); |
| 483 | } |
| 484 | |
| 485 | TEST(ValidEntryInFlash, UpdateAndCopy_DifferentFormatLargerAlignment) { |
| 486 | // Use 64-bit alignment, larger than the original entry's alignment. |
David Rogers | d64cc01 | 2020-05-26 12:37:37 -0700 | [diff] [blame] | 487 | FakeFlashMemoryBuffer<1024, 4> flash(kEntry1); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 488 | FlashPartition partition(&flash, 0, 4, 64); |
| 489 | Entry entry; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 490 | ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry)); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 491 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 492 | ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1)); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 493 | |
| 494 | StatusWithSize result = entry.Copy(64); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 495 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 496 | EXPECT_EQ(AlignUp(kEntry1.size(), 64), result.size()); |
| 497 | |
| 498 | constexpr auto new_data = MakeNewFormatWithSumEntry<64>(); |
| 499 | static_assert(new_data.size() == 64); |
| 500 | |
| 501 | EXPECT_EQ(0, |
| 502 | std::memcmp(&flash.buffer()[64], new_data.data(), new_data.size())); |
| 503 | |
| 504 | Entry new_entry; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 505 | ASSERT_EQ(OkStatus(), |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 506 | Entry::Read(partition, 64, kFormatsWithSum, &new_entry)); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 507 | EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash()); |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 508 | EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id()); |
| 509 | } |
| 510 | |
| 511 | TEST_F(ValidEntryInFlash, UpdateAndCopy_NoChecksum_UpdatesToNewFormat) { |
David Rogers | 436b3aa | 2020-08-03 08:44:10 -0700 | [diff] [blame] | 512 | // For magic value always use a random 32 bit integer rather than a human |
| 513 | // readable 4 bytes. See pw_kvs/format.h for more information. |
| 514 | constexpr EntryFormat no_checksum{.magic = 0x43fae18f, .checksum = nullptr}; |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 515 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 516 | ASSERT_EQ(OkStatus(), entry_.Update(no_checksum, kTransactionId1 + 1)); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 517 | |
| 518 | auto result = entry_.Copy(kEntry1.size()); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 519 | ASSERT_EQ(OkStatus(), result.status()); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 520 | EXPECT_EQ(kEntry1.size(), result.size()); |
| 521 | |
| 522 | constexpr auto kNewHeader1 = |
Wyatt Hepler | 6b3a6c9 | 2020-08-03 10:15:56 -0700 | [diff] [blame] | 523 | bytes::Concat(no_checksum.magic, // magic |
| 524 | uint32_t(0), // checksum (none) |
| 525 | uint8_t(0), // alignment (changed to 16 B from 32) |
| 526 | uint8_t(kKey1.size()), // key length |
| 527 | uint16_t(kValue1.size()), // value size |
| 528 | kTransactionId1 + 1); // transaction ID |
| 529 | constexpr auto kNewEntry1 = |
| 530 | bytes::Concat(kNewHeader1, kKey1, kValue1, kPadding1); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 531 | |
| 532 | EXPECT_EQ(0, |
| 533 | std::memcmp(&flash_.buffer()[kEntry1.size()], |
| 534 | kNewEntry1.data(), |
| 535 | kNewEntry1.size())); |
| 536 | } |
| 537 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 538 | TEST_F(ValidEntryInFlash, UpdateAndCopyMultple_DifferentFormat) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 539 | ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 6)); |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 540 | |
| 541 | FlashPartition::Address new_address = entry_.size(); |
| 542 | |
| 543 | for (int i = 0; i < 10; i++) { |
| 544 | StatusWithSize copy_result = entry_.Copy(new_address + (i * entry_.size())); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 545 | ASSERT_EQ(OkStatus(), copy_result.status()); |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 546 | ASSERT_EQ(kEntry1.size(), copy_result.size()); |
| 547 | } |
| 548 | |
| 549 | for (int j = 0; j < 10; j++) { |
| 550 | Entry entry; |
| 551 | FlashPartition::Address read_address = (new_address + (j * entry_.size())); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 552 | ASSERT_EQ(OkStatus(), |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 553 | Entry::Read(partition_, read_address, kFormatsWithSum, &entry)); |
| 554 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 555 | EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash()); |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 556 | EXPECT_EQ(kFormatWithSum.magic, entry.magic()); |
| 557 | EXPECT_EQ(read_address, entry.address()); |
| 558 | EXPECT_EQ(kTransactionId1 + 6, entry.transaction_id()); |
| 559 | EXPECT_FALSE(entry.deleted()); |
| 560 | } |
| 561 | } |
| 562 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 563 | TEST_F(ValidEntryInFlash, DifferentFormat_UpdatedCopy_FailsWithWrongMagic) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 564 | ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 6)); |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 565 | |
| 566 | FlashPartition::Address new_address = entry_.size(); |
| 567 | |
| 568 | StatusWithSize copy_result = entry_.Copy(new_address); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 569 | ASSERT_EQ(OkStatus(), copy_result.status()); |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 570 | ASSERT_EQ(kEntry1.size(), copy_result.size()); |
| 571 | |
| 572 | Entry entry; |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 573 | ASSERT_EQ(Status::DataLoss(), |
David Rogers | 31b358b | 2020-04-15 05:00:50 -0700 | [diff] [blame] | 574 | Entry::Read(partition_, new_address, kFormats, &entry)); |
| 575 | } |
| 576 | |
Wyatt Hepler | 5007049 | 2020-04-23 21:50:34 -0700 | [diff] [blame] | 577 | TEST_F(ValidEntryInFlash, UpdateAndCopy_WriteError) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 578 | flash_.InjectWriteError(FlashError::Unconditional(Status::Cancelled())); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 579 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 580 | ASSERT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1)); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 581 | |
| 582 | auto result = entry_.Copy(kEntry1.size()); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 583 | EXPECT_EQ(Status::Cancelled(), result.status()); |
Wyatt Hepler | 1d59456 | 2020-03-10 18:26:02 -0700 | [diff] [blame] | 584 | EXPECT_EQ(kEntry1.size(), result.size()); |
| 585 | } |
| 586 | |
Wyatt Hepler | 97fc794 | 2020-02-06 15:55:45 -0800 | [diff] [blame] | 587 | } // namespace |
Wyatt Hepler | 1fc1104 | 2020-02-19 17:17:51 -0800 | [diff] [blame] | 588 | } // namespace pw::kvs::internal |