pw_status: Update Status::CODE to Status::Code()
- Update Status::CODE style to Status::Code() using
pw_status/update_style.py.
- Make minor adjustments to the pw_assert tests to get them passing.
Change-Id: Ie54c3c605178fd1e42c7cedbcff324115f3ed279
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/19165
Commit-Queue: Wyatt Hepler <hepler@google.com>
Reviewed-by: Ewout van Bekkum <ewout@google.com>
diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
index 0f3dc89..536de87 100644
--- a/pw_kvs/alignment_test.cc
+++ b/pw_kvs/alignment_test.cc
@@ -141,26 +141,26 @@
AlignedWriterBuffer<32> writer(kAlignment, check_against_data);
// Write values smaller than the alignment.
- EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(0, 1)).status());
- EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(1, 9)).status());
+ EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(0, 1)).status());
+ EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(1, 9)).status());
// Write values larger than the alignment but smaller than the buffer.
- EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(10, 11)).status());
+ EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(10, 11)).status());
// Exactly fill the remainder of the buffer.
- EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(21, 11)).status());
+ EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(21, 11)).status());
// Fill the buffer more than once.
- EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(32, 66)).status());
+ EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(32, 66)).status());
// Write nothing.
- EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(98, 0)).status());
+ EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 0)).status());
// Write the remaining data.
- EXPECT_EQ(Status::OK, writer.Write(kBytes.subspan(98, 2)).status());
+ EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 2)).status());
auto result = writer.Flush();
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(kData.size(), result.size());
}
@@ -202,7 +202,7 @@
ADD_FAILURE();
break;
}
- return StatusWithSize(Status::UNKNOWN, data.size());
+ return StatusWithSize::Unknown(data.size());
}
};
@@ -213,7 +213,7 @@
AlignedWriterBuffer<4> writer(3, output);
writer.Write(std::as_bytes(std::span("Everything is fine.")));
output.state = OutputWithErrorInjection::kBreakOnNext;
- EXPECT_EQ(Status::UNKNOWN,
+ EXPECT_EQ(Status::Unknown(),
writer.Write(std::as_bytes(std::span("No more writes, okay?")))
.status());
writer.Flush();
@@ -222,7 +222,7 @@
TEST(AlignedWriter, Write_ReturnsTotalBytesWritten) {
static Status return_status;
- return_status = Status::OK;
+ return_status = Status::Ok();
OutputToFunction output([](std::span<const byte> data) {
return StatusWithSize(return_status, data.size());
@@ -232,17 +232,17 @@
StatusWithSize result =
writer.Write(std::as_bytes(std::span("12345678901"sv)));
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(0u, result.size()); // No writes; haven't filled buffer.
result = writer.Write(std::as_bytes(std::span("2345678901"sv)));
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(20u, result.size());
- return_status = Status::PERMISSION_DENIED;
+ return_status = Status::PermissionDenied();
result = writer.Write(std::as_bytes(std::span("2345678901234567890"sv)));
- EXPECT_EQ(Status::PERMISSION_DENIED, result.status());
+ EXPECT_EQ(Status::PermissionDenied(), result.status());
EXPECT_EQ(40u, result.size());
}
@@ -252,17 +252,17 @@
AlignedWriterBuffer<4> writer(2, output);
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
writer.Write(std::as_bytes(std::span("12345678901"sv))).status());
StatusWithSize result = writer.Flush();
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(12u, result.size());
}
TEST(AlignedWriter, Flush_Error_ReturnsTotalBytesWritten) {
OutputToFunction output([](std::span<const byte> data) {
- return StatusWithSize(Status::ABORTED, data.size());
+ return StatusWithSize::Aborted(data.size());
});
AlignedWriterBuffer<20> writer(10, output);
@@ -270,7 +270,7 @@
EXPECT_EQ(0u, writer.Write(std::as_bytes(std::span("12345678901"sv))).size());
StatusWithSize result = writer.Flush();
- EXPECT_EQ(Status::ABORTED, result.status());
+ EXPECT_EQ(Status::Aborted(), result.status());
EXPECT_EQ(20u, result.size());
}
@@ -284,12 +284,12 @@
EXPECT_LE(index_ + data.size(), kBytes.size());
if (index_ + data.size() > kBytes.size()) {
- return StatusWithSize::INTERNAL;
+ return StatusWithSize::Internal();
}
// Check if reading from the index that was programmed to cause an error.
if (index_ <= break_on_index_ && break_on_index_ <= index_ + data.size()) {
- return StatusWithSize::ABORTED;
+ return StatusWithSize::Aborted();
}
std::memcpy(data.data(), kBytes.data(), data.size());
@@ -306,11 +306,11 @@
InputWithErrorInjection input;
StatusWithSize result = writer.Write(input, kData.size());
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_LE(result.size(), kData.size()); // May not have written it all yet.
result = writer.Flush();
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(kData.size(), result.size());
}
@@ -321,7 +321,7 @@
input.BreakOnIndex(kAlignment + 2);
StatusWithSize result = writer.Write(input, kData.size());
- EXPECT_EQ(Status::ABORTED, result.status());
+ EXPECT_EQ(Status::Aborted(), result.status());
EXPECT_LE(result.size(), kAlignment); // Wrote the first chunk, nothing more.
}
@@ -333,7 +333,7 @@
output.state = OutputWithErrorInjection::kBreakOnNext;
StatusWithSize result = writer.Write(input, kData.size());
- EXPECT_EQ(Status::UNKNOWN, result.status());
+ EXPECT_EQ(Status::Unknown(), result.status());
EXPECT_EQ(3u, result.size()); // Attempted to write 3 bytes.
}
diff --git a/pw_kvs/checksum.cc b/pw_kvs/checksum.cc
index 0a885f7..08f59b8 100644
--- a/pw_kvs/checksum.cc
+++ b/pw_kvs/checksum.cc
@@ -22,12 +22,12 @@
Status ChecksumAlgorithm::Verify(std::span<const byte> checksum) const {
if (checksum.size() < size_bytes()) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
if (std::memcmp(state_.data(), checksum.data(), size_bytes()) != 0) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
- return Status::OK;
+ return Status::Ok();
}
} // namespace pw::kvs
diff --git a/pw_kvs/checksum_test.cc b/pw_kvs/checksum_test.cc
index 0db5ed2..4fffae0 100644
--- a/pw_kvs/checksum_test.cc
+++ b/pw_kvs/checksum_test.cc
@@ -32,19 +32,20 @@
ChecksumAlgorithm& algo = crc16_algo;
algo.Update(kString.data(), kString.size());
- EXPECT_EQ(Status::OK, algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
+ EXPECT_EQ(Status::Ok(),
+ algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
}
TEST(Checksum, Verify_Failure) {
ChecksumCrc16 algo;
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
algo.Verify(std::as_bytes(std::span(kString.data(), 2))));
}
TEST(Checksum, Verify_InvalidSize) {
ChecksumCrc16 algo;
- EXPECT_EQ(Status::INVALID_ARGUMENT, algo.Verify({}));
- EXPECT_EQ(Status::INVALID_ARGUMENT,
+ EXPECT_EQ(Status::InvalidArgument(), algo.Verify({}));
+ EXPECT_EQ(Status::InvalidArgument(),
algo.Verify(std::as_bytes(std::span(kString.substr(0, 1)))));
}
@@ -55,7 +56,7 @@
algo.Update(std::as_bytes(std::span(kString)));
- EXPECT_EQ(Status::OK, algo.Verify(crc));
+ EXPECT_EQ(Status::Ok(), algo.Verify(crc));
}
TEST(Checksum, Reset) {
@@ -71,20 +72,20 @@
TEST(IgnoreChecksum, NeverUpdate_VerifyWithoutData) {
IgnoreChecksum checksum;
- EXPECT_EQ(Status::OK, checksum.Verify({}));
+ EXPECT_EQ(Status::Ok(), checksum.Verify({}));
}
TEST(IgnoreChecksum, NeverUpdate_VerifyWithData) {
IgnoreChecksum checksum;
- EXPECT_EQ(Status::OK, checksum.Verify(std::as_bytes(std::span(kString))));
+ EXPECT_EQ(Status::Ok(), checksum.Verify(std::as_bytes(std::span(kString))));
}
TEST(IgnoreChecksum, AfterUpdate_Verify) {
IgnoreChecksum checksum;
checksum.Update(std::as_bytes(std::span(kString)));
- EXPECT_EQ(Status::OK, checksum.Verify({}));
+ EXPECT_EQ(Status::Ok(), checksum.Verify({}));
}
constexpr size_t kAlignment = 10;
@@ -143,7 +144,7 @@
EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(state.data()),
state.size()),
kData);
- EXPECT_EQ(Status::OK, checksum.Verify(kBytes));
+ EXPECT_EQ(Status::Ok(), checksum.Verify(kBytes));
}
} // namespace
diff --git a/pw_kvs/entry.cc b/pw_kvs/entry.cc
index cfa9e76..0fa68da 100644
--- a/pw_kvs/entry.cc
+++ b/pw_kvs/entry.cc
@@ -43,10 +43,10 @@
PW_TRY(partition.Read(address, sizeof(header), &header));
if (partition.AppearsErased(std::as_bytes(std::span(&header.magic, 1)))) {
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
if (header.key_length_bytes > kMaxKeyLength) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
const EntryFormat* format = formats.Find(header.magic);
@@ -54,11 +54,11 @@
PW_LOG_ERROR("Found corrupt magic: %" PRIx32 " at address %u",
header.magic,
unsigned(address));
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
*entry = Entry(&partition, address, *format, header);
- return Status::OK;
+ return Status::Ok();
}
Status Entry::ReadKey(FlashPartition& partition,
@@ -66,7 +66,7 @@
size_t key_length,
char* key) {
if (key_length == 0u || key_length > kMaxKeyLength) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
return partition.Read(address + sizeof(EntryHeader), key_length, key)
@@ -145,7 +145,7 @@
StatusWithSize Entry::ReadValue(std::span<byte> buffer,
size_t offset_bytes) const {
if (offset_bytes > value_size()) {
- return StatusWithSize::OUT_OF_RANGE;
+ return StatusWithSize::OutOfRange();
}
const size_t remaining_bytes = value_size() - offset_bytes;
@@ -157,14 +157,14 @@
PW_TRY_WITH_SIZE(result);
if (read_size != remaining_bytes) {
- return StatusWithSize(Status::RESOURCE_EXHAUSTED, read_size);
+ return StatusWithSize::ResourceExhausted(read_size);
}
return StatusWithSize(read_size);
}
Status Entry::ValueMatches(std::span<const std::byte> value) const {
if (value_size() != value.size_bytes()) {
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
Address address = address_ + sizeof(EntryHeader) + key_length();
@@ -177,20 +177,20 @@
PW_TRY(partition_->Read(address, std::span(buffer).first(read_size)));
if (std::memcmp(buffer.data(), value_ptr, read_size) != 0) {
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
address += read_size;
value_ptr += read_size;
}
- return Status::OK;
+ return Status::Ok();
}
Status Entry::VerifyChecksum(string_view key,
std::span<const byte> value) const {
if (checksum_algo_ == nullptr) {
- return header_.checksum == 0 ? Status::OK : Status::DATA_LOSS;
+ return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
}
CalculateChecksum(key, value);
return checksum_algo_->Verify(checksum_bytes());
@@ -216,11 +216,11 @@
PW_LOG_ERROR("Expected checksum 0x%08" PRIx32 ", found 0x%08" PRIx32,
header_.checksum,
header_to_verify.checksum);
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (checksum_algo_ == nullptr) {
- return header_.checksum == 0 ? Status::OK : Status::DATA_LOSS;
+ return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
}
// The checksum is calculated as if the header's checksum field were 0.
@@ -281,7 +281,7 @@
header_.checksum = 0;
if (checksum_algo_ == nullptr) {
- return Status::OK;
+ return Status::Ok();
}
checksum_algo_->Reset();
@@ -307,7 +307,7 @@
std::memcpy(&header_.checksum,
checksum.data(),
std::min(checksum.size(), sizeof(header_.checksum)));
- return Status::OK;
+ return Status::Ok();
}
void Entry::AddPaddingBytesToChecksum() const {
diff --git a/pw_kvs/entry_cache.cc b/pw_kvs/entry_cache.cc
index c6d58a8..b6245a4 100644
--- a/pw_kvs/entry_cache.cc
+++ b/pw_kvs/entry_cache.cc
@@ -103,18 +103,18 @@
if (!key_found) {
PW_LOG_ERROR("No valid entries for key. Data has been lost!");
- return StatusWithSize(Status::DATA_LOSS, error_val);
+ return StatusWithSize::DataLoss(error_val);
} else if (key == read_key) {
PW_LOG_DEBUG("Found match for key hash 0x%08" PRIx32, hash);
*metadata = EntryMetadata(descriptors_[i], addresses(i));
- return StatusWithSize(Status::OK, error_val);
+ return StatusWithSize::Ok(error_val);
} else {
PW_LOG_WARN("Found key hash collision for 0x%08" PRIx32, hash);
- return StatusWithSize(Status::ALREADY_EXISTS, error_val);
+ return StatusWithSize::AlreadyExists(error_val);
}
}
}
- return StatusWithSize::NOT_FOUND;
+ return StatusWithSize::NotFound();
}
EntryMetadata EntryCache::AddNew(const KeyDescriptor& descriptor,
@@ -139,17 +139,17 @@
// Write a new entry if there is room.
if (index == -1) {
if (full()) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
AddNew(descriptor, address);
- return Status::OK;
+ return Status::Ok();
}
// Existing entry is old; replace the existing entry with the new one.
if (descriptor.transaction_id > descriptors_[index].transaction_id) {
descriptors_[index] = descriptor;
ResetAddresses(index, address);
- return Status::OK;
+ return Status::Ok();
}
// If the entries have a duplicate transaction ID, add the new (redundant)
@@ -160,7 +160,7 @@
" with transaction ID %" PRIu32 " has non-matching hash",
descriptor.key_hash,
descriptor.transaction_id);
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
// Verify that this entry is not in the same sector as an existing copy of
@@ -169,7 +169,7 @@
if (existing_address / sector_size_bytes == address / sector_size_bytes) {
PW_LOG_DEBUG("Multiple Redundant entries in same sector %u",
unsigned(address / sector_size_bytes));
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
}
@@ -177,7 +177,7 @@
} else {
PW_LOG_DEBUG("Found stale entry when appending; ignoring");
}
- return Status::OK;
+ return Status::Ok();
}
size_t EntryCache::present_entries() const {
diff --git a/pw_kvs/entry_cache_test.cc b/pw_kvs/entry_cache_test.cc
index 2bdedf4..7d6a25f 100644
--- a/pw_kvs/entry_cache_test.cc
+++ b/pw_kvs/entry_cache_test.cc
@@ -83,7 +83,7 @@
}
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -98,13 +98,13 @@
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry_Full) {
for (uint32_t i = 0; i < kMaxEntries; ++i) {
ASSERT_EQ( // Fill up the cache
- Status::OK,
+ Status::Ok(),
entries_.AddNewOrUpdateExisting({i, i, EntryState::kValid}, i, 1));
}
ASSERT_EQ(kMaxEntries, entries_.total_entries());
ASSERT_TRUE(entries_.full());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED,
+ EXPECT_EQ(Status::ResourceExhausted(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 1));
EXPECT_EQ(kMaxEntries, entries_.total_entries());
}
@@ -113,7 +113,7 @@
KeyDescriptor kd = kDescriptor;
kd.transaction_id += 3;
- ASSERT_EQ(Status::OK, entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
+ ASSERT_EQ(Status::Ok(), entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -125,15 +125,15 @@
}
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntry) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
entries_.AddNewOrUpdateExisting(kDescriptor, 3000, 2000));
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
entries_.AddNewOrUpdateExisting(kDescriptor, 7000, 2000));
// Duplicates beyond the redundancy are ignored.
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
entries_.AddNewOrUpdateExisting(kDescriptor, 9000, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -150,9 +150,9 @@
}
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntryInSameSector) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 1000));
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1950, 1000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -320,7 +320,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(Hash(kTheKey), metadata.hash());
EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -330,14 +330,14 @@
TEST_F(InitializedEntryCache, Find_PresentEntryWithSingleReadError) {
// Inject 2 read errors so that the initial key read and the follow-up full
// read of the first entry fail.
- flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 2));
+ flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 2));
EntryMetadata metadata;
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(1u, result.size());
EXPECT_EQ(Hash(kTheKey), metadata.hash());
EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -345,14 +345,14 @@
}
TEST_F(InitializedEntryCache, Find_PresentEntryWithMultiReadError) {
- flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 4));
+ flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 4));
EntryMetadata metadata;
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
- ASSERT_EQ(Status::DATA_LOSS, result.status());
+ ASSERT_EQ(Status::DataLoss(), result.status());
EXPECT_EQ(1u, result.size());
CheckForCorruptSectors(§ors_.FromAddress(0),
§ors_.FromAddress(kSize1));
@@ -364,7 +364,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, "delorted", &metadata);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(Hash("delorted"), metadata.hash());
EXPECT_EQ(EntryState::kDeleted, metadata.state());
@@ -377,7 +377,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, "3.141", &metadata);
- ASSERT_EQ(Status::NOT_FOUND, result.status());
+ ASSERT_EQ(Status::NotFound(), result.status());
EXPECT_EQ(0u, result.size());
CheckForCorruptSectors();
}
@@ -387,7 +387,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kCollision2, &metadata);
- EXPECT_EQ(Status::ALREADY_EXISTS, result.status());
+ EXPECT_EQ(Status::AlreadyExists(), result.status());
EXPECT_EQ(0u, result.size());
CheckForCorruptSectors();
}
diff --git a/pw_kvs/entry_test.cc b/pw_kvs/entry_test.cc
index 411f241..8ac1d1a 100644
--- a/pw_kvs/entry_test.cc
+++ b/pw_kvs/entry_test.cc
@@ -116,7 +116,7 @@
class ValidEntryInFlash : public ::testing::Test {
protected:
ValidEntryInFlash() : flash_(kEntry1), partition_(&flash_) {
- EXPECT_EQ(Status::OK, Entry::Read(partition_, 0, kFormats, &entry_));
+ EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
}
FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -125,8 +125,8 @@
};
TEST_F(ValidEntryInFlash, PassesChecksumVerification) {
- EXPECT_EQ(Status::OK, entry_.VerifyChecksumInFlash());
- EXPECT_EQ(Status::OK, entry_.VerifyChecksum("key45", kValue1));
+ EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("key45", kValue1));
}
TEST_F(ValidEntryInFlash, HeaderContents) {
@@ -141,7 +141,7 @@
Entry::KeyBuffer key = {};
auto result = entry_.ReadKey(key);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(result.size(), entry_.key_length());
EXPECT_STREQ(key.data(), "key45");
}
@@ -150,7 +150,7 @@
char value[32] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(result.size(), entry_.value_size());
EXPECT_STREQ(value, "VALUE!");
}
@@ -159,7 +159,7 @@
char value[3] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
- ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+ ASSERT_EQ(Status::ResourceExhausted(), result.status());
EXPECT_EQ(3u, result.size());
EXPECT_EQ(value[0], 'V');
EXPECT_EQ(value[1], 'A');
@@ -170,7 +170,7 @@
char value[3] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 3);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(3u, result.size());
EXPECT_EQ(value[0], 'U');
EXPECT_EQ(value[1], 'E');
@@ -181,7 +181,7 @@
char value[1] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 4);
- ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+ ASSERT_EQ(Status::ResourceExhausted(), result.status());
EXPECT_EQ(1u, result.size());
EXPECT_EQ(value[0], 'E');
}
@@ -190,7 +190,7 @@
char value[16] = {'?'};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 6);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(value[0], '?');
}
@@ -199,7 +199,7 @@
char value[16] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 7);
- EXPECT_EQ(Status::OUT_OF_RANGE, result.status());
+ EXPECT_EQ(Status::OutOfRange(), result.status());
EXPECT_EQ(0u, result.size());
}
@@ -211,7 +211,7 @@
partition, 64, kFormatWithChecksum, "key45", kValue1, kTransactionId1);
auto result = entry.Write("key45", kValue1);
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(32u, result.size());
EXPECT_EQ(std::memcmp(&flash.buffer()[64], kEntry1.data(), kEntry1.size()),
0);
@@ -233,7 +233,7 @@
protected:
TombstoneEntryInFlash()
: flash_(bytes::Concat(kHeader2, kKeyAndPadding2)), partition_(&flash_) {
- EXPECT_EQ(Status::OK, Entry::Read(partition_, 0, kFormats, &entry_));
+ EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
}
FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -242,8 +242,8 @@
};
TEST_F(TombstoneEntryInFlash, PassesChecksumVerification) {
- EXPECT_EQ(Status::OK, entry_.VerifyChecksumInFlash());
- EXPECT_EQ(Status::OK, entry_.VerifyChecksum("K", {}));
+ EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("K", {}));
}
TEST_F(TombstoneEntryInFlash, HeaderContents) {
@@ -258,7 +258,7 @@
Entry::KeyBuffer key = {};
auto result = entry_.ReadKey(key);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(result.size(), entry_.key_length());
EXPECT_STREQ(key.data(), "K");
}
@@ -267,7 +267,7 @@
char value[32] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(0u, result.size());
}
@@ -280,7 +280,7 @@
Entry::Tombstone(partition, 16, kFormatWithChecksum, "K", 0x03020100);
auto result = entry.Write("K", {});
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(32u, result.size());
EXPECT_EQ(std::memcmp(&flash.buffer()[16],
bytes::Concat(kHeader2, kKeyAndPadding2).data(),
@@ -296,15 +296,15 @@
const EntryFormat format{kMagicWithChecksum, nullptr};
const internal::EntryFormats formats(format);
- ASSERT_EQ(Status::OK, Entry::Read(partition, 0, formats, &entry));
+ ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
- EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksumInFlash());
- EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksum({}, {}));
+ EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksum({}, {}));
std::memset(&flash.buffer()[4], 0, 4); // set the checksum field to 0
- ASSERT_EQ(Status::OK, Entry::Read(partition, 0, formats, &entry));
- EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash());
- EXPECT_EQ(Status::OK, entry.VerifyChecksum({}, {}));
+ ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
+ EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), entry.VerifyChecksum({}, {}));
}
TEST(Entry, Checksum_ChecksPadding) {
@@ -312,20 +312,20 @@
bytes::Concat(kHeader1, kKey1, kValue1, bytes::String("\0\0\0\0\1")));
FlashPartition partition(&flash);
Entry entry;
- ASSERT_EQ(Status::OK, Entry::Read(partition, 0, kFormats, &entry));
+ ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
// Last byte in padding is a 1; should fail.
- EXPECT_EQ(Status::DATA_LOSS, entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
// The in-memory verification fills in 0s for the padding.
- EXPECT_EQ(Status::OK, entry.VerifyChecksum("key45", kValue1));
+ EXPECT_EQ(Status::Ok(), entry.VerifyChecksum("key45", kValue1));
flash.buffer()[kEntry1.size() - 1] = byte{0};
- EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
}
TEST_F(ValidEntryInFlash, Update_SameFormat_TransactionIdIsUpdated) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
entry_.Update(kFormatWithChecksum, kTransactionId1 + 3));
EXPECT_EQ(kFormatWithChecksum.magic, entry_.magic());
@@ -336,7 +336,7 @@
TEST_F(ValidEntryInFlash,
Update_DifferentFormat_MagicAndTransactionIdAreUpdated) {
- ASSERT_EQ(Status::OK, entry_.Update(kFormat, kTransactionId1 + 6));
+ ASSERT_EQ(Status::Ok(), entry_.Update(kFormat, kTransactionId1 + 6));
EXPECT_EQ(kFormat.magic, entry_.magic());
EXPECT_EQ(0u, entry_.address());
@@ -345,9 +345,9 @@
}
TEST_F(ValidEntryInFlash, Update_ReadError_WithChecksumIsError) {
- flash_.InjectReadError(FlashError::Unconditional(Status::ABORTED));
+ flash_.InjectReadError(FlashError::Unconditional(Status::Aborted()));
- EXPECT_EQ(Status::ABORTED,
+ EXPECT_EQ(Status::Aborted(),
entry_.Update(kFormatWithChecksum, kTransactionId1 + 1));
}
@@ -357,15 +357,16 @@
.checksum = nullptr};
TEST_F(ValidEntryInFlash, Update_ReadError_NoChecksumIsOkay) {
- flash_.InjectReadError(FlashError::Unconditional(Status::ABORTED));
+ flash_.InjectReadError(FlashError::Unconditional(Status::Aborted()));
- EXPECT_EQ(Status::OK, entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+ EXPECT_EQ(Status::Ok(),
+ entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
}
TEST_F(ValidEntryInFlash, Copy) {
auto result = entry_.Copy(123);
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(entry_.size(), result.size());
EXPECT_EQ(0,
std::memcmp(
@@ -373,9 +374,9 @@
}
TEST_F(ValidEntryInFlash, Copy_ReadError) {
- flash_.InjectReadError(FlashError::Unconditional(Status::UNIMPLEMENTED));
+ flash_.InjectReadError(FlashError::Unconditional(Status::Unimplemented()));
auto result = entry_.Copy(kEntry1.size());
- EXPECT_EQ(Status::UNIMPLEMENTED, result.status());
+ EXPECT_EQ(Status::Unimplemented(), result.status());
EXPECT_EQ(0u, result.size());
}
@@ -435,10 +436,10 @@
TEST_F(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSmallerAlignment) {
// Uses 16-bit alignment, smaller than the original entry's alignment.
- ASSERT_EQ(Status::OK, entry_.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry_.Copy(kEntry1.size());
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(kEntry1.size(), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<16>();
@@ -449,9 +450,9 @@
std::memcmp(
&flash_.buffer()[kEntry1.size()], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
Entry::Read(partition_, 32, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::OK, new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kFormatWithSum.magic, new_entry.magic());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -461,12 +462,12 @@
FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
FlashPartition partition(&flash, 0, 4, 32);
Entry entry;
- ASSERT_EQ(Status::OK, Entry::Read(partition, 0, kFormats, &entry));
+ ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
- ASSERT_EQ(Status::OK, entry.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry.Copy(32);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(AlignUp(kEntry1.size(), 32), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<32>();
@@ -476,9 +477,9 @@
std::memcmp(&flash.buffer()[32], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
Entry::Read(partition, 32, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::OK, new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -487,12 +488,12 @@
FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
FlashPartition partition(&flash, 0, 4, 64);
Entry entry;
- ASSERT_EQ(Status::OK, Entry::Read(partition, 0, kFormats, &entry));
+ ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
- ASSERT_EQ(Status::OK, entry.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry.Copy(64);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(AlignUp(kEntry1.size(), 64), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<64>();
@@ -502,9 +503,9 @@
std::memcmp(&flash.buffer()[64], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
Entry::Read(partition, 64, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::OK, new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -513,10 +514,10 @@
// readable 4 bytes. See pw_kvs/format.h for more information.
constexpr EntryFormat no_checksum{.magic = 0x43fae18f, .checksum = nullptr};
- ASSERT_EQ(Status::OK, entry_.Update(no_checksum, kTransactionId1 + 1));
+ ASSERT_EQ(Status::Ok(), entry_.Update(no_checksum, kTransactionId1 + 1));
auto result = entry_.Copy(kEntry1.size());
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(kEntry1.size(), result.size());
constexpr auto kNewHeader1 =
@@ -536,23 +537,23 @@
}
TEST_F(ValidEntryInFlash, UpdateAndCopyMultple_DifferentFormat) {
- ASSERT_EQ(Status::OK, entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+ ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
FlashPartition::Address new_address = entry_.size();
for (int i = 0; i < 10; i++) {
StatusWithSize copy_result = entry_.Copy(new_address + (i * entry_.size()));
- ASSERT_EQ(Status::OK, copy_result.status());
+ ASSERT_EQ(Status::Ok(), copy_result.status());
ASSERT_EQ(kEntry1.size(), copy_result.size());
}
for (int j = 0; j < 10; j++) {
Entry entry;
FlashPartition::Address read_address = (new_address + (j * entry_.size()));
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
Entry::Read(partition_, read_address, kFormatsWithSum, &entry));
- EXPECT_EQ(Status::OK, entry.VerifyChecksumInFlash());
+ EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
EXPECT_EQ(kFormatWithSum.magic, entry.magic());
EXPECT_EQ(read_address, entry.address());
EXPECT_EQ(kTransactionId1 + 6, entry.transaction_id());
@@ -561,26 +562,27 @@
}
TEST_F(ValidEntryInFlash, DifferentFormat_UpdatedCopy_FailsWithWrongMagic) {
- ASSERT_EQ(Status::OK, entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+ ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
FlashPartition::Address new_address = entry_.size();
StatusWithSize copy_result = entry_.Copy(new_address);
- ASSERT_EQ(Status::OK, copy_result.status());
+ ASSERT_EQ(Status::Ok(), copy_result.status());
ASSERT_EQ(kEntry1.size(), copy_result.size());
Entry entry;
- ASSERT_EQ(Status::DATA_LOSS,
+ ASSERT_EQ(Status::DataLoss(),
Entry::Read(partition_, new_address, kFormats, &entry));
}
TEST_F(ValidEntryInFlash, UpdateAndCopy_WriteError) {
- flash_.InjectWriteError(FlashError::Unconditional(Status::CANCELLED));
+ flash_.InjectWriteError(FlashError::Unconditional(Status::Cancelled()));
- ASSERT_EQ(Status::OK, entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+ ASSERT_EQ(Status::Ok(),
+ entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
auto result = entry_.Copy(kEntry1.size());
- EXPECT_EQ(Status::CANCELLED, result.status());
+ EXPECT_EQ(Status::Cancelled(), result.status());
EXPECT_EQ(kEntry1.size(), result.size());
}
diff --git a/pw_kvs/fake_flash_memory.cc b/pw_kvs/fake_flash_memory.cc
index 217870c..b649567 100644
--- a/pw_kvs/fake_flash_memory.cc
+++ b/pw_kvs/fake_flash_memory.cc
@@ -29,23 +29,23 @@
}
}
- return Status::OK;
+ return Status::Ok();
}
Status FlashError::Check(FlashMemory::Address start_address, size_t size) {
// Check if the event overlaps with this address range.
if (begin_ != kAnyAddress &&
(start_address >= end_ || (start_address + size) <= begin_)) {
- return Status::OK;
+ return Status::Ok();
}
if (delay_ > 0u) {
delay_ -= 1;
- return Status::OK;
+ return Status::Ok();
}
if (remaining_ == 0u) {
- return Status::OK;
+ return Status::Ok();
}
if (remaining_ != kAlways) {
@@ -60,7 +60,7 @@
PW_LOG_ERROR(
"Attempted to erase sector at non-sector aligned boundary; address %x",
unsigned(address));
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
const size_t sector_id = address / sector_size_bytes();
if (address / sector_size_bytes() + num_sectors > sector_count()) {
@@ -69,18 +69,18 @@
"address: %x, sector implied: %u",
unsigned(address),
unsigned(sector_id));
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
std::memset(
&buffer_[address], int(kErasedValue), sector_size_bytes() * num_sectors);
- return Status::OK;
+ return Status::Ok();
}
StatusWithSize FakeFlashMemory::Read(Address address,
std::span<std::byte> output) {
if (address + output.size() >= sector_count() * size_bytes()) {
- return StatusWithSize::OUT_OF_RANGE;
+ return StatusWithSize::OutOfRange();
}
// Check for injected read errors
@@ -97,14 +97,14 @@
unsigned(address),
unsigned(data.size()),
unsigned(alignment_bytes()));
- return StatusWithSize::INVALID_ARGUMENT;
+ return StatusWithSize::InvalidArgument();
}
if (data.size() > sector_size_bytes() - (address % sector_size_bytes())) {
PW_LOG_ERROR("Write crosses sector boundary; address %x, size %u B",
unsigned(address),
unsigned(data.size()));
- return StatusWithSize::INVALID_ARGUMENT;
+ return StatusWithSize::InvalidArgument();
}
if (address + data.size() > sector_count() * sector_size_bytes()) {
@@ -113,7 +113,7 @@
unsigned(address),
unsigned(data.size()),
unsigned(sector_count() * sector_size_bytes()));
- return StatusWithSize::OUT_OF_RANGE;
+ return StatusWithSize::OutOfRange();
}
// Check in erased state
@@ -121,7 +121,7 @@
if (buffer_[address + i] != kErasedValue) {
PW_LOG_ERROR("Writing to previously written address: %x",
unsigned(address));
- return StatusWithSize::UNKNOWN;
+ return StatusWithSize::Unknown();
}
}
diff --git a/pw_kvs/flash_memory.cc b/pw_kvs/flash_memory.cc
index 5da2f85..ceb2d3e 100644
--- a/pw_kvs/flash_memory.cc
+++ b/pw_kvs/flash_memory.cc
@@ -43,7 +43,7 @@
Status FlashPartition::Erase(Address address, size_t num_sectors) {
if (permission_ == PartitionPermission::kReadOnly) {
- return Status::PERMISSION_DENIED;
+ return Status::PermissionDenied();
}
PW_TRY(CheckBounds(address, num_sectors * sector_size_bytes()));
@@ -61,7 +61,7 @@
StatusWithSize FlashPartition::Write(Address address,
std::span<const byte> data) {
if (permission_ == PartitionPermission::kReadOnly) {
- return StatusWithSize::PERMISSION_DENIED;
+ return StatusWithSize::PermissionDenied();
}
PW_TRY_WITH_SIZE(CheckBounds(address, data.size()));
const size_t address_alignment_offset = address % alignment_bytes();
@@ -76,7 +76,7 @@
bool* is_erased) {
// Relying on Read() to check address and len arguments.
if (is_erased == nullptr) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
// TODO(pwbug/214): Currently using a single flash alignment to do both the
@@ -86,7 +86,7 @@
const size_t alignment = alignment_bytes();
if (alignment > kMaxFlashAlignment || kMaxFlashAlignment % alignment ||
length % alignment) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
byte buffer[kMaxFlashAlignment];
@@ -101,7 +101,7 @@
for (byte b : std::span(buffer, read_size)) {
if (b != erased_byte) {
// Detected memory chunk is not entirely erased
- return Status::OK;
+ return Status::Ok();
}
}
@@ -109,7 +109,7 @@
length -= read_size;
}
*is_erased = true;
- return Status::OK;
+ return Status::Ok();
}
bool FlashPartition::AppearsErased(std::span<const byte> data) const {
@@ -128,9 +128,9 @@
"Attempted out-of-bound flash memory access (address: %u length: %u)",
unsigned(address),
unsigned(length));
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
- return Status::OK;
+ return Status::Ok();
}
} // namespace pw::kvs
diff --git a/pw_kvs/flash_partition_test.cc b/pw_kvs/flash_partition_test.cc
index dd56254..aa7a12d 100644
--- a/pw_kvs/flash_partition_test.cc
+++ b/pw_kvs/flash_partition_test.cc
@@ -37,7 +37,7 @@
const size_t alignment = partition.alignment_bytes();
- ASSERT_EQ(Status::OK, partition.Erase(0, partition.sector_count()));
+ ASSERT_EQ(Status::Ok(), partition.Erase(0, partition.sector_count()));
const size_t chunks_per_sector = partition.sector_size_bytes() / alignment;
@@ -53,7 +53,7 @@
chunk_index++) {
StatusWithSize status =
partition.Write(address, as_bytes(std::span(test_data, alignment)));
- ASSERT_EQ(Status::OK, status.status());
+ ASSERT_EQ(Status::Ok(), status.status());
ASSERT_EQ(alignment, status.size());
address += alignment;
}
@@ -71,7 +71,7 @@
memset(test_data, 0, sizeof(test_data));
StatusWithSize status = partition.Read(address, alignment, test_data);
- EXPECT_EQ(Status::OK, status.status());
+ EXPECT_EQ(Status::Ok(), status.status());
EXPECT_EQ(alignment, status.size());
if (!status.ok() || (alignment != status.size())) {
error_count++;
@@ -140,7 +140,8 @@
std::min(sizeof(test_data), test_partition.sector_size_bytes());
auto data_span = std::span(test_data, block_size);
- ASSERT_EQ(Status::OK, test_partition.Erase(0, test_partition.sector_count()));
+ ASSERT_EQ(Status::Ok(),
+ test_partition.Erase(0, test_partition.sector_count()));
// Write to the first page of each sector.
for (size_t sector_index = 0; sector_index < test_partition.sector_count();
@@ -149,20 +150,20 @@
sector_index * test_partition.sector_size_bytes();
StatusWithSize status = test_partition.Write(address, as_bytes(data_span));
- ASSERT_EQ(Status::OK, status.status());
+ ASSERT_EQ(Status::Ok(), status.status());
ASSERT_EQ(block_size, status.size());
}
// Preset the flag to make sure the check actually sets it.
bool is_erased = true;
- ASSERT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+ ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
ASSERT_EQ(false, is_erased);
- ASSERT_EQ(Status::OK, test_partition.Erase());
+ ASSERT_EQ(Status::Ok(), test_partition.Erase());
// Preset the flag to make sure the check actually sets it.
is_erased = false;
- ASSERT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+ ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
ASSERT_EQ(true, is_erased);
// Read the first page of each sector and make sure it has been erased.
@@ -173,7 +174,7 @@
StatusWithSize status =
test_partition.Read(address, data_span.size_bytes(), data_span.data());
- EXPECT_EQ(Status::OK, status.status());
+ EXPECT_EQ(Status::Ok(), status.status());
EXPECT_EQ(data_span.size_bytes(), status.size());
EXPECT_EQ(true, test_partition.AppearsErased(as_bytes(data_span)));
@@ -242,10 +243,10 @@
// Make sure the partition is big enough to do this test.
ASSERT_GE(test_partition.size_bytes(), 3 * kMaxFlashAlignment);
- ASSERT_EQ(Status::OK, test_partition.Erase());
+ ASSERT_EQ(Status::Ok(), test_partition.Erase());
bool is_erased = true;
- ASSERT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+ ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
ASSERT_EQ(true, is_erased);
static const uint8_t fill_byte = 0x55;
@@ -255,26 +256,26 @@
// Write the chunk with fill byte.
StatusWithSize status = test_partition.Write(alignment, as_bytes(data_span));
- ASSERT_EQ(Status::OK, status.status());
+ ASSERT_EQ(Status::Ok(), status.status());
ASSERT_EQ(data_span.size_bytes(), status.size());
- EXPECT_EQ(Status::OK, test_partition.IsErased(&is_erased));
+ EXPECT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
EXPECT_EQ(false, is_erased);
// Check the chunk that was written.
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
test_partition.IsRegionErased(
alignment, data_span.size_bytes(), &is_erased));
EXPECT_EQ(false, is_erased);
// Check a region that starts erased but later has been written.
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
test_partition.IsRegionErased(0, 2 * alignment, &is_erased));
EXPECT_EQ(false, is_erased);
// Check erased for a region smaller than kMaxFlashAlignment. This has been a
// bug in the past.
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
test_partition.IsRegionErased(0, alignment, &is_erased));
EXPECT_EQ(true, is_erased);
}
diff --git a/pw_kvs/flash_partition_with_stats.cc b/pw_kvs/flash_partition_with_stats.cc
index 25e60ad..d6fe283 100644
--- a/pw_kvs/flash_partition_with_stats.cc
+++ b/pw_kvs/flash_partition_with_stats.cc
@@ -27,7 +27,7 @@
const char* label) {
// If size is zero saving stats is disabled so do not save any stats.
if (sector_counters_.size() == 0) {
- return Status::OK;
+ return Status::Ok();
}
KeyValueStore::StorageStats stats = kvs.GetStorageStats();
@@ -37,7 +37,7 @@
std::FILE* out_file = std::fopen(file_name, "a+");
if (out_file == nullptr) {
PW_LOG_ERROR("Failed to dump to %s", file_name);
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
// If file is empty add the header row.
@@ -65,7 +65,7 @@
std::fprintf(out_file, "\n");
std::fclose(out_file);
- return Status::OK;
+ return Status::Ok();
}
Status FlashPartitionWithStats::Erase(Address address, size_t num_sectors) {
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 05441d9..71da378 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -67,14 +67,14 @@
"large as the number of sectors in the flash partition (=%u)",
unsigned(sectors_.max_size()),
unsigned(partition_.sector_count()));
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
if (partition_.sector_count() < 2) {
ERR("KVS init failed: FlashParition sector count (=%u) must be at 2. KVS "
"requires at least 1 working sector + 1 free/reserved sector",
unsigned(partition_.sector_count()));
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
const size_t sector_size_bytes = partition_.sector_size_bytes();
@@ -85,7 +85,7 @@
"allowed sector size (=%u)",
unsigned(sector_size_bytes),
unsigned(SectorDescriptor::max_sector_size()));
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
Status metadata_result = InitializeMetadata();
@@ -101,7 +101,7 @@
Status recovery_status = FixErrors();
if (recovery_status.ok()) {
- if (metadata_result == Status::OUT_OF_RANGE) {
+ if (metadata_result == Status::OutOfRange()) {
error_stats_.missing_redundant_entries_recovered =
pre_fix_redundancy_errors;
INF("KVS init: Redundancy level successfully updated");
@@ -109,7 +109,7 @@
WRN("KVS init: Corruption detected and fully repaired");
}
initialized_ = InitializationState::kReady;
- } else if (recovery_status == Status::RESOURCE_EXHAUSTED) {
+ } else if (recovery_status == Status::ResourceExhausted()) {
WRN("KVS init: Unable to maintain required free sector");
} else {
WRN("KVS init: Corruption detected and unable repair");
@@ -130,10 +130,10 @@
if (error_detected_) {
WRN("KVS init: Corruption found but not repaired, KVS unavailable until "
"successful maintenance.");
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
- return Status::OK;
+ return Status::Ok();
}
Status KeyValueStore::InitializeMetadata() {
@@ -168,7 +168,7 @@
Address next_entry_address;
Status status = LoadEntry(entry_address, &next_entry_address);
- if (status == Status::NOT_FOUND) {
+ if (status == Status::NotFound()) {
DBG("Hit un-written data in sector; moving to the next sector");
break;
} else if (!status.ok()) {
@@ -282,7 +282,7 @@
if (!other_errors && entry_copies_missing == entry_cache_.total_entries()) {
INF("KVS configuration changed to redundancy of %u total copies per key",
unsigned(redundancy()));
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
}
@@ -292,9 +292,9 @@
unsigned(total_corrupt_bytes),
unsigned(corrupt_entries),
unsigned(entry_copies_missing));
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
- return Status::OK;
+ return Status::Ok();
}
KeyValueStore::StorageStats KeyValueStore::GetStorageStats() const {
@@ -392,11 +392,11 @@
if (formats_.KnownMagic(magic)) {
DBG("Found entry magic at address %u", unsigned(address));
*next_entry_address = address;
- return Status::OK;
+ return Status::Ok();
}
}
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
StatusWithSize KeyValueStore::Get(string_view key,
@@ -420,7 +420,7 @@
DBG("%u B value with %u B key cannot fit in one sector",
unsigned(value.size()),
unsigned(key.size()));
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
EntryMetadata metadata;
@@ -435,7 +435,7 @@
return WriteEntryForExistingKey(metadata, EntryState::kValid, key, value);
}
- if (status == Status::NOT_FOUND) {
+ if (status == Status::NotFound()) {
return WriteEntryForNewKey(key, value);
}
@@ -495,7 +495,7 @@
Status KeyValueStore::ReadEntry(const EntryMetadata& metadata,
Entry& entry) const {
// Try to read an entry
- Status read_result = Status::DATA_LOSS;
+ Status read_result = Status::DataLoss();
for (Address address : metadata.addresses()) {
read_result = Entry::Read(partition_, address, formats_, &entry);
if (read_result.ok()) {
@@ -528,9 +528,9 @@
// If the key's hash collides with an existing key or if the key is deleted,
// treat it as if it is not in the KVS.
- if (status == Status::ALREADY_EXISTS ||
+ if (status == Status::AlreadyExists() ||
(status.ok() && metadata->state() == EntryState::kDeleted)) {
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
return status;
}
@@ -580,7 +580,7 @@
DBG("Requested %u B read, but value is %u B",
unsigned(size_bytes),
unsigned(actual_size));
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
StatusWithSize result =
@@ -598,27 +598,27 @@
Status KeyValueStore::CheckWriteOperation(string_view key) const {
if (InvalidKey(key)) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
// For normal write operation the KVS must be fully ready.
if (!initialized()) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
- return Status::OK;
+ return Status::Ok();
}
Status KeyValueStore::CheckReadOperation(string_view key) const {
if (InvalidKey(key)) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
// Operations that are explicitly read-only can be done after init() has been
// called but not fully ready (when needing maintenance).
if (initialized_ == InitializationState::kNotInitialized) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
- return Status::OK;
+ return Status::Ok();
}
Status KeyValueStore::WriteEntryForExistingKey(EntryMetadata& metadata,
@@ -637,7 +637,7 @@
if (entry_cache_.full()) {
WRN("KVS full: trying to store a new entry, but can't. Have %u entries",
unsigned(entry_cache_.total_entries()));
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
return WriteEntry(key, value, EntryState::kValid);
@@ -659,7 +659,7 @@
// keep the existing entry.
DBG("Write for key 0x%08x with matching value skipped",
unsigned(prior_metadata->hash()));
- return Status::OK;
+ return Status::Ok();
}
// List of addresses for sectors with space for this entry.
@@ -686,7 +686,7 @@
PW_TRY(AppendEntry(entry, key, value));
new_metadata.AddNewAddress(reserved_addresses[i]);
}
- return Status::OK;
+ return Status::Ok();
}
KeyValueStore::EntryMetadata KeyValueStore::CreateOrUpdateKeyDescriptor(
@@ -730,7 +730,7 @@
unsigned(write_addresses[i]));
}
- return Status::OK;
+ return Status::Ok();
}
// Finds a sector to use for writing a new entry to. Does automatic garbage
@@ -747,7 +747,7 @@
bool do_auto_gc = options_.gc_on_write != GargbageCollectOnWrite::kDisabled;
// Do garbage collection as needed, so long as policy allows.
- while (result == Status::RESOURCE_EXHAUSTED && do_auto_gc) {
+ while (result == Status::ResourceExhausted() && do_auto_gc) {
if (options_.gc_on_write == GargbageCollectOnWrite::kOneSector) {
// If GC config option is kOneSector clear the flag to not do any more
// GC after this try.
@@ -756,9 +756,9 @@
// Garbage collect and then try again to find the best sector.
Status gc_status = GarbageCollect(reserved);
if (!gc_status.ok()) {
- if (gc_status == Status::NOT_FOUND) {
+ if (gc_status == Status::NotFound()) {
// Not enough space, and no reclaimable bytes, this KVS is full!
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
return gc_status;
}
@@ -772,7 +772,7 @@
// that have copies of the key trying to be written.
if (gc_sector_count > (partition_.sector_count() + 2)) {
ERR("Did more GC sectors than total sectors!!!!");
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
}
@@ -813,7 +813,7 @@
sector.RemoveWritableBytes(result.size());
sector.AddValidBytes(result.size());
- return Status::OK;
+ return Status::Ok();
}
StatusWithSize KeyValueStore::CopyEntryToSector(Entry& entry,
@@ -864,12 +864,12 @@
sectors_.FromAddress(address).RemoveValidBytes(result_size);
address = new_address;
- return Status::OK;
+ return Status::Ok();
}
Status KeyValueStore::FullMaintenance() {
if (initialized_ == InitializationState::kNotInitialized) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
// Full maintenance can be a potentially heavy operation, and should be
@@ -931,7 +931,7 @@
Status KeyValueStore::PartialMaintenance() {
if (initialized_ == InitializationState::kNotInitialized) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
CheckForErrors();
@@ -955,7 +955,7 @@
if (sector_to_gc == nullptr) {
// Nothing to GC.
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
// Step 2: Garbage collect the selected sector.
@@ -975,7 +975,7 @@
}
}
- return Status::OK;
+ return Status::Ok();
};
Status KeyValueStore::GarbageCollectSector(
@@ -994,7 +994,7 @@
ERR(" Failed to relocate valid entries from sector being garbage "
"collected, %u valid bytes remain",
unsigned(sector_to_gc.valid_bytes()));
- return Status::INTERNAL;
+ return Status::Internal();
}
// Step 2: Reinitialize the sector
@@ -1003,7 +1003,7 @@
sector_to_gc.set_writable_bytes(partition_.sector_size_bytes());
DBG(" Garbage Collect sector %u complete", sectors_.Index(sector_to_gc));
- return Status::OK;
+ return Status::Ok();
}
StatusWithSize KeyValueStore::UpdateEntriesToPrimaryFormat() {
@@ -1073,7 +1073,7 @@
metadata.AddNewAddress(new_address);
}
- return Status::OK;
+ return Status::Ok();
}
Status KeyValueStore::RepairCorruptSectors() {
@@ -1081,15 +1081,15 @@
// sector failed on the first pass, then do a second pass, since a later
// sector might have cleared up space or otherwise unblocked the earlier
// failed sector.
- Status repair_status = Status::OK;
+ Status repair_status = Status::Ok();
size_t loop_count = 0;
do {
loop_count++;
// Error of RESOURCE_EXHAUSTED indicates no space found for relocation.
// Reset back to OK for the next pass.
- if (repair_status == Status::RESOURCE_EXHAUSTED) {
- repair_status = Status::OK;
+ if (repair_status == Status::ResourceExhausted()) {
+ repair_status = Status::Ok();
}
DBG(" Pass %u", unsigned(loop_count));
@@ -1100,7 +1100,7 @@
if (sector_status.ok()) {
error_stats_.corrupt_sectors_recovered += 1;
} else if (repair_status.ok() ||
- repair_status == Status::RESOURCE_EXHAUSTED) {
+ repair_status == Status::ResourceExhausted()) {
repair_status = sector_status;
}
}
@@ -1112,7 +1112,7 @@
}
Status KeyValueStore::EnsureFreeSectorExists() {
- Status repair_status = Status::OK;
+ Status repair_status = Status::Ok();
bool empty_sector_found = false;
DBG(" Find empty sector");
@@ -1136,11 +1136,11 @@
}
Status KeyValueStore::EnsureEntryRedundancy() {
- Status repair_status = Status::OK;
+ Status repair_status = Status::Ok();
if (redundancy() == 1) {
DBG(" Redundancy not in use, nothting to check");
- return Status::OK;
+ return Status::Ok();
}
DBG(" Write any needed additional duplicate copies of keys to fulfill %u"
diff --git a/pw_kvs/key_value_store_binary_format_test.cc b/pw_kvs/key_value_store_binary_format_test.cc
index ba2964a..ea1b596 100644
--- a/pw_kvs/key_value_store_binary_format_test.cc
+++ b/pw_kvs/key_value_store_binary_format_test.cc
@@ -189,19 +189,19 @@
TEST_F(KvsErrorHandling, Init_Ok) {
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
byte buffer[64];
- EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorHandling, Init_DuplicateEntries_ReturnsDataLossButReadsEntry) {
InitFlashTo(bytes::Concat(kEntry1, kEntry1));
- EXPECT_EQ(Status::DATA_LOSS, kvs_.Init());
+ EXPECT_EQ(Status::DataLoss(), kvs_.Init());
byte buffer[64];
- EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorHandling, Init_CorruptEntry_FindsSubsequentValidEntry) {
@@ -210,10 +210,10 @@
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
flash_.buffer()[i] = byte(int(flash_.buffer()[i]) + 1);
- ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+ ASSERT_EQ(Status::DataLoss(), kvs_.Init());
byte buffer[64];
- ASSERT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
- ASSERT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+ ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
// One valid entry.
@@ -230,15 +230,15 @@
flash_.buffer()[9] = byte(0xef);
flash_.buffer()[67] = byte(0xef);
- ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+ ASSERT_EQ(Status::DataLoss(), kvs_.Init());
EXPECT_EQ(2u, kvs_.size());
byte buffer[64];
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k3y", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("4k", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(64u, stats.in_use_bytes);
@@ -250,9 +250,9 @@
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
flash_.InjectReadError(
- FlashError::InRange(Status::UNAUTHENTICATED, kEntry1.size()));
+ FlashError::InRange(Status::Unauthenticated(), kEntry1.size()));
- EXPECT_EQ(Status::DATA_LOSS, kvs_.Init());
+ EXPECT_EQ(Status::DataLoss(), kvs_.Init());
EXPECT_FALSE(kvs_.initialized());
}
@@ -267,16 +267,16 @@
flash_.buffer()[513] = byte(0xef);
flash_.buffer()[1025] = byte(0xef);
- ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
- EXPECT_EQ(Status::FAILED_PRECONDITION,
+ ASSERT_EQ(Status::DataLoss(), kvs_.Init());
+ EXPECT_EQ(Status::FailedPrecondition(),
kvs_.Put("hello", bytes::String("world")));
- EXPECT_EQ(Status::FAILED_PRECONDITION, kvs_.Put("a", bytes::String("b")));
+ EXPECT_EQ(Status::FailedPrecondition(), kvs_.Put("a", bytes::String("b")));
// Existing valid entries should still be readable.
EXPECT_EQ(1u, kvs_.size());
byte buffer[64];
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(32u, stats.in_use_bytes);
@@ -295,7 +295,7 @@
flash_.buffer()[1025] = byte(0xef);
flash_.buffer()[1537] = byte(0xef);
- ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+ ASSERT_EQ(Status::DataLoss(), kvs_.Init());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -310,12 +310,12 @@
TEST_F(KvsErrorHandling, DISABLED_Init_OkWithWriteErrorOnFlash) {
InitFlashTo(bytes::Concat(kEntry1, kEmpty32Bytes, kEntry2));
- EXPECT_EQ(Status::DATA_LOSS, kvs_.Init());
+ EXPECT_EQ(Status::DataLoss(), kvs_.Init());
byte buffer[64];
EXPECT_EQ(2u, kvs_.size());
EXPECT_EQ(true, kvs_.error_detected());
- EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -334,14 +334,14 @@
// Corrupt a byte of entry version 8 (addresses 32-63).
flash_.buffer()[34] = byte(0xef);
- ASSERT_EQ(Status::DATA_LOSS, kvs_.Init());
+ ASSERT_EQ(Status::DataLoss(), kvs_.Init());
char buffer[64] = {};
EXPECT_EQ(1u, kvs_.size());
auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -352,12 +352,12 @@
// the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
// configurations).
TEST_F(KvsErrorHandling, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
- ASSERT_EQ(Status::OK, kvs_.Init());
- flash_.InjectWriteError(FlashError::Unconditional(Status::UNAVAILABLE, 1));
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
+ flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
- EXPECT_EQ(Status::UNAVAILABLE, kvs_.Put("key1", bytes::String("value1")));
+ EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", std::span<byte>()).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", std::span<byte>()).status());
ASSERT_TRUE(kvs_.empty());
auto stats = kvs_.GetStorageStats();
@@ -367,7 +367,7 @@
// The bytes were marked used, so a new key should not overlap with the bytes
// from the failed Put.
- EXPECT_EQ(Status::OK, kvs_.Put("key1", bytes::String("value1")));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -397,22 +397,22 @@
TEST_F(KvsErrorRecovery, Init_Ok) {
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
byte buffer[64];
- EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorRecovery, Init_DuplicateEntries_RecoversDuringInit) {
InitFlashTo(bytes::Concat(kEntry1, kEntry1));
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.corrupt_sectors_recovered, 1u);
byte buffer[64];
- EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorRecovery, Init_CorruptEntry_FindsSubsequentValidEntry) {
@@ -421,10 +421,10 @@
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
flash_.buffer()[i] = byte(int(flash_.buffer()[i]) + 1);
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
byte buffer[64];
- ASSERT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
- ASSERT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+ ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
// One valid entry.
@@ -442,15 +442,15 @@
flash_.buffer()[9] = byte(0xef);
flash_.buffer()[67] = byte(0xef);
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
EXPECT_EQ(2u, kvs_.size());
byte buffer[64];
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("k3y", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("4k", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(64u, stats.in_use_bytes);
@@ -463,9 +463,9 @@
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
flash_.InjectReadError(
- FlashError::InRange(Status::UNAUTHENTICATED, kEntry1.size()));
+ FlashError::InRange(Status::Unauthenticated(), kEntry1.size()));
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
EXPECT_TRUE(kvs_.initialized());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(32u, stats.in_use_bytes);
@@ -484,15 +484,15 @@
flash_.buffer()[513] = byte(0xef);
flash_.buffer()[1025] = byte(0xef);
- ASSERT_EQ(Status::OK, kvs_.Init());
- EXPECT_EQ(Status::OK, kvs_.Put("hello", bytes::String("world")));
- EXPECT_EQ(Status::OK, kvs_.Put("a", bytes::String("b")));
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Put("hello", bytes::String("world")));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("a", bytes::String("b")));
// Existing valid entries should still be readable.
EXPECT_EQ(3u, kvs_.size());
byte buffer[64];
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(96u, stats.in_use_bytes);
@@ -512,7 +512,7 @@
flash_.buffer()[1025] = byte(0xef);
flash_.buffer()[1537] = byte(0xef);
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -528,12 +528,12 @@
TEST_F(KvsErrorRecovery, DISABLED_Init_OkWithWriteErrorOnFlash) {
InitFlashTo(bytes::Concat(kEntry1, kEmpty32Bytes, kEntry2));
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
byte buffer[64];
EXPECT_EQ(2u, kvs_.size());
EXPECT_EQ(false, kvs_.error_detected());
- EXPECT_EQ(Status::OK, kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::OK, kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -554,14 +554,14 @@
// Corrupt a byte of entry version 8 (addresses 32-63).
flash_.buffer()[34] = byte(0xef);
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
char buffer[64] = {};
EXPECT_EQ(1u, kvs_.size());
auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -572,13 +572,13 @@
// the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
// configurations).
TEST_F(KvsErrorRecovery, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
- ASSERT_EQ(Status::OK, kvs_.Init());
- flash_.InjectWriteError(FlashError::Unconditional(Status::UNAVAILABLE, 1));
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
+ flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
- EXPECT_EQ(Status::UNAVAILABLE, kvs_.Put("key1", bytes::String("value1")));
+ EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
EXPECT_EQ(true, kvs_.error_detected());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", std::span<byte>()).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", std::span<byte>()).status());
ASSERT_TRUE(kvs_.empty());
auto stats = kvs_.GetStorageStats();
@@ -590,7 +590,7 @@
// The bytes were marked used, so a new key should not overlap with the bytes
// from the failed Put.
- EXPECT_EQ(Status::OK, kvs_.Put("key1", bytes::String("value1")));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -647,7 +647,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -660,7 +660,7 @@
char val[sizeof(str_value)] = {}; \
StatusWithSize stat = \
kvs_.Get(key, std::as_writable_bytes(std::span(val))); \
- ASSERT_EQ(Status::OK, stat.status()); \
+ ASSERT_EQ(Status::Ok(), stat.status()); \
ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
ASSERT_STREQ(str_value, val); \
} while (0)
@@ -681,7 +681,7 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- EXPECT_EQ(Status::OK, partition_.Erase(0, 1));
+ EXPECT_EQ(Status::Ok(), partition_.Erase(0, 1));
ASSERT_CONTAINS_ENTRY("key1", "value1");
ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -698,7 +698,7 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+ EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (192u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -715,7 +715,7 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- EXPECT_EQ(Status::OK, partition_.Erase(partition_.sector_size_bytes(), 1));
+ EXPECT_EQ(Status::Ok(), partition_.Erase(partition_.sector_size_bytes(), 1));
ASSERT_CONTAINS_ENTRY("key1", "value1");
ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -736,9 +736,9 @@
TEST_F(InitializedRedundantMultiMagicKvs, SingleReadErrors) {
// Inject 2 read errors, so the first read attempt fully fails.
- flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 2));
+ flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 2));
- flash_.InjectReadError(FlashError::Unconditional(Status::INTERNAL, 1, 7));
+ flash_.InjectReadError(FlashError::Unconditional(Status::Internal(), 1, 7));
ASSERT_CONTAINS_ENTRY("key1", "value1");
ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -757,9 +757,9 @@
}
TEST_F(InitializedRedundantMultiMagicKvs, SingleWriteError) {
- flash_.InjectWriteError(FlashError::Unconditional(Status::INTERNAL, 1, 1));
+ flash_.InjectWriteError(FlashError::Unconditional(Status::Internal(), 1, 1));
- EXPECT_EQ(Status::INTERNAL, kvs_.Put("new key", bytes::String("abcd?")));
+ EXPECT_EQ(Status::Internal(), kvs_.Put("new key", bytes::String("abcd?")));
EXPECT_EQ(true, kvs_.error_detected());
@@ -773,10 +773,10 @@
char val[20] = {};
EXPECT_EQ(
- Status::OK,
+ Status::Ok(),
kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+ EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (224u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -785,23 +785,23 @@
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
EXPECT_EQ(
- Status::OK,
+ Status::Ok(),
kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
}
TEST_F(InitializedRedundantMultiMagicKvs, DataLossAfterLosingBothCopies) {
- EXPECT_EQ(Status::OK, partition_.Erase(0, 2));
+ EXPECT_EQ(Status::Ok(), partition_.Erase(0, 2));
char val[20] = {};
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("key1", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("k2", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("k3y", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("A Key", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("kee", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(true, kvs_.error_detected());
@@ -815,7 +815,7 @@
}
TEST_F(InitializedRedundantMultiMagicKvs, PutNewEntry_UsesFirstFormat) {
- EXPECT_EQ(Status::OK, kvs_.Put("new key", bytes::String("abcd?")));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("new key", bytes::String("abcd?")));
constexpr auto kNewEntry =
MakeValidEntry(kMagic, 129, "new key", bytes::String("abcd?"));
@@ -827,7 +827,7 @@
}
TEST_F(InitializedRedundantMultiMagicKvs, PutExistingEntry_UsesFirstFormat) {
- EXPECT_EQ(Status::OK, kvs_.Put("A Key", bytes::String("New value!")));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("A Key", bytes::String("New value!")));
constexpr auto kNewEntry =
MakeValidEntry(kMagic, 129, "A Key", bytes::String("New value!"));
@@ -843,20 +843,20 @@
char val[sizeof(str_value)] = {}; \
StatusWithSize stat = \
kvs.Get(key, std::as_writable_bytes(std::span(val))); \
- ASSERT_EQ(Status::OK, stat.status()); \
+ ASSERT_EQ(Status::Ok(), stat.status()); \
ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
ASSERT_STREQ(str_value, val); \
} while (0)
TEST_F(InitializedRedundantMultiMagicKvs, UpdateEntryFormat) {
- ASSERT_EQ(Status::OK, kvs_.FullMaintenance());
+ ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 2, 1> local_kvs(
&partition_,
{.magic = kMagic, .checksum = &default_checksum},
kNoGcOptions);
- ASSERT_EQ(Status::OK, local_kvs.Init());
+ ASSERT_EQ(Status::Ok(), local_kvs.Init());
EXPECT_EQ(false, local_kvs.error_detected());
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -885,7 +885,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -906,14 +906,14 @@
// Similar to test for InitializedRedundantMultiMagicKvs. Doing similar test
// with different KVS configuration.
TEST_F(InitializedMultiMagicKvs, UpdateEntryFormat) {
- ASSERT_EQ(Status::OK, kvs_.FullMaintenance());
+ ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 1, 1> local_kvs(
&partition_,
{.magic = kMagic, .checksum = &default_checksum},
kNoGcOptions);
- ASSERT_EQ(Status::OK, local_kvs.Init());
+ ASSERT_EQ(Status::Ok(), local_kvs.Init());
EXPECT_EQ(false, local_kvs.error_detected());
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -938,7 +938,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -947,16 +947,16 @@
};
TEST_F(InitializedRedundantLazyRecoveryKvs, WriteAfterDataLoss) {
- EXPECT_EQ(Status::OK, partition_.Erase(0, 4));
+ EXPECT_EQ(Status::Ok(), partition_.Erase(0, 4));
char val[20] = {};
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("key1", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("k2", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("k3y", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
kvs_.Get("4k", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(true, kvs_.error_detected());
@@ -968,9 +968,9 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- ASSERT_EQ(Status::DATA_LOSS, kvs_.Put("key1", 1000));
+ ASSERT_EQ(Status::DataLoss(), kvs_.Put("key1", 1000));
- EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+ EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, 0u);
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1005,7 +1005,7 @@
ASSERT_CONTAINS_ENTRY("k3y", "value3");
ASSERT_CONTAINS_ENTRY("4k", "value4");
- EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
+ EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (128u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1030,7 +1030,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 8> flash_;
@@ -1066,17 +1066,17 @@
// Add a near-sector size key entry to fill the KVS with a valid large entry
// and stale data. Modify the value in between Puts so it actually writes
// (identical value writes are skipped).
- EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
// Instantiate a new KVS with redundancy of 2. This KVS should add an extra
// copy of each valid key as part of the init process. Because there is not
@@ -1086,7 +1086,7 @@
&partition_,
{.magic = kMagic, .checksum = &default_checksum},
kRecoveryLazyGcOptions);
- ASSERT_EQ(Status::OK, local_kvs.Init());
+ ASSERT_EQ(Status::Ok(), local_kvs.Init());
// Verify no errors found in the new KVS and all the entries are present.
EXPECT_EQ(false, local_kvs.error_detected());
@@ -1095,7 +1095,7 @@
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k3y", "value3");
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "4k", "value4");
StatusWithSize big_key_size = local_kvs.ValueSize("big_key");
- EXPECT_EQ(Status::OK, big_key_size.status());
+ EXPECT_EQ(Status::Ok(), big_key_size.status());
EXPECT_EQ(sizeof(test_data), big_key_size.size());
// Verify that storage stats of the new redundant KVS match expected values.
diff --git a/pw_kvs/key_value_store_fuzz_test.cc b/pw_kvs/key_value_store_fuzz_test.cc
index fcfca4c..4fd86bc 100644
--- a/pw_kvs/key_value_store_fuzz_test.cc
+++ b/pw_kvs/key_value_store_fuzz_test.cc
@@ -46,7 +46,7 @@
EmptyInitializedKvs()
: kvs_(&test_partition, {.magic = 0x873a9b50, .checksum = &checksum}) {
test_partition.Erase(0, test_partition.sector_count());
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
}
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -63,7 +63,7 @@
for (int i = 0; i < kFuzzIterations; ++i) {
for (unsigned key_size = 1; key_size < sizeof(value); ++key_size) {
for (unsigned value_size = 0; value_size < sizeof(value); ++value_size) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put(std::string_view(value, key_size),
std::as_bytes(std::span(value, value_size))));
}
diff --git a/pw_kvs/key_value_store_initialized_test.cc b/pw_kvs/key_value_store_initialized_test.cc
index 6ed0b52..7ea3fd9 100644
--- a/pw_kvs/key_value_store_initialized_test.cc
+++ b/pw_kvs/key_value_store_initialized_test.cc
@@ -83,7 +83,7 @@
protected:
EmptyInitializedKvs() : kvs_(&test_partition, default_format) {
test_partition.Erase();
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
}
// Intention of this is to put and erase key-val to fill up sectors. It's a
@@ -107,7 +107,7 @@
while (size_to_fill > 0) {
// Changing buffer value so put actually does something
buffer[0] = static_cast<byte>(static_cast<uint8_t>(buffer[0]) + 1);
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put(key,
std::span(buffer.data(),
chunk_len - kvs_attr.ChunkHeaderSize() -
@@ -115,7 +115,7 @@
size_to_fill -= chunk_len;
chunk_len = std::min(size_to_fill, kMaxPutSize);
}
- ASSERT_EQ(Status::OK, kvs_.Delete(key));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete(key));
}
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -127,7 +127,7 @@
std::array<char, 8> value{'v', 'a', 'l', 'u', 'e', '6', '7', '\0'};
for (int i = 0; i < 1000; ++i) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put("The Key!", std::as_bytes(std::span(value))));
}
}
@@ -136,7 +136,7 @@
std::array<char, 7> value{'v', 'a', 'l', 'u', 'e', '6', '\0'};
for (int i = 0; i < 1000; ++i) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put("The Key!", std::as_bytes(std::span(value))));
}
}
@@ -146,27 +146,27 @@
for (int i = 0; i < 100; ++i) {
for (unsigned size = 0; size < value.size(); ++size) {
- ASSERT_EQ(Status::OK, kvs_.Put("The Key!", i));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("The Key!", i));
}
}
}
TEST_F(EmptyInitializedKvs, PutAndGetByValue_ConvertibleToSpan) {
constexpr float input[] = {1.0, -3.5};
- ASSERT_EQ(Status::OK, kvs_.Put("key", input));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
float output[2] = {};
- ASSERT_EQ(Status::OK, kvs_.Get("key", &output));
+ ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
EXPECT_EQ(input[0], output[0]);
EXPECT_EQ(input[1], output[1]);
}
TEST_F(EmptyInitializedKvs, PutAndGetByValue_Span) {
float input[] = {1.0, -3.5};
- ASSERT_EQ(Status::OK, kvs_.Put("key", std::span(input)));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", std::span(input)));
float output[2] = {};
- ASSERT_EQ(Status::OK, kvs_.Get("key", &output));
+ ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
EXPECT_EQ(input[0], output[0]);
EXPECT_EQ(input[1], output[1]);
}
@@ -178,116 +178,117 @@
};
const TestStruct input{-1234.5, true};
- ASSERT_EQ(Status::OK, kvs_.Put("key", input));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
TestStruct output;
- ASSERT_EQ(Status::OK, kvs_.Get("key", &output));
+ ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
EXPECT_EQ(input.a, output.a);
EXPECT_EQ(input.b, output.b);
}
TEST_F(EmptyInitializedKvs, Get_Simple) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
auto result = kvs_.Get("Charles", std::as_writable_bytes(std::span(value)));
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(sizeof("Mingus"), result.size());
EXPECT_STREQ("Mingus", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
auto result =
kvs_.Get("Charles", std::as_writable_bytes(std::span(value)), 4);
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(sizeof("Mingus") - 4, result.size());
EXPECT_STREQ("us", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset_FillBuffer) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[4] = {};
auto result =
kvs_.Get("Charles", std::as_writable_bytes(std::span(value, 3)), 1);
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+ EXPECT_EQ(Status::ResourceExhausted(), result.status());
EXPECT_EQ(3u, result.size());
EXPECT_STREQ("ing", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset_PastEnd) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
auto result = kvs_.Get("Charles",
std::as_writable_bytes(std::span(value)),
sizeof("Mingus") + 1);
- EXPECT_EQ(Status::OUT_OF_RANGE, result.status());
+ EXPECT_EQ(Status::OutOfRange(), result.status());
EXPECT_EQ(0u, result.size());
}
TEST_F(EmptyInitializedKvs, GetValue) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint32_t value = 0;
- EXPECT_EQ(Status::OK, kvs_.Get("key", &value));
+ EXPECT_EQ(Status::Ok(), kvs_.Get("key", &value));
EXPECT_EQ(uint32_t(0xfeedbeef), value);
}
TEST_F(EmptyInitializedKvs, GetValue_TooSmall) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint8_t value = 0;
- EXPECT_EQ(Status::INVALID_ARGUMENT, kvs_.Get("key", &value));
+ EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
EXPECT_EQ(0u, value);
}
TEST_F(EmptyInitializedKvs, GetValue_TooLarge) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint64_t value = 0;
- EXPECT_EQ(Status::INVALID_ARGUMENT, kvs_.Get("key", &value));
+ EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
EXPECT_EQ(0u, value);
}
TEST_F(EmptyInitializedKvs, Delete_GetDeletedKey_ReturnsNotFound) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("kEy", {}).status());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize("kEy").status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Get("kEy", {}).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.ValueSize("kEy").status());
}
TEST_F(EmptyInitializedKvs, Delete_AddBackKey_PersistsAfterInitialization) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
- EXPECT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
char data[6] = {};
- ASSERT_EQ(Status::OK, kvs_.Get("kEy", &data));
+ ASSERT_EQ(Status::Ok(), kvs_.Get("kEy", &data));
EXPECT_STREQ(data, "45678");
// Ensure that the re-added key is still present after reinitialization.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> new_kvs(&test_partition,
default_format);
- ASSERT_EQ(Status::OK, new_kvs.Init());
+ ASSERT_EQ(Status::Ok(), new_kvs.Init());
- EXPECT_EQ(Status::OK, new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
+ EXPECT_EQ(Status::Ok(),
+ new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
char new_data[6] = {};
- EXPECT_EQ(Status::OK, new_kvs.Get("kEy", &new_data));
+ EXPECT_EQ(Status::Ok(), new_kvs.Get("kEy", &new_data));
EXPECT_STREQ(data, "45678");
}
TEST_F(EmptyInitializedKvs, Delete_AllItems_KvsIsEmpty) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
EXPECT_EQ(0u, kvs_.size());
EXPECT_TRUE(kvs_.empty());
@@ -298,17 +299,17 @@
constexpr std::string_view key1 = "D4";
constexpr std::string_view key2 = "dFU6S";
- ASSERT_EQ(Status::OK, kvs_.Put(key1, 1000));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
- EXPECT_EQ(Status::ALREADY_EXISTS, kvs_.Put(key2, 999));
+ EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
int value = 0;
- EXPECT_EQ(Status::OK, kvs_.Get(key1, &value));
+ EXPECT_EQ(Status::Ok(), kvs_.Get(key1, &value));
EXPECT_EQ(1000, value);
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get(key2, &value));
- EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize(key2).status());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Delete(key2));
+ EXPECT_EQ(Status::NotFound(), kvs_.Get(key2, &value));
+ EXPECT_EQ(Status::NotFound(), kvs_.ValueSize(key2).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Delete(key2));
}
TEST_F(EmptyInitializedKvs, Collision_WithDeletedKey) {
@@ -316,18 +317,18 @@
constexpr std::string_view key1 = "1U2";
constexpr std::string_view key2 = "ahj9d";
- ASSERT_EQ(Status::OK, kvs_.Put(key1, 1000));
- ASSERT_EQ(Status::OK, kvs_.Delete(key1));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
// key2 collides with key1's tombstone.
- EXPECT_EQ(Status::ALREADY_EXISTS, kvs_.Put(key2, 999));
+ EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
int value = 0;
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get(key1, &value));
+ EXPECT_EQ(Status::NotFound(), kvs_.Get(key1, &value));
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get(key2, &value));
- EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize(key2).status());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Delete(key2));
+ EXPECT_EQ(Status::NotFound(), kvs_.Get(key2, &value));
+ EXPECT_EQ(Status::NotFound(), kvs_.ValueSize(key2).status());
+ EXPECT_EQ(Status::NotFound(), kvs_.Delete(key2));
}
TEST_F(EmptyInitializedKvs, Iteration_Empty_ByReference) {
@@ -345,62 +346,63 @@
}
TEST_F(EmptyInitializedKvs, Iteration_OneItem) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
for (KeyValueStore::Item entry : kvs_) {
EXPECT_STREQ(entry.key(), "kEy"); // Make sure null-terminated.
char temp[sizeof("123")] = {};
- EXPECT_EQ(Status::OK, entry.Get(&temp));
+ EXPECT_EQ(Status::Ok(), entry.Get(&temp));
EXPECT_STREQ("123", temp);
}
}
TEST_F(EmptyInitializedKvs, Iteration_GetWithOffset) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
+ ASSERT_EQ(Status::Ok(),
+ kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
for (KeyValueStore::Item entry : kvs_) {
char temp[5];
auto result = entry.Get(std::as_writable_bytes(std::span(temp)), 4);
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(5u, result.size());
EXPECT_STREQ("bad!", temp);
}
}
TEST_F(EmptyInitializedKvs, Iteration_GetValue) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint32_t value = 0;
- EXPECT_EQ(Status::OK, entry.Get(&value));
+ EXPECT_EQ(Status::Ok(), entry.Get(&value));
EXPECT_EQ(uint32_t(0xfeedbeef), value);
}
}
TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooSmall) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint8_t value = 0;
- EXPECT_EQ(Status::INVALID_ARGUMENT, entry.Get(&value));
+ EXPECT_EQ(Status::InvalidArgument(), entry.Get(&value));
EXPECT_EQ(0u, value);
}
}
TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooLarge) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint64_t value = 0;
- EXPECT_EQ(Status::INVALID_ARGUMENT, entry.Get(&value));
+ EXPECT_EQ(Status::InvalidArgument(), entry.Get(&value));
EXPECT_EQ(0u, value);
}
}
TEST_F(EmptyInitializedKvs, Iteration_EmptyAfterDeletion) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
for (KeyValueStore::Item entry : kvs_) {
static_cast<void>(entry);
@@ -423,10 +425,10 @@
std::memset(buf2, 2, sizeof(buf2));
// Start with things in KVS
- ASSERT_EQ(Status::OK, kvs_.Put(key1, buf1));
- ASSERT_EQ(Status::OK, kvs_.Put(key2, buf2));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(key1, buf1));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(key2, buf2));
for (size_t j = 0; j < keys.size(); j++) {
- ASSERT_EQ(Status::OK, kvs_.Put(keys[j], j));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
}
for (size_t i = 0; i < 100; i++) {
@@ -435,28 +437,28 @@
size_t size2 = (kLargestBufSize) / (100 - i);
for (size_t j = 0; j < 50; j++) {
// Rewrite a single key many times, can fill up a sector
- ASSERT_EQ(Status::OK, kvs_.Put("some_data", j));
+ ASSERT_EQ(Status::Ok(), kvs_.Put("some_data", j));
}
// Delete and re-add everything
- ASSERT_EQ(Status::OK, kvs_.Delete(key1));
- ASSERT_EQ(Status::OK, kvs_.Put(key1, std::span(buf1, size1)));
- ASSERT_EQ(Status::OK, kvs_.Delete(key2));
- ASSERT_EQ(Status::OK, kvs_.Put(key2, std::span(buf2, size2)));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(key1, std::span(buf1, size1)));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete(key2));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(key2, std::span(buf2, size2)));
for (size_t j = 0; j < keys.size(); j++) {
- ASSERT_EQ(Status::OK, kvs_.Delete(keys[j]));
- ASSERT_EQ(Status::OK, kvs_.Put(keys[j], j));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[j]));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
}
// Re-enable and verify
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
static byte buf[4 * 1024];
- ASSERT_EQ(Status::OK, kvs_.Get(key1, std::span(buf, size1)).status());
+ ASSERT_EQ(Status::Ok(), kvs_.Get(key1, std::span(buf, size1)).status());
ASSERT_EQ(std::memcmp(buf, buf1, size1), 0);
- ASSERT_EQ(Status::OK, kvs_.Get(key2, std::span(buf, size2)).status());
+ ASSERT_EQ(Status::Ok(), kvs_.Get(key2, std::span(buf, size2)).status());
ASSERT_EQ(std::memcmp(buf2, buf2, size2), 0);
for (size_t j = 0; j < keys.size(); j++) {
size_t ret = 1000;
- ASSERT_EQ(Status::OK, kvs_.Get(keys[j], &ret));
+ ASSERT_EQ(Status::Ok(), kvs_.Get(keys[j], &ret));
ASSERT_EQ(ret, j);
}
}
@@ -466,28 +468,28 @@
// Add some data
uint8_t value1 = 0xDA;
ASSERT_EQ(
- Status::OK,
+ Status::Ok(),
kvs_.Put(keys[0], std::as_bytes(std::span(&value1, sizeof(value1)))));
uint32_t value2 = 0xBAD0301f;
- ASSERT_EQ(Status::OK, kvs_.Put(keys[1], value2));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], value2));
// Verify data
uint32_t test2;
- EXPECT_EQ(Status::OK, kvs_.Get(keys[1], &test2));
+ EXPECT_EQ(Status::Ok(), kvs_.Get(keys[1], &test2));
uint8_t test1;
- ASSERT_EQ(Status::OK, kvs_.Get(keys[0], &test1));
+ ASSERT_EQ(Status::Ok(), kvs_.Get(keys[0], &test1));
EXPECT_EQ(test1, value1);
EXPECT_EQ(test2, value2);
// Delete a key
- EXPECT_EQ(Status::OK, kvs_.Delete(keys[0]));
+ EXPECT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
// Verify it was erased
- EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NOT_FOUND);
+ EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NotFound());
test2 = 0;
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
kvs_.Get(keys[1],
std::span(reinterpret_cast<byte*>(&test2), sizeof(test2)))
.status());
diff --git a/pw_kvs/key_value_store_map_test.cc b/pw_kvs/key_value_store_map_test.cc
index 87d0dee..27b961c 100644
--- a/pw_kvs/key_value_store_map_test.cc
+++ b/pw_kvs/key_value_store_map_test.cc
@@ -88,9 +88,9 @@
// For KVS magic value always use a random 32 bit integer rather than a
// human readable 4 bytes. See pw_kvs/format.h for more information.
kvs_(&partition_, {.magic = 0xc857e51d, .checksum = nullptr}) {
- EXPECT_EQ(Status::OK, partition_.Erase());
+ EXPECT_EQ(Status::Ok(), partition_.Erase());
Status result = kvs_.Init();
- EXPECT_EQ(Status::OK, result);
+ EXPECT_EQ(Status::Ok(), result);
if (!result.ok()) {
std::abort();
@@ -250,7 +250,7 @@
EXPECT_EQ(map_entry->first, item.key());
char value[kMaxValueLength + 1] = {};
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
item.Get(std::as_writable_bytes(std::span(value))).status());
EXPECT_EQ(map_entry->second, std::string(value));
}
@@ -267,10 +267,10 @@
Status result = kvs_.Put(key, std::as_bytes(std::span(value)));
if (key.empty() || key.size() > internal::Entry::kMaxKeyLength) {
- EXPECT_EQ(Status::INVALID_ARGUMENT, result);
+ EXPECT_EQ(Status::InvalidArgument(), result);
} else if (map_.size() == kvs_.max_size()) {
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result);
- } else if (result == Status::RESOURCE_EXHAUSTED) {
+ EXPECT_EQ(Status::ResourceExhausted(), result);
+ } else if (result == Status::ResourceExhausted()) {
EXPECT_FALSE(map_.empty());
} else if (result.ok()) {
map_[key] = value;
@@ -290,9 +290,9 @@
Status result = kvs_.Delete(key);
if (key.empty() || key.size() > internal::Entry::kMaxKeyLength) {
- EXPECT_EQ(Status::INVALID_ARGUMENT, result);
+ EXPECT_EQ(Status::InvalidArgument(), result);
} else if (map_.count(key) == 0) {
- EXPECT_EQ(Status::NOT_FOUND, result);
+ EXPECT_EQ(Status::NotFound(), result);
} else if (result.ok()) {
map_.erase(key);
@@ -302,7 +302,7 @@
}
deleted_.insert(key);
- } else if (result == Status::RESOURCE_EXHAUSTED) {
+ } else if (result == Status::ResourceExhausted()) {
PW_LOG_WARN("Delete: RESOURCE_EXHAUSTED could not delete key %s",
key.c_str());
} else {
@@ -315,14 +315,14 @@
void Init() {
StartOperation("Init");
Status status = kvs_.Init();
- EXPECT_EQ(Status::OK, status);
+ EXPECT_EQ(Status::Ok(), status);
FinishOperation("Init", status);
}
void GCFull() {
StartOperation("GCFull");
Status status = kvs_.FullMaintenance();
- EXPECT_EQ(Status::OK, status);
+ EXPECT_EQ(Status::Ok(), status);
KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
if (post_stats.in_use_bytes > ((partition_.size_bytes() * 70) / 100)) {
@@ -338,10 +338,10 @@
Status status = kvs_.PartialMaintenance();
KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
if (pre_stats.reclaimable_bytes != 0) {
- EXPECT_EQ(Status::OK, status);
+ EXPECT_EQ(Status::Ok(), status);
EXPECT_LT(post_stats.reclaimable_bytes, pre_stats.reclaimable_bytes);
} else {
- EXPECT_EQ(Status::NOT_FOUND, status);
+ EXPECT_EQ(Status::NotFound(), status);
EXPECT_EQ(post_stats.reclaimable_bytes, 0U);
}
FinishOperation("GCPartial", status);
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index e02aa91..2820793 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -121,12 +121,12 @@
std::FILE* out_file = std::fopen(filename, "w+");
if (out_file == nullptr) {
PW_LOG_ERROR("Failed to dump to %s", filename);
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
std::vector<std::byte> out_vec(memory.size_bytes());
Status status =
memory.Read(0, std::span<std::byte>(out_vec.data(), out_vec.size()));
- if (status != Status::OK) {
+ if (status != Status::Ok()) {
fclose(out_file);
return status;
}
@@ -137,17 +137,17 @@
PW_LOG_ERROR("Failed to dump to %s, written=%u",
filename,
static_cast<unsigned>(written));
- status = Status::DATA_LOSS;
+ status = Status::DataLoss();
} else {
PW_LOG_INFO("Dumped to %s", filename);
- status = Status::OK;
+ status = Status::Ok();
}
fclose(out_file);
return status;
}
#else
- Status Dump(const char*) { return Status::OK; }
+ Status Dump(const char*) { return Status::Ok(); }
#endif // DUMP_KVS_STATE_TO_FILE
};
@@ -179,7 +179,7 @@
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&test_partition,
format);
- EXPECT_EQ(kvs.Init(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
}
TEST(InitCheck, ZeroSectors) {
@@ -195,7 +195,7 @@
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&test_partition,
format);
- EXPECT_EQ(kvs.Init(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
}
TEST(InitCheck, TooManySectors) {
@@ -210,11 +210,11 @@
constexpr EntryFormat format{.magic = 0x610f6d17, .checksum = nullptr};
KeyValueStoreBuffer<kMaxEntries, 2> kvs(&test_partition, format);
- EXPECT_EQ(kvs.Init(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
}
-#define ASSERT_OK(expr) ASSERT_EQ(Status::OK, expr)
-#define EXPECT_OK(expr) EXPECT_EQ(Status::OK, expr)
+#define ASSERT_OK(expr) ASSERT_EQ(Status::Ok(), expr)
+#define EXPECT_OK(expr) EXPECT_EQ(Status::Ok(), expr)
TEST(InMemoryKvs, WriteOneKeyMultipleTimes) {
// Create and erase the fake flash. It will persist across reloads.
@@ -358,7 +358,7 @@
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::OK, flash.partition.Erase());
+ ASSERT_EQ(Status::Ok(), flash.partition.Erase());
// Create and initialize the KVS.
// For KVS magic value always use a random 32 bit integer rather than a
@@ -393,7 +393,7 @@
TEST(InMemoryKvs, CallingEraseTwice_NothingWrittenToFlash) {
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::OK, flash.partition.Erase());
+ ASSERT_EQ(Status::Ok(), flash.partition.Erase());
// Create and initialize the KVS.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -401,13 +401,13 @@
ASSERT_OK(kvs.Init());
const uint8_t kValue = 0xDA;
- ASSERT_EQ(Status::OK, kvs.Put(keys[0], kValue));
- ASSERT_EQ(Status::OK, kvs.Delete(keys[0]));
+ ASSERT_EQ(Status::Ok(), kvs.Put(keys[0], kValue));
+ ASSERT_EQ(Status::Ok(), kvs.Delete(keys[0]));
// Compare before / after checksums to verify that nothing was written.
const uint16_t crc = checksum::Crc16Ccitt::Calculate(flash.memory.buffer());
- EXPECT_EQ(kvs.Delete(keys[0]), Status::NOT_FOUND);
+ EXPECT_EQ(kvs.Delete(keys[0]), Status::NotFound());
EXPECT_EQ(crc, checksum::Crc16Ccitt::Calculate(flash.memory.buffer()));
}
@@ -415,8 +415,8 @@
class LargeEmptyInitializedKvs : public ::testing::Test {
protected:
LargeEmptyInitializedKvs() : kvs_(&large_test_partition, default_format) {
- ASSERT_EQ(Status::OK, large_test_partition.Erase());
- ASSERT_EQ(Status::OK, kvs_.Init());
+ ASSERT_EQ(Status::Ok(), large_test_partition.Erase());
+ ASSERT_EQ(Status::Ok(), kvs_.Init());
}
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -426,23 +426,23 @@
const uint8_t kValue1 = 0xDA;
const uint8_t kValue2 = 0x12;
uint8_t value;
- ASSERT_EQ(Status::OK, kvs_.Put(keys[0], kValue1));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
EXPECT_EQ(kvs_.size(), 1u);
- ASSERT_EQ(Status::OK, kvs_.Delete(keys[0]));
- EXPECT_EQ(kvs_.Get(keys[0], &value), Status::NOT_FOUND);
- ASSERT_EQ(Status::OK, kvs_.Put(keys[1], kValue1));
- ASSERT_EQ(Status::OK, kvs_.Put(keys[2], kValue2));
- ASSERT_EQ(Status::OK, kvs_.Delete(keys[1]));
- EXPECT_EQ(Status::OK, kvs_.Get(keys[2], &value));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
+ EXPECT_EQ(kvs_.Get(keys[0], &value), Status::NotFound());
+ ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], kValue1));
+ ASSERT_EQ(Status::Ok(), kvs_.Put(keys[2], kValue2));
+ ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[1]));
+ EXPECT_EQ(Status::Ok(), kvs_.Get(keys[2], &value));
EXPECT_EQ(kValue2, value);
- ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NOT_FOUND);
+ ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NotFound());
EXPECT_EQ(kvs_.size(), 1u);
}
TEST(InMemoryKvs, Put_MaxValueSize) {
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::OK, flash.partition.Erase());
+ ASSERT_EQ(Status::Ok(), flash.partition.Erase());
// Create and initialize the KVS.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -462,12 +462,12 @@
ASSERT_GT(sizeof(large_test_flash), max_value_size + 2 * sizeof(EntryHeader));
auto big_data = std::as_bytes(std::span(&large_test_flash, 1));
- EXPECT_EQ(Status::OK, kvs.Put("K", big_data.subspan(0, max_value_size)));
+ EXPECT_EQ(Status::Ok(), kvs.Put("K", big_data.subspan(0, max_value_size)));
// Larger than maximum is rejected.
- EXPECT_EQ(Status::INVALID_ARGUMENT,
+ EXPECT_EQ(Status::InvalidArgument(),
kvs.Put("K", big_data.subspan(0, max_value_size + 1)));
- EXPECT_EQ(Status::INVALID_ARGUMENT, kvs.Put("K", big_data));
+ EXPECT_EQ(Status::InvalidArgument(), kvs.Put("K", big_data));
}
} // namespace pw::kvs
diff --git a/pw_kvs/key_value_store_wear_test.cc b/pw_kvs/key_value_store_wear_test.cc
index d6cadc4..d272535 100644
--- a/pw_kvs/key_value_store_wear_test.cc
+++ b/pw_kvs/key_value_store_wear_test.cc
@@ -35,7 +35,7 @@
: flash_(internal::Entry::kMinAlignmentBytes),
partition_(&flash_, 0, flash_.sector_count()),
kvs_(&partition_, format) {
- EXPECT_EQ(Status::OK, kvs_.Init());
+ EXPECT_EQ(Status::Ok(), kvs_.Init());
}
static constexpr size_t kSectors = 16;
@@ -92,7 +92,7 @@
test_data[0]++;
EXPECT_EQ(
- Status::OK,
+ Status::Ok(),
kvs_.Put("key",
std::as_bytes(std::span(test_data, sizeof(test_data) - 70))));
}
@@ -105,7 +105,7 @@
test_data[0]++;
printf("Add entry %zu\n", i);
- EXPECT_EQ(Status::OK, kvs_.Put("big_key", test_data));
+ EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
}
EXPECT_EQ(2u, kvs_.size());
diff --git a/pw_kvs/public/pw_kvs/alignment.h b/pw_kvs/public/pw_kvs/alignment.h
index e8cf191..56d0c08 100644
--- a/pw_kvs/public/pw_kvs/alignment.h
+++ b/pw_kvs/public/pw_kvs/alignment.h
@@ -116,7 +116,7 @@
// TODO: This should convert to PW_CHECK once that is available for use in
// host tests.
if (alignment_bytes > kBufferSize) {
- return StatusWithSize::INTERNAL;
+ return StatusWithSize::Internal();
}
AlignedWriterBuffer<kBufferSize> buffer(alignment_bytes, output);
diff --git a/pw_kvs/public/pw_kvs/fake_flash_memory.h b/pw_kvs/public/pw_kvs/fake_flash_memory.h
index c1b0bbe..9795e01 100644
--- a/pw_kvs/public/pw_kvs/fake_flash_memory.h
+++ b/pw_kvs/public/pw_kvs/fake_flash_memory.h
@@ -97,9 +97,9 @@
write_errors_(write_errors) {}
// The fake flash is always enabled.
- Status Enable() override { return Status::OK; }
+ Status Enable() override { return Status::Ok(); }
- Status Disable() override { return Status::OK; }
+ Status Disable() override { return Status::Ok(); }
bool IsEnabled() const override { return true; }
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index a486889..029fba2 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -59,7 +59,7 @@
virtual bool IsEnabled() const = 0;
- virtual Status SelfTest() { return Status::UNIMPLEMENTED; }
+ virtual Status SelfTest() { return Status::Unimplemented(); }
// Erase num_sectors starting at a given address. Blocking call.
// Address should be on a sector boundary. Returns:
@@ -199,7 +199,7 @@
virtual ~FlashPartition() = default;
// Performs any required partition or flash-level initialization.
- virtual Status Init() { return Status::OK; }
+ virtual Status Init() { return Status::Ok(); }
// Erase num_sectors starting at a given address. Blocking call.
// Address must be on a sector boundary. Returns:
diff --git a/pw_kvs/public/pw_kvs/io.h b/pw_kvs/public/pw_kvs/io.h
index 167182f..80a0ef0 100644
--- a/pw_kvs/public/pw_kvs/io.h
+++ b/pw_kvs/public/pw_kvs/io.h
@@ -71,7 +71,7 @@
// Output adapter that calls a method on a class with a std::span of bytes. If
// the method returns void instead of the expected Status, Write always returns
-// Status::OK.
+// Status::Ok().
template <auto kMethod>
class OutputToMethod final : public Output {
using Class = typename internal::FunctionTraits<decltype(kMethod)>::Class;
diff --git a/pw_kvs/sectors.cc b/pw_kvs/sectors.cc
index 7377a11..94ff16e 100644
--- a/pw_kvs/sectors.cc
+++ b/pw_kvs/sectors.cc
@@ -108,7 +108,7 @@
if ((find_mode == kAppendEntry) ||
(sector->RecoverableBytes(sector_size_bytes) == 0)) {
*found_sector = sector;
- return Status::OK;
+ return Status::Ok();
} else {
if ((non_empty_least_reclaimable_sector == nullptr) ||
(non_empty_least_reclaimable_sector->RecoverableBytes(
@@ -137,7 +137,7 @@
Index(first_empty_sector));
last_new_ = first_empty_sector;
*found_sector = first_empty_sector;
- return Status::OK;
+ return Status::Ok();
}
// Tier 3 check: If we got this far, use the sector with least recoverable
@@ -147,13 +147,13 @@
DBG(" Found a usable sector %u, with %u B recoverable, in GC",
Index(*found_sector),
unsigned((*found_sector)->RecoverableBytes(sector_size_bytes)));
- return Status::OK;
+ return Status::Ok();
}
// No sector was found.
DBG(" Unable to find a usable sector");
*found_sector = nullptr;
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
SectorDescriptor& Sectors::WearLeveledSectorFromIndex(size_t idx) const {
diff --git a/pw_kvs/test_key_value_store_test.cc b/pw_kvs/test_key_value_store_test.cc
index 5219925..af6d4a9 100644
--- a/pw_kvs/test_key_value_store_test.cc
+++ b/pw_kvs/test_key_value_store_test.cc
@@ -24,10 +24,10 @@
// Simple test to verify that the TestKvs() does basic function.
TEST(TestKvs, PutGetValue) {
KeyValueStore& kvs = TestKvs();
- ASSERT_EQ(Status::OK, kvs.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(Status::Ok(), kvs.Put("key", uint32_t(0xfeedbeef)));
uint32_t value = 0;
- EXPECT_EQ(Status::OK, kvs.Get("key", &value));
+ EXPECT_EQ(Status::Ok(), kvs.Get("key", &value));
EXPECT_EQ(uint32_t(0xfeedbeef), value);
}
