pw_status: Replace Status::Ok() with OkStatus()
- Mark Status::Ok() and StatusWithSize::Ok() as deprecated.
- Replace Status::Ok() with OkStatus().
- Replace StatusWithSize::Ok() with StatusWithSize().
Change-Id: If7192282446bf6d7f90990bb0b4f1b1b89a9228a
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/29003
Pigweed-Auto-Submit: Wyatt Hepler <hepler@google.com>
Commit-Queue: Auto-Submit <auto-submit@pigweed.google.com.iam.gserviceaccount.com>
Reviewed-by: Keir Mierle <keir@google.com>
diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
index 536de87..fca1a7f 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(OkStatus(), writer.Write(kBytes.subspan(0, 1)).status());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), writer.Write(kBytes.subspan(32, 66)).status());
// Write nothing.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 0)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(98, 0)).status());
// Write the remaining data.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 2)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(98, 2)).status());
auto result = writer.Flush();
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(kData.size(), result.size());
}
@@ -222,7 +222,7 @@
TEST(AlignedWriter, Write_ReturnsTotalBytesWritten) {
static Status return_status;
- return_status = Status::Ok();
+ return_status = OkStatus();
OutputToFunction output([](std::span<const byte> data) {
return StatusWithSize(return_status, data.size());
@@ -232,11 +232,11 @@
StatusWithSize result =
writer.Write(std::as_bytes(std::span("12345678901"sv)));
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), result.status());
EXPECT_EQ(20u, result.size());
return_status = Status::PermissionDenied();
@@ -252,11 +252,11 @@
AlignedWriterBuffer<4> writer(2, output);
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
writer.Write(std::as_bytes(std::span("12345678901"sv))).status());
StatusWithSize result = writer.Flush();
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(12u, result.size());
}
@@ -306,11 +306,11 @@
InputWithErrorInjection input;
StatusWithSize result = writer.Write(input, kData.size());
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), result.status());
EXPECT_EQ(kData.size(), result.size());
}
diff --git a/pw_kvs/checksum.cc b/pw_kvs/checksum.cc
index 08f59b8..4215406 100644
--- a/pw_kvs/checksum.cc
+++ b/pw_kvs/checksum.cc
@@ -27,7 +27,7 @@
if (std::memcmp(state_.data(), checksum.data(), size_bytes()) != 0) {
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::kvs
diff --git a/pw_kvs/checksum_test.cc b/pw_kvs/checksum_test.cc
index 4fffae0..17e8f01 100644
--- a/pw_kvs/checksum_test.cc
+++ b/pw_kvs/checksum_test.cc
@@ -32,8 +32,7 @@
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(OkStatus(), algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
}
TEST(Checksum, Verify_Failure) {
@@ -56,7 +55,7 @@
algo.Update(std::as_bytes(std::span(kString)));
- EXPECT_EQ(Status::Ok(), algo.Verify(crc));
+ EXPECT_EQ(OkStatus(), algo.Verify(crc));
}
TEST(Checksum, Reset) {
@@ -72,20 +71,20 @@
TEST(IgnoreChecksum, NeverUpdate_VerifyWithoutData) {
IgnoreChecksum checksum;
- EXPECT_EQ(Status::Ok(), checksum.Verify({}));
+ EXPECT_EQ(OkStatus(), checksum.Verify({}));
}
TEST(IgnoreChecksum, NeverUpdate_VerifyWithData) {
IgnoreChecksum checksum;
- EXPECT_EQ(Status::Ok(), checksum.Verify(std::as_bytes(std::span(kString))));
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), checksum.Verify({}));
}
constexpr size_t kAlignment = 10;
@@ -144,7 +143,7 @@
EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(state.data()),
state.size()),
kData);
- EXPECT_EQ(Status::Ok(), checksum.Verify(kBytes));
+ EXPECT_EQ(OkStatus(), checksum.Verify(kBytes));
}
} // namespace
diff --git a/pw_kvs/entry.cc b/pw_kvs/entry.cc
index 18fa216..fc01b0c 100644
--- a/pw_kvs/entry.cc
+++ b/pw_kvs/entry.cc
@@ -58,7 +58,7 @@
}
*entry = Entry(&partition, address, *format, header);
- return Status::Ok();
+ return OkStatus();
}
Status Entry::ReadKey(FlashPartition& partition,
@@ -183,12 +183,12 @@
value_ptr += read_size;
}
- return Status::Ok();
+ return OkStatus();
}
Status Entry::VerifyChecksum(Key key, std::span<const byte> value) const {
if (checksum_algo_ == nullptr) {
- return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
+ return header_.checksum == 0 ? OkStatus() : Status::DataLoss();
}
CalculateChecksum(key, value);
return checksum_algo_->Verify(checksum_bytes());
@@ -218,7 +218,7 @@
}
if (checksum_algo_ == nullptr) {
- return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
+ return header_.checksum == 0 ? OkStatus() : Status::DataLoss();
}
// The checksum is calculated as if the header's checksum field were 0.
@@ -279,7 +279,7 @@
header_.checksum = 0;
if (checksum_algo_ == nullptr) {
- return Status::Ok();
+ return OkStatus();
}
checksum_algo_->Reset();
@@ -305,7 +305,7 @@
std::memcpy(&header_.checksum,
checksum.data(),
std::min(checksum.size(), sizeof(header_.checksum)));
- return Status::Ok();
+ return OkStatus();
}
void Entry::AddPaddingBytesToChecksum() const {
diff --git a/pw_kvs/entry_cache.cc b/pw_kvs/entry_cache.cc
index c63e349..e71d42e 100644
--- a/pw_kvs/entry_cache.cc
+++ b/pw_kvs/entry_cache.cc
@@ -107,7 +107,7 @@
} 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::Ok(error_val);
+ return StatusWithSize(error_val);
} else {
PW_LOG_WARN("Found key hash collision for 0x%08" PRIx32, hash);
return StatusWithSize::AlreadyExists(error_val);
@@ -142,14 +142,14 @@
return Status::ResourceExhausted();
}
AddNew(descriptor, address);
- return Status::Ok();
+ return OkStatus();
}
// 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 OkStatus();
}
// If the entries have a duplicate transaction ID, add the new (redundant)
@@ -177,7 +177,7 @@
} else {
PW_LOG_DEBUG("Found stale entry when appending; ignoring");
}
- return Status::Ok();
+ return OkStatus();
}
size_t EntryCache::present_entries() const {
diff --git a/pw_kvs/entry_cache_test.cc b/pw_kvs/entry_cache_test.cc
index 7d6a25f..6b7c9fa 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(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -98,7 +98,7 @@
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry_Full) {
for (uint32_t i = 0; i < kMaxEntries; ++i) {
ASSERT_EQ( // Fill up the cache
- Status::Ok(),
+ OkStatus(),
entries_.AddNewOrUpdateExisting({i, i, EntryState::kValid}, i, 1));
}
ASSERT_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(OkStatus(), 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(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 3000, 2000));
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 7000, 2000));
// Duplicates beyond the redundancy are ignored.
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 9000, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -150,7 +150,7 @@
}
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntryInSameSector) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 1000));
EXPECT_EQ(Status::DataLoss(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1950, 1000));
@@ -320,7 +320,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(Hash(kTheKey), metadata.hash());
EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -337,7 +337,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(1u, result.size());
EXPECT_EQ(Hash(kTheKey), metadata.hash());
EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -364,7 +364,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, "delorted", &metadata);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(Hash("delorted"), metadata.hash());
EXPECT_EQ(EntryState::kDeleted, metadata.state());
diff --git a/pw_kvs/entry_test.cc b/pw_kvs/entry_test.cc
index 8ac1d1a..f9496e3 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(OkStatus(), 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(OkStatus(), entry_.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), result.status());
EXPECT_EQ(result.size(), entry_.value_size());
EXPECT_STREQ(value, "VALUE!");
}
@@ -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(OkStatus(), result.status());
EXPECT_EQ(3u, result.size());
EXPECT_EQ(value[0], 'U');
EXPECT_EQ(value[1], '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(OkStatus(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(value[0], '?');
}
@@ -211,7 +211,7 @@
partition, 64, kFormatWithChecksum, "key45", kValue1, kTransactionId1);
auto result = entry.Write("key45", kValue1);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), entry_.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), Entry::Read(partition, 0, formats, &entry));
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(OkStatus(), Entry::Read(partition, 0, formats, &entry));
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
// Last byte in padding is a 1; should fail.
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(OkStatus(), entry.VerifyChecksum("key45", kValue1));
flash.buffer()[kEntry1.size() - 1] = byte{0};
- EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
}
TEST_F(ValidEntryInFlash, Update_SameFormat_TransactionIdIsUpdated) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
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(OkStatus(), entry_.Update(kFormat, kTransactionId1 + 6));
EXPECT_EQ(kFormat.magic, entry_.magic());
EXPECT_EQ(0u, entry_.address());
@@ -359,14 +359,13 @@
TEST_F(ValidEntryInFlash, Update_ReadError_NoChecksumIsOkay) {
flash_.InjectReadError(FlashError::Unconditional(Status::Aborted()));
- EXPECT_EQ(Status::Ok(),
- entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+ EXPECT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
}
TEST_F(ValidEntryInFlash, Copy) {
auto result = entry_.Copy(123);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(entry_.size(), result.size());
EXPECT_EQ(0,
std::memcmp(
@@ -436,10 +435,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(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry_.Copy(kEntry1.size());
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(kEntry1.size(), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<16>();
@@ -450,9 +449,9 @@
std::memcmp(
&flash_.buffer()[kEntry1.size()], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
Entry::Read(partition_, 32, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kFormatWithSum.magic, new_entry.magic());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -462,12 +461,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(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
- ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry.Copy(32);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(AlignUp(kEntry1.size(), 32), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<32>();
@@ -477,9 +476,9 @@
std::memcmp(&flash.buffer()[32], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
Entry::Read(partition, 32, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -488,12 +487,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(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
- ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry.Copy(64);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(AlignUp(kEntry1.size(), 64), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<64>();
@@ -503,9 +502,9 @@
std::memcmp(&flash.buffer()[64], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
Entry::Read(partition, 64, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -514,10 +513,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(OkStatus(), entry_.Update(no_checksum, kTransactionId1 + 1));
auto result = entry_.Copy(kEntry1.size());
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(kEntry1.size(), result.size());
constexpr auto kNewHeader1 =
@@ -537,23 +536,23 @@
}
TEST_F(ValidEntryInFlash, UpdateAndCopyMultple_DifferentFormat) {
- ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(),
Entry::Read(partition_, read_address, kFormatsWithSum, &entry));
- EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
EXPECT_EQ(kFormatWithSum.magic, entry.magic());
EXPECT_EQ(read_address, entry.address());
EXPECT_EQ(kTransactionId1 + 6, entry.transaction_id());
@@ -562,12 +561,12 @@
}
TEST_F(ValidEntryInFlash, DifferentFormat_UpdatedCopy_FailsWithWrongMagic) {
- ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), copy_result.status());
ASSERT_EQ(kEntry1.size(), copy_result.size());
Entry entry;
@@ -578,8 +577,7 @@
TEST_F(ValidEntryInFlash, UpdateAndCopy_WriteError) {
flash_.InjectWriteError(FlashError::Unconditional(Status::Cancelled()));
- ASSERT_EQ(Status::Ok(),
- entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
auto result = entry_.Copy(kEntry1.size());
EXPECT_EQ(Status::Cancelled(), result.status());
diff --git a/pw_kvs/fake_flash_memory.cc b/pw_kvs/fake_flash_memory.cc
index 7796a72..4c30913 100644
--- a/pw_kvs/fake_flash_memory.cc
+++ b/pw_kvs/fake_flash_memory.cc
@@ -31,23 +31,23 @@
}
}
- return Status::Ok();
+ return OkStatus();
}
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 OkStatus();
}
if (delay_ > 0u) {
delay_ -= 1;
- return Status::Ok();
+ return OkStatus();
}
if (remaining_ == 0u) {
- return Status::Ok();
+ return OkStatus();
}
if (remaining_ != kAlways) {
@@ -76,7 +76,7 @@
std::memset(
&buffer_[address], int(kErasedValue), sector_size_bytes() * num_sectors);
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize FakeFlashMemory::Read(Address address,
diff --git a/pw_kvs/flash_memory.cc b/pw_kvs/flash_memory.cc
index 93e08d7..1bcacf6 100644
--- a/pw_kvs/flash_memory.cc
+++ b/pw_kvs/flash_memory.cc
@@ -125,7 +125,7 @@
for (byte b : std::span(buffer, read_size)) {
if (b != erased_byte) {
// Detected memory chunk is not entirely erased
- return Status::Ok();
+ return OkStatus();
}
}
@@ -133,7 +133,7 @@
length -= read_size;
}
*is_erased = true;
- return Status::Ok();
+ return OkStatus();
}
bool FlashPartition::AppearsErased(std::span<const byte> data) const {
@@ -154,7 +154,7 @@
unsigned(length));
return Status::OutOfRange();
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::kvs
diff --git a/pw_kvs/flash_partition_test.cc b/pw_kvs/flash_partition_test.cc
index b9a2299..193f3d2 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), status.status());
EXPECT_EQ(alignment, status.size());
if (!status.ok() || (alignment != status.size())) {
error_count++;
@@ -140,8 +140,7 @@
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(OkStatus(), 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();
@@ -150,20 +149,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(OkStatus(), 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(OkStatus(), test_partition.IsErased(&is_erased));
ASSERT_EQ(false, is_erased);
- ASSERT_EQ(Status::Ok(), test_partition.Erase());
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), test_partition.IsErased(&is_erased));
ASSERT_EQ(true, is_erased);
// Read the first page of each sector and make sure it has been erased.
@@ -174,7 +173,7 @@
StatusWithSize status =
test_partition.Read(address, data_span.size_bytes(), data_span.data());
- EXPECT_EQ(Status::Ok(), status.status());
+ EXPECT_EQ(OkStatus(), status.status());
EXPECT_EQ(data_span.size_bytes(), status.size());
EXPECT_EQ(true, test_partition.AppearsErased(as_bytes(data_span)));
@@ -243,10 +242,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(OkStatus(), test_partition.Erase());
bool is_erased = true;
- ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+ ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
ASSERT_EQ(true, is_erased);
static const uint8_t fill_byte = 0x55;
@@ -256,26 +255,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(OkStatus(), status.status());
ASSERT_EQ(data_span.size_bytes(), status.size());
- EXPECT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+ EXPECT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
EXPECT_EQ(false, is_erased);
// Check the chunk that was written.
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
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(OkStatus(),
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(OkStatus(),
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 6b2431b..26b0eee 100644
--- a/pw_kvs/flash_partition_with_stats.cc
+++ b/pw_kvs/flash_partition_with_stats.cc
@@ -29,7 +29,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 OkStatus();
}
KeyValueStore::StorageStats stats = kvs.GetStorageStats();
@@ -67,7 +67,7 @@
std::fprintf(out_file, "\n");
std::fclose(out_file);
- return Status::Ok();
+ return OkStatus();
}
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 77ed52d..6c2a1a6 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -134,7 +134,7 @@
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::InitializeMetadata() {
@@ -295,7 +295,7 @@
unsigned(entry_copies_missing));
return Status::FailedPrecondition();
}
- return Status::Ok();
+ return OkStatus();
}
KeyValueStore::StorageStats KeyValueStore::GetStorageStats() const {
@@ -394,7 +394,7 @@
if (formats_.KnownMagic(magic)) {
DBG("Found entry magic at address %u", unsigned(address));
*next_entry_address = address;
- return Status::Ok();
+ return OkStatus();
}
}
@@ -605,7 +605,7 @@
if (!initialized()) {
return Status::FailedPrecondition();
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::CheckReadOperation(Key key) const {
@@ -618,7 +618,7 @@
if (initialized_ == InitializationState::kNotInitialized) {
return Status::FailedPrecondition();
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::WriteEntryForExistingKey(EntryMetadata& metadata,
@@ -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 OkStatus();
}
// 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 OkStatus();
}
KeyValueStore::EntryMetadata KeyValueStore::CreateOrUpdateKeyDescriptor(
@@ -730,7 +730,7 @@
unsigned(write_addresses[i]));
}
- return Status::Ok();
+ return OkStatus();
}
// Finds a sector to use for writing a new entry to. Does automatic garbage
@@ -813,7 +813,7 @@
sector.RemoveWritableBytes(result.size());
sector.AddValidBytes(result.size());
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize KeyValueStore::CopyEntryToSector(Entry& entry,
@@ -864,7 +864,7 @@
sectors_.FromAddress(address).RemoveValidBytes(result_size);
address = new_address;
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::FullMaintenanceHelper(MaintenanceType maintenance_type) {
@@ -976,7 +976,7 @@
}
}
- return Status::Ok();
+ return OkStatus();
};
Status KeyValueStore::GarbageCollectSector(
@@ -1008,7 +1008,7 @@
}
DBG(" Garbage Collect sector %u complete", sectors_.Index(sector_to_gc));
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize KeyValueStore::UpdateEntriesToPrimaryFormat() {
@@ -1078,7 +1078,7 @@
metadata.AddNewAddress(new_address);
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::RepairCorruptSectors() {
@@ -1086,7 +1086,7 @@
// 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 = OkStatus();
size_t loop_count = 0;
do {
@@ -1094,7 +1094,7 @@
// Error of RESOURCE_EXHAUSTED indicates no space found for relocation.
// Reset back to OK for the next pass.
if (repair_status == Status::ResourceExhausted()) {
- repair_status = Status::Ok();
+ repair_status = OkStatus();
}
DBG(" Pass %u", unsigned(loop_count));
@@ -1117,7 +1117,7 @@
}
Status KeyValueStore::EnsureFreeSectorExists() {
- Status repair_status = Status::Ok();
+ Status repair_status = OkStatus();
bool empty_sector_found = false;
DBG(" Find empty sector");
@@ -1141,11 +1141,11 @@
}
Status KeyValueStore::EnsureEntryRedundancy() {
- Status repair_status = Status::Ok();
+ Status repair_status = OkStatus();
if (redundancy() == 1) {
DBG(" Redundancy not in use, nothting to check");
- return Status::Ok();
+ return OkStatus();
}
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 76c0667..1fb046a 100644
--- a/pw_kvs/key_value_store_binary_format_test.cc
+++ b/pw_kvs/key_value_store_binary_format_test.cc
@@ -189,10 +189,10 @@
TEST_F(KvsErrorHandling, Init_Ok) {
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorHandling, Init_DuplicateEntries_ReturnsDataLossButReadsEntry) {
@@ -200,7 +200,7 @@
EXPECT_EQ(Status::DataLoss(), kvs_.Init());
byte buffer[64];
- EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
}
@@ -213,7 +213,7 @@
ASSERT_EQ(Status::DataLoss(), kvs_.Init());
byte buffer[64];
ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ ASSERT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
// One valid entry.
@@ -236,9 +236,9 @@
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("4k", buffer).status());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(64u, stats.in_use_bytes);
@@ -276,7 +276,7 @@
EXPECT_EQ(1u, kvs_.size());
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(32u, stats.in_use_bytes);
@@ -314,8 +314,8 @@
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(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -341,7 +341,7 @@
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(OkStatus(), result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -352,7 +352,7 @@
// the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
// configurations).
TEST_F(KvsErrorHandling, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
@@ -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(OkStatus(), kvs_.Put("key1", bytes::String("value1")));
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -397,21 +397,21 @@
TEST_F(KvsErrorRecovery, Init_Ok) {
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorRecovery, Init_DuplicateEntries_RecoversDuringInit) {
InitFlashTo(bytes::Concat(kEntry1, kEntry1));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), kvs_.Get("key1", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
}
@@ -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(OkStatus(), kvs_.Init());
byte buffer[64];
ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), kvs_.Init());
EXPECT_EQ(2u, kvs_.size());
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("4k", buffer).status());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(64u, stats.in_use_bytes);
@@ -465,7 +465,7 @@
flash_.InjectReadError(
FlashError::InRange(Status::Unauthenticated(), kEntry1.size()));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Put("hello", bytes::String("world")));
+ EXPECT_EQ(OkStatus(), kvs_.Put("a", bytes::String("b")));
// Existing valid entries should still be readable.
EXPECT_EQ(3u, kvs_.size());
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -572,7 +572,7 @@
// the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
// configurations).
TEST_F(KvsErrorRecovery, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
@@ -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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), partition_.Erase(partition_.sector_size_bytes(), 1));
ASSERT_CONTAINS_ENTRY("key1", "value1");
ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -725,7 +725,7 @@
EXPECT_EQ(false, kvs_.error_detected());
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (192u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -773,10 +773,10 @@
char val[20] = {};
EXPECT_EQ(
- Status::Ok(),
+ OkStatus(),
kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (224u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -785,12 +785,12 @@
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
EXPECT_EQ(
- Status::Ok(),
+ OkStatus(),
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(OkStatus(), partition_.Erase(0, 2));
char val[20] = {};
EXPECT_EQ(Status::DataLoss(),
@@ -815,7 +815,7 @@
}
TEST_F(InitializedRedundantMultiMagicKvs, PutNewEntry_UsesFirstFormat) {
- EXPECT_EQ(Status::Ok(), kvs_.Put("new key", bytes::String("abcd?")));
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -947,7 +947,7 @@
};
TEST_F(InitializedRedundantLazyRecoveryKvs, WriteAfterDataLoss) {
- EXPECT_EQ(Status::Ok(), partition_.Erase(0, 4));
+ EXPECT_EQ(OkStatus(), partition_.Erase(0, 4));
char val[20] = {};
EXPECT_EQ(Status::DataLoss(),
@@ -970,7 +970,7 @@
ASSERT_EQ(Status::DataLoss(), kvs_.Put("key1", 1000));
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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 4fd86bc..6a257d6 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(OkStatus(), 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(OkStatus(),
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 7ea3fd9..9994fb6 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(OkStatus(), 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(OkStatus(),
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(OkStatus(), 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(OkStatus(),
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(OkStatus(),
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(OkStatus(), 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(OkStatus(), kvs_.Put("key", input));
float output[2] = {};
- ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), kvs_.Put("key", std::span(input)));
float output[2] = {};
- ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+ ASSERT_EQ(OkStatus(), kvs_.Get("key", &output));
EXPECT_EQ(input[0], output[0]);
EXPECT_EQ(input[1], output[1]);
}
@@ -178,39 +178,39 @@
};
const TestStruct input{-1234.5, true};
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", input));
TestStruct output;
- ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(),
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(OkStatus(), result.status());
EXPECT_EQ(sizeof("Mingus"), result.size());
EXPECT_STREQ("Mingus", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
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(OkStatus(), 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(OkStatus(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[4] = {};
@@ -222,7 +222,7 @@
}
TEST_F(EmptyInitializedKvs, Get_WithOffset_PastEnd) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
@@ -234,15 +234,15 @@
}
TEST_F(EmptyInitializedKvs, GetValue) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint32_t value = 0;
- EXPECT_EQ(Status::Ok(), kvs_.Get("key", &value));
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint8_t value = 0;
EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
@@ -250,7 +250,7 @@
}
TEST_F(EmptyInitializedKvs, GetValue_TooLarge) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint64_t value = 0;
EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
@@ -258,37 +258,36 @@
}
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(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
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(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
- EXPECT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
+ EXPECT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
char data[6] = {};
- ASSERT_EQ(Status::Ok(), kvs_.Get("kEy", &data));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), new_kvs.Init());
- EXPECT_EQ(Status::Ok(),
- new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
EXPECT_EQ(0u, kvs_.size());
EXPECT_TRUE(kvs_.empty());
@@ -299,12 +298,12 @@
constexpr std::string_view key1 = "D4";
constexpr std::string_view key2 = "dFU6S";
- ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key1, 1000));
EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
int value = 0;
- EXPECT_EQ(Status::Ok(), kvs_.Get(key1, &value));
+ EXPECT_EQ(OkStatus(), kvs_.Get(key1, &value));
EXPECT_EQ(1000, value);
EXPECT_EQ(Status::NotFound(), kvs_.Get(key2, &value));
@@ -317,8 +316,8 @@
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(OkStatus(), kvs_.Put(key1, 1000));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(key1));
// key2 collides with key1's tombstone.
EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
@@ -346,42 +345,41 @@
}
TEST_F(EmptyInitializedKvs, Iteration_OneItem) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), 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(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint32_t value = 0;
- EXPECT_EQ(Status::Ok(), entry.Get(&value));
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint8_t value = 0;
@@ -391,7 +389,7 @@
}
TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooLarge) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint64_t value = 0;
@@ -401,8 +399,8 @@
}
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(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
for (KeyValueStore::Item entry : kvs_) {
static_cast<void>(entry);
@@ -425,10 +423,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(OkStatus(), kvs_.Put(key1, buf1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key2, buf2));
for (size_t j = 0; j < keys.size(); j++) {
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[j], j));
}
for (size_t i = 0; i < 100; i++) {
@@ -437,28 +435,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(OkStatus(), 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(OkStatus(), kvs_.Delete(key1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key1, std::span(buf1, size1)));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(key2));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), kvs_.Delete(keys[j]));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[j], j));
}
// Re-enable and verify
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
static byte buf[4 * 1024];
- ASSERT_EQ(Status::Ok(), kvs_.Get(key1, std::span(buf, size1)).status());
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), 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(OkStatus(), kvs_.Get(keys[j], &ret));
ASSERT_EQ(ret, j);
}
}
@@ -468,28 +466,28 @@
// Add some data
uint8_t value1 = 0xDA;
ASSERT_EQ(
- Status::Ok(),
+ OkStatus(),
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(OkStatus(), kvs_.Put(keys[1], value2));
// Verify data
uint32_t test2;
- EXPECT_EQ(Status::Ok(), kvs_.Get(keys[1], &test2));
+ EXPECT_EQ(OkStatus(), kvs_.Get(keys[1], &test2));
uint8_t test1;
- ASSERT_EQ(Status::Ok(), kvs_.Get(keys[0], &test1));
+ ASSERT_EQ(OkStatus(), 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(OkStatus(), kvs_.Delete(keys[0]));
// Verify it was erased
EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NotFound());
test2 = 0;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
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 27b961c..0ae42f3 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(OkStatus(), partition_.Erase());
Status result = kvs_.Init();
- EXPECT_EQ(Status::Ok(), result);
+ EXPECT_EQ(OkStatus(), 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(OkStatus(),
item.Get(std::as_writable_bytes(std::span(value))).status());
EXPECT_EQ(map_entry->second, std::string(value));
}
@@ -315,14 +315,14 @@
void Init() {
StartOperation("Init");
Status status = kvs_.Init();
- EXPECT_EQ(Status::Ok(), status);
+ EXPECT_EQ(OkStatus(), status);
FinishOperation("Init", status);
}
void GCFull() {
StartOperation("GCFull");
Status status = kvs_.FullMaintenance();
- EXPECT_EQ(Status::Ok(), status);
+ EXPECT_EQ(OkStatus(), status);
KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
if (post_stats.in_use_bytes > ((partition_.size_bytes() * 70) / 100)) {
@@ -338,7 +338,7 @@
Status status = kvs_.PartialMaintenance();
KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
if (pre_stats.reclaimable_bytes != 0) {
- EXPECT_EQ(Status::Ok(), status);
+ EXPECT_EQ(OkStatus(), status);
EXPECT_LT(post_stats.reclaimable_bytes, pre_stats.reclaimable_bytes);
} else {
EXPECT_EQ(Status::NotFound(), status);
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 73b1a12..967cf1e 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -69,7 +69,7 @@
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 != OkStatus()) {
fclose(out_file);
return status;
}
@@ -83,14 +83,14 @@
status = Status::DataLoss();
} else {
PW_LOG_INFO("Dumped to %s", filename);
- status = Status::Ok();
+ status = OkStatus();
}
fclose(out_file);
return status;
}
#else
- Status Dump(const char*) { return Status::Ok(); }
+ Status Dump(const char*) { return OkStatus(); }
#endif // DUMP_KVS_STATE_TO_FILE
};
@@ -156,8 +156,8 @@
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(OkStatus(), expr)
+#define EXPECT_OK(expr) EXPECT_EQ(OkStatus(), expr)
TEST(InMemoryKvs, WriteOneKeyMultipleTimes) {
// Create and erase the fake flash. It will persist across reloads.
@@ -301,7 +301,7 @@
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+ ASSERT_EQ(OkStatus(), flash.partition.Erase());
// Create and initialize the KVS.
// For KVS magic value always use a random 32 bit integer rather than a
@@ -336,7 +336,7 @@
TEST(InMemoryKvs, CallingEraseTwice_NothingWrittenToFlash) {
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+ ASSERT_EQ(OkStatus(), flash.partition.Erase());
// Create and initialize the KVS.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -344,8 +344,8 @@
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(OkStatus(), kvs.Put(keys[0], kValue));
+ ASSERT_EQ(OkStatus(), kvs.Delete(keys[0]));
// Compare before / after checksums to verify that nothing was written.
const uint16_t crc = checksum::Crc16Ccitt::Calculate(flash.memory.buffer());
@@ -358,8 +358,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(OkStatus(), large_test_partition.Erase());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
}
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -369,14 +369,14 @@
const uint8_t kValue1 = 0xDA;
const uint8_t kValue2 = 0x12;
uint8_t value;
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue1));
EXPECT_EQ(kvs_.size(), 1u);
- ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
+ ASSERT_EQ(OkStatus(), 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));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[1], kValue1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[2], kValue2));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(keys[1]));
+ EXPECT_EQ(OkStatus(), kvs_.Get(keys[2], &value));
EXPECT_EQ(kValue2, value);
ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NotFound());
EXPECT_EQ(kvs_.size(), 1u);
@@ -388,8 +388,8 @@
// Write a key and write again with a different value, resulting in a stale
// entry from the first write.
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue2));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue2));
EXPECT_EQ(kvs_.size(), 1u);
KeyValueStore::StorageStats stats = kvs_.GetStorageStats();
@@ -398,14 +398,14 @@
// Do regular FullMaintenance, which should not touch the sector with valid
// data.
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.sector_erase_count, 0u);
EXPECT_GT(stats.reclaimable_bytes, 0u);
// Do aggressive FullMaintenance, which should GC the sector with valid data,
// resulting in no reclaimable bytes and an erased sector.
- EXPECT_EQ(Status::Ok(), kvs_.HeavyMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.HeavyMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.sector_erase_count, 1u);
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -414,7 +414,7 @@
TEST(InMemoryKvs, Put_MaxValueSize) {
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+ ASSERT_EQ(OkStatus(), flash.partition.Erase());
// Create and initialize the KVS.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -434,7 +434,7 @@
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(OkStatus(), kvs.Put("K", big_data.subspan(0, max_value_size)));
// Larger than maximum is rejected.
EXPECT_EQ(Status::InvalidArgument(),
diff --git a/pw_kvs/key_value_store_wear_test.cc b/pw_kvs/key_value_store_wear_test.cc
index d272535..4110c16 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(OkStatus(), kvs_.Init());
}
static constexpr size_t kSectors = 16;
@@ -92,7 +92,7 @@
test_data[0]++;
EXPECT_EQ(
- Status::Ok(),
+ OkStatus(),
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(OkStatus(), kvs_.Put("big_key", test_data));
}
EXPECT_EQ(2u, kvs_.size());
diff --git a/pw_kvs/public/pw_kvs/fake_flash_memory.h b/pw_kvs/public/pw_kvs/fake_flash_memory.h
index 9795e01..e892d92 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 OkStatus(); }
- Status Disable() override { return Status::Ok(); }
+ Status Disable() override { return OkStatus(); }
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 3b25d88..28fd043 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -187,7 +187,7 @@
virtual ~FlashPartition() = default;
// Performs any required partition or flash-level initialization.
- virtual Status Init() { return Status::Ok(); }
+ virtual Status Init() { return OkStatus(); }
// 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 341b80a..193427c 100644
--- a/pw_kvs/public/pw_kvs/io.h
+++ b/pw_kvs/public/pw_kvs/io.h
@@ -73,7 +73,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().
+// OkStatus().
template <typename T, T 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 e8d91b7..67ede37 100644
--- a/pw_kvs/sectors.cc
+++ b/pw_kvs/sectors.cc
@@ -111,7 +111,7 @@
if ((find_mode == kAppendEntry) ||
(sector->RecoverableBytes(sector_size_bytes) == 0)) {
*found_sector = sector;
- return Status::Ok();
+ return OkStatus();
} else {
if ((non_empty_least_reclaimable_sector == nullptr) ||
(non_empty_least_reclaimable_sector->RecoverableBytes(
@@ -140,7 +140,7 @@
Index(first_empty_sector));
last_new_ = first_empty_sector;
*found_sector = first_empty_sector;
- return Status::Ok();
+ return OkStatus();
}
// Tier 3 check: If we got this far, use the sector with least recoverable
@@ -150,7 +150,7 @@
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 OkStatus();
}
// No sector was found.
diff --git a/pw_kvs/test_key_value_store_test.cc b/pw_kvs/test_key_value_store_test.cc
index af6d4a9..97ececd 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(OkStatus(), kvs.Put("key", uint32_t(0xfeedbeef)));
uint32_t value = 0;
- EXPECT_EQ(Status::Ok(), kvs.Get("key", &value));
+ EXPECT_EQ(OkStatus(), kvs.Get("key", &value));
EXPECT_EQ(uint32_t(0xfeedbeef), value);
}
