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_allocator/block.cc b/pw_allocator/block.cc
index 6b7b7fd..67b0a7b 100644
--- a/pw_allocator/block.cc
+++ b/pw_allocator/block.cc
@@ -21,11 +21,11 @@
Status Block::Init(const std::span<std::byte> region, Block** block) {
// Ensure the region we're given is aligned and sized accordingly
if (reinterpret_cast<uintptr_t>(region.data()) % alignof(Block) != 0) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
if (region.size() < sizeof(Block)) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
union {
@@ -46,18 +46,18 @@
#if PW_ALLOCATOR_POISON_ENABLE
(*block)->PoisonBlock();
#endif // PW_ALLOCATOR_POISON_ENABLE
- return Status::OK;
+ return Status::Ok();
}
Status Block::Split(size_t head_block_inner_size, Block** new_block) {
if (new_block == nullptr) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
// Don't split used blocks.
// TODO: Relax this restriction? Flag to enable/disable this check?
if (Used()) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
// First round the head_block_inner_size up to a alignof(Block) bounary.
@@ -74,7 +74,7 @@
// (1) Are we trying to allocate a head block larger than the current head
// block? This may happen because of the alignment above.
if (aligned_head_block_inner_size > InnerSize()) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
// (2) Does the resulting block have enough space to store the header?
@@ -82,7 +82,7 @@
// size == sizeof(Block))?
if (InnerSize() - aligned_head_block_inner_size <
sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
// Create the new block inside the current one.
@@ -118,18 +118,18 @@
(*new_block)->PoisonBlock();
#endif // PW_ALLOCATOR_POISON_ENABLE
- return Status::OK;
+ return Status::Ok();
}
Status Block::MergeNext() {
// Anything to merge with?
if (Last()) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
// Is this or the next block in use?
if (Used() || Next()->Used()) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
// Simply enough, this block's next pointer becomes the next block's
@@ -142,14 +142,14 @@
Next()->prev = this;
}
- return Status::OK;
+ return Status::Ok();
}
Status Block::MergePrev() {
// We can't merge if we have no previous. After that though, merging with
// the previous block is just MergeNext from the previous block.
if (prev == nullptr) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
// WARNING: This class instance will still exist, but technically be invalid
diff --git a/pw_allocator/block_test.cc b/pw_allocator/block_test.cc
index c71cd38..0fd5d39 100644
--- a/pw_allocator/block_test.cc
+++ b/pw_allocator/block_test.cc
@@ -30,7 +30,7 @@
Block* block = nullptr;
auto status = Block::Init(std::span(bytes, kN), &block);
- ASSERT_EQ(status, Status::OK);
+ ASSERT_EQ(status, Status::Ok());
EXPECT_EQ(block->OuterSize(), kN);
EXPECT_EQ(block->InnerSize(),
kN - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -50,7 +50,7 @@
Block* block = nullptr;
auto status = Block::Init(std::span(byte_ptr + 1, kN - 1), &block);
- EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+ EXPECT_EQ(status, Status::InvalidArgument());
}
TEST(Block, CannotCreateTooSmallBlock) {
@@ -59,7 +59,7 @@
Block* block = nullptr;
auto status = Block::Init(std::span(bytes, kN), &block);
- EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+ EXPECT_EQ(status, Status::InvalidArgument());
}
TEST(Block, CanSplitBlock) {
@@ -73,7 +73,7 @@
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
- ASSERT_EQ(status, Status::OK);
+ ASSERT_EQ(status, Status::Ok());
EXPECT_EQ(block->InnerSize(), kSplitN);
EXPECT_EQ(block->OuterSize(),
kSplitN + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -106,7 +106,7 @@
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
- ASSERT_EQ(status, Status::OK);
+ ASSERT_EQ(status, Status::Ok());
EXPECT_EQ(block->InnerSize(), split_len);
EXPECT_EQ(block->OuterSize(),
split_len + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -159,7 +159,7 @@
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
- EXPECT_EQ(status, Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(status, Status::ResourceExhausted());
EXPECT_EQ(next_block, nullptr);
}
@@ -172,7 +172,7 @@
Block::Init(std::span(bytes, kN), &block);
auto status = block->Split(kSplitN, nullptr);
- EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+ EXPECT_EQ(status, Status::InvalidArgument());
}
TEST(Block, CannotMakeBlockLargerInSplit) {
@@ -186,7 +186,7 @@
Block* next_block = nullptr;
auto status = block->Split(block->InnerSize() + 1, &next_block);
- EXPECT_EQ(status, Status::OUT_OF_RANGE);
+ EXPECT_EQ(status, Status::OutOfRange());
}
TEST(Block, CannotMakeSecondBlockLargerInSplit) {
@@ -202,7 +202,7 @@
block->InnerSize() - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET + 1,
&next_block);
- ASSERT_EQ(status, Status::RESOURCE_EXHAUSTED);
+ ASSERT_EQ(status, Status::ResourceExhausted());
EXPECT_EQ(next_block, nullptr);
}
@@ -217,7 +217,7 @@
Block* next_block = nullptr;
auto status = block->Split(0, &next_block);
- ASSERT_EQ(status, Status::OK);
+ ASSERT_EQ(status, Status::Ok());
EXPECT_EQ(block->InnerSize(), static_cast<size_t>(0));
}
@@ -234,7 +234,7 @@
block->InnerSize() - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET,
&next_block);
- ASSERT_EQ(status, Status::OK);
+ ASSERT_EQ(status, Status::Ok());
EXPECT_EQ(next_block->InnerSize(), static_cast<size_t>(0));
}
@@ -267,7 +267,7 @@
Block* next_block = nullptr;
auto status = block->Split(512, &next_block);
- EXPECT_EQ(status, Status::FAILED_PRECONDITION);
+ EXPECT_EQ(status, Status::FailedPrecondition());
}
TEST(Block, CanMergeWithNextBlock) {
@@ -287,7 +287,7 @@
Block* block3 = nullptr;
block->Split(kSplit2, &block3);
- EXPECT_EQ(block3->MergeNext(), Status::OK);
+ EXPECT_EQ(block3->MergeNext(), Status::Ok());
EXPECT_EQ(block->Next(), block3);
EXPECT_EQ(block3->Prev(), block);
@@ -312,8 +312,8 @@
Block* next_block = nullptr;
block->Split(512, &next_block);
- EXPECT_EQ(next_block->MergeNext(), Status::OUT_OF_RANGE);
- EXPECT_EQ(block->MergePrev(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(next_block->MergeNext(), Status::OutOfRange());
+ EXPECT_EQ(block->MergePrev(), Status::OutOfRange());
}
TEST(Block, CannotMergeUsedBlock) {
@@ -329,8 +329,8 @@
block->Split(512, &next_block);
block->MarkUsed();
- EXPECT_EQ(block->MergeNext(), Status::FAILED_PRECONDITION);
- EXPECT_EQ(next_block->MergePrev(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(block->MergeNext(), Status::FailedPrecondition());
+ EXPECT_EQ(next_block->MergePrev(), Status::FailedPrecondition());
}
TEST(Block, CanCheckValidBlock) {
diff --git a/pw_allocator/freelist.cc b/pw_allocator/freelist.cc
index 4629a4f..d46e010 100644
--- a/pw_allocator/freelist.cc
+++ b/pw_allocator/freelist.cc
@@ -19,7 +19,7 @@
Status FreeList::AddChunk(std::span<std::byte> chunk) {
// Check that the size is enough to actually store what we need
if (chunk.size() < sizeof(FreeListNode)) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
union {
@@ -36,7 +36,7 @@
aliased.node->next = chunks_[chunk_ptr];
chunks_[chunk_ptr] = aliased.node;
- return Status::OK;
+ return Status::Ok();
}
std::span<std::byte> FreeList::FindChunk(size_t size) const {
@@ -85,14 +85,14 @@
// Check head first.
if (chunks_[chunk_ptr] == nullptr) {
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
aliased.node = chunks_[chunk_ptr];
if (aliased.data == chunk.data()) {
chunks_[chunk_ptr] = aliased.node->next;
- return Status::OK;
+ return Status::Ok();
}
// No? Walk the nodes.
@@ -103,13 +103,13 @@
if (aliased_next.data == chunk.data()) {
// Found it, remove this node out of the chain
aliased.node->next = aliased_next.node->next;
- return Status::OK;
+ return Status::Ok();
}
aliased.node = aliased.node->next;
}
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
size_t FreeList::FindChunkPtrForSize(size_t size, bool non_null) const {
diff --git a/pw_allocator/freelist_test.cc b/pw_allocator/freelist_test.cc
index 0484a7a..865ea3f 100644
--- a/pw_allocator/freelist_test.cc
+++ b/pw_allocator/freelist_test.cc
@@ -43,7 +43,7 @@
byte data[kN] = {std::byte(0)};
auto status = list.AddChunk(std::span(data, kN));
- EXPECT_EQ(status, Status::OK);
+ EXPECT_EQ(status, Status::Ok());
auto item = list.FindChunk(kN);
EXPECT_EQ(item.size(), kN);
@@ -70,7 +70,7 @@
list.AddChunk(std::span(data, kN));
auto status = list.RemoveChunk(std::span(data, kN));
- EXPECT_EQ(status, Status::OK);
+ EXPECT_EQ(status, Status::Ok());
auto item = list.FindChunk(kN);
EXPECT_EQ(item.size(), static_cast<size_t>(0));
@@ -148,7 +148,7 @@
list.AddChunk(std::span(data, kN));
auto status = list.RemoveChunk(std::span(data2, kN));
- EXPECT_EQ(status, Status::NOT_FOUND);
+ EXPECT_EQ(status, Status::NotFound());
}
TEST(FreeList, CanStoreMultipleChunksPerBucket) {
diff --git a/pw_assert/assert_backend_compile_test.cc b/pw_assert/assert_backend_compile_test.cc
index da19e34..6e1ac2e 100644
--- a/pw_assert/assert_backend_compile_test.cc
+++ b/pw_assert/assert_backend_compile_test.cc
@@ -203,7 +203,7 @@
TEST(Check, CheckOkMacrosCompile) {
MAYBE_SKIP_TEST;
- pw::Status status = pw::Status::UNKNOWN;
+ pw::Status status = pw::Status::Unknown();
// Typical case with long names.
PW_CHECK_OK(status);
@@ -216,10 +216,10 @@
CHECK_OK(status, "msg: %d", 5);
// Status from a literal.
- PW_CHECK_OK(pw::Status::OK);
+ PW_CHECK_OK(pw::Status::Ok());
// Status from a function.
- PW_CHECK_OK(MakeStatus(pw::Status::OK));
+ PW_CHECK_OK(MakeStatus(pw::Status::Ok()));
// Status from C enums.
PW_CHECK_OK(PW_STATUS_OK);
diff --git a/pw_assert/assert_facade_test.cc b/pw_assert/assert_facade_test.cc
index 34faecb..083d206 100644
--- a/pw_assert/assert_facade_test.cc
+++ b/pw_assert/assert_facade_test.cc
@@ -421,32 +421,32 @@
// When DCHECKs are disabled, they should not trip, and their arguments
// shouldn't be evaluated.
-TEST(AssertPass, DCheckDisabledSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledSingleSideEffectingCall_1) {
global_state_for_multi_evaluate_test = 0;
PW_DCHECK(IncrementsGlobal() == 0);
EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
}
-TEST(AssertPass, DCheckDisabledSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledSingleSideEffectingCall_2) {
global_state_for_multi_evaluate_test = 0;
PW_DCHECK(IncrementsGlobal() == 1);
EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
}
-TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall_1) {
global_state_for_multi_evaluate_test = 0;
PW_DCHECK_INT_EQ(0, IncrementsGlobal());
EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
}
-TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls) {
+TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls_1) {
global_state_for_multi_evaluate_test = 0;
PW_DCHECK_INT_EQ(IncrementsGlobal(), IncrementsGlobal());
EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
}
-TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall) {
+TEST(AssertPass, DCheckDisabledBinaryOpSingleSideEffectingCall_2) {
global_state_for_multi_evaluate_test = 0;
PW_DCHECK_INT_EQ(12314, IncrementsGlobal());
EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
}
-TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls) {
+TEST(AssertPass, DCheckDisabledBinaryOpTwoSideEffectingCalls_2) {
global_state_for_multi_evaluate_test = 0;
PW_DCHECK_INT_EQ(IncrementsGlobal() + 10, IncrementsGlobal());
EXPECT_EQ(global_state_for_multi_evaluate_test, 0);
@@ -475,25 +475,25 @@
// Verify PW_CHECK_OK, including message handling.
TEST_F(AssertFail, StatusNotOK) {
- pw::Status status = pw::Status::UNKNOWN;
+ pw::Status status = pw::Status::Unknown();
PW_CHECK_OK(status);
EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). ");
}
TEST_F(AssertFail, StatusNotOKMessageNoArguments) {
- pw::Status status = pw::Status::UNKNOWN;
+ pw::Status status = pw::Status::Unknown();
PW_CHECK_OK(status, "msg");
EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg");
}
TEST_F(AssertFail, StatusNotOKMessageArguments) {
- pw::Status status = pw::Status::UNKNOWN;
+ pw::Status status = pw::Status::Unknown();
PW_CHECK_OK(status, "msg: %d", 5);
EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg: 5");
}
// Example expression for the test below.
-pw::Status DoTheThing() { return pw::Status::RESOURCE_EXHAUSTED; }
+pw::Status DoTheThing() { return pw::Status::ResourceExhausted(); }
TEST_F(AssertFail, NonTrivialExpression) {
PW_CHECK_OK(DoTheThing());
@@ -504,32 +504,25 @@
// Note: This function seems pointless but it is not, since pw::Status::FOO
// constants are not actually status objects, but code objects. This way we can
// ensure the macros work with both real status objects and literals.
-pw::Status MakeStatus(pw::Status status) { return status; }
-TEST_F(AssertPass, Constant) { PW_CHECK_OK(pw::Status::OK); }
-TEST_F(AssertPass, Dynamic) { PW_CHECK_OK(MakeStatus(pw::Status::OK)); }
+TEST_F(AssertPass, Function) { PW_CHECK_OK(pw::Status::Ok()); }
TEST_F(AssertPass, Enum) { PW_CHECK_OK(PW_STATUS_OK); }
-TEST_F(AssertFail, Constant) { PW_CHECK_OK(pw::Status::UNKNOWN); }
-TEST_F(AssertFail, Dynamic) { PW_CHECK_OK(MakeStatus(pw::Status::UNKNOWN)); }
+TEST_F(AssertFail, Function) { PW_CHECK_OK(pw::Status::Unknown()); }
TEST_F(AssertFail, Enum) { PW_CHECK_OK(PW_STATUS_UNKNOWN); }
#if PW_ASSERT_ENABLE_DEBUG
// In debug mode, the asserts should check their arguments.
-TEST_F(AssertPass, DCheckConstant) { PW_DCHECK_OK(pw::Status::OK); }
-TEST_F(AssertPass, DCheckDynamic) { PW_DCHECK_OK(MakeStatus(pw::Status::OK)); }
-TEST_F(AssertFail, DCheckConstant) { PW_DCHECK_OK(pw::Status::UNKNOWN); }
-TEST_F(AssertFail, DCheckDynamic) {
- PW_DCHECK_OK(MakeStatus(pw::Status::UNKNOWN));
-}
+TEST_F(AssertPass, DCheckFunction) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckEnum) { PW_DCHECK_OK(PW_STATUS_OK); }
+TEST_F(AssertFail, DCheckFunction) { PW_DCHECK_OK(pw::Status::Unknown()); }
+TEST_F(AssertFail, DCheckEnum) { PW_DCHECK_OK(PW_STATUS_UNKNOWN); }
#else // PW_ASSERT_ENABLE_DEBUG
// In release mode, all the asserts should pass.
-TEST_F(AssertPass, DCheckConstant) { PW_DCHECK_OK(pw::Status::OK); }
-TEST_F(AssertPass, DCheckDynamic) { PW_DCHECK_OK(MakeStatus(pw::Status::OK)); }
-TEST_F(AssertPass, DCheckConstant) { PW_DCHECK_OK(pw::Status::UNKNOWN); }
-TEST_F(AssertPass, DCheckDynamic) {
- PW_DCHECK_OK(MakeStatus(pw::Status::UNKNOWN));
-}
+TEST_F(AssertPass, DCheckFunction_Ok) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckEnum_Ok) { PW_DCHECK_OK(PW_STATUS_OK); }
+TEST_F(AssertPass, DCheckFunction_Err) { PW_DCHECK_OK(pw::Status::Unknown()); }
+TEST_F(AssertPass, DCheckEnum_Err) { PW_DCHECK_OK(PW_STATUS_UNKNOWN); }
#endif // PW_ASSERT_ENABLE_DEBUG
// TODO: Figure out how to run some of these tests is C.
diff --git a/pw_blob_store/blob_store.cc b/pw_blob_store/blob_store.cc
index 96a40f8..5e1f543 100644
--- a/pw_blob_store/blob_store.cc
+++ b/pw_blob_store/blob_store.cc
@@ -23,7 +23,7 @@
Status BlobStore::Init() {
if (initialized_) {
- return Status::OK;
+ return Status::Ok();
}
PW_LOG_INFO("Init BlobStore");
@@ -46,7 +46,7 @@
PW_LOG_DEBUG("BlobStore init - Have valid blob of %u bytes",
static_cast<unsigned>(write_address_));
- return Status::OK;
+ return Status::Ok();
}
// No saved blob, check for flash being erased.
@@ -61,36 +61,36 @@
} else {
PW_LOG_DEBUG("BlobStore init - not erased");
}
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::LoadMetadata() {
if (!kvs_.Get(MetadataKey(), &metadata_).ok()) {
// If no metadata was read, make sure the metadata is reset.
metadata_.reset();
- return Status::NOT_FOUND;
+ return Status::NotFound();
}
if (!ValidateChecksum().ok()) {
PW_LOG_ERROR("BlobStore init - Invalidating blob with invalid checksum");
Invalidate();
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
- return Status::OK;
+ return Status::Ok();
}
size_t BlobStore::MaxDataSizeBytes() const { return partition_.size_bytes(); }
Status BlobStore::OpenWrite() {
if (!initialized_) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
// Writer can only be opened if there are no other writer or readers already
// open.
if (writer_open_ || readers_open_ != 0) {
- return Status::UNAVAILABLE;
+ return Status::Unavailable();
}
PW_LOG_DEBUG("Blob writer open");
@@ -99,28 +99,28 @@
Invalidate();
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::OpenRead() {
if (!initialized_) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
// Reader can only be opened if there is no writer open.
if (writer_open_) {
- return Status::UNAVAILABLE;
+ return Status::Unavailable();
}
if (!ValidToRead()) {
PW_LOG_ERROR("Blob reader unable open without valid data");
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
PW_LOG_DEBUG("Blob reader open");
readers_open_++;
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::CloseWrite() {
@@ -128,11 +128,11 @@
// If not valid to write, there was data loss and the close will result in a
// not valid blob. Don't need to flush any write buffered bytes.
if (!ValidToWrite()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (write_address_ == 0) {
- return Status::OK;
+ return Status::Ok();
}
PW_LOG_DEBUG(
@@ -164,14 +164,14 @@
if (!ValidateChecksum().ok()) {
Invalidate();
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (!kvs_.Put(MetadataKey(), metadata_).ok()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
- return Status::OK;
+ return Status::Ok();
};
const Status status = do_close_write();
@@ -179,36 +179,36 @@
if (!status.ok()) {
valid_data_ = false;
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::CloseRead() {
PW_CHECK_UINT_GT(readers_open_, 0);
readers_open_--;
PW_LOG_DEBUG("Blob reader close");
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::Write(ConstByteSpan data) {
if (!ValidToWrite()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (data.size_bytes() == 0) {
- return Status::OK;
+ return Status::Ok();
}
if (WriteBytesRemaining() == 0) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
if (WriteBytesRemaining() < data.size_bytes()) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
Status status = EraseIfNeeded();
// TODO: switch to TRY once available.
if (!status.ok()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
// Write in (up to) 3 steps:
@@ -242,14 +242,14 @@
// If there was not enough bytes to finish filling the write buffer, there
// should not be any bytes left.
PW_DCHECK(data.size_bytes() == 0);
- return Status::OK;
+ return Status::Ok();
}
// The write buffer is full, flush to flash.
Status status = CommitToFlash(write_buffer_);
// TODO: switch to TRY once available.
if (!status.ok()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
PW_DCHECK(WriteBufferEmpty());
@@ -267,7 +267,7 @@
Status status = CommitToFlash(data.first(flash_write_size_bytes_));
// TODO: switch to TRY once available.
if (!status.ok()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
data = data.subspan(flash_write_size_bytes_);
@@ -283,18 +283,18 @@
write_address_ += data.size_bytes();
}
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::AddToWriteBuffer(ConstByteSpan data) {
if (!ValidToWrite()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (WriteBytesRemaining() == 0) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
if (WriteBufferBytesFree() < data.size_bytes()) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
size_t bytes_in_buffer = WriteBufferBytesUsed();
@@ -303,15 +303,15 @@
write_buffer_.data() + bytes_in_buffer, data.data(), data.size_bytes());
write_address_ += data.size_bytes();
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::Flush() {
if (!ValidToWrite()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (WriteBufferBytesUsed() == 0) {
- return Status::OK;
+ return Status::Ok();
}
// Don't need to check available space, AddToWriteBuffer() will not enqueue
// more than can be written to flash.
@@ -319,7 +319,7 @@
Status status = EraseIfNeeded();
// TODO: switch to TRY once available.
if (!status.ok()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
ByteSpan data = std::span(write_buffer_.data(), WriteBufferBytesUsed());
@@ -327,7 +327,7 @@
Status status = CommitToFlash(data.first(flash_write_size_bytes_));
// TODO: switch to TRY once available.
if (!status.ok()) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
data = data.subspan(flash_write_size_bytes_);
@@ -345,7 +345,7 @@
PW_DCHECK_UINT_EQ(data.size_bytes(), 0);
}
- return Status::OK;
+ return Status::Ok();
}
Status BlobStore::FlushFinalPartialChunk() {
@@ -406,15 +406,15 @@
// Always just erase. Erase is smart enough to only erase if needed.
return Erase();
}
- return Status::OK;
+ return Status::Ok();
}
StatusWithSize BlobStore::Read(size_t offset, ByteSpan dest) const {
if (!ValidToRead()) {
- return StatusWithSize::FAILED_PRECONDITION;
+ return StatusWithSize::FailedPrecondition();
}
if (offset >= ReadableDataBytes()) {
- return StatusWithSize::OUT_OF_RANGE;
+ return StatusWithSize::OutOfRange();
}
size_t available_bytes = ReadableDataBytes() - offset;
@@ -425,12 +425,12 @@
Result<ConstByteSpan> BlobStore::GetMemoryMappedBlob() const {
if (!ValidToRead()) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
std::byte* mcu_address = partition_.PartitionAddressToMcuAddress(0);
if (mcu_address == nullptr) {
- return Status::UNIMPLEMENTED;
+ return Status::Unimplemented();
}
return ConstByteSpan(mcu_address, ReadableDataBytes());
}
@@ -451,7 +451,7 @@
// Erased blobs should be valid as soon as the flash is erased. Even though
// there are 0 bytes written, they are valid.
PW_DCHECK(valid_data_);
- return Status::OK;
+ return Status::Ok();
}
Invalidate();
@@ -480,25 +480,25 @@
Status status = kvs_.Delete(MetadataKey());
- return (status == Status::OK || status == Status::NOT_FOUND)
- ? Status::OK
- : Status::INTERNAL;
+ return (status == Status::Ok() || status == Status::NotFound())
+ ? Status::Ok()
+ : Status::Internal();
}
Status BlobStore::ValidateChecksum() {
if (metadata_.data_size_bytes == 0) {
PW_LOG_INFO("Blob unable to validate checksum of an empty blob");
- return Status::UNAVAILABLE;
+ return Status::Unavailable();
}
if (checksum_algo_ == nullptr) {
if (metadata_.checksum != 0) {
PW_LOG_ERROR(
"Blob invalid to have a checkum value with no checksum algo");
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
- return Status::OK;
+ return Status::Ok();
}
PW_LOG_DEBUG("Validate checksum of 0x%08x in flash for blob of %u bytes",
@@ -515,7 +515,7 @@
Status BlobStore::CalculateChecksumFromFlash(size_t bytes_to_check) {
if (checksum_algo_ == nullptr) {
- return Status::OK;
+ return Status::Ok();
}
checksum_algo_->Reset();
@@ -536,7 +536,7 @@
// Safe to ignore the return from Finish, checksum_algo_ keeps the state
// information that it needs.
checksum_algo_->Finish();
- return Status::OK;
+ return Status::Ok();
}
} // namespace pw::blob_store
diff --git a/pw_blob_store/blob_store_chunk_write_test.cc b/pw_blob_store/blob_store_chunk_write_test.cc
index ccbd26d..cf7219d 100644
--- a/pw_blob_store/blob_store_chunk_write_test.cc
+++ b/pw_blob_store/blob_store_chunk_write_test.cc
@@ -60,11 +60,11 @@
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::OK, writer.Open());
- EXPECT_EQ(Status::OK, writer.Erase());
+ EXPECT_EQ(Status::Ok(), writer.Open());
+ EXPECT_EQ(Status::Ok(), writer.Erase());
ByteSpan source = source_buffer_;
while (source.size_bytes() > 0) {
@@ -74,20 +74,20 @@
static_cast<unsigned>(write_size),
static_cast<unsigned>(source.size_bytes()));
- ASSERT_EQ(Status::OK, writer.Write(source.first(write_size)));
+ ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
source = source.subspan(write_size);
}
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(Status::Ok(), writer.Close());
// Use reader to check for valid data.
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::OK, reader.Open());
+ ASSERT_EQ(Status::Ok(), reader.Open());
Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
ASSERT_TRUE(result.ok());
VerifyFlash(result.value());
- EXPECT_EQ(Status::OK, reader.Close());
+ EXPECT_EQ(Status::Ok(), reader.Close());
}
void VerifyFlash(ConstByteSpan verify_bytes) {
diff --git a/pw_blob_store/blob_store_deferred_write_test.cc b/pw_blob_store/blob_store_deferred_write_test.cc
index 4f3d581..71996e1 100644
--- a/pw_blob_store/blob_store_deferred_write_test.cc
+++ b/pw_blob_store/blob_store_deferred_write_test.cc
@@ -63,10 +63,10 @@
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kWriteSize);
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
BlobStore::DeferredWriter writer(blob);
- EXPECT_EQ(Status::OK, writer.Open());
+ EXPECT_EQ(Status::Ok(), writer.Open());
ByteSpan source = buffer_;
while (source.size_bytes() > 0) {
@@ -76,7 +76,7 @@
static_cast<unsigned>(write_size),
static_cast<unsigned>(source.size_bytes()));
- ASSERT_EQ(Status::OK, writer.Write(source.first(write_size)));
+ ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
// TODO: Add check that the write did not go to flash yet.
source = source.subspan(write_size);
@@ -84,19 +84,19 @@
if (bytes_since_flush >= flush_interval) {
bytes_since_flush = 0;
- ASSERT_EQ(Status::OK, writer.Flush());
+ ASSERT_EQ(Status::Ok(), writer.Flush());
}
}
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(Status::Ok(), writer.Close());
// Use reader to check for valid data.
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::OK, reader.Open());
+ ASSERT_EQ(Status::Ok(), reader.Open());
Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
ASSERT_TRUE(result.ok());
VerifyFlash(result.value());
- EXPECT_EQ(Status::OK, reader.Close());
+ EXPECT_EQ(Status::Ok(), reader.Close());
}
void VerifyFlash(ConstByteSpan verify_bytes) {
diff --git a/pw_blob_store/blob_store_test.cc b/pw_blob_store/blob_store_test.cc
index d21bd9d..880c516 100644
--- a/pw_blob_store/blob_store_test.cc
+++ b/pw_blob_store/blob_store_test.cc
@@ -61,21 +61,21 @@
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::OK, writer.Open());
- EXPECT_EQ(Status::OK, writer.Erase());
- ASSERT_EQ(Status::OK, writer.Write(source_buffer_));
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(Status::Ok(), writer.Open());
+ EXPECT_EQ(Status::Ok(), writer.Erase());
+ ASSERT_EQ(Status::Ok(), writer.Write(source_buffer_));
+ EXPECT_EQ(Status::Ok(), writer.Close());
// Use reader to check for valid data.
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::OK, reader.Open());
+ ASSERT_EQ(Status::Ok(), reader.Open());
Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
ASSERT_TRUE(result.ok());
VerifyFlash(result.value());
- EXPECT_EQ(Status::OK, reader.Close());
+ EXPECT_EQ(Status::Ok(), reader.Close());
}
// Open a new blob instance and read the blob using the given read chunk size.
@@ -86,18 +86,18 @@
char name[16] = "TestBlobBlock";
BlobStoreBuffer<16> blob(name, partition_, &checksum, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
// Use reader to check for valid data.
BlobStore::BlobReader reader1(blob);
- ASSERT_EQ(Status::OK, reader1.Open());
+ ASSERT_EQ(Status::Ok(), reader1.Open());
Result<ConstByteSpan> result = reader1.GetMemoryMappedBlob();
ASSERT_TRUE(result.ok());
VerifyFlash(result.value());
- EXPECT_EQ(Status::OK, reader1.Close());
+ EXPECT_EQ(Status::Ok(), reader1.Close());
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::OK, reader.Open());
+ ASSERT_EQ(Status::Ok(), reader.Open());
std::array<std::byte, kBlobDataSize> read_buffer_;
@@ -111,10 +111,10 @@
ASSERT_EQ(read_span.size_bytes(), reader.ConservativeReadLimit());
auto result = reader.Read(read_span.first(read_size));
- ASSERT_EQ(result.status(), Status::OK);
+ ASSERT_EQ(result.status(), Status::Ok());
read_span = read_span.subspan(read_size);
}
- EXPECT_EQ(Status::OK, reader.Close());
+ EXPECT_EQ(Status::Ok(), reader.Close());
VerifyFlash(read_buffer_);
}
@@ -143,7 +143,7 @@
TEST_F(BlobStoreTest, Init_Ok) {
BlobStoreBuffer<256> blob("Blob_OK", partition_, nullptr, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
}
TEST_F(BlobStoreTest, Discard) {
@@ -153,24 +153,24 @@
kvs::ChecksumCrc16 checksum;
BlobStoreBuffer<256> blob(
"TestBlobBlock", partition_, &checksum, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::OK, writer.Open());
- EXPECT_EQ(Status::OK, writer.Discard());
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(Status::Ok(), writer.Open());
+ EXPECT_EQ(Status::Ok(), writer.Discard());
+ EXPECT_EQ(Status::Ok(), writer.Close());
}
TEST_F(BlobStoreTest, MultipleErase) {
BlobStoreBuffer<256> blob("Blob_OK", partition_, nullptr, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::OK, writer.Open());
+ EXPECT_EQ(Status::Ok(), writer.Open());
- EXPECT_EQ(Status::OK, writer.Erase());
- EXPECT_EQ(Status::OK, writer.Erase());
- EXPECT_EQ(Status::OK, writer.Erase());
+ EXPECT_EQ(Status::Ok(), writer.Erase());
+ EXPECT_EQ(Status::Ok(), writer.Erase());
+ EXPECT_EQ(Status::Ok(), writer.Erase());
}
TEST_F(BlobStoreTest, OffsetRead) {
@@ -184,17 +184,17 @@
char name[16] = "TestBlobBlock";
BlobStoreBuffer<16> blob(name, partition_, &checksum, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::OK, reader.Open(kOffset));
+ ASSERT_EQ(Status::Ok(), reader.Open(kOffset));
std::array<std::byte, kBlobDataSize - kOffset> read_buffer_;
ByteSpan read_span = read_buffer_;
ASSERT_EQ(read_span.size_bytes(), reader.ConservativeReadLimit());
auto result = reader.Read(read_span);
- ASSERT_EQ(result.status(), Status::OK);
- EXPECT_EQ(Status::OK, reader.Close());
+ ASSERT_EQ(result.status(), Status::Ok());
+ EXPECT_EQ(Status::Ok(), reader.Close());
VerifyFlash(read_buffer_, kOffset);
}
@@ -208,9 +208,9 @@
char name[16] = "TestBlobBlock";
BlobStoreBuffer<16> blob(name, partition_, &checksum, kvs::TestKvs());
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(Status::Ok(), blob.Init());
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::INVALID_ARGUMENT, reader.Open(kOffset));
+ ASSERT_EQ(Status::InvalidArgument(), reader.Open(kOffset));
}
TEST_F(BlobStoreTest, ChunkRead1) {
diff --git a/pw_blob_store/public/pw_blob_store/blob_store.h b/pw_blob_store/public/pw_blob_store/blob_store.h
index 1fd5263..e8b1db0 100644
--- a/pw_blob_store/public/pw_blob_store/blob_store.h
+++ b/pw_blob_store/public/pw_blob_store/blob_store.h
@@ -200,10 +200,10 @@
Status Open(size_t offset = 0) {
PW_DCHECK(!open_);
if (!store_.ValidToRead()) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
if (offset >= store_.ReadableDataBytes()) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
offset_ = offset;
diff --git a/pw_bytes/byte_builder.cc b/pw_bytes/byte_builder.cc
index bcfc9de..ba01c0f 100644
--- a/pw_bytes/byte_builder.cc
+++ b/pw_bytes/byte_builder.cc
@@ -34,21 +34,21 @@
}
if (bytes_to_append > max_size() - size()) {
- status_ = Status::RESOURCE_EXHAUSTED;
+ status_ = Status::ResourceExhausted();
return 0;
}
size_ += bytes_to_append;
- status_ = Status::OK;
+ status_ = Status::Ok();
return bytes_to_append;
}
void ByteBuilder::resize(size_t new_size) {
if (new_size <= size_) {
size_ = new_size;
- status_ = Status::OK;
+ status_ = Status::Ok();
} else {
- status_ = Status::OUT_OF_RANGE;
+ status_ = Status::OutOfRange();
}
}
diff --git a/pw_bytes/byte_builder_test.cc b/pw_bytes/byte_builder_test.cc
index 2f81de7..d1d1e7b 100644
--- a/pw_bytes/byte_builder_test.cc
+++ b/pw_bytes/byte_builder_test.cc
@@ -99,7 +99,7 @@
constexpr auto kBytesTestLiteral = MakeBytes(0x04, 0x05, 0x06, 0x07);
EXPECT_FALSE(bb.append(kBytesTestLiteral.data(), 4).ok());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
EXPECT_EQ(0u, bb.size());
}
@@ -129,7 +129,7 @@
TEST(ByteBuilder, Append_Bytes_Exhausted) {
ByteBuffer<8> bb;
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.append(9, byte{0x04}).status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.append(9, byte{0x04}).status());
EXPECT_EQ(0u, bb.size());
}
@@ -156,7 +156,7 @@
ByteBuilder bb(buffer);
bb.resize(1);
- EXPECT_EQ(Status::OUT_OF_RANGE, bb.append(9, byte{0x04}).status());
+ EXPECT_EQ(Status::OutOfRange(), bb.append(9, byte{0x04}).status());
}
TEST(ByteBuilder, Resize_Smaller) {
@@ -192,12 +192,12 @@
EXPECT_EQ(3u, bb.size());
bb.resize(5);
EXPECT_EQ(3u, bb.size());
- EXPECT_EQ(bb.status(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(bb.status(), Status::OutOfRange());
}
TEST(ByteBuilder, Status_StartsOk) {
ByteBuffer<16> bb;
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
}
TEST(ByteBuilder, Status_StatusUpdate) {
@@ -205,13 +205,13 @@
ByteBuffer<2> bb;
EXPECT_FALSE(bb.append(buffer).ok());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
bb.resize(4);
- EXPECT_EQ(Status::OUT_OF_RANGE, bb.status());
+ EXPECT_EQ(Status::OutOfRange(), bb.status());
EXPECT_FALSE(bb.append(buffer.data(), 0).ok());
- EXPECT_EQ(Status::OUT_OF_RANGE, bb.status());
+ EXPECT_EQ(Status::OutOfRange(), bb.status());
}
TEST(ByteBuilder, Status_ClearStatus_SetsStatusToOk) {
@@ -219,16 +219,16 @@
ByteBuffer<2> bb;
EXPECT_FALSE(bb.append(buffer).ok());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
bb.clear_status();
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
}
TEST(ByteBuilder, PushBack) {
ByteBuffer<12> bb;
bb.push_back(byte{0x01});
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
EXPECT_EQ(1u, bb.size());
EXPECT_EQ(byte{0x01}, bb.data()[0]);
}
@@ -236,7 +236,7 @@
TEST(ByteBuilder, PushBack_Full) {
ByteBuffer<1> bb;
bb.push_back(byte{0x01});
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
EXPECT_EQ(1u, bb.size());
}
@@ -245,7 +245,7 @@
bb.push_back(byte{0x01});
bb.push_back(byte{0x01});
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
EXPECT_EQ(1u, bb.size());
}
@@ -256,7 +256,7 @@
bb.append(buffer.data(), 3);
bb.pop_back();
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
EXPECT_EQ(2u, bb.size());
EXPECT_EQ(byte{0x01}, bb.data()[0]);
EXPECT_EQ(byte{0x02}, bb.data()[1]);
@@ -270,7 +270,7 @@
bb.pop_back();
bb.pop_back();
bb.pop_back();
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
EXPECT_EQ(0u, bb.size());
EXPECT_TRUE(bb.empty());
}
@@ -306,13 +306,13 @@
two.push_back(byte{0x01});
two.push_back(byte{0x01});
two.push_back(byte{0x01});
- ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
+ ASSERT_EQ(Status::ResourceExhausted(), two.status());
one = two;
EXPECT_EQ(byte{0x01}, two.data()[7]);
EXPECT_EQ(byte{0x01}, two.data()[8]);
EXPECT_EQ(byte{0x01}, two.data()[9]);
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, one.status());
+ EXPECT_EQ(Status::ResourceExhausted(), one.status());
}
TEST(ByteBuffer, CopyConstructFromSameSize) {
@@ -338,7 +338,7 @@
EXPECT_EQ(byte{0x01}, two.data()[0]);
EXPECT_EQ(byte{0x02}, two.data()[1]);
- EXPECT_EQ(Status::OK, two.status());
+ EXPECT_EQ(Status::Ok(), two.status());
}
TEST(ByteBuilder, ResizeError_NoDataAddedAfter) {
@@ -350,11 +350,11 @@
EXPECT_EQ(3u, bb.size());
bb.resize(5);
EXPECT_EQ(3u, bb.size());
- EXPECT_EQ(bb.status(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(bb.status(), Status::OutOfRange());
bb.PutInt8(0xFE);
EXPECT_EQ(3u, bb.size());
- EXPECT_EQ(bb.status(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(bb.status(), Status::OutOfRange());
}
TEST(ByteBuilder, AddingNoBytesToZeroSizedByteBuffer) {
@@ -372,7 +372,7 @@
EXPECT_EQ(byte{0xFE}, bb.data()[0]);
EXPECT_EQ(byte{0x02}, bb.data()[1]);
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
}
TEST(ByteBuffer, Putting8ByteInts_Exhausted) {
@@ -383,7 +383,7 @@
EXPECT_EQ(byte{0xFE}, bb.data()[0]);
EXPECT_EQ(byte{0x02}, bb.data()[1]);
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
}
TEST(ByteBuffer, Putting16ByteInts_Full_kLittleEndian) {
@@ -396,7 +396,7 @@
EXPECT_EQ(byte{0x08}, bb.data()[2]);
EXPECT_EQ(byte{0x00}, bb.data()[3]);
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
}
TEST(ByteBuffer, Putting16ByteInts_Exhausted_kBigEndian) {
@@ -411,7 +411,7 @@
bb.PutInt16(0xFAFA, std::endian::big);
EXPECT_EQ(4u, bb.size());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
}
TEST(ByteBuffer, Putting32ByteInts_Full_kLittleEndian) {
@@ -428,7 +428,7 @@
EXPECT_EQ(byte{0x00}, bb.data()[6]);
EXPECT_EQ(byte{0x00}, bb.data()[7]);
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
}
TEST(ByteBuffer, Putting32ByteInts_Exhausted_kBigEndian) {
@@ -447,7 +447,7 @@
bb.PutInt32(-114743374, std::endian::big);
EXPECT_EQ(8u, bb.size());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
}
TEST(ByteBuffer, Putting64ByteInts_Full_kLittleEndian) {
@@ -472,7 +472,7 @@
EXPECT_EQ(byte{0xFF}, bb.data()[14]);
EXPECT_EQ(byte{0xFF}, bb.data()[15]);
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
}
TEST(ByteBuffer, Putting64ByteInts_Exhausted_kBigEndian) {
@@ -499,7 +499,7 @@
bb.PutInt64(-6099875637501324530, std::endian::big);
EXPECT_EQ(16u, bb.size());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, bb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), bb.status());
}
TEST(ByteBuffer, PuttingInts_MixedTypes_MixedEndian) {
@@ -527,7 +527,7 @@
EXPECT_EQ(byte{0x17}, bb.data()[14]);
EXPECT_EQ(byte{0xFB}, bb.data()[15]);
- EXPECT_EQ(Status::OK, bb.status());
+ EXPECT_EQ(Status::Ok(), bb.status());
}
TEST(ByteBuffer, Iterator) {
diff --git a/pw_bytes/public/pw_bytes/byte_builder.h b/pw_bytes/public/pw_bytes/byte_builder.h
index 70c0876..f046cb0 100644
--- a/pw_bytes/public/pw_bytes/byte_builder.h
+++ b/pw_bytes/public/pw_bytes/byte_builder.h
@@ -228,7 +228,7 @@
return StatusWithSize(status_, size_);
}
- // True if status() is Status::OK.
+ // True if status() is Status::Ok().
bool ok() const { return status_.ok(); }
// True if the bytes builder is empty.
@@ -243,11 +243,11 @@
// Clears the bytes and resets its error state.
void clear() {
size_ = 0;
- status_ = Status::OK;
+ status_ = Status::Ok();
};
- // Sets the statuses to Status::OK;
- void clear_status() { status_ = Status::OK; }
+ // Sets the statuses to Status::Ok();
+ void clear_status() { status_ = Status::Ok(); }
// Appends a single byte. Sets the status to RESOURCE_EXHAUSTED if the
// byte cannot be added because the buffer is full.
diff --git a/pw_cpu_exception_armv7m/proto_dump.cc b/pw_cpu_exception_armv7m/proto_dump.cc
index 894b2c0..086652d 100644
--- a/pw_cpu_exception_armv7m/proto_dump.cc
+++ b/pw_cpu_exception_armv7m/proto_dump.cc
@@ -55,10 +55,10 @@
// reflected here.
Status status = state_encoder.WriteR12(cpu_state.base.r12);
if (!status.ok()) {
- return status == Status::RESOURCE_EXHAUSTED ? Status::RESOURCE_EXHAUSTED
- : Status::UNKNOWN;
+ return status == Status::ResourceExhausted() ? Status::ResourceExhausted()
+ : Status::Unknown();
}
- return Status::OK;
+ return Status::Ok();
}
} // namespace pw::cpu_exception
diff --git a/pw_hdlc_lite/decoder.cc b/pw_hdlc_lite/decoder.cc
index 37c0023..fc96824 100644
--- a/pw_hdlc_lite/decoder.cc
+++ b/pw_hdlc_lite/decoder.cc
@@ -38,13 +38,13 @@
// Report an error if non-flag bytes were read between frames.
if (current_frame_size_ != 0u) {
current_frame_size_ = 0;
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
} else {
// Count bytes to track how many are discarded.
current_frame_size_ += 1;
}
- return Status::UNAVAILABLE; // Report error when starting a new frame.
+ return Status::Unavailable(); // Report error when starting a new frame.
}
case State::kFrame: {
if (new_byte == kFlag) {
@@ -65,14 +65,14 @@
} else {
AppendByte(new_byte);
}
- return Status::UNAVAILABLE;
+ return Status::Unavailable();
}
case State::kFrameEscape: {
// The flag character cannot be escaped; return an error.
if (new_byte == kFlag) {
state_ = State::kFrame;
current_frame_size_ = 0;
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (new_byte == kEscape) {
@@ -86,7 +86,7 @@
state_ = State::kFrame;
AppendByte(new_byte ^ kUnescapeConstant);
}
- return Status::UNAVAILABLE;
+ return Status::Unavailable();
}
}
PW_CRASH("Bad decoder state");
@@ -104,28 +104,28 @@
Status Decoder::CheckFrame() const {
// Empty frames are not an error; repeated flag characters are okay.
if (current_frame_size_ == 0u) {
- return Status::UNAVAILABLE;
+ return Status::Unavailable();
}
if (current_frame_size_ < Frame::kMinSizeBytes) {
PW_LOG_ERROR("Received %lu-byte frame; frame must be at least 6 bytes",
static_cast<unsigned long>(current_frame_size_));
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (current_frame_size_ > max_size()) {
PW_LOG_ERROR("Frame size [%lu] exceeds the maximum buffer size [%lu]",
static_cast<unsigned long>(current_frame_size_),
static_cast<unsigned long>(max_size()));
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
if (!VerifyFrameCheckSequence()) {
PW_LOG_ERROR("Frame check sequence verification failed");
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
- return Status::OK;
+ return Status::Ok();
}
bool Decoder::VerifyFrameCheckSequence() const {
diff --git a/pw_hdlc_lite/decoder_test.cc b/pw_hdlc_lite/decoder_test.cc
index 787fbf1..b8400e2 100644
--- a/pw_hdlc_lite/decoder_test.cc
+++ b/pw_hdlc_lite/decoder_test.cc
@@ -46,23 +46,23 @@
[](const Result<Frame>&) { FAIL(); });
decoder.clear();
- Status status = Status::UNKNOWN;
+ Status status = Status::Unknown();
decoder.Process(
bytes::String("~1234\xa3\xe0\xe3\x9b~"),
[&status](const Result<Frame>& result) { status = result.status(); });
- EXPECT_EQ(Status::OK, status);
+ EXPECT_EQ(Status::Ok(), status);
}
TEST(Decoder, ExactFit) {
DecoderBuffer<8> decoder;
for (byte b : bytes::String("~1234\xa3\xe0\xe3\x9b")) {
- EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+ EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
auto result = decoder.Process(kFlag);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
ASSERT_EQ(result.value().data().size(), 2u);
ASSERT_EQ(result.value().data()[0], byte{'3'});
ASSERT_EQ(result.value().data()[1], byte{'4'});
@@ -72,11 +72,11 @@
DecoderBuffer<6> decoder;
for (byte b : bytes::String("~12\xcd\x44\x53\x4f")) {
- EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+ EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
auto result = decoder.Process(kFlag);
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(Status::Ok(), result.status());
EXPECT_EQ(result.value().data().size(), 0u);
}
@@ -84,14 +84,14 @@
DecoderBuffer<8> decoder;
for (byte b : bytes::String("~123456789")) {
- EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+ EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+ EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
for (byte b : bytes::String("~123456789012345678901234567890")) {
- EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+ EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+ EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
}
TEST(Decoder, TooLargeForBuffer_StaysWithinBufferBoundaries) {
@@ -100,28 +100,28 @@
Decoder decoder(std::span(buffer.data(), 8));
for (byte b : bytes::String("~1234567890123456789012345678901234567890")) {
- EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+ EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
for (size_t i = 8; i < buffer.size(); ++i) {
ASSERT_EQ(byte{'?'}, buffer[i]);
}
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+ EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
}
TEST(Decoder, TooLargeForBuffer_DecodesNextFrame) {
DecoderBuffer<8> decoder;
for (byte b : bytes::String("~123456789012345678901234567890")) {
- EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+ EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, decoder.Process(kFlag).status());
+ EXPECT_EQ(Status::ResourceExhausted(), decoder.Process(kFlag).status());
for (byte b : bytes::String("1234\xa3\xe0\xe3\x9b")) {
- EXPECT_EQ(Status::UNAVAILABLE, decoder.Process(b).status());
+ EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
- EXPECT_EQ(Status::OK, decoder.Process(kFlag).status());
+ EXPECT_EQ(Status::Ok(), decoder.Process(kFlag).status());
}
} // namespace
diff --git a/pw_hdlc_lite/encoder.cc b/pw_hdlc_lite/encoder.cc
index dde2556..4a785ee 100644
--- a/pw_hdlc_lite/encoder.cc
+++ b/pw_hdlc_lite/encoder.cc
@@ -83,7 +83,7 @@
}
if (end == data.end()) {
fcs_.Update(data);
- return Status::OK;
+ return Status::Ok();
}
if (Status status = EscapeAndWrite(*end, writer_); !status.ok()) {
return status;
diff --git a/pw_hdlc_lite/encoder_test.cc b/pw_hdlc_lite/encoder_test.cc
index 0321c86..72a66ce 100644
--- a/pw_hdlc_lite/encoder_test.cc
+++ b/pw_hdlc_lite/encoder_test.cc
@@ -50,21 +50,21 @@
} while (0)
TEST_F(WriteInfoFrame, EmptyPayload) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(kAddress, std::span<byte>(), writer_));
EXPECT_ENCODER_WROTE(
bytes::Concat(kFlag, kAddress, kControl, uint32_t{0x8D12B2C2}, kFlag));
}
TEST_F(WriteInfoFrame, OneBytePayload) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(kAddress, bytes::String("A"), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(
kFlag, kAddress, kControl, 'A', uint32_t{0xA63E2FA5}, kFlag));
}
TEST_F(WriteInfoFrame, OneBytePayload_Escape0x7d) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(kAddress, bytes::Array<0x7d>(), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
kAddress,
@@ -76,7 +76,7 @@
}
TEST_F(WriteInfoFrame, OneBytePayload_Escape0x7E) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(kAddress, bytes::Array<0x7e>(), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
kAddress,
@@ -88,14 +88,14 @@
}
TEST_F(WriteInfoFrame, AddressNeedsEscaping) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(0x7d, bytes::String("A"), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(
kFlag, kEscape, byte{0x5d}, kControl, 'A', uint32_t{0xA2B35317}, kFlag));
}
TEST_F(WriteInfoFrame, Crc32NeedsEscaping) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(kAddress, bytes::String("abcdefg"), writer_));
// The CRC-32 is 0x38B9FC7E, so the 0x7E must be escaped.
@@ -109,9 +109,9 @@
}
TEST_F(WriteInfoFrame, MultiplePayloads) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(kAddress, bytes::String("ABC"), writer_));
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(kAddress, bytes::String("DEF"), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
kAddress,
@@ -128,7 +128,7 @@
}
TEST_F(WriteInfoFrame, PayloadWithNoEscapes) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(
kAddress, bytes::String("123456789012345678901234"), writer_));
@@ -144,7 +144,7 @@
}
TEST_F(WriteInfoFrame, PayloadWithMultipleEscapes) {
- ASSERT_EQ(Status::OK,
+ ASSERT_EQ(Status::Ok(),
WriteInformationFrame(
kAddress,
bytes::Array<0x7E, 0x7B, 0x61, 0x62, 0x63, 0x7D, 0x7E>(),
@@ -162,7 +162,7 @@
TEST_F(WriteInfoFrame, WriterError) {
constexpr auto data = bytes::Initialized<sizeof(buffer_)>(0x7e);
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED,
+ EXPECT_EQ(Status::ResourceExhausted(),
WriteInformationFrame(kAddress, data, writer_));
}
diff --git a/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h b/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h
index 1b88bb5..1e14066 100644
--- a/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h
+++ b/pw_hdlc_lite/public/pw_hdlc_lite/decoder.h
@@ -97,7 +97,7 @@
void Process(ConstByteSpan data, F&& callback, Args&&... args) {
for (std::byte b : data) {
auto result = Process(b);
- if (result.status() != Status::UNAVAILABLE) {
+ if (result.status() != Status::Unavailable()) {
std::invoke(
std::forward<F>(callback), std::forward<Args>(args)..., result);
}
diff --git a/pw_hdlc_lite/rpc_channel_test.cc b/pw_hdlc_lite/rpc_channel_test.cc
index c98d656..7e0d0dd 100644
--- a/pw_hdlc_lite/rpc_channel_test.cc
+++ b/pw_hdlc_lite/rpc_channel_test.cc
@@ -61,7 +61,7 @@
constexpr auto expected = bytes::Concat(
kFlag, kAddress, kControl, 'A', uint32_t{0xA63E2FA5}, kFlag);
- EXPECT_EQ(Status::OK, output.SendAndReleaseBuffer(sizeof(test_data)));
+ EXPECT_EQ(Status::Ok(), output.SendAndReleaseBuffer(sizeof(test_data)));
ASSERT_EQ(memory_writer.bytes_written(), expected.size());
EXPECT_EQ(
@@ -88,7 +88,7 @@
byte{0x7d} ^ byte{0x20},
uint32_t{0x89515322},
kFlag);
- EXPECT_EQ(Status::OK, output.SendAndReleaseBuffer(test_data.size()));
+ EXPECT_EQ(Status::Ok(), output.SendAndReleaseBuffer(test_data.size()));
ASSERT_EQ(memory_writer.bytes_written(), 10u);
EXPECT_EQ(
@@ -109,7 +109,7 @@
constexpr auto expected = bytes::Concat(
kFlag, kAddress, kControl, 'A', uint32_t{0xA63E2FA5}, kFlag);
- EXPECT_EQ(Status::OK, output.SendAndReleaseBuffer(sizeof(test_data)));
+ EXPECT_EQ(Status::Ok(), output.SendAndReleaseBuffer(sizeof(test_data)));
ASSERT_EQ(memory_writer.bytes_written(), expected.size());
EXPECT_EQ(
diff --git a/pw_hex_dump/hex_dump.cc b/pw_hex_dump/hex_dump.cc
index fef1a90..ae979df 100644
--- a/pw_hex_dump/hex_dump.cc
+++ b/pw_hex_dump/hex_dump.cc
@@ -48,11 +48,11 @@
Status DumpAddr(std::span<char> dest, uintptr_t addr) {
if (dest.data() == nullptr) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
// Include null terminator.
if (dest.size() < kHexAddrStringSize + 1) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
dest[0] = '0';
dest[1] = 'x';
@@ -123,11 +123,11 @@
Status FormattedHexDumper::DumpLine() {
if (source_data_.empty()) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
if (!ValidateBufferSize().ok() || dest_.data() == nullptr) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
if (dest_[0] == 0 && flags.show_header) {
@@ -212,22 +212,23 @@
Status FormattedHexDumper::SetLineBuffer(std::span<char> dest) {
if (dest.data() == nullptr || dest.size_bytes() == 0) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
dest_ = dest;
- return ValidateBufferSize().ok() ? Status::OK : Status::RESOURCE_EXHAUSTED;
+ return ValidateBufferSize().ok() ? Status::Ok() : Status::ResourceExhausted();
}
Status FormattedHexDumper::BeginDump(ConstByteSpan data) {
current_offset_ = 0;
source_data_ = data;
if (data.data() == nullptr) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
if (dest_.data() != nullptr && dest_.size_bytes() > 0) {
dest_[0] = 0;
}
- return ValidateBufferSize().ok() ? Status::OK : Status::FAILED_PRECONDITION;
+ return ValidateBufferSize().ok() ? Status::Ok()
+ : Status::FailedPrecondition();
}
Status FormattedHexDumper::ValidateBufferSize() {
@@ -250,10 +251,10 @@
}
if (dest_.size_bytes() < required_size) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
- return Status::OK;
+ return Status::Ok();
}
} // namespace pw::dump
diff --git a/pw_hex_dump/hex_dump_test.cc b/pw_hex_dump/hex_dump_test.cc
index 51ad7fa..1b10251 100644
--- a/pw_hex_dump/hex_dump_test.cc
+++ b/pw_hex_dump/hex_dump_test.cc
@@ -100,7 +100,7 @@
TEST_F(HexDump, DumpAddr_ZeroSizeT) {
constexpr const char* expected = EXPECTED_SIGNIFICANT_BYTES("00000000");
size_t zero = 0;
- EXPECT_EQ(DumpAddr(dest_, zero), Status::OK);
+ EXPECT_EQ(DumpAddr(dest_, zero), Status::Ok());
EXPECT_STREQ(expected, dest_.data());
}
@@ -156,7 +156,7 @@
for (size_t i = 0; i < source_data.size(); i += kTestBytesPerLine) {
EXPECT_TRUE(dumper_.DumpLine().ok());
}
- EXPECT_EQ(dumper_.DumpLine(), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(dumper_.DumpLine(), Status::ResourceExhausted());
}
// This test is provided for convenience of debugging, as it actually logs the
@@ -172,7 +172,7 @@
while (dumper_.DumpLine().ok()) {
PW_LOG_INFO("%s", dest_.data());
}
- EXPECT_EQ(dumper_.DumpLine(), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(dumper_.DumpLine(), Status::ResourceExhausted());
}
TEST_F(HexDump, FormattedHexDump_NoSpaces) {
@@ -351,7 +351,7 @@
default_flags_.bytes_per_line = 13;
dumper_ = FormattedHexDumper(dest_, default_flags_);
- EXPECT_EQ(dumper_.BeginDump(source_data), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(dumper_.BeginDump(source_data), Status::FailedPrecondition());
EXPECT_FALSE(dumper_.DumpLine().ok());
EXPECT_STREQ(expected, dest_.data());
}
@@ -363,7 +363,7 @@
default_flags_.group_every = 1;
dumper_ = FormattedHexDumper(dest_, default_flags_);
- EXPECT_EQ(dumper_.BeginDump(source_data), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(dumper_.BeginDump(source_data), Status::FailedPrecondition());
EXPECT_FALSE(dumper_.DumpLine().ok());
EXPECT_STREQ(expected, dest_.data());
}
@@ -375,7 +375,7 @@
default_flags_.prefix_mode = FormattedHexDumper::AddressMode::kOffset;
dumper_ = FormattedHexDumper(dest_, default_flags_);
- EXPECT_EQ(dumper_.BeginDump(source_data), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(dumper_.BeginDump(source_data), Status::FailedPrecondition());
EXPECT_FALSE(dumper_.DumpLine().ok());
EXPECT_STREQ(expected, dest_.data());
}
@@ -383,22 +383,22 @@
TEST(BadBuffer, ZeroSize) {
char buffer[1] = {static_cast<char>(0xaf)};
FormattedHexDumper dumper(std::span<char>(buffer, 0));
- EXPECT_EQ(dumper.BeginDump(source_data), Status::FAILED_PRECONDITION);
- EXPECT_EQ(dumper.DumpLine(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(dumper.BeginDump(source_data), Status::FailedPrecondition());
+ EXPECT_EQ(dumper.DumpLine(), Status::FailedPrecondition());
EXPECT_EQ(buffer[0], static_cast<char>(0xaf));
}
TEST(BadBuffer, NullPtrDest) {
FormattedHexDumper dumper;
- EXPECT_EQ(dumper.SetLineBuffer(std::span<char>()), Status::INVALID_ARGUMENT);
- EXPECT_EQ(dumper.BeginDump(source_data), Status::FAILED_PRECONDITION);
- EXPECT_EQ(dumper.DumpLine(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(dumper.SetLineBuffer(std::span<char>()), Status::InvalidArgument());
+ EXPECT_EQ(dumper.BeginDump(source_data), Status::FailedPrecondition());
+ EXPECT_EQ(dumper.DumpLine(), Status::FailedPrecondition());
}
TEST(BadBuffer, NullPtrSrc) {
char buffer[24] = {static_cast<char>(0)};
FormattedHexDumper dumper(buffer);
- EXPECT_EQ(dumper.BeginDump(ByteSpan(nullptr, 64)), Status::INVALID_ARGUMENT);
+ EXPECT_EQ(dumper.BeginDump(ByteSpan(nullptr, 64)), Status::InvalidArgument());
// Don't actually dump nullptr in this test as it could cause a crash.
}
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);
}
diff --git a/pw_metric/metric_service_nanopb_test.cc b/pw_metric/metric_service_nanopb_test.cc
index b8b15b0..0948261 100644
--- a/pw_metric/metric_service_nanopb_test.cc
+++ b/pw_metric/metric_service_nanopb_test.cc
@@ -33,7 +33,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::OK, context.status());
+ EXPECT_EQ(Status::Ok(), context.status());
// No metrics should be in the response.
EXPECT_EQ(0u, context.responses().size());
@@ -52,7 +52,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::OK, context.status());
+ EXPECT_EQ(Status::Ok(), context.status());
// All of the responses should have fit in one proto.
EXPECT_EQ(1u, context.responses().size());
@@ -77,7 +77,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::OK, context.status());
+ EXPECT_EQ(Status::Ok(), context.status());
// All of the responses should fit in one proto.
EXPECT_EQ(1u, context.responses().size());
@@ -111,7 +111,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::OK, context.status());
+ EXPECT_EQ(Status::Ok(), context.status());
// The response had to be split into two parts; check that they have the
// appropriate sizes.
diff --git a/pw_protobuf/codegen_test.cc b/pw_protobuf/codegen_test.cc
index c9845c9..0b26657 100644
--- a/pw_protobuf/codegen_test.cc
+++ b/pw_protobuf/codegen_test.cc
@@ -167,7 +167,7 @@
// clang-format on
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
0);
@@ -186,7 +186,7 @@
0x08, 0x00, 0x08, 0x10, 0x08, 0x20, 0x08, 0x30};
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
0);
@@ -202,7 +202,7 @@
constexpr uint8_t expected_proto[] = {0x0a, 0x04, 0x00, 0x10, 0x20, 0x30};
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
0);
@@ -222,7 +222,7 @@
0x1a, 0x03, 't', 'h', 'e', 0x1a, 0x5, 'q', 'u', 'i', 'c', 'k',
0x1a, 0x5, 'b', 'r', 'o', 'w', 'n', 0x1a, 0x3, 'f', 'o', 'x'};
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
0);
@@ -246,7 +246,7 @@
// clang-format on
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
0);
@@ -270,7 +270,7 @@
0x08, 0x03, 0x1a, 0x06, 0x0a, 0x04, 0xde, 0xad, 0xbe, 0xef};
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
0);
@@ -294,7 +294,7 @@
}
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
}
TEST(Codegen, NonPigweedPackage) {
@@ -307,7 +307,7 @@
packed.WritePacked("packed");
std::span<const std::byte> proto;
- EXPECT_EQ(encoder.Encode(&proto), Status::OK);
+ EXPECT_EQ(encoder.Encode(&proto), Status::Ok());
}
} // namespace
diff --git a/pw_protobuf/decoder.cc b/pw_protobuf/decoder.cc
index 72127be..70880ad 100644
--- a/pw_protobuf/decoder.cc
+++ b/pw_protobuf/decoder.cc
@@ -27,24 +27,24 @@
}
}
if (proto_.empty()) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
previous_field_consumed_ = false;
- return FieldSize() == 0 ? Status::DATA_LOSS : Status::OK;
+ return FieldSize() == 0 ? Status::DataLoss() : Status::Ok();
}
Status Decoder::SkipField() {
if (proto_.empty()) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
size_t bytes_to_skip = FieldSize();
if (bytes_to_skip == 0) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
proto_ = proto_.subspan(bytes_to_skip);
- return proto_.empty() ? Status::OUT_OF_RANGE : Status::OK;
+ return proto_.empty() ? Status::OutOfRange() : Status::Ok();
}
uint32_t Decoder::FieldNumber() const {
@@ -60,10 +60,10 @@
return status;
}
if (value > std::numeric_limits<uint32_t>::max()) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
*out = value;
- return Status::OK;
+ return Status::Ok();
}
Status Decoder::ReadSint32(int32_t* out) {
@@ -73,10 +73,10 @@
return status;
}
if (value > std::numeric_limits<int32_t>::max()) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
*out = value;
- return Status::OK;
+ return Status::Ok();
}
Status Decoder::ReadSint64(int64_t* out) {
@@ -86,7 +86,7 @@
return status;
}
*out = varint::ZigZagDecode(value);
- return Status::OK;
+ return Status::Ok();
}
Status Decoder::ReadBool(bool* out) {
@@ -96,7 +96,7 @@
return status;
}
*out = value;
- return Status::OK;
+ return Status::Ok();
}
Status Decoder::ReadString(std::string_view* out) {
@@ -107,7 +107,7 @@
}
*out = std::string_view(reinterpret_cast<const char*>(bytes.data()),
bytes.size());
- return Status::OK;
+ return Status::Ok();
}
size_t Decoder::FieldSize() const {
@@ -159,17 +159,17 @@
uint64_t key;
size_t bytes_read = varint::Decode(proto_, &key);
if (bytes_read == 0) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
WireType wire_type = static_cast<WireType>(key & kWireTypeMask);
if (wire_type != expected_type) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
// Advance past the key.
proto_ = proto_.subspan(bytes_read);
- return Status::OK;
+ return Status::Ok();
}
Status Decoder::ReadVarint(uint64_t* out) {
@@ -179,13 +179,13 @@
size_t bytes_read = varint::Decode(proto_, out);
if (bytes_read == 0) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
// Advance to the next field.
proto_ = proto_.subspan(bytes_read);
previous_field_consumed_ = true;
- return Status::OK;
+ return Status::Ok();
}
Status Decoder::ReadFixed(std::byte* out, size_t size) {
@@ -197,14 +197,14 @@
}
if (proto_.size() < size) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
std::memcpy(out, proto_.data(), size);
proto_ = proto_.subspan(size);
previous_field_consumed_ = true;
- return Status::OK;
+ return Status::Ok();
}
Status Decoder::ReadDelimited(std::span<const std::byte>* out) {
@@ -216,24 +216,24 @@
uint64_t length;
size_t bytes_read = varint::Decode(proto_, &length);
if (bytes_read == 0) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
proto_ = proto_.subspan(bytes_read);
if (proto_.size() < length) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
*out = proto_.first(length);
proto_ = proto_.subspan(length);
previous_field_consumed_ = true;
- return Status::OK;
+ return Status::Ok();
}
Status CallbackDecoder::Decode(std::span<const std::byte> proto) {
if (handler_ == nullptr || state_ != kReady) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
state_ = kDecodeInProgress;
@@ -242,7 +242,7 @@
// Iterate the proto, calling the handler with each field number.
while (state_ == kDecodeInProgress) {
if (Status status = decoder_.Next(); !status.ok()) {
- if (status == Status::OUT_OF_RANGE) {
+ if (status == Status::OutOfRange()) {
// Reached the end of the proto.
break;
}
@@ -253,7 +253,7 @@
Status status = handler_->ProcessField(*this, decoder_.FieldNumber());
if (!status.ok()) {
- state_ = status == Status::CANCELLED ? kDecodeCancelled : kDecodeFailed;
+ state_ = status == Status::Cancelled() ? kDecodeCancelled : kDecodeFailed;
return status;
}
@@ -265,11 +265,11 @@
}
if (state_ != kDecodeInProgress) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
state_ = kReady;
- return Status::OK;
+ return Status::Ok();
}
} // namespace pw::protobuf
diff --git a/pw_protobuf/decoder_test.cc b/pw_protobuf/decoder_test.cc
index 7dad4b2..0b4f6ff 100644
--- a/pw_protobuf/decoder_test.cc
+++ b/pw_protobuf/decoder_test.cc
@@ -50,7 +50,7 @@
}
called = true;
- return Status::OK;
+ return Status::Ok();
}
bool called = false;
@@ -83,45 +83,45 @@
Decoder decoder(std::as_bytes(std::span(encoded_proto)));
int32_t v1 = 0;
- EXPECT_EQ(decoder.Next(), Status::OK);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
ASSERT_EQ(decoder.FieldNumber(), 1u);
- EXPECT_EQ(decoder.ReadInt32(&v1), Status::OK);
+ EXPECT_EQ(decoder.ReadInt32(&v1), Status::Ok());
EXPECT_EQ(v1, 42);
int32_t v2 = 0;
- EXPECT_EQ(decoder.Next(), Status::OK);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
ASSERT_EQ(decoder.FieldNumber(), 2u);
- EXPECT_EQ(decoder.ReadSint32(&v2), Status::OK);
+ EXPECT_EQ(decoder.ReadSint32(&v2), Status::Ok());
EXPECT_EQ(v2, -13);
bool v3 = true;
- EXPECT_EQ(decoder.Next(), Status::OK);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
ASSERT_EQ(decoder.FieldNumber(), 3u);
- EXPECT_EQ(decoder.ReadBool(&v3), Status::OK);
+ EXPECT_EQ(decoder.ReadBool(&v3), Status::Ok());
EXPECT_FALSE(v3);
double v4 = 0;
- EXPECT_EQ(decoder.Next(), Status::OK);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
ASSERT_EQ(decoder.FieldNumber(), 4u);
- EXPECT_EQ(decoder.ReadDouble(&v4), Status::OK);
+ EXPECT_EQ(decoder.ReadDouble(&v4), Status::Ok());
EXPECT_EQ(v4, 3.14159);
uint32_t v5 = 0;
- EXPECT_EQ(decoder.Next(), Status::OK);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
ASSERT_EQ(decoder.FieldNumber(), 5u);
- EXPECT_EQ(decoder.ReadFixed32(&v5), Status::OK);
+ EXPECT_EQ(decoder.ReadFixed32(&v5), Status::Ok());
EXPECT_EQ(v5, 0xdeadbeef);
std::string_view v6;
char buffer[16];
- EXPECT_EQ(decoder.Next(), Status::OK);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
ASSERT_EQ(decoder.FieldNumber(), 6u);
- EXPECT_EQ(decoder.ReadString(&v6), Status::OK);
+ EXPECT_EQ(decoder.ReadString(&v6), Status::Ok());
std::memcpy(buffer, v6.data(), v6.size());
buffer[v6.size()] = '\0';
EXPECT_STREQ(buffer, "Hello world");
- EXPECT_EQ(decoder.Next(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(decoder.Next(), Status::OutOfRange());
}
TEST(Decoder, Decode_SkipsUnusedFields) {
@@ -146,14 +146,14 @@
// Don't process any fields except for the fourth. Next should still iterate
// correctly despite field values not being consumed.
- EXPECT_EQ(decoder.Next(), Status::OK);
- EXPECT_EQ(decoder.Next(), Status::OK);
- EXPECT_EQ(decoder.Next(), Status::OK);
- EXPECT_EQ(decoder.Next(), Status::OK);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), Status::Ok());
ASSERT_EQ(decoder.FieldNumber(), 4u);
- EXPECT_EQ(decoder.Next(), Status::OK);
- EXPECT_EQ(decoder.Next(), Status::OK);
- EXPECT_EQ(decoder.Next(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), Status::OutOfRange());
}
TEST(CallbackDecoder, Decode) {
@@ -179,7 +179,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::OK);
+ Status::Ok());
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.test_int32, 42);
EXPECT_EQ(handler.test_sint32, -13);
@@ -206,7 +206,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::OK);
+ Status::Ok());
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.test_int32, 44);
}
@@ -216,7 +216,7 @@
TestDecodeHandler handler;
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(std::span<std::byte>()), Status::OK);
+ EXPECT_EQ(decoder.Decode(std::span<std::byte>()), Status::Ok());
EXPECT_FALSE(handler.called);
EXPECT_EQ(handler.test_int32, 0);
EXPECT_EQ(handler.test_sint32, 0);
@@ -231,7 +231,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::DATA_LOSS);
+ Status::DataLoss());
}
// Only processes fields numbered 1 or 3.
@@ -241,10 +241,10 @@
uint32_t field_number) override {
switch (field_number) {
case 1:
- EXPECT_EQ(decoder.ReadInt32(&field_one), Status::OK);
+ EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
break;
case 3:
- EXPECT_EQ(decoder.ReadInt32(&field_three), Status::OK);
+ EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
break;
default:
// Do nothing.
@@ -252,7 +252,7 @@
}
called = true;
- return Status::OK;
+ return Status::Ok();
}
bool called = false;
@@ -286,7 +286,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::OK);
+ Status::Ok());
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.field_one, 42);
EXPECT_EQ(handler.field_three, 99);
@@ -299,17 +299,17 @@
uint32_t field_number) override {
switch (field_number) {
case 1:
- EXPECT_EQ(decoder.ReadInt32(&field_one), Status::OK);
- return Status::CANCELLED;
+ EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
+ return Status::Cancelled();
case 3:
- EXPECT_EQ(decoder.ReadInt32(&field_three), Status::OK);
+ EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
break;
default:
// Do nothing.
break;
}
- return Status::OK;
+ return Status::Ok();
}
int32_t field_one = 0;
@@ -336,7 +336,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::CANCELLED);
+ Status::Cancelled());
EXPECT_EQ(handler.field_one, 42);
EXPECT_EQ(handler.field_three, 1111);
}
diff --git a/pw_protobuf/encoder.cc b/pw_protobuf/encoder.cc
index 96b9b7d..6a5eceb 100644
--- a/pw_protobuf/encoder.cc
+++ b/pw_protobuf/encoder.cc
@@ -32,18 +32,18 @@
std::span varint_buf = buffer_.last(RemainingSize());
if (varint_buf.empty()) {
- encode_status_ = Status::RESOURCE_EXHAUSTED;
+ encode_status_ = Status::ResourceExhausted();
return encode_status_;
}
size_t written = pw::varint::EncodeLittleEndianBase128(value, varint_buf);
if (written == 0) {
- encode_status_ = Status::RESOURCE_EXHAUSTED;
+ encode_status_ = Status::ResourceExhausted();
return encode_status_;
}
cursor_ += written;
- return Status::OK;
+ return Status::Ok();
}
Status Encoder::WriteRawBytes(const std::byte* ptr, size_t size) {
@@ -52,7 +52,7 @@
}
if (size > RemainingSize()) {
- encode_status_ = Status::RESOURCE_EXHAUSTED;
+ encode_status_ = Status::ResourceExhausted();
return encode_status_;
}
@@ -61,7 +61,7 @@
std::memmove(cursor_, ptr, size);
cursor_ += size;
- return Status::OK;
+ return Status::Ok();
}
Status Encoder::Push(uint32_t field_number) {
@@ -70,7 +70,7 @@
}
if (blob_count_ == blob_locations_.size() || depth_ == blob_stack_.size()) {
- encode_status_ = Status::RESOURCE_EXHAUSTED;
+ encode_status_ = Status::ResourceExhausted();
return encode_status_;
}
@@ -85,7 +85,7 @@
if (sizeof(SizeType) > RemainingSize()) {
// Rollback if there isn't enough space.
cursor_ = original_cursor;
- encode_status_ = Status::RESOURCE_EXHAUSTED;
+ encode_status_ = Status::ResourceExhausted();
return encode_status_;
}
@@ -105,7 +105,7 @@
blob_stack_[depth_++] = size_cursor;
cursor_ += sizeof(*size_cursor);
- return Status::OK;
+ return Status::Ok();
}
Status Encoder::Pop() {
@@ -114,7 +114,7 @@
}
if (depth_ == 0) {
- encode_status_ = Status::FAILED_PRECONDITION;
+ encode_status_ = Status::FailedPrecondition();
return encode_status_;
}
@@ -123,7 +123,7 @@
SizeType child_size = *blob_stack_[--depth_];
IncreaseParentSize(child_size + VarintSizeBytes(child_size));
- return Status::OK;
+ return Status::Ok();
}
Status Encoder::Encode(std::span<const std::byte>* out) {
@@ -135,7 +135,7 @@
if (blob_count_ == 0) {
// If there are no nested blobs, the buffer already contains a valid proto.
*out = buffer_.first(EncodedSize());
- return Status::OK;
+ return Status::Ok();
}
union {
@@ -180,7 +180,7 @@
// Point the cursor to the end of the encoded proto.
cursor_ = write_cursor;
*out = buffer_.first(EncodedSize());
- return Status::OK;
+ return Status::Ok();
}
} // namespace pw::protobuf
diff --git a/pw_protobuf/encoder_test.cc b/pw_protobuf/encoder_test.cc
index 8a86057..109943d 100644
--- a/pw_protobuf/encoder_test.cc
+++ b/pw_protobuf/encoder_test.cc
@@ -85,16 +85,16 @@
std::byte encode_buffer[32];
NestedEncoder encoder(encode_buffer);
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
- EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::OK);
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+ EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
EXPECT_EQ(encoder.WriteFixed64(kTestProtoCyclesField, 0xdeadbeef8badf00d),
- Status::OK);
- EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), Status::OK);
+ Status::Ok());
+ EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), Status::Ok());
EXPECT_EQ(encoder.WriteString(kTestProtoErrorMessageField, "broken 💩"),
- Status::OK);
+ Status::Ok());
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
}
@@ -104,19 +104,19 @@
NestedEncoder encoder(encode_buffer);
// 2 bytes.
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
// 2 bytes.
- EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::OK);
+ EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
// 9 bytes; not enough space! The encoder will start writing the field but
// should rollback when it realizes it doesn't have enough space.
EXPECT_EQ(encoder.WriteFixed64(kTestProtoCyclesField, 0xdeadbeef8badf00d),
- Status::RESOURCE_EXHAUSTED);
+ Status::ResourceExhausted());
// Any further write operations should fail.
EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034),
- Status::RESOURCE_EXHAUSTED);
+ Status::ResourceExhausted());
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::ResourceExhausted());
EXPECT_EQ(encoded.size(), 0u);
}
@@ -124,17 +124,17 @@
std::byte encode_buffer[12];
NestedEncoder encoder(encode_buffer);
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
// Invalid proto field numbers.
- EXPECT_EQ(encoder.WriteUint32(0, 1337), Status::INVALID_ARGUMENT);
+ EXPECT_EQ(encoder.WriteUint32(0, 1337), Status::InvalidArgument());
encoder.Clear();
- EXPECT_EQ(encoder.WriteString(1u << 31, "ha"), Status::INVALID_ARGUMENT);
+ EXPECT_EQ(encoder.WriteString(1u << 31, "ha"), Status::InvalidArgument());
encoder.Clear();
- EXPECT_EQ(encoder.WriteBool(19091, false), Status::INVALID_ARGUMENT);
+ EXPECT_EQ(encoder.WriteBool(19091, false), Status::InvalidArgument());
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::INVALID_ARGUMENT);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::InvalidArgument());
EXPECT_EQ(encoded.size(), 0u);
}
@@ -144,47 +144,48 @@
// TestProto test_proto;
// test_proto.magic_number = 42;
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::OK);
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
{
// NestedProto& nested_proto = test_proto.nested;
- EXPECT_EQ(encoder.Push(kTestProtoNestedField), Status::OK);
+ EXPECT_EQ(encoder.Push(kTestProtoNestedField), Status::Ok());
// nested_proto.hello = "world";
- EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"), Status::OK);
+ EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"),
+ Status::Ok());
// nested_proto.id = 999;
- EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), Status::OK);
+ EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), Status::Ok());
{
// DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
- EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::OK);
+ EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
// double_nested_proto.key = "version";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "version"),
- Status::OK);
+ Status::Ok());
// double_nested_proto.value = "2.9.1";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "2.9.1"),
- Status::OK);
+ Status::Ok());
- EXPECT_EQ(encoder.Pop(), Status::OK);
+ EXPECT_EQ(encoder.Pop(), Status::Ok());
} // end DoubleNestedProto
{
// DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
- EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::OK);
+ EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
// double_nested_proto.key = "device";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "device"),
- Status::OK);
+ Status::Ok());
// double_nested_proto.value = "left-soc";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "left-soc"),
- Status::OK);
+ Status::Ok());
- EXPECT_EQ(encoder.Pop(), Status::OK);
+ EXPECT_EQ(encoder.Pop(), Status::Ok());
} // end DoubleNestedProto
- EXPECT_EQ(encoder.Pop(), Status::OK);
+ EXPECT_EQ(encoder.Pop(), Status::Ok());
} // end NestedProto
// test_proto.ziggy = -13;
- EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::OK);
+ EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
// clang-format off
constexpr uint8_t encoded_proto[] = {
@@ -214,7 +215,7 @@
// clang-format on
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
}
@@ -224,16 +225,16 @@
NestedEncoder<2, 10> encoder(encode_buffer);
// One level of nesting.
- EXPECT_EQ(encoder.Push(2), Status::OK);
+ EXPECT_EQ(encoder.Push(2), Status::Ok());
// Two levels of nesting.
- EXPECT_EQ(encoder.Push(1), Status::OK);
+ EXPECT_EQ(encoder.Push(1), Status::Ok());
// Three levels of nesting: error!
- EXPECT_EQ(encoder.Push(1), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(encoder.Push(1), Status::ResourceExhausted());
// Further operations should fail.
- EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
- EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
- EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
+ EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
+ EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
}
TEST(Encoder, NestedBlobLimit) {
@@ -241,23 +242,23 @@
NestedEncoder<5, 3> encoder(encode_buffer);
// Write first blob.
- EXPECT_EQ(encoder.Push(1), Status::OK);
- EXPECT_EQ(encoder.Pop(), Status::OK);
+ EXPECT_EQ(encoder.Push(1), Status::Ok());
+ EXPECT_EQ(encoder.Pop(), Status::Ok());
// Write second blob.
- EXPECT_EQ(encoder.Push(2), Status::OK);
+ EXPECT_EQ(encoder.Push(2), Status::Ok());
// Write nested third blob.
- EXPECT_EQ(encoder.Push(3), Status::OK);
- EXPECT_EQ(encoder.Pop(), Status::OK);
+ EXPECT_EQ(encoder.Push(3), Status::Ok());
+ EXPECT_EQ(encoder.Pop(), Status::Ok());
// End second blob.
- EXPECT_EQ(encoder.Pop(), Status::OK);
+ EXPECT_EQ(encoder.Pop(), Status::Ok());
// Write fourth blob: error!.
- EXPECT_EQ(encoder.Push(4), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(encoder.Push(4), Status::ResourceExhausted());
// Nothing to pop.
- EXPECT_EQ(encoder.Pop(), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(encoder.Pop(), Status::ResourceExhausted());
}
TEST(Encoder, RepeatedField) {
@@ -274,7 +275,7 @@
0x08, 0x00, 0x08, 0x32, 0x08, 0x64, 0x08, 0x96, 0x01, 0x08, 0xc8, 0x01};
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
}
@@ -292,7 +293,7 @@
// key size v[0] v[1] v[2] v[3] v[4]
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
}
@@ -305,7 +306,7 @@
encoder.WritePackedUint32(1, values);
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::ResourceExhausted());
EXPECT_EQ(encoded.size(), 0u);
}
@@ -327,7 +328,7 @@
0x12, 0x08, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01};
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
}
@@ -344,7 +345,7 @@
0x0a, 0x09, 0xc7, 0x01, 0x31, 0x01, 0x00, 0x02, 0x32, 0xc8, 0x01};
std::span<const std::byte> encoded;
- EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
+ EXPECT_EQ(encoder.Encode(&encoded), Status::Ok());
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
}
diff --git a/pw_protobuf/find.cc b/pw_protobuf/find.cc
index 923097a..635f50b 100644
--- a/pw_protobuf/find.cc
+++ b/pw_protobuf/find.cc
@@ -20,12 +20,12 @@
uint32_t field_number) {
if (field_number != field_number_) {
// Continue to the next field.
- return Status::OK;
+ return Status::Ok();
}
found_ = true;
if (nested_handler_ == nullptr) {
- return Status::CANCELLED;
+ return Status::Cancelled();
}
std::span<const std::byte> submessage;
diff --git a/pw_protobuf/public/pw_protobuf/decoder.h b/pw_protobuf/public/pw_protobuf/decoder.h
index 595bc9a..6cb402e 100644
--- a/pw_protobuf/public/pw_protobuf/decoder.h
+++ b/pw_protobuf/public/pw_protobuf/decoder.h
@@ -192,7 +192,7 @@
// break;
// }
//
-// return Status::OK;
+// return Status::Ok();
// }
//
// int bar;
@@ -303,8 +303,8 @@
// Receives a pointer to the decoder object, allowing the handler to call
// the appropriate method to extract the field's data.
//
- // If the status returned is not Status::OK, the decode operation is exited
- // with the provided status. Returning Status::CANCELLED allows a convenient
+ // If the status returned is not Status::Ok(), the decode operation is exited
+ // with the provided status. Returning Status::Cancelled() allows a convenient
// way of stopping a decode early (for example, if a desired field is found).
virtual Status ProcessField(CallbackDecoder& decoder,
uint32_t field_number) = 0;
diff --git a/pw_protobuf/public/pw_protobuf/encoder.h b/pw_protobuf/public/pw_protobuf/encoder.h
index 3e86368..14483d2 100644
--- a/pw_protobuf/public/pw_protobuf/encoder.h
+++ b/pw_protobuf/public/pw_protobuf/encoder.h
@@ -40,7 +40,7 @@
blob_count_(0),
blob_stack_(stack),
depth_(0),
- encode_status_(Status::OK) {}
+ encode_status_(Status::Ok()) {}
// Disallow copy/assign to avoid confusion about who owns the buffer.
Encoder(const Encoder& other) = delete;
@@ -259,7 +259,7 @@
// obtained from Encode().
void Clear() {
cursor_ = buffer_.data();
- encode_status_ = Status::OK;
+ encode_status_ = Status::Ok();
blob_count_ = 0;
depth_ = 0;
}
@@ -278,7 +278,7 @@
// Encodes the key for a proto field consisting of its number and wire type.
Status WriteFieldKey(uint32_t field_number, WireType wire_type) {
if (!ValidFieldNumber(field_number)) {
- encode_status_ = Status::INVALID_ARGUMENT;
+ encode_status_ = Status::InvalidArgument();
return encode_status_;
}
diff --git a/pw_random/xor_shift_test.cc b/pw_random/xor_shift_test.cc
index 660c981..6b7e379 100644
--- a/pw_random/xor_shift_test.cc
+++ b/pw_random/xor_shift_test.cc
@@ -44,7 +44,7 @@
XorShiftStarRng64 rng(seed1);
for (size_t i = 0; i < result1_count; ++i) {
uint64_t val = 0;
- EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+ EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
EXPECT_EQ(val, result1[i]);
}
}
@@ -53,7 +53,7 @@
XorShiftStarRng64 rng(seed2);
for (size_t i = 0; i < result2_count; ++i) {
uint64_t val = 0;
- EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+ EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
EXPECT_EQ(val, result2[i]);
}
}
@@ -62,7 +62,7 @@
XorShiftStarRng64 rng(seed1);
uint64_t val = 0;
rng.InjectEntropyBits(0x1, 1);
- EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+ EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
EXPECT_NE(val, result1[0]);
}
@@ -72,14 +72,14 @@
XorShiftStarRng64 rng_1(seed1);
uint64_t first_val = 0;
rng_1.InjectEntropyBits(0x1, 1);
- EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::OK);
+ EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
// Use the same starting seed.
XorShiftStarRng64 rng_2(seed1);
uint64_t second_val = 0;
// Use a different number of entropy bits.
rng_2.InjectEntropyBits(0x1, 2);
- EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::OK);
+ EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::Ok());
EXPECT_NE(first_val, second_val);
}
@@ -91,7 +91,7 @@
XorShiftStarRng64 rng_1(seed1);
uint64_t first_val = 0;
rng_1.InjectEntropyBits(0x6, 3);
- EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::OK);
+ EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
// Use the same starting seed.
XorShiftStarRng64 rng_2(seed1);
@@ -100,7 +100,7 @@
rng_2.InjectEntropyBits(0x1, 1);
rng_2.InjectEntropyBits(0x1, 1);
rng_2.InjectEntropyBits(0x0, 1);
- EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::OK);
+ EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::Ok());
EXPECT_EQ(first_val, second_val);
}
@@ -114,7 +114,7 @@
std::byte(0x17),
std::byte(0x02)};
rng.InjectEntropy(entropy);
- EXPECT_EQ(rng.GetInt(val).status(), Status::OK);
+ EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
EXPECT_NE(val, result1[0]);
}
diff --git a/pw_result/public/pw_result/result.h b/pw_result/public/pw_result/result.h
index 60bcc05..7093551 100644
--- a/pw_result/public/pw_result/result.h
+++ b/pw_result/public/pw_result/result.h
@@ -26,17 +26,20 @@
template <typename T>
class Result {
public:
- constexpr Result(T&& value) : value_(std::move(value)), status_(Status::OK) {}
- constexpr Result(const T& value) : value_(value), status_(Status::OK) {}
+ constexpr Result(T&& value)
+ : value_(std::move(value)), status_(Status::Ok()) {}
+ constexpr Result(const T& value) : value_(value), status_(Status::Ok()) {}
template <typename... Args>
constexpr Result(std::in_place_t, Args&&... args)
- : value_(std::forward<Args>(args)...), status_(Status::OK) {}
+ : value_(std::forward<Args>(args)...), status_(Status::Ok()) {}
// TODO(pwbug/246): This can be constexpr when tokenized asserts are fixed.
- Result(Status status) : status_(status) { PW_CHECK(status_ != Status::OK); }
+ Result(Status status) : status_(status) { PW_CHECK(status_ != Status::Ok()); }
// TODO(pwbug/246): This can be constexpr when tokenized asserts are fixed.
- Result(Status::Code code) : status_(code) { PW_CHECK(status_ != Status::OK); }
+ Result(Status::Code code) : status_(code) {
+ PW_CHECK(status_ != Status::Ok());
+ }
constexpr Result(const Result&) = default;
constexpr Result& operator=(const Result&) = default;
diff --git a/pw_result/result_test.cc b/pw_result/result_test.cc
index b29c240..ef913fd 100644
--- a/pw_result/result_test.cc
+++ b/pw_result/result_test.cc
@@ -22,19 +22,19 @@
TEST(Result, CreateOk) {
Result<const char*> res("hello");
EXPECT_TRUE(res.ok());
- EXPECT_EQ(res.status(), Status::OK);
+ EXPECT_EQ(res.status(), Status::Ok());
EXPECT_EQ(res.value(), "hello");
}
TEST(Result, CreateNotOk) {
- Result<int> res(Status::DATA_LOSS);
+ Result<int> res(Status::DataLoss());
EXPECT_FALSE(res.ok());
- EXPECT_EQ(res.status(), Status::DATA_LOSS);
+ EXPECT_EQ(res.status(), Status::DataLoss());
}
TEST(Result, ValueOr) {
Result<int> good(3);
- Result<int> bad(Status::DATA_LOSS);
+ Result<int> bad(Status::DataLoss());
EXPECT_EQ(good.value_or(42), 3);
EXPECT_EQ(bad.value_or(42), 42);
}
@@ -55,7 +55,7 @@
Result<float> Divide(float a, float b) {
if (b == 0) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
return a / b;
}
@@ -69,7 +69,7 @@
TEST(Divide, ReturnNotOk) {
Result<float> res = Divide(10, 0);
EXPECT_FALSE(res.ok());
- EXPECT_EQ(res.status(), Status::INVALID_ARGUMENT);
+ EXPECT_EQ(res.status(), Status::InvalidArgument());
}
} // namespace
diff --git a/pw_result/size_report/pointer_noinline.cc b/pw_result/size_report/pointer_noinline.cc
index 7c77de6..522c9fe 100644
--- a/pw_result/size_report/pointer_noinline.cc
+++ b/pw_result/size_report/pointer_noinline.cc
@@ -18,10 +18,10 @@
PW_NO_INLINE pw::Status Divide(float a, float b, float* out) {
if (b == 0) {
- return pw::Status::INVALID_ARGUMENT;
+ return pw::Status::InvalidArgument();
}
*out = a / b;
- return pw::Status::OK;
+ return pw::Status::Ok();
}
int volatile* unoptimizable;
diff --git a/pw_result/size_report/pointer_read.cc b/pw_result/size_report/pointer_read.cc
index e346452..fb4f948 100644
--- a/pw_result/size_report/pointer_read.cc
+++ b/pw_result/size_report/pointer_read.cc
@@ -34,11 +34,11 @@
size_t size,
std::span<const std::byte>* out) {
if (offset + size >= std::size(kArray)) {
- return pw::Status::OUT_OF_RANGE;
+ return pw::Status::OutOfRange();
}
*out = std::span<const std::byte>(std::data(kArray) + offset, size);
- return pw::Status::OK;
+ return pw::Status::Ok();
}
} // namespace
diff --git a/pw_result/size_report/pointer_simple.cc b/pw_result/size_report/pointer_simple.cc
index eb536d4..7c1440e 100644
--- a/pw_result/size_report/pointer_simple.cc
+++ b/pw_result/size_report/pointer_simple.cc
@@ -17,10 +17,10 @@
pw::Status Divide(float a, float b, float* out) {
if (b == 0) {
- return pw::Status::INVALID_ARGUMENT;
+ return pw::Status::InvalidArgument();
}
*out = a / b;
- return pw::Status::OK;
+ return pw::Status::Ok();
}
int volatile* unoptimizable;
diff --git a/pw_result/size_report/result_noinline.cc b/pw_result/size_report/result_noinline.cc
index c099dc5..b008e52 100644
--- a/pw_result/size_report/result_noinline.cc
+++ b/pw_result/size_report/result_noinline.cc
@@ -18,7 +18,7 @@
PW_NO_INLINE pw::Result<float> Divide(float a, float b) {
if (b == 0) {
- return pw::Status::INVALID_ARGUMENT;
+ return pw::Status::InvalidArgument();
}
return a / b;
}
diff --git a/pw_result/size_report/result_read.cc b/pw_result/size_report/result_read.cc
index 9bc9ffd..351be04 100644
--- a/pw_result/size_report/result_read.cc
+++ b/pw_result/size_report/result_read.cc
@@ -33,7 +33,7 @@
PW_NO_INLINE pw::Result<std::span<const std::byte>> Read(size_t offset,
size_t size) {
if (offset + size >= std::size(kArray)) {
- return pw::Status::OUT_OF_RANGE;
+ return pw::Status::OutOfRange();
}
return std::span<const std::byte>(std::data(kArray) + offset, size);
diff --git a/pw_result/size_report/result_simple.cc b/pw_result/size_report/result_simple.cc
index 91772b9..333eca8 100644
--- a/pw_result/size_report/result_simple.cc
+++ b/pw_result/size_report/result_simple.cc
@@ -17,7 +17,7 @@
pw::Result<float> Divide(float a, float b) {
if (b == 0) {
- return pw::Status::INVALID_ARGUMENT;
+ return pw::Status::InvalidArgument();
}
return a / b;
}
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer.cc b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
index 31eb222..d122162 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
@@ -33,24 +33,24 @@
if ((buffer.data() == nullptr) || //
(buffer.size_bytes() == 0) || //
(buffer.size_bytes() > kMaxBufferBytes)) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
buffer_ = buffer.data();
buffer_bytes_ = buffer.size_bytes();
Clear();
- return Status::OK;
+ return Status::Ok();
}
Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data,
byte user_preamble_data,
bool drop_elements_if_needed) {
if (buffer_ == nullptr) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
if (data.size_bytes() == 0) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
// Prepare the preamble, and ensure we can fit the preamble and entry.
@@ -59,7 +59,7 @@
size_t total_write_bytes =
(user_preamble_ ? 1 : 0) + varint_bytes + data.size_bytes();
if (buffer_bytes_ < total_write_bytes) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
if (drop_elements_if_needed) {
@@ -70,7 +70,7 @@
}
} else if (RawAvailableBytes() < total_write_bytes) {
// TryPushBack() case: don't evict items.
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
// Write the new entry into the ring buffer.
@@ -80,7 +80,7 @@
RawWrite(std::span(varint_buf, varint_bytes));
RawWrite(data);
entry_count_++;
- return Status::OK;
+ return Status::Ok();
}
auto GetOutput(std::span<byte> data_out, size_t* write_index) {
@@ -90,8 +90,8 @@
memcpy(data_out.data() + *write_index, src.data(), copy_size);
*write_index += copy_size;
- return (copy_size == src.size_bytes()) ? Status::OK
- : Status::RESOURCE_EXHAUSTED;
+ return (copy_size == src.size_bytes()) ? Status::Ok()
+ : Status::ResourceExhausted();
};
}
@@ -119,10 +119,10 @@
template <typename T>
Status PrefixedEntryRingBuffer::InternalRead(T read_output, bool get_preamble) {
if (buffer_ == nullptr) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
if (EntryCount() == 0) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
// Figure out where to start reading (wrapped); accounting for preamble.
@@ -150,10 +150,10 @@
Status PrefixedEntryRingBuffer::PopFront() {
if (buffer_ == nullptr) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
if (EntryCount() == 0) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
// Advance the read pointer past the front entry to the next one.
@@ -161,16 +161,16 @@
size_t entry_bytes = info.preamble_bytes + info.data_bytes;
read_idx_ = IncrementIndex(read_idx_, entry_bytes);
entry_count_--;
- return Status::OK;
+ return Status::Ok();
}
Status PrefixedEntryRingBuffer::Dering() {
if (buffer_ == nullptr) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
// Check if by luck we're already deringed.
if (read_idx_ == 0) {
- return Status::OK;
+ return Status::Ok();
}
auto buffer_span = std::span(buffer_, buffer_bytes_);
@@ -184,7 +184,7 @@
}
write_idx_ -= read_idx_;
read_idx_ = 0;
- return Status::OK;
+ return Status::Ok();
}
size_t PrefixedEntryRingBuffer::FrontEntryDataSizeBytes() {
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
index 271ce74..5838ca4 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
@@ -35,20 +35,20 @@
EXPECT_EQ(ring.EntryCount(), 0u);
EXPECT_EQ(ring.SetBuffer(std::span<byte>(nullptr, 10u)),
- Status::INVALID_ARGUMENT);
- EXPECT_EQ(ring.SetBuffer(std::span(buf, 0u)), Status::INVALID_ARGUMENT);
+ Status::InvalidArgument());
+ EXPECT_EQ(ring.SetBuffer(std::span(buf, 0u)), Status::InvalidArgument());
EXPECT_EQ(ring.FrontEntryDataSizeBytes(), 0u);
- EXPECT_EQ(ring.PushBack(buf), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(ring.PushBack(buf), Status::FailedPrecondition());
EXPECT_EQ(ring.EntryCount(), 0u);
- EXPECT_EQ(ring.PeekFront(buf, &count), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(ring.PeekFront(buf, &count), Status::FailedPrecondition());
EXPECT_EQ(count, 0u);
EXPECT_EQ(ring.EntryCount(), 0u);
EXPECT_EQ(ring.PeekFrontWithPreamble(buf, &count),
- Status::FAILED_PRECONDITION);
+ Status::FailedPrecondition());
EXPECT_EQ(count, 0u);
EXPECT_EQ(ring.EntryCount(), 0u);
- EXPECT_EQ(ring.PopFront(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(ring.PopFront(), Status::FailedPrecondition());
EXPECT_EQ(ring.EntryCount(), 0u);
}
@@ -83,23 +83,23 @@
// out and happen to see a previous value.
size_t read_size = 500U;
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+ EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
EXPECT_EQ(ring.EntryCount(), 0u);
- EXPECT_EQ(ring.PopFront(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(ring.PopFront(), Status::OutOfRange());
EXPECT_EQ(ring.EntryCount(), 0u);
EXPECT_EQ(ring.PushBack(std::span(single_entry_data, 0u)),
- Status::INVALID_ARGUMENT);
+ Status::InvalidArgument());
EXPECT_EQ(ring.EntryCount(), 0u);
EXPECT_EQ(
ring.PushBack(std::span(single_entry_data, sizeof(test_buffer) + 5)),
- Status::OUT_OF_RANGE);
+ Status::OutOfRange());
EXPECT_EQ(ring.EntryCount(), 0u);
- EXPECT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OUT_OF_RANGE);
+ EXPECT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OutOfRange());
EXPECT_EQ(read_size, 0u);
read_size = 500U;
EXPECT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size),
- Status::OUT_OF_RANGE);
+ Status::OutOfRange());
EXPECT_EQ(read_size, 0u);
size_t user_preamble_bytes = (user_data ? 1 : 0);
@@ -115,12 +115,12 @@
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
- Status::OK);
+ Status::Ok());
ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
read_size = 500U;
- ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OK);
+ ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::Ok());
ASSERT_EQ(read_size, data_size);
// ASSERT_THAT(std::span(expect_buffer).last(data_size),
@@ -131,9 +131,10 @@
0);
read_size = 500U;
- ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size), Status::OK);
+ ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size),
+ Status::Ok());
ASSERT_EQ(read_size, single_entry_total_size);
- ASSERT_EQ(ring.PopFront(), Status::OK);
+ ASSERT_EQ(ring.PopFront(), Status::Ok());
if (user_data) {
expect_buffer[0] = byte(i);
@@ -167,7 +168,7 @@
PrefixedEntryRingBuffer ring(user_data);
byte test_buffer[single_entry_test_buffer_size];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+ EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
EXPECT_EQ(ring.EntryCount(), 0u);
constexpr size_t data_size = sizeof(single_entry_data) - (user_data ? 1 : 0);
@@ -181,7 +182,7 @@
for (j = 0; j < kSingleEntryCycles; j++) {
memset(write_buffer, j + seed, sizeof(write_buffer));
- ASSERT_EQ(ring.PushBack(write_buffer), Status::OK);
+ ASSERT_EQ(ring.PushBack(write_buffer), Status::Ok());
size_t expected_count = (j < kCountingUpMaxExpectedEntries)
? j + 1
@@ -195,11 +196,11 @@
byte read_buffer[sizeof(write_buffer)];
size_t read_size;
memset(write_buffer, fill_val + j, sizeof(write_buffer));
- ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OK);
+ ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::Ok());
ASSERT_EQ(memcmp(write_buffer, read_buffer, data_size), 0);
- ASSERT_EQ(ring.PopFront(), Status::OK);
+ ASSERT_EQ(ring.PopFront(), Status::Ok());
}
}
}
@@ -221,13 +222,13 @@
PrefixedEntryRingBuffer ring(user_data);
byte test_buffer[single_entry_test_buffer_size];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+ EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
auto output = [](std::span<const byte> src) -> Status {
for (byte b : src) {
read_buffer.push_back(b);
}
- return Status::OK;
+ return Status::Ok();
};
size_t user_preamble_bytes = (user_data ? 1 : 0);
@@ -243,12 +244,12 @@
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
- Status::OK);
+ Status::Ok());
ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
read_buffer.clear();
- ASSERT_EQ(ring.PeekFront(output), Status::OK);
+ ASSERT_EQ(ring.PeekFront(output), Status::Ok());
ASSERT_EQ(read_buffer.size(), data_size);
ASSERT_EQ(memcmp(std::span(expect_buffer).last(data_size).data(),
@@ -257,9 +258,9 @@
0);
read_buffer.clear();
- ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::OK);
+ ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
ASSERT_EQ(read_buffer.size(), single_entry_total_size);
- ASSERT_EQ(ring.PopFront(), Status::OK);
+ ASSERT_EQ(ring.PopFront(), Status::Ok());
if (user_data) {
expect_buffer[0] = byte(i);
@@ -292,7 +293,7 @@
PrefixedEntryRingBuffer ring;
byte test_buffer[kTestBufferSize];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+ EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
// Entry data is entry size - preamble (single byte in this case).
byte single_entry_buffer[kEntrySizeBytes - 1u];
@@ -335,7 +336,7 @@
EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
EXPECT_EQ(expected_result.size(), ring.TotalUsedBytes());
- ASSERT_EQ(ring.Dering(), Status::OK);
+ ASSERT_EQ(ring.Dering(), Status::Ok());
// Check values after doing the dering.
EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
@@ -347,11 +348,11 @@
for (byte b : src) {
actual_result.push_back(b);
}
- return Status::OK;
+ return Status::Ok();
};
while (ring.EntryCount()) {
- ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::OK);
- ASSERT_EQ(ring.PopFront(), Status::OK);
+ ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
+ ASSERT_EQ(ring.PopFront(), Status::Ok());
}
// Ensure the actual result out of the ring buffer matches our manually
@@ -396,7 +397,7 @@
T item;
} aliased;
size_t bytes_read = 0;
- PW_CHECK_INT_EQ(ring.PeekFront(aliased.buffer, &bytes_read), Status::OK);
+ PW_CHECK_INT_EQ(ring.PeekFront(aliased.buffer, &bytes_read), Status::Ok());
PW_CHECK_INT_EQ(bytes_read, sizeof(T));
return aliased.item;
}
@@ -404,7 +405,7 @@
TEST(PrefixedEntryRingBuffer, TryPushBack) {
PrefixedEntryRingBuffer ring;
byte test_buffer[kTestBufferSize];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
+ EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
// Fill up the ring buffer with a constant.
int total_items = 0;
@@ -413,7 +414,7 @@
if (status.ok()) {
total_items++;
} else {
- EXPECT_EQ(status, Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(status, Status::ResourceExhausted());
break;
}
}
@@ -421,13 +422,13 @@
// Should be unable to push more items.
for (int i = 0; i < total_items; ++i) {
- EXPECT_EQ(TryPushBack<int>(ring, 100), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(TryPushBack<int>(ring, 100), Status::ResourceExhausted());
EXPECT_EQ(PeekFront<int>(ring), 5);
}
// Fill up the ring buffer with a constant.
for (int i = 0; i < total_items; ++i) {
- EXPECT_EQ(PushBack<int>(ring, 100), Status::OK);
+ EXPECT_EQ(PushBack<int>(ring, 100), Status::Ok());
}
EXPECT_EQ(PeekFront<int>(ring), 100);
}
diff --git a/pw_rpc/base_server_writer.cc b/pw_rpc/base_server_writer.cc
index 5e33aa9..1e3c396 100644
--- a/pw_rpc/base_server_writer.cc
+++ b/pw_rpc/base_server_writer.cc
@@ -74,7 +74,7 @@
Status BaseServerWriter::ReleasePayloadBuffer(
std::span<const std::byte> payload) {
if (!open()) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
return call_.channel().Send(response_, ResponsePacket(payload));
}
diff --git a/pw_rpc/base_server_writer_test.cc b/pw_rpc/base_server_writer_test.cc
index 1a7dae0..bb6b8a2 100644
--- a/pw_rpc/base_server_writer_test.cc
+++ b/pw_rpc/base_server_writer_test.cc
@@ -119,7 +119,7 @@
EXPECT_EQ(packet.service_id(), context.kServiceId);
EXPECT_EQ(packet.method_id(), context.get().method().id());
EXPECT_TRUE(packet.payload().empty());
- EXPECT_EQ(packet.status(), Status::OK);
+ EXPECT_EQ(packet.status(), Status::Ok());
}
TEST(ServerWriter, Close) {
@@ -136,11 +136,11 @@
FakeServerWriter writer(context.get());
constexpr byte data[] = {byte{0xf0}, byte{0x0d}};
- ASSERT_EQ(Status::OK, writer.Write(data));
+ ASSERT_EQ(Status::Ok(), writer.Write(data));
byte encoded[64];
auto sws = context.packet(data).Encode(encoded);
- ASSERT_EQ(Status::OK, sws.status());
+ ASSERT_EQ(Status::Ok(), sws.status());
EXPECT_EQ(sws.size(), context.output().sent_data().size());
EXPECT_EQ(
@@ -154,7 +154,7 @@
writer.Finish();
constexpr byte data[] = {byte{0xf0}, byte{0x0d}};
- EXPECT_EQ(Status::FAILED_PRECONDITION, writer.Write(data));
+ EXPECT_EQ(Status::FailedPrecondition(), writer.Write(data));
}
} // namespace
diff --git a/pw_rpc/channel.cc b/pw_rpc/channel.cc
index 1074cea..8771109 100644
--- a/pw_rpc/channel.cc
+++ b/pw_rpc/channel.cc
@@ -34,7 +34,7 @@
if (!encoded.ok()) {
PW_LOG_ERROR("Failed to encode response packet to channel buffer");
output().SendAndReleaseBuffer(0);
- return Status::INTERNAL;
+ return Status::Internal();
}
return output().SendAndReleaseBuffer(encoded.size());
diff --git a/pw_rpc/channel_test.cc b/pw_rpc/channel_test.cc
index b160729..cdddc14 100644
--- a/pw_rpc/channel_test.cc
+++ b/pw_rpc/channel_test.cc
@@ -28,7 +28,7 @@
public:
NameTester(const char* name) : ChannelOutput(name) {}
std::span<std::byte> AcquireBuffer() override { return {}; }
- Status SendAndReleaseBuffer(size_t) override { return Status::OK; }
+ Status SendAndReleaseBuffer(size_t) override { return Status::Ok(); }
};
EXPECT_STREQ("hello_world", NameTester("hello_world").name());
@@ -59,7 +59,7 @@
Channel::OutputBuffer output_buffer = channel.AcquireBuffer();
EXPECT_TRUE(output_buffer.payload(kTestPacket).empty());
- EXPECT_EQ(Status::INTERNAL, channel.Send(output_buffer, kTestPacket));
+ EXPECT_EQ(Status::Internal(), channel.Send(output_buffer, kTestPacket));
}
TEST(Channel, OutputBuffer_ExactFit) {
@@ -72,7 +72,7 @@
EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
- EXPECT_EQ(Status::OK, channel.Send(output_buffer, kTestPacket));
+ EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
}
TEST(Channel, OutputBuffer_PayloadDoesNotFit_ReportsError) {
@@ -83,7 +83,7 @@
byte data[1] = {};
packet.set_payload(data);
- EXPECT_EQ(Status::INTERNAL, channel.Send(packet));
+ EXPECT_EQ(Status::Internal(), channel.Send(packet));
}
TEST(Channel, OutputBuffer_ExtraRoom) {
@@ -96,7 +96,7 @@
EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
- EXPECT_EQ(Status::OK, channel.Send(output_buffer, kTestPacket));
+ EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
}
TEST(Channel, OutputBuffer_ReturnsStatusFromChannelOutputSend) {
@@ -104,9 +104,9 @@
internal::Channel channel(100, &output);
Channel::OutputBuffer output_buffer = channel.AcquireBuffer();
- output.set_send_status(Status::ABORTED);
+ output.set_send_status(Status::Aborted());
- EXPECT_EQ(Status::ABORTED, channel.Send(output_buffer, kTestPacket));
+ EXPECT_EQ(Status::Aborted(), channel.Send(output_buffer, kTestPacket));
}
} // namespace
diff --git a/pw_rpc/nanopb/codegen_test.cc b/pw_rpc/nanopb/codegen_test.cc
index a65ff9d..10ab42a 100644
--- a/pw_rpc/nanopb/codegen_test.cc
+++ b/pw_rpc/nanopb/codegen_test.cc
@@ -53,28 +53,28 @@
TEST(NanopbCodegen, InvokeUnaryRpc) {
TestMethodContext<&test::TestService::TestRpc> context;
- EXPECT_EQ(Status::OK,
- context.call({.integer = 123, .status_code = Status::OK}));
+ EXPECT_EQ(Status::Ok(),
+ context.call({.integer = 123, .status_code = Status::Ok()}));
EXPECT_EQ(124, context.response().value);
EXPECT_EQ(
- Status::INVALID_ARGUMENT,
- context.call({.integer = 999, .status_code = Status::INVALID_ARGUMENT}));
+ Status::InvalidArgument(),
+ context.call({.integer = 999, .status_code = Status::InvalidArgument()}));
EXPECT_EQ(1000, context.response().value);
}
TEST(NanopbCodegen, InvokeStreamingRpc) {
TestMethodContext<&test::TestService::TestStreamRpc> context;
- context.call({.integer = 0, .status_code = Status::ABORTED});
+ context.call({.integer = 0, .status_code = Status::Aborted()});
- EXPECT_EQ(Status::ABORTED, context.status());
+ EXPECT_EQ(Status::Aborted(), context.status());
EXPECT_TRUE(context.done());
EXPECT_TRUE(context.responses().empty());
EXPECT_EQ(0u, context.total_responses());
- context.call({.integer = 4, .status_code = Status::OK});
+ context.call({.integer = 4, .status_code = Status::Ok()});
ASSERT_EQ(4u, context.responses().size());
ASSERT_EQ(4u, context.total_responses());
@@ -83,7 +83,7 @@
EXPECT_EQ(context.responses()[i].number, i);
}
- EXPECT_EQ(Status::OK, context.status());
+ EXPECT_EQ(Status::Ok(), context.status());
}
TEST(NanopbCodegen, InvokeStreamingRpc_ContextKeepsFixedNumberOfResponses) {
@@ -91,7 +91,7 @@
ASSERT_EQ(3u, context.responses().max_size());
- context.call({.integer = 5, .status_code = Status::NOT_FOUND});
+ context.call({.integer = 5, .status_code = Status::NotFound()});
ASSERT_EQ(3u, context.responses().size());
ASSERT_EQ(5u, context.total_responses());
@@ -114,9 +114,9 @@
EXPECT_FALSE(context.done());
- writer.Finish(Status::CANCELLED);
+ writer.Finish(Status::Cancelled());
ASSERT_TRUE(context.done());
- EXPECT_EQ(Status::CANCELLED, context.status());
+ EXPECT_EQ(Status::Cancelled(), context.status());
ASSERT_EQ(3u, context.responses().size());
ASSERT_EQ(3u, context.total_responses());
diff --git a/pw_rpc/nanopb/echo_service_test.cc b/pw_rpc/nanopb/echo_service_test.cc
index 4f69533..2d4b6f2 100644
--- a/pw_rpc/nanopb/echo_service_test.cc
+++ b/pw_rpc/nanopb/echo_service_test.cc
@@ -21,13 +21,13 @@
TEST(EchoService, Echo_EchoesRequestMessage) {
TestMethodContext<&EchoService::Echo> context;
- ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), Status::OK);
+ ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), Status::Ok());
EXPECT_STREQ(context.response().msg, "Hello, world");
}
TEST(EchoService, Echo_EmptyRequest) {
TestMethodContext<&EchoService::Echo> context;
- ASSERT_EQ(context.call({.msg = {}}), Status::OK);
+ ASSERT_EQ(context.call({.msg = {}}), Status::Ok());
EXPECT_STREQ(context.response().msg, "");
}
diff --git a/pw_rpc/nanopb/nanopb_method.cc b/pw_rpc/nanopb/nanopb_method.cc
index 72a0d7a..bc96dc9 100644
--- a/pw_rpc/nanopb/nanopb_method.cc
+++ b/pw_rpc/nanopb/nanopb_method.cc
@@ -55,7 +55,7 @@
PW_LOG_WARN("Failed to decode request payload from channel %u",
unsigned(channel.id()));
- channel.Send(Packet::ServerError(request, Status::DATA_LOSS));
+ channel.Send(Packet::ServerError(request, Status::DataLoss()));
return false;
}
@@ -80,7 +80,8 @@
PW_LOG_WARN("Failed to encode response packet for channel %u",
unsigned(channel.id()));
- channel.Send(response_buffer, Packet::ServerError(request, Status::INTERNAL));
+ channel.Send(response_buffer,
+ Packet::ServerError(request, Status::Internal()));
}
} // namespace pw::rpc::internal
diff --git a/pw_rpc/nanopb/nanopb_method_test.cc b/pw_rpc/nanopb/nanopb_method_test.cc
index 31b2397..a98ea50 100644
--- a/pw_rpc/nanopb/nanopb_method_test.cc
+++ b/pw_rpc/nanopb/nanopb_method_test.cc
@@ -77,13 +77,13 @@
pw_rpc_test_TestResponse& response) {
last_request = request;
response.value = request.integer + 5;
- return Status::UNAUTHENTICATED;
+ return Status::Unauthenticated();
}
Status DoNothing(ServerContext&,
const pw_rpc_test_Empty&,
pw_rpc_test_Empty&) {
- return Status::UNKNOWN;
+ return Status::Unknown();
}
void StartStream(ServerContext&,
@@ -103,7 +103,7 @@
method.Invoke(context.get(), context.packet(request));
const Packet& response = context.output().sent_packet();
- EXPECT_EQ(response.status(), Status::UNAUTHENTICATED);
+ EXPECT_EQ(response.status(), Status::Unauthenticated());
// Field 1 (encoded as 1 << 3) with 128 as the value.
constexpr std::byte expected[]{
@@ -125,7 +125,7 @@
const Packet& packet = context.output().sent_packet();
EXPECT_EQ(PacketType::SERVER_ERROR, packet.type());
- EXPECT_EQ(Status::DATA_LOSS, packet.status());
+ EXPECT_EQ(Status::DataLoss(), packet.status());
EXPECT_EQ(context.kServiceId, packet.service_id());
EXPECT_EQ(method.id(), packet.method_id());
}
@@ -145,7 +145,7 @@
const Packet& packet = context.output().sent_packet();
EXPECT_EQ(PacketType::SERVER_ERROR, packet.type());
- EXPECT_EQ(Status::INTERNAL, packet.status());
+ EXPECT_EQ(Status::Internal(), packet.status());
EXPECT_EQ(context.kServiceId, packet.service_id());
EXPECT_EQ(method.id(), packet.method_id());
@@ -171,12 +171,12 @@
method.Invoke(context.get(), context.packet({}));
- EXPECT_EQ(Status::OK, last_writer.Write({.value = 100}));
+ EXPECT_EQ(Status::Ok(), last_writer.Write({.value = 100}));
PW_ENCODE_PB(pw_rpc_test_TestResponse, payload, .value = 100);
std::array<byte, 128> encoded_response = {};
auto encoded = context.packet(payload).Encode(encoded_response);
- ASSERT_EQ(Status::OK, encoded.status());
+ ASSERT_EQ(Status::Ok(), encoded.status());
ASSERT_EQ(encoded.size(), context.output().sent_data().size());
EXPECT_EQ(0,
@@ -200,13 +200,13 @@
// Verify that the encoded size of a packet with an empty payload is correct.
std::array<byte, 128> encoded_response = {};
auto encoded = context.packet({}).Encode(encoded_response);
- ASSERT_EQ(Status::OK, encoded.status());
+ ASSERT_EQ(Status::Ok(), encoded.status());
ASSERT_EQ(kNoPayloadPacketSize, encoded.size());
method.Invoke(context.get(), context.packet({}));
- EXPECT_EQ(Status::OK, last_writer.Write({})); // Barely fits
- EXPECT_EQ(Status::INTERNAL, last_writer.Write({.value = 1})); // Too big
+ EXPECT_EQ(Status::Ok(), last_writer.Write({})); // Barely fits
+ EXPECT_EQ(Status::Internal(), last_writer.Write({.value = 1})); // Too big
}
} // namespace
diff --git a/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h b/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
index 0ce388c..127c712 100644
--- a/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
+++ b/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
@@ -25,7 +25,7 @@
const pw_rpc_EchoMessage& request,
pw_rpc_EchoMessage& response) {
std::strncpy(response.msg, request.msg, sizeof(response.msg));
- return Status::OK;
+ return Status::Ok();
}
};
diff --git a/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h b/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h
index 3a1508c..3a97cff 100644
--- a/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h
+++ b/pw_rpc/nanopb/public/pw_rpc/internal/nanopb_method.h
@@ -300,7 +300,7 @@
}
ReleasePayloadBuffer({});
- return Status::INTERNAL;
+ return Status::Internal();
}
} // namespace pw::rpc
diff --git a/pw_rpc/nanopb/public/pw_rpc/test_method_context.h b/pw_rpc/nanopb/public/pw_rpc/test_method_context.h
index 07fdd3c..c30941b 100644
--- a/pw_rpc/nanopb/public/pw_rpc/test_method_context.h
+++ b/pw_rpc/nanopb/public/pw_rpc/test_method_context.h
@@ -36,7 +36,7 @@
// struct can be accessed via context.response().
//
// pw::rpc::TestMethodContext<&my::CoolService::TheMethod> context;
-// EXPECT_EQ(Status::OK, context.call({.some_arg = 123}));
+// EXPECT_EQ(Status::Ok(), context.call({.some_arg = 123}));
// EXPECT_EQ(500, context.response().some_response_value);
//
// For a server streaming RPC, context.call(request) invokes the method. As in a
@@ -47,7 +47,7 @@
// context.call({.some_arg = 123});
//
// EXPECT_TRUE(context.done()); // Check that the RPC completed
-// EXPECT_EQ(Status::OK, context.status()); // Check the status
+// EXPECT_EQ(Status::Ok(), context.status()); // Check the status
//
// EXPECT_EQ(3u, context.responses().size());
// EXPECT_EQ(123, context.responses()[0].value); // check individual responses
@@ -237,7 +237,7 @@
responses_.clear();
total_responses_ = 0;
stream_ended_ = false;
- last_status_ = Status::UNKNOWN;
+ last_status_ = Status::Unknown();
}
template <typename Response>
@@ -245,7 +245,7 @@
PW_CHECK(!stream_ended_);
if (size == 0u) {
- return Status::OK;
+ return Status::Ok();
}
internal::Packet packet;
@@ -268,7 +268,7 @@
default:
PW_CRASH("Unhandled PacketType");
}
- return Status::OK;
+ return Status::Ok();
}
} // namespace internal::test
diff --git a/pw_rpc/packet.cc b/pw_rpc/packet.cc
index dfbdb50..56969ca 100644
--- a/pw_rpc/packet.cc
+++ b/pw_rpc/packet.cc
@@ -64,7 +64,7 @@
}
}
- return status == Status::DATA_LOSS ? Status::DATA_LOSS : Status::OK;
+ return status == Status::DataLoss() ? Status::DataLoss() : Status::Ok();
}
StatusWithSize Packet::Encode(std::span<byte> buffer) const {
diff --git a/pw_rpc/packet_test.cc b/pw_rpc/packet_test.cc
index 44b2df9..2fd53a2 100644
--- a/pw_rpc/packet_test.cc
+++ b/pw_rpc/packet_test.cc
@@ -87,12 +87,12 @@
auto sws = packet.Encode(buffer);
EXPECT_EQ(0u, sws.size());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sws.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sws.status());
}
TEST(Packet, Decode_ValidPacket) {
Packet packet;
- ASSERT_EQ(Status::OK, Packet::FromBuffer(kEncoded, packet));
+ ASSERT_EQ(Status::Ok(), Packet::FromBuffer(kEncoded, packet));
EXPECT_EQ(PacketType::RESPONSE, packet.type());
EXPECT_EQ(1u, packet.channel_id());
@@ -108,7 +108,7 @@
byte bad_data[] = {byte{0xFF}, byte{0x00}, byte{0x00}, byte{0xFF}};
Packet packet;
- EXPECT_EQ(Status::DATA_LOSS, Packet::FromBuffer(bad_data, packet));
+ EXPECT_EQ(Status::DataLoss(), Packet::FromBuffer(bad_data, packet));
}
TEST(Packet, EncodeDecode) {
@@ -119,15 +119,15 @@
packet.set_service_id(0xdeadbeef);
packet.set_method_id(0x03a82921);
packet.set_payload(payload);
- packet.set_status(Status::UNAVAILABLE);
+ packet.set_status(Status::Unavailable());
byte buffer[128];
StatusWithSize sws = packet.Encode(buffer);
- ASSERT_EQ(sws.status(), Status::OK);
+ ASSERT_EQ(sws.status(), Status::Ok());
std::span<byte> packet_data(buffer, sws.size());
Packet decoded;
- ASSERT_EQ(Status::OK, Packet::FromBuffer(packet_data, decoded));
+ ASSERT_EQ(Status::Ok(), Packet::FromBuffer(packet_data, decoded));
EXPECT_EQ(decoded.type(), packet.type());
EXPECT_EQ(decoded.channel_id(), packet.channel_id());
@@ -138,7 +138,7 @@
packet.payload().data(),
packet.payload().size()),
0);
- EXPECT_EQ(decoded.status(), Status::UNAVAILABLE);
+ EXPECT_EQ(decoded.status(), Status::Unavailable());
}
constexpr size_t kReservedSize = 2 /* type */ + 2 /* channel */ +
diff --git a/pw_rpc/public/pw_rpc/internal/base_server_writer.h b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
index 1ace1e6..295cd4c 100644
--- a/pw_rpc/public/pw_rpc/internal/base_server_writer.h
+++ b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
@@ -53,7 +53,7 @@
uint32_t method_id() const;
// Closes the ServerWriter, if it is open.
- void Finish(Status status = Status::OK);
+ void Finish(Status status = Status::Ok());
protected:
constexpr BaseServerWriter() : state_{kClosed} {}
diff --git a/pw_rpc/public/pw_rpc/internal/packet.h b/pw_rpc/public/pw_rpc/internal/packet.h
index a6feddf..f881187 100644
--- a/pw_rpc/public/pw_rpc/internal/packet.h
+++ b/pw_rpc/public/pw_rpc/internal/packet.h
@@ -33,7 +33,7 @@
// Creates an RPC packet with the channel, service, and method ID of the
// provided packet.
static constexpr Packet Response(const Packet& request,
- Status status = Status::OK) {
+ Status status = Status::Ok()) {
return Packet(PacketType::RESPONSE,
request.channel_id(),
request.service_id(),
@@ -62,7 +62,7 @@
uint32_t service_id,
uint32_t method_id,
std::span<const std::byte> payload = {},
- Status status = Status::OK)
+ Status status = Status::Ok())
: type_(type),
channel_id_(channel_id),
service_id_(service_id),
diff --git a/pw_rpc/pw_rpc_private/internal_test_utils.h b/pw_rpc/pw_rpc_private/internal_test_utils.h
index c3f958d..aeb2237 100644
--- a/pw_rpc/pw_rpc_private/internal_test_utils.h
+++ b/pw_rpc/pw_rpc_private/internal_test_utils.h
@@ -41,13 +41,13 @@
Status SendAndReleaseBuffer(size_t size) override {
if (size == 0u) {
- return Status::OK;
+ return Status::Ok();
}
packet_count_ += 1;
sent_data_ = std::span(buffer_.data(), size);
Status status = internal::Packet::FromBuffer(sent_data_, sent_packet_);
- EXPECT_EQ(Status::OK, status);
+ EXPECT_EQ(Status::Ok(), status);
return send_status_;
}
@@ -106,7 +106,7 @@
kServiceId,
context_.method().id(),
payload,
- Status::OK);
+ Status::Ok());
}
internal::ServerCall& get() { return context_; }
@@ -144,13 +144,13 @@
// Sends a packet to be processed by the client. Returns the client's
// ProcessPacket status.
Status SendPacket(internal::PacketType type,
- Status status = Status::OK,
+ Status status = Status::Ok(),
std::span<const std::byte> payload = {}) {
internal::Packet packet(
type, kChannelId, kServiceId, kMethodId, payload, status);
std::byte buffer[input_buffer_size];
StatusWithSize sws = packet.Encode(buffer);
- EXPECT_EQ(sws.status(), Status::OK);
+ EXPECT_EQ(sws.status(), Status::Ok());
return client_.ProcessPacket(std::span(buffer, sws.size()));
}
diff --git a/pw_rpc/server.cc b/pw_rpc/server.cc
index 109221d..f7afeea 100644
--- a/pw_rpc/server.cc
+++ b/pw_rpc/server.cc
@@ -45,7 +45,7 @@
// Only send an ERROR response if a valid channel ID was provided.
if (packet.channel_id() != Channel::kUnassignedChannelId) {
internal::Channel temp_channel(packet.channel_id(), &interface);
- temp_channel.Send(Packet::ServerError(packet, Status::DATA_LOSS));
+ temp_channel.Send(Packet::ServerError(packet, Status::DataLoss()));
}
return false;
}
@@ -67,11 +67,11 @@
ChannelOutput& interface) {
Packet packet;
if (!DecodePacket(interface, data, packet)) {
- return Status::DATA_LOSS;
+ return Status::DataLoss();
}
if (packet.destination() != Packet::kServer) {
- return Status::INVALID_ARGUMENT;
+ return Status::InvalidArgument();
}
internal::Channel* channel = FindChannel(packet.channel_id());
@@ -82,16 +82,16 @@
// If a channel can't be assigned, send a RESOURCE_EXHAUSTED error.
internal::Channel temp_channel(packet.channel_id(), &interface);
temp_channel.Send(
- Packet::ServerError(packet, Status::RESOURCE_EXHAUSTED));
- return Status::OK; // OK since the packet was handled
+ Packet::ServerError(packet, Status::ResourceExhausted()));
+ return Status::Ok(); // OK since the packet was handled
}
}
const auto [service, method] = FindMethod(packet);
if (method == nullptr) {
- channel->Send(Packet::ServerError(packet, Status::NOT_FOUND));
- return Status::OK;
+ channel->Send(Packet::ServerError(packet, Status::NotFound()));
+ return Status::Ok();
}
switch (packet.type()) {
@@ -112,11 +112,11 @@
HandleCancelPacket(packet, *channel);
break;
default:
- channel->Send(Packet::ServerError(packet, Status::UNIMPLEMENTED));
+ channel->Send(Packet::ServerError(packet, Status::Unimplemented()));
PW_LOG_WARN("Unable to handle packet of type %u",
unsigned(packet.type()));
}
- return Status::OK;
+ return Status::Ok();
}
std::tuple<Service*, const internal::Method*> Server::FindMethod(
@@ -142,10 +142,10 @@
});
if (writer == writers_.end()) {
- channel.Send(Packet::ServerError(packet, Status::FAILED_PRECONDITION));
+ channel.Send(Packet::ServerError(packet, Status::FailedPrecondition()));
PW_LOG_WARN("Received CANCEL packet for method that is not pending");
} else {
- writer->Finish(Status::CANCELLED);
+ writer->Finish(Status::Cancelled());
}
}
diff --git a/pw_rpc/server_test.cc b/pw_rpc/server_test.cc
index 7c7a0fd..44a7888 100644
--- a/pw_rpc/server_test.cc
+++ b/pw_rpc/server_test.cc
@@ -81,7 +81,7 @@
std::span<const byte> payload = kDefaultPayload) {
auto sws = Packet(type, channel_id, service_id, method_id, payload)
.Encode(request_buffer_);
- EXPECT_EQ(Status::OK, sws.status());
+ EXPECT_EQ(Status::Ok(), sws.status());
return std::span(request_buffer_, sws.size());
}
@@ -95,7 +95,7 @@
};
TEST_F(BasicServer, ProcessPacket_ValidMethod_InvokesMethod) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, 1, 42, 100), output_));
@@ -109,13 +109,13 @@
}
TEST_F(BasicServer, ProcessPacket_IncompletePacket_NothingIsInvoked) {
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, 0, 42, 101), output_));
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 0, 101),
output_));
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 0),
output_));
@@ -124,7 +124,7 @@
}
TEST_F(BasicServer, ProcessPacket_NoChannel_SendsNothing) {
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, 0, 42, 101), output_));
@@ -132,25 +132,25 @@
}
TEST_F(BasicServer, ProcessPacket_NoService_SendsDataLoss) {
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 0, 101),
output_));
EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
- EXPECT_EQ(output_.sent_packet().status(), Status::DATA_LOSS);
+ EXPECT_EQ(output_.sent_packet().status(), Status::DataLoss());
}
TEST_F(BasicServer, ProcessPacket_NoMethod_SendsDataLoss) {
- EXPECT_EQ(Status::DATA_LOSS,
+ EXPECT_EQ(Status::DataLoss(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 0),
output_));
EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
- EXPECT_EQ(output_.sent_packet().status(), Status::DATA_LOSS);
+ EXPECT_EQ(output_.sent_packet().status(), Status::DataLoss());
}
TEST_F(BasicServer, ProcessPacket_InvalidMethod_NothingIsInvoked) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, 1, 42, 101), output_));
@@ -159,7 +159,7 @@
}
TEST_F(BasicServer, ProcessPacket_InvalidMethod_SendsError) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 27),
output_));
@@ -168,11 +168,11 @@
EXPECT_EQ(packet.channel_id(), 1u);
EXPECT_EQ(packet.service_id(), 42u);
EXPECT_EQ(packet.method_id(), 27u); // No method ID 27
- EXPECT_EQ(packet.status(), Status::NOT_FOUND);
+ EXPECT_EQ(packet.status(), Status::NotFound());
}
TEST_F(BasicServer, ProcessPacket_InvalidService_SendsError) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 43, 27),
output_));
@@ -181,12 +181,12 @@
EXPECT_EQ(packet.channel_id(), 1u);
EXPECT_EQ(packet.service_id(), 43u); // No service ID 43
EXPECT_EQ(packet.method_id(), 27u);
- EXPECT_EQ(packet.status(), Status::NOT_FOUND);
+ EXPECT_EQ(packet.status(), Status::NotFound());
}
TEST_F(BasicServer, ProcessPacket_UnassignedChannel_AssignsToAvailableSlot) {
TestOutput<128> unassigned_output;
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 100),
unassigned_output));
@@ -197,13 +197,13 @@
ProcessPacket_UnassignedChannel_SendsResourceExhaustedIfCannotAssign) {
channels_[2] = Channel::Create<3>(&output_); // Occupy only available channel
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 27),
output_));
const Packet& packet = output_.sent_packet();
- EXPECT_EQ(packet.status(), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(packet.status(), Status::ResourceExhausted());
EXPECT_EQ(packet.channel_id(), 99u);
EXPECT_EQ(packet.service_id(), 42u);
EXPECT_EQ(packet.method_id(), 27u);
@@ -211,7 +211,7 @@
TEST_F(BasicServer, ProcessPacket_Cancel_MethodNotActive_SendsError) {
// Set up a fake ServerWriter representing an ongoing RPC.
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
output_));
@@ -221,7 +221,7 @@
EXPECT_EQ(packet.channel_id(), 1u);
EXPECT_EQ(packet.service_id(), 42u);
EXPECT_EQ(packet.method_id(), 100u);
- EXPECT_EQ(packet.status(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(packet.status(), Status::FailedPrecondition());
}
class MethodPending : public BasicServer {
@@ -240,7 +240,7 @@
};
TEST_F(MethodPending, ProcessPacket_Cancel_ClosesServerWriter) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
output_));
@@ -249,7 +249,7 @@
}
TEST_F(MethodPending, ProcessPacket_Cancel_SendsStreamEndPacket) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
output_));
@@ -260,40 +260,40 @@
EXPECT_EQ(packet.service_id(), 42u);
EXPECT_EQ(packet.method_id(), 100u);
EXPECT_TRUE(packet.payload().empty());
- EXPECT_EQ(packet.status(), Status::CANCELLED);
+ EXPECT_EQ(packet.status(), Status::Cancelled());
}
TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectChannel) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 2, 42, 100),
output_));
EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
- EXPECT_EQ(output_.sent_packet().status(), Status::FAILED_PRECONDITION);
+ EXPECT_EQ(output_.sent_packet().status(), Status::FailedPrecondition());
EXPECT_TRUE(writer_.open());
}
TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectService) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 43, 100),
output_));
EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
- EXPECT_EQ(output_.sent_packet().status(), Status::NOT_FOUND);
+ EXPECT_EQ(output_.sent_packet().status(), Status::NotFound());
EXPECT_EQ(output_.sent_packet().service_id(), 43u);
EXPECT_EQ(output_.sent_packet().method_id(), 100u);
EXPECT_TRUE(writer_.open());
}
TEST_F(MethodPending, ProcessPacket_CancelIncorrectMethod) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(Status::Ok(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 101),
output_));
EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR);
- EXPECT_EQ(output_.sent_packet().status(), Status::NOT_FOUND);
+ EXPECT_EQ(output_.sent_packet().status(), Status::NotFound());
EXPECT_TRUE(writer_.open());
}
diff --git a/pw_status/public/pw_status/status.h b/pw_status/public/pw_status/status.h
index d4c591e..2a46335 100644
--- a/pw_status/public/pw_status/status.h
+++ b/pw_status/public/pw_status/status.h
@@ -27,39 +27,39 @@
// pw_Status uses the canonical Google error codes. The following was copied
// from Tensorflow and prefixed with PW_STATUS_.
typedef enum {
- PW_STATUS_OK = 0, // Use Status::OK in C++
+ PW_STATUS_OK = 0, // Use Status::Ok() in C++
// The operation was cancelled (typically by the caller).
- PW_STATUS_CANCELLED = 1, // Use Status::CANCELLED in C++
+ PW_STATUS_CANCELLED = 1, // Use Status::Cancelled() in C++
// Unknown error. An example of where this error may be returned is
// if a Status value received from another address space belongs to
// an error-space that is not known in this address space. Also,
// errors raised by APIs that do not return enough error information
// may be converted to this error.
- PW_STATUS_UNKNOWN = 2, // Use Status::UNKNOWN in C++
+ PW_STATUS_UNKNOWN = 2, // Use Status::Unknown() in C++
// Client specified an invalid argument. Note that this differs
// from FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments
// that are problematic regardless of the state of the system
// (e.g. a malformed file name).
- PW_STATUS_INVALID_ARGUMENT = 3, // Use Status::INVALID_ARGUMENT in C++
+ PW_STATUS_INVALID_ARGUMENT = 3, // Use Status::InvalidArgument() in C++
// Deadline expired before operation could complete. For operations
// that change the state of the system, this error may be returned
// even if the operation has completed successfully. For example, a
// successful response from a server could have been delayed long
// enough for the deadline to expire.
- PW_STATUS_DEADLINE_EXCEEDED = 4, // Use Status::DEADLINE_EXCEEDED in C++
+ PW_STATUS_DEADLINE_EXCEEDED = 4, // Use Status::DeadlineExceeded() in C++
// Some requested entity (e.g. file or directory) was not found.
// For privacy reasons, this code *may* be returned when the client
// does not have the access right to the entity.
- PW_STATUS_NOT_FOUND = 5, // Use Status::NOT_FOUND in C++
+ PW_STATUS_NOT_FOUND = 5, // Use Status::NotFound() in C++
// Some entity that we attempted to create (e.g. file or directory)
// already exists.
- PW_STATUS_ALREADY_EXISTS = 6, // Use Status::ALREADY_EXISTS in C++
+ PW_STATUS_ALREADY_EXISTS = 6, // Use Status::AlreadyExists() in C++
// The caller does not have permission to execute the specified
// operation. PERMISSION_DENIED must not be used for rejections
@@ -67,15 +67,15 @@
// instead for those errors). PERMISSION_DENIED must not be
// used if the caller cannot be identified (use UNAUTHENTICATED
// instead for those errors).
- PW_STATUS_PERMISSION_DENIED = 7, // Use Status::PERMISSION_DENIED in C++
+ PW_STATUS_PERMISSION_DENIED = 7, // Use Status::PermissionDenied() in C++
// The request does not have valid authentication credentials for the
// operation.
- PW_STATUS_UNAUTHENTICATED = 16, // Use Status::UNAUTHENTICATED in C++
+ PW_STATUS_UNAUTHENTICATED = 16, // Use Status::Unauthenticated() in C++
// Some resource has been exhausted, perhaps a per-user quota, or
// perhaps the entire filesystem is out of space.
- PW_STATUS_RESOURCE_EXHAUSTED = 8, // Use Status::RESOURCE_EXHAUSTED in C++
+ PW_STATUS_RESOURCE_EXHAUSTED = 8, // Use Status::ResourceExhausted() in C++
// Operation was rejected because the system is not in a state
// required for the operation's execution. For example, directory
@@ -96,14 +96,14 @@
// REST Get/Update/Delete on a resource and the resource on the
// server does not match the condition. E.g. conflicting
// read-modify-write on the same resource.
- PW_STATUS_FAILED_PRECONDITION = 9, // Use Status::FAILED_PRECONDITION in C++
+ PW_STATUS_FAILED_PRECONDITION = 9, // Use Status::FailedPrecondition() in C++
// The operation was aborted, typically due to a concurrency issue
// like sequencer check failures, transaction aborts, etc.
//
// See litmus test above for deciding between FAILED_PRECONDITION,
// ABORTED, and UNAVAILABLE.
- PW_STATUS_ABORTED = 10, // Use Status::ABORTED in C++
+ PW_STATUS_ABORTED = 10, // Use Status::Aborted() in C++
// Operation tried to iterate past the valid input range. E.g. seeking or
// reading past end of file.
@@ -120,15 +120,15 @@
// error) when it applies so that callers who are iterating through
// a space can easily look for an OUT_OF_RANGE error to detect when
// they are done.
- PW_STATUS_OUT_OF_RANGE = 11, // Use Status::OUT_OF_RANGE in C++
+ PW_STATUS_OUT_OF_RANGE = 11, // Use Status::OutOfRange() in C++
// Operation is not implemented or not supported/enabled in this service.
- PW_STATUS_UNIMPLEMENTED = 12, // Use Status::UNIMPLEMENTED in C++
+ PW_STATUS_UNIMPLEMENTED = 12, // Use Status::Unimplemented() in C++
// Internal errors. Means some invariants expected by underlying
// system has been broken. If you see one of these errors,
// something is very broken.
- PW_STATUS_INTERNAL = 13, // Use Status::INTERNAL in C++
+ PW_STATUS_INTERNAL = 13, // Use Status::Internal() in C++
// The service is currently unavailable. This is a most likely a
// transient condition and may be corrected by retrying with
@@ -136,10 +136,10 @@
//
// See litmus test above for deciding between FAILED_PRECONDITION,
// ABORTED, and UNAVAILABLE.
- PW_STATUS_UNAVAILABLE = 14, // Use Status::UNAVAILABLE in C++
+ PW_STATUS_UNAVAILABLE = 14, // Use Status::Unavailable() in C++
// Unrecoverable data loss or corruption.
- PW_STATUS_DATA_LOSS = 15, // Use Status::DATA_LOSS in C++
+ PW_STATUS_DATA_LOSS = 15, // Use Status::DataLoss() in C++
// An extra enum entry to prevent people from writing code that
// fails to compile when a new code is added.
@@ -194,14 +194,14 @@
namespace pw {
// The Status class is a thin, zero-cost abstraction around the pw_Status enum.
-// It initializes to Status::OK by default and adds ok() and str() methods.
+// It initializes to Status::Ok() by default and adds ok() and str() methods.
// Implicit conversions are permitted between pw_Status and pw::Status.
class Status {
public:
using Code = pw_Status;
// All of the pw_Status codes are available in the Status class as, e.g.
- // pw::Status::OK or pw::Status::OUT_OF_RANGE.
+ // pw::Status::Ok() or pw::Status::OutOfRange().
//
// These aliases are DEPRECATED -- prefer using the helper functions below.
// For example, change Status::CANCELLED to Status::Cancelled().
@@ -289,7 +289,7 @@
// Status implicitly converts to a Status::Code.
constexpr operator Code() const { return code_; }
- // True if the status is Status::OK.
+ // True if the status is Status::Ok().
constexpr bool ok() const { return code_ == PW_STATUS_OK; }
// Returns a null-terminated string representation of the Status.
diff --git a/pw_status/public/pw_status/status_with_size.h b/pw_status/public/pw_status/status_with_size.h
index 6064dc3..8c79e8c 100644
--- a/pw_status/public/pw_status/status_with_size.h
+++ b/pw_status/public/pw_status/status_with_size.h
@@ -75,28 +75,28 @@
public:
// Non-OK StatusWithSizes can be constructed from these constants, such as:
//
- // StatusWithSize result = StatusWithSize::NOT_FOUND;
+ // StatusWithSize result = StatusWithSize::NotFound();
//
// These constants are DEPRECATED! Use the helper functions below instead. For
- // example, change StatusWithSize::NOT_FOUND to StatusWithSize::NotFound().
+ // example, change StatusWithSize::NotFound() to StatusWithSize::NotFound().
//
// TODO(pwbug/268): Migrate to the functions and remove these constants.
- static constexpr Constant CANCELLED{Status::CANCELLED};
- static constexpr Constant UNKNOWN{Status::UNKNOWN};
- static constexpr Constant INVALID_ARGUMENT{Status::INVALID_ARGUMENT};
- static constexpr Constant DEADLINE_EXCEEDED{Status::DEADLINE_EXCEEDED};
- static constexpr Constant NOT_FOUND{Status::NOT_FOUND};
- static constexpr Constant ALREADY_EXISTS{Status::ALREADY_EXISTS};
- static constexpr Constant PERMISSION_DENIED{Status::PERMISSION_DENIED};
- static constexpr Constant RESOURCE_EXHAUSTED{Status::RESOURCE_EXHAUSTED};
- static constexpr Constant FAILED_PRECONDITION{Status::FAILED_PRECONDITION};
- static constexpr Constant ABORTED{Status::ABORTED};
- static constexpr Constant OUT_OF_RANGE{Status::OUT_OF_RANGE};
- static constexpr Constant UNIMPLEMENTED{Status::UNIMPLEMENTED};
- static constexpr Constant INTERNAL{Status::INTERNAL};
- static constexpr Constant UNAVAILABLE{Status::UNAVAILABLE};
- static constexpr Constant DATA_LOSS{Status::DATA_LOSS};
- static constexpr Constant UNAUTHENTICATED{Status::UNAUTHENTICATED};
+ static constexpr Constant CANCELLED{Status::Cancelled()};
+ static constexpr Constant UNKNOWN{Status::Unknown()};
+ static constexpr Constant INVALID_ARGUMENT{Status::InvalidArgument()};
+ static constexpr Constant DEADLINE_EXCEEDED{Status::DeadlineExceeded()};
+ static constexpr Constant NOT_FOUND{Status::NotFound()};
+ static constexpr Constant ALREADY_EXISTS{Status::AlreadyExists()};
+ static constexpr Constant PERMISSION_DENIED{Status::PermissionDenied()};
+ static constexpr Constant RESOURCE_EXHAUSTED{Status::ResourceExhausted()};
+ static constexpr Constant FAILED_PRECONDITION{Status::FailedPrecondition()};
+ static constexpr Constant ABORTED{Status::Aborted()};
+ static constexpr Constant OUT_OF_RANGE{Status::OutOfRange()};
+ static constexpr Constant UNIMPLEMENTED{Status::Unimplemented()};
+ static constexpr Constant INTERNAL{Status::Internal()};
+ static constexpr Constant UNAVAILABLE{Status::Unavailable()};
+ static constexpr Constant DATA_LOSS{Status::DataLoss()};
+ static constexpr Constant UNAUTHENTICATED{Status::Unauthenticated()};
// Functions that create a StatusWithSize with the specified status code. For
// codes other than OK, the size defaults to 0.
@@ -177,7 +177,7 @@
// The maximum valid value for size.
static constexpr size_t max_size() { return kSizeMask; }
- // True if status() == Status::OK.
+ // True if status() == Status::Ok().
constexpr bool ok() const { return (size_ & kStatusMask) == 0u; }
constexpr Status status() const {
diff --git a/pw_status/try_test.cc b/pw_status/try_test.cc
index 4d52e5a..b84258b 100644
--- a/pw_status/try_test.cc
+++ b/pw_status/try_test.cc
@@ -26,7 +26,7 @@
PW_TRY(ReturnStatus(status));
// Any status other than OK should have already returned.
- EXPECT_EQ(status, Status::OK);
+ EXPECT_EQ(status, Status::Ok());
return status;
}
@@ -34,45 +34,46 @@
PW_TRY(ReturnStatusWithSize(status));
// Any status other than OK should have already returned.
- EXPECT_EQ(status.status(), Status::OK);
+ EXPECT_EQ(status.status(), Status::Ok());
return status.status();
}
TEST(Status, Try_Status) {
- EXPECT_EQ(TryStatus(Status::OK), Status::OK);
+ EXPECT_EQ(TryStatus(Status::Ok()), Status::Ok());
// Don't need all the status types, just pick a few not-ok ones.
- EXPECT_EQ(TryStatus(Status::CANCELLED), Status::CANCELLED);
- EXPECT_EQ(TryStatus(Status::DATA_LOSS), Status::DATA_LOSS);
- EXPECT_EQ(TryStatus(Status::UNIMPLEMENTED), Status::UNIMPLEMENTED);
+ EXPECT_EQ(TryStatus(Status::Cancelled()), Status::Cancelled());
+ EXPECT_EQ(TryStatus(Status::DataLoss()), Status::DataLoss());
+ EXPECT_EQ(TryStatus(Status::Unimplemented()), Status::Unimplemented());
}
TEST(Status, Try_StatusWithSizeOk) {
for (size_t i = 0; i < 32; ++i) {
- StatusWithSize val(Status::OK, 0);
- EXPECT_EQ(TryStatus(val), Status::OK);
+ StatusWithSize val(Status::Ok(), 0);
+ EXPECT_EQ(TryStatus(val), Status::Ok());
}
}
TEST(Status, Try_StatusWithSizeError) {
for (size_t i = 0; i < 32; ++i) {
- StatusWithSize val(Status::DATA_LOSS, i);
- EXPECT_EQ(TryStatus(val), Status::DATA_LOSS);
+ StatusWithSize val(Status::DataLoss(), i);
+ EXPECT_EQ(TryStatus(val), Status::DataLoss());
}
}
TEST(Status, Try_StatusWithSizeFromConstant) {
// Don't need all the status types, just pick a few not-ok ones.
- EXPECT_EQ(TryStatus(StatusWithSize::CANCELLED), Status::CANCELLED);
- EXPECT_EQ(TryStatus(StatusWithSize::DATA_LOSS), Status::DATA_LOSS);
- EXPECT_EQ(TryStatus(StatusWithSize::UNIMPLEMENTED), Status::UNIMPLEMENTED);
+ EXPECT_EQ(TryStatus(StatusWithSize::Cancelled()), Status::Cancelled());
+ EXPECT_EQ(TryStatus(StatusWithSize::DataLoss()), Status::DataLoss());
+ EXPECT_EQ(TryStatus(StatusWithSize::Unimplemented()),
+ Status::Unimplemented());
}
Status TryStatusAssign(size_t& size_val, StatusWithSize status) {
PW_TRY_ASSIGN(size_val, ReturnStatusWithSize(status));
// Any status other than OK should have already returned.
- EXPECT_EQ(status.status(), Status::OK);
+ EXPECT_EQ(status.status(), Status::Ok());
EXPECT_EQ(size_val, status.size());
return status.status();
}
@@ -81,8 +82,8 @@
size_t size_val = 0;
for (size_t i = 1; i < 32; ++i) {
- StatusWithSize val(Status::OK, i);
- EXPECT_EQ(TryStatusAssign(size_val, val), Status::OK);
+ StatusWithSize val(Status::Ok(), i);
+ EXPECT_EQ(TryStatusAssign(size_val, val), Status::Ok());
EXPECT_EQ(size_val, i);
}
}
@@ -91,8 +92,8 @@
size_t size_val = 0u;
for (size_t i = 1; i < 32; ++i) {
- StatusWithSize val(Status::OUT_OF_RANGE, i);
- EXPECT_EQ(TryStatusAssign(size_val, val), Status::OUT_OF_RANGE);
+ StatusWithSize val(Status::OutOfRange(), i);
+ EXPECT_EQ(TryStatusAssign(size_val, val), Status::OutOfRange());
EXPECT_EQ(size_val, 0u);
}
}
@@ -109,52 +110,52 @@
PW_TRY_WITH_SIZE(ReturnStatus(status));
// Any status other than OK should have already returned.
- EXPECT_EQ(status, Status::OK);
+ EXPECT_EQ(status, Status::Ok());
StatusWithSize return_val(status, 0u);
return return_val;
}
TEST(Status, TryWithSize_StatusOk) {
- StatusWithSize result = TryStatusWithSize(Status::OK);
- EXPECT_EQ(result.status(), Status::OK);
+ StatusWithSize result = TryStatusWithSize(Status::Ok());
+ EXPECT_EQ(result.status(), Status::Ok());
EXPECT_EQ(result.size(), 0u);
}
TEST(Status, TryWithSize_StatusError) {
- StatusWithSize result = TryStatusWithSize(Status::PERMISSION_DENIED);
- EXPECT_EQ(result.status(), Status::PERMISSION_DENIED);
+ StatusWithSize result = TryStatusWithSize(Status::PermissionDenied());
+ EXPECT_EQ(result.status(), Status::PermissionDenied());
EXPECT_EQ(result.size(), 0u);
}
TEST(Status, TryWithSize_StatusWithSizeOk) {
for (size_t i = 0; i < 32; ++i) {
- StatusWithSize val(Status::OK, i);
- EXPECT_EQ(TryStatusWithSize(val).status(), Status::OK);
+ StatusWithSize val(Status::Ok(), i);
+ EXPECT_EQ(TryStatusWithSize(val).status(), Status::Ok());
EXPECT_EQ(TryStatusWithSize(val).size(), i);
}
}
TEST(Status, TryWithSize_StatusWithSizeError) {
for (size_t i = 0; i < 32; ++i) {
- StatusWithSize val(Status::DATA_LOSS, i);
+ StatusWithSize val(Status::DataLoss(), i);
StatusWithSize result = TryStatusWithSize(val);
- EXPECT_EQ(result.status(), Status::DATA_LOSS);
+ EXPECT_EQ(result.status(), Status::DataLoss());
EXPECT_EQ(result.size(), i);
}
}
TEST(Status, TryWithSize_StatusWithSizeConst) {
- StatusWithSize result = TryStatusWithSize(StatusWithSize::DATA_LOSS);
- EXPECT_EQ(result.status(), Status::DATA_LOSS);
+ StatusWithSize result = TryStatusWithSize(StatusWithSize::DataLoss());
+ EXPECT_EQ(result.status(), Status::DataLoss());
EXPECT_EQ(result.size(), 0u);
- result = TryStatusWithSize(StatusWithSize::NOT_FOUND);
- EXPECT_EQ(result.status(), Status::NOT_FOUND);
+ result = TryStatusWithSize(StatusWithSize::NotFound());
+ EXPECT_EQ(result.status(), Status::NotFound());
EXPECT_EQ(result.size(), 0u);
- result = TryStatusWithSize(StatusWithSize::UNIMPLEMENTED);
- EXPECT_EQ(result.status(), Status::UNIMPLEMENTED);
+ result = TryStatusWithSize(StatusWithSize::Unimplemented());
+ EXPECT_EQ(result.status(), Status::Unimplemented());
EXPECT_EQ(result.size(), 0u);
}
diff --git a/pw_stream/memory_stream.cc b/pw_stream/memory_stream.cc
index b0a9c36..8f7e29e 100644
--- a/pw_stream/memory_stream.cc
+++ b/pw_stream/memory_stream.cc
@@ -23,22 +23,22 @@
Status MemoryWriter::DoWrite(ConstByteSpan data) {
if (ConservativeWriteLimit() == 0) {
- return Status::OUT_OF_RANGE;
+ return Status::OutOfRange();
}
if (ConservativeWriteLimit() < data.size_bytes()) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
size_t bytes_to_write = data.size_bytes();
std::memcpy(dest_.data() + bytes_written_, data.data(), bytes_to_write);
bytes_written_ += bytes_to_write;
- return Status::OK;
+ return Status::Ok();
}
StatusWithSize MemoryReader::DoRead(ByteSpan dest) {
if (source_.size_bytes() == bytes_read_) {
- return StatusWithSize::OUT_OF_RANGE;
+ return StatusWithSize::OutOfRange();
}
size_t bytes_to_read =
diff --git a/pw_stream/memory_stream_test.cc b/pw_stream/memory_stream_test.cc
index e08a299..0a0241e 100644
--- a/pw_stream/memory_stream_test.cc
+++ b/pw_stream/memory_stream_test.cc
@@ -38,7 +38,7 @@
EXPECT_EQ(memory_writer.bytes_written(), 0u);
Status status =
memory_writer.Write(&kExpectedStruct, sizeof(kExpectedStruct));
- EXPECT_EQ(status, Status::OK);
+ EXPECT_EQ(status, Status::Ok());
EXPECT_EQ(memory_writer.bytes_written(), sizeof(kExpectedStruct));
} // namespace
@@ -68,13 +68,14 @@
for (size_t i = 0; i < sizeof(buffer); ++i) {
buffer[i] = std::byte(counter++);
}
- EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::OK);
+ EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::Ok());
}
EXPECT_GT(memory_writer.ConservativeWriteLimit(), 0u);
EXPECT_LT(memory_writer.ConservativeWriteLimit(), kTempBufferSize);
- EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::RESOURCE_EXHAUSTED);
+ EXPECT_EQ(memory_writer.Write(std::span(buffer)),
+ Status::ResourceExhausted());
EXPECT_EQ(memory_writer.bytes_written(), counter);
counter = 0;
@@ -98,12 +99,12 @@
size_t bytes_to_write =
std::min(sizeof(buffer), memory_writer.ConservativeWriteLimit());
EXPECT_EQ(memory_writer.Write(std::span(buffer, bytes_to_write)),
- Status::OK);
+ Status::Ok());
}
EXPECT_EQ(memory_writer.ConservativeWriteLimit(), 0u);
- EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::OUT_OF_RANGE);
+ EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::OutOfRange());
EXPECT_EQ(memory_writer.bytes_written(), memory_buffer.size());
for (const std::byte& value : memory_writer.WrittenData()) {
@@ -115,7 +116,7 @@
std::byte buffer[5] = {};
MemoryWriter memory_writer(memory_buffer);
- EXPECT_EQ(memory_writer.Write(buffer, 0), Status::OK);
+ EXPECT_EQ(memory_writer.Write(buffer, 0), Status::Ok());
EXPECT_EQ(memory_writer.bytes_written(), 0u);
}
@@ -169,7 +170,7 @@
// Read exactly the available bytes.
EXPECT_EQ(memory_reader.ConservativeReadLimit(), dest.size());
Result<ByteSpan> result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::OK);
+ EXPECT_EQ(result.status(), Status::Ok());
EXPECT_EQ(result.value().size_bytes(), dest.size());
ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -180,7 +181,7 @@
// Shoud be no byte remaining.
EXPECT_EQ(memory_reader.ConservativeReadLimit(), 0u);
result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(result.status(), Status::OutOfRange());
}
TEST(MemoryReader, EmptySpanRead) {
@@ -195,7 +196,7 @@
// Read exactly the available bytes.
Result<ByteSpan> result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::OK);
+ EXPECT_EQ(result.status(), Status::Ok());
EXPECT_EQ(result.value().size_bytes(), 0u);
EXPECT_EQ(result.value().data(), dest.data());
@@ -218,7 +219,7 @@
// Try and read double the bytes available. Use the pointer/size version of
// the API.
Result<ByteSpan> result = memory_reader.Read(dest.data(), dest.size());
- EXPECT_EQ(result.status(), Status::OK);
+ EXPECT_EQ(result.status(), Status::Ok());
EXPECT_EQ(result.value().size_bytes(), source.size());
ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -229,7 +230,7 @@
// Shoud be no byte remaining.
EXPECT_EQ(memory_reader.ConservativeReadLimit(), 0u);
result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(result.status(), Status::OutOfRange());
}
TEST(MemoryReader, MultipleReads) {
@@ -253,7 +254,7 @@
// Try and read a chunk of bytes.
Result<ByteSpan> result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::OK);
+ EXPECT_EQ(result.status(), Status::Ok());
EXPECT_EQ(result.value().size_bytes(), dest.size());
EXPECT_EQ(memory_reader.ConservativeReadLimit(),
read_limit - result.value().size_bytes());
diff --git a/pw_stream/public/pw_stream/memory_stream.h b/pw_stream/public/pw_stream/memory_stream.h
index 980381a..299fb3a 100644
--- a/pw_stream/public/pw_stream/memory_stream.h
+++ b/pw_stream/public/pw_stream/memory_stream.h
@@ -41,7 +41,7 @@
// Implementation for writing data to this stream.
//
// If the in-memory buffer is exhausted in the middle of a write, this will
- // perform a partial write and Status::RESOURCE_EXHAUSTED will be returned.
+ // perform a partial write and Status::ResourceExhausted() will be returned.
Status DoWrite(ConstByteSpan data) override;
ByteSpan dest_;
diff --git a/pw_stream/public/pw_stream/null_stream.h b/pw_stream/public/pw_stream/null_stream.h
index b5482c3..70048dc 100644
--- a/pw_stream/public/pw_stream/null_stream.h
+++ b/pw_stream/public/pw_stream/null_stream.h
@@ -33,7 +33,7 @@
}
private:
- Status DoWrite(ConstByteSpan data) override { return Status::OK; }
+ Status DoWrite(ConstByteSpan data) override { return Status::Ok(); }
};
} // namespace pw::stream
diff --git a/pw_stream/public/pw_stream/stream.h b/pw_stream/public/pw_stream/stream.h
index 66a5955..5e0a0c0 100644
--- a/pw_stream/public/pw_stream/stream.h
+++ b/pw_stream/public/pw_stream/stream.h
@@ -73,7 +73,8 @@
// written. This number is advisory and not guaranteed to write without a
// RESOURCE_EXHAUSTED or OUT_OF_RANGE. As Writer processes/handles enqueued of
// other contexts write data this number can go up or down for some Writers.
- // Returns zero if, in the current state, Write() would not return Status::OK.
+ // Returns zero if, in the current state, Write() would not return
+ // Status::Ok().
virtual size_t ConservativeWriteLimit() const = 0;
private:
@@ -125,7 +126,8 @@
// requested bytes or without a RESOURCE_EXHAUSTED or OUT_OF_RANGE. As Reader
// processes/handles/receives enqueued data or other contexts read data this
// number can go up or down for some Readers.
- // Returns zero if, in the current state, Read() would not return Status::OK.
+ // Returns zero if, in the current state, Read() would not return
+ // Status::Ok().
virtual size_t ConservativeReadLimit() const = 0;
private:
diff --git a/pw_string/format.cc b/pw_string/format.cc
index c9ed379..c08bf3c 100644
--- a/pw_string/format.cc
+++ b/pw_string/format.cc
@@ -31,7 +31,7 @@
const char* format,
va_list args) {
if (buffer.empty()) {
- return StatusWithSize::RESOURCE_EXHAUSTED;
+ return StatusWithSize::ResourceExhausted();
}
const int result = std::vsnprintf(buffer.data(), buffer.size(), format, args);
@@ -40,12 +40,12 @@
// Discard any output by terminating the buffer.
if (result < 0) {
buffer[0] = '\0';
- return StatusWithSize::INVALID_ARGUMENT;
+ return StatusWithSize::InvalidArgument();
}
// If result >= buffer.size(), the output was truncated and null-terminated.
if (static_cast<unsigned>(result) >= buffer.size()) {
- return StatusWithSize(Status::RESOURCE_EXHAUSTED, buffer.size() - 1);
+ return StatusWithSize::ResourceExhausted(buffer.size() - 1);
}
return StatusWithSize(result);
diff --git a/pw_string/format_test.cc b/pw_string/format_test.cc
index dfaac7b..b7aab52 100644
--- a/pw_string/format_test.cc
+++ b/pw_string/format_test.cc
@@ -26,7 +26,7 @@
char buffer[32];
auto result = Format(buffer, "-_-");
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(3u, result.size());
EXPECT_STREQ("-_-", buffer);
}
@@ -35,7 +35,7 @@
char buffer[32];
auto result = Format(buffer, "%d4%s", 123, "5");
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(5u, result.size());
EXPECT_STREQ("12345", buffer);
}
@@ -43,7 +43,7 @@
TEST(Format, EmptyBuffer_ReturnsResourceExhausted) {
auto result = Format(std::span<char>(), "?");
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+ EXPECT_EQ(Status::ResourceExhausted(), result.status());
EXPECT_EQ(0u, result.size());
}
@@ -51,7 +51,7 @@
char buffer[5];
auto result = Format(buffer, "2big!");
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+ EXPECT_EQ(Status::ResourceExhausted(), result.status());
EXPECT_EQ(4u, result.size());
EXPECT_STREQ("2big", buffer);
}
@@ -60,7 +60,7 @@
char buffer[5];
auto result = Format(buffer, "%s", "2big!");
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+ EXPECT_EQ(Status::ResourceExhausted(), result.status());
EXPECT_EQ(4u, result.size());
EXPECT_STREQ("2big", buffer);
}
@@ -81,7 +81,7 @@
char buffer[8];
auto result = CallFormatWithVaList(buffer, "Yo%s", "?!");
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_EQ(4u, result.size());
EXPECT_STREQ("Yo?!", buffer);
}
diff --git a/pw_string/public/pw_string/format.h b/pw_string/public/pw_string/format.h
index 5c0adfe..f3aa337 100644
--- a/pw_string/public/pw_string/format.h
+++ b/pw_string/public/pw_string/format.h
@@ -35,9 +35,9 @@
//
// The status is
//
-// Status::OK if the operation succeeded,
-// Status::RESOURCE_EXHAUSTED if the buffer was too small to fit the output,
-// Status::INVALID_ARGUMENT if there was a formatting error.
+// Status::Ok() if the operation succeeded,
+// Status::ResourceExhausted() if the buffer was too small to fit the output,
+// Status::InvalidArgument() if there was a formatting error.
//
PW_PRINTF_FORMAT(2, 3)
StatusWithSize Format(std::span<char> buffer, const char* format, ...);
diff --git a/pw_string/public/pw_string/string_builder.h b/pw_string/public/pw_string/string_builder.h
index 21769b3..425fbfb 100644
--- a/pw_string/public/pw_string/string_builder.h
+++ b/pw_string/public/pw_string/string_builder.h
@@ -135,7 +135,7 @@
// The status from the last operation. May be OK while status() is not OK.
Status last_status() const { return last_status_; }
- // True if status() is Status::OK.
+ // True if status() is Status::Ok().
bool ok() const { return status_.ok(); }
// True if the string is empty.
@@ -150,10 +150,10 @@
// Clears the string and resets its error state.
void clear();
- // Sets the statuses to Status::OK;
+ // Sets the statuses to Status::Ok();
void clear_status() {
- status_ = Status::OK;
- last_status_ = Status::OK;
+ status_ = Status::Ok();
+ last_status_ = Status::Ok();
}
// Appends a single character. Stets the status to RESOURCE_EXHAUSTED if the
diff --git a/pw_string/string_builder.cc b/pw_string/string_builder.cc
index b433e7f..1bc3b1f 100644
--- a/pw_string/string_builder.cc
+++ b/pw_string/string_builder.cc
@@ -24,8 +24,8 @@
void StringBuilder::clear() {
size_ = 0;
NullTerminate();
- status_ = Status::OK;
- last_status_ = Status::OK;
+ status_ = Status::Ok();
+ last_status_ = Status::Ok();
}
StringBuilder& StringBuilder::append(size_t count, char ch) {
@@ -55,7 +55,7 @@
size_t pos,
size_t count) {
if (pos > str.size()) {
- SetErrorStatus(Status::OUT_OF_RANGE);
+ SetErrorStatus(Status::OutOfRange());
return *this;
}
@@ -68,9 +68,9 @@
NullTerminate();
if (buffer_.empty() || chars_to_append != copied) {
- SetErrorStatus(Status::RESOURCE_EXHAUSTED);
+ SetErrorStatus(Status::ResourceExhausted());
} else {
- last_status_ = Status::OK;
+ last_status_ = Status::Ok();
}
return copied;
}
@@ -79,9 +79,9 @@
if (new_size <= size_) {
size_ = new_size;
NullTerminate();
- last_status_ = Status::OK;
+ last_status_ = Status::Ok();
} else {
- SetErrorStatus(Status::OUT_OF_RANGE);
+ SetErrorStatus(Status::OutOfRange());
}
}
diff --git a/pw_string/string_builder_test.cc b/pw_string/string_builder_test.cc
index d078299..cfef0e7 100644
--- a/pw_string/string_builder_test.cc
+++ b/pw_string/string_builder_test.cc
@@ -75,7 +75,7 @@
StringBuilder sb(std::span(buffer, 0));
sb << CustomType() << " is " << 12345;
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
EXPECT_EQ(kNoTouch, std::string_view(buffer, sizeof(buffer)));
}
@@ -102,44 +102,44 @@
TEST(StringBuilder, EmptyBuffer_AppendEmpty_ResourceExhausted) {
StringBuilder sb(std::span<char>{});
- EXPECT_EQ(Status::OK, sb.last_status());
- EXPECT_EQ(Status::OK, sb.status());
+ EXPECT_EQ(Status::Ok(), sb.last_status());
+ EXPECT_EQ(Status::Ok(), sb.status());
sb << "";
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
}
TEST(StringBuilder, Status_StartsOk) {
StringBuffer<16> sb;
- EXPECT_EQ(Status::OK, sb.status());
- EXPECT_EQ(Status::OK, sb.last_status());
+ EXPECT_EQ(Status::Ok(), sb.status());
+ EXPECT_EQ(Status::Ok(), sb.last_status());
}
TEST(StringBuilder, Status_StatusAndLastStatusUpdate) {
StringBuffer<16> sb;
sb << "Well, if only there were enough room in here for this string";
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
sb.resize(1029);
- EXPECT_EQ(Status::OUT_OF_RANGE, sb.status());
- EXPECT_EQ(Status::OUT_OF_RANGE, sb.last_status());
+ EXPECT_EQ(Status::OutOfRange(), sb.status());
+ EXPECT_EQ(Status::OutOfRange(), sb.last_status());
sb << "";
- EXPECT_EQ(Status::OUT_OF_RANGE, sb.status());
- EXPECT_EQ(Status::OK, sb.last_status());
+ EXPECT_EQ(Status::OutOfRange(), sb.status());
+ EXPECT_EQ(Status::Ok(), sb.last_status());
}
TEST(StringBuilder, Status_ClearStatus_SetsStatuesToOk) {
StringBuffer<2> sb = MakeString<2>("Won't fit!!!!!");
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
sb.clear_status();
- EXPECT_EQ(Status::OK, sb.status());
- EXPECT_EQ(Status::OK, sb.last_status());
+ EXPECT_EQ(Status::Ok(), sb.status());
+ EXPECT_EQ(Status::Ok(), sb.last_status());
}
TEST(StringBuilder, StreamOutput_OutputSelf) {
@@ -153,7 +153,7 @@
TEST(StringBuilder, PushBack) {
StringBuffer<12> sb;
sb.push_back('?');
- EXPECT_EQ(Status::OK, sb.last_status());
+ EXPECT_EQ(Status::Ok(), sb.last_status());
EXPECT_EQ(1u, sb.size());
EXPECT_STREQ("?", sb.data());
}
@@ -161,14 +161,14 @@
TEST(StringBuilder, PushBack_Full) {
StringBuffer<1> sb;
sb.push_back('!');
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
EXPECT_EQ(0u, sb.size());
}
TEST(StringBuilder, PopBack) {
auto sb = MakeString<12>("Welcome!");
sb.pop_back();
- EXPECT_EQ(Status::OK, sb.last_status());
+ EXPECT_EQ(Status::Ok(), sb.last_status());
EXPECT_EQ(7u, sb.size());
EXPECT_STREQ("Welcome", sb.data());
}
@@ -176,7 +176,7 @@
TEST(StringBuilder, PopBack_Empty) {
StringBuffer<12> sb;
sb.pop_back();
- EXPECT_EQ(Status::OUT_OF_RANGE, sb.last_status());
+ EXPECT_EQ(Status::OutOfRange(), sb.last_status());
EXPECT_EQ(0u, sb.size());
}
@@ -185,7 +185,7 @@
std::memset(bad_string, '?', sizeof(bad_string));
StringBuffer<6> sb;
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.append(bad_string).last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.append(bad_string).last_status());
EXPECT_STREQ("?????", sb.data());
}
@@ -199,7 +199,7 @@
TEST(StringBuilder, Append_Chars_Full) {
StringBuffer<8> sb;
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.append(8, '?').last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.append(8, '?').last_status());
EXPECT_STREQ("???????", sb.data());
}
@@ -219,8 +219,8 @@
TEST(StringBuilder, Append_CString_Full) {
auto sb = MakeString<6>("hello");
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.append("890123", 1).last_status());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.append("890123", 1).last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
EXPECT_EQ(sb.max_size(), sb.size());
EXPECT_STREQ("hello", sb.data());
}
@@ -263,14 +263,14 @@
auto sb = MakeString<12>("Four");
EXPECT_EQ(4u, sb.size());
sb.resize(10);
- EXPECT_EQ(sb.status(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(sb.status(), Status::OutOfRange());
EXPECT_EQ(4u, sb.size());
}
TEST(StringBuilder, Resize_LargerThanCapacity_Fails) {
auto sb = MakeString<12>("Four");
sb.resize(1234);
- EXPECT_EQ(sb.status(), Status::OUT_OF_RANGE);
+ EXPECT_EQ(sb.status(), Status::OutOfRange());
EXPECT_EQ(4u, sb.size());
EXPECT_STREQ("Four", sb.data());
}
@@ -289,10 +289,10 @@
TEST(StringBuilder, Format_ExhaustBuffer) {
StringBuffer<6> sb;
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.Format("012345").status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.Format("012345").status());
EXPECT_STREQ("01234", sb.data());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
}
TEST(StringBuilder, StreamOutput_MultipleTypes) {
@@ -316,7 +316,7 @@
sb << true << "Now it's way " << static_cast<unsigned char>(2) << " long";
EXPECT_FALSE(sb.ok());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
EXPECT_STREQ("0true", sb.data());
}
@@ -342,7 +342,7 @@
EXPECT_EQ(2u, sb.size());
sb << "234";
EXPECT_STREQ("012", sb.data());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
EXPECT_EQ(3u, sb.size());
}
@@ -353,7 +353,7 @@
StringBuffer<6> sb;
sb << "hey" << bad_string;
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
EXPECT_STREQ("hey??", sb.data());
}
@@ -362,7 +362,7 @@
constexpr std::string_view hello("hello");
buffer << hello;
- EXPECT_EQ(Status::OK, buffer.status());
+ EXPECT_EQ(Status::Ok(), buffer.status());
EXPECT_STREQ("hello", buffer.data());
}
@@ -390,13 +390,13 @@
two << "0123456789";
ASSERT_STREQ("What heck", two.data());
- ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
- ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.last_status());
+ ASSERT_EQ(Status::ResourceExhausted(), two.status());
+ ASSERT_EQ(Status::ResourceExhausted(), two.last_status());
one = two;
EXPECT_STREQ("What heck", one.data());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, one.status());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, one.last_status());
+ EXPECT_EQ(Status::ResourceExhausted(), one.status());
+ EXPECT_EQ(Status::ResourceExhausted(), one.last_status());
StringBuffer<12> three;
three = two;
@@ -421,8 +421,8 @@
two << "0123456789";
two << "";
ASSERT_STREQ("What heck", two.data());
- ASSERT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
- ASSERT_EQ(Status::OK, two.last_status());
+ ASSERT_EQ(Status::ResourceExhausted(), two.status());
+ ASSERT_EQ(Status::Ok(), two.last_status());
}
TEST(StringBuffer, CopyConstructFromSmaller) {
@@ -430,7 +430,7 @@
StringBuffer<12> two(one);
EXPECT_STREQ("You are t", two.data());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, two.status());
+ EXPECT_EQ(Status::ResourceExhausted(), two.status());
}
TEST(StringBuilder, Object) {
@@ -514,7 +514,7 @@
TEST(MakeString, LargerThanDefaultSize_Truncates) {
auto sb = MakeString("1844674407", 3709551615, 123456);
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, sb.status());
+ EXPECT_EQ(Status::ResourceExhausted(), sb.status());
EXPECT_STREQ(kLongestString, sb.data());
}
diff --git a/pw_string/to_string_test.cc b/pw_string/to_string_test.cc
index 6f4a4da..2f3608d 100644
--- a/pw_string/to_string_test.cc
+++ b/pw_string/to_string_test.cc
@@ -43,13 +43,13 @@
int result =
std::snprintf(buffer.data(), buffer.size(), CustomType::kToString);
if (result < 0) {
- return StatusWithSize::UNKNOWN;
+ return StatusWithSize::Unknown();
}
if (static_cast<size_t>(result) < buffer.size()) {
return StatusWithSize(result);
}
- return StatusWithSize(Status::RESOURCE_EXHAUSTED,
- buffer.empty() ? 0u : buffer.size() - 1);
+ return StatusWithSize::ResourceExhausted(buffer.empty() ? 0u
+ : buffer.size() - 1);
}
namespace {
@@ -101,14 +101,14 @@
auto result = ToString(MyEnum::kLuckyNumber, buffer);
EXPECT_EQ(1u, result.size());
- EXPECT_EQ(Status::OK, result.status());
+ EXPECT_EQ(Status::Ok(), result.status());
EXPECT_STREQ("8", buffer);
}
TEST(ToString, Integer_EmptyBuffer_WritesNothing) {
auto result = ToString(-1234, std::span(buffer, 0));
EXPECT_EQ(0u, result.size());
- EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
+ EXPECT_EQ(Status::ResourceExhausted(), result.status());
}
TEST(ToString, Integer_BufferTooSmall_WritesNullTerminator) {
@@ -218,7 +218,7 @@
TEST(ToString, StatusCode) {
EXPECT_EQ(sizeof("UNAVAILABLE") - 1,
- ToString(Status::UNAVAILABLE, buffer).size());
+ ToString(Status::Unavailable(), buffer).size());
EXPECT_STREQ("UNAVAILABLE", buffer);
}
diff --git a/pw_string/type_to_string.cc b/pw_string/type_to_string.cc
index ce417e1..483d10e 100644
--- a/pw_string/type_to_string.cc
+++ b/pw_string/type_to_string.cc
@@ -51,7 +51,7 @@
if (!buffer.empty()) {
buffer[0] = '\0';
}
- return StatusWithSize::RESOURCE_EXHAUSTED;
+ return StatusWithSize::ResourceExhausted();
}
} // namespace
@@ -183,14 +183,15 @@
StatusWithSize CopyString(const std::string_view& value,
std::span<char> buffer) {
if (buffer.empty()) {
- return StatusWithSize::RESOURCE_EXHAUSTED;
+ return StatusWithSize::ResourceExhausted();
}
const size_t copied = value.copy(buffer.data(), buffer.size() - 1);
buffer[copied] = '\0';
return StatusWithSize(
- copied == value.size() ? Status::OK : Status::RESOURCE_EXHAUSTED, copied);
+ copied == value.size() ? Status::Ok() : Status::ResourceExhausted(),
+ copied);
}
StatusWithSize CopyEntireString(const std::string_view& value,
diff --git a/pw_sys_io/public/pw_sys_io/sys_io.h b/pw_sys_io/public/pw_sys_io/sys_io.h
index 5f545b3..5973579 100644
--- a/pw_sys_io/public/pw_sys_io/sys_io.h
+++ b/pw_sys_io/public/pw_sys_io/sys_io.h
@@ -20,7 +20,7 @@
//
// This facade doesn't dictate any policies on input and output data encoding,
// format, or transmission protocol. It only requires that backends return a
-// Status::OK if the operation succeeds. Backends may provide useful error
+// Status::Ok() if the operation succeeds. Backends may provide useful error
// Status types, but depending on the implementation-specific Status values is
// NOT recommended. Since this facade provides a very vague I/O interface, it
// does NOT provide tests. Backends are expected to provide their own testing to
@@ -51,7 +51,7 @@
// This function will block until it either succeeds or fails to read a byte
// from the pw_sys_io backend.
//
-// Returns Status::OK if a byte was successfully read.
+// Returns Status::Ok() if a byte was successfully read.
Status ReadByte(std::byte* dest);
// Write a single byte out the sys io backend.
@@ -60,7 +60,7 @@
// This function will block until it either succeeds or fails to write a byte
// out the pw_sys_io backend.
//
-// Returns Status::OK if a byte was successfully read.
+// Returns Status::Ok() if a byte was successfully read.
Status WriteByte(std::byte b);
// Write a string out the sys io backend.
@@ -70,7 +70,7 @@
// backend, adding any platform-specific newline character(s) (these are
// accounted for in the returned StatusWithSize).
//
-// Return status is Status::OK if all the bytes from the source string were
+// Return status is Status::Ok() if all the bytes from the source string were
// successfully written. In all cases, the number of bytes successfully written
// are returned as part of the StatusWithSize.
StatusWithSize WriteLine(const std::string_view& s);
@@ -84,9 +84,9 @@
// undefined. This function blocks until either an error occurs, or all bytes
// are successfully read from the backend's ReadByte() implementation.
//
-// Return status is Status::OK if the destination span was successfully filled.
-// In all cases, the number of bytes successuflly read to the destination span
-// are returned as part of the StatusWithSize.
+// Return status is Status::Ok() if the destination span was successfully
+// filled. In all cases, the number of bytes successuflly read to the
+// destination span are returned as part of the StatusWithSize.
StatusWithSize ReadBytes(std::span<std::byte> dest);
// Write std::span of bytes out the sys io backend using WriteByte().
@@ -98,7 +98,7 @@
// either an error occurs, or all bytes are successfully read from the backend's
// WriteByte() implementation.
//
-// Return status is Status::OK if all the bytes from the source span were
+// Return status is Status::Ok() if all the bytes from the source span were
// successfully written. In all cases, the number of bytes successfully written
// are returned as part of the StatusWithSize.
StatusWithSize WriteBytes(std::span<const std::byte> src);
diff --git a/pw_sys_io_arduino/sys_io_arduino.cc b/pw_sys_io_arduino/sys_io_arduino.cc
index b63e21f..c06f3a9 100644
--- a/pw_sys_io_arduino/sys_io_arduino.cc
+++ b/pw_sys_io_arduino/sys_io_arduino.cc
@@ -40,7 +40,7 @@
break;
}
}
- return Status::OK;
+ return Status::Ok();
}
// Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -53,7 +53,7 @@
while (Serial.availableForWrite() < 1) {
}
Serial.write((uint8_t)b);
- return Status::OK;
+ return Status::Ok();
}
// Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
index 253b0c5..ddf901e 100644
--- a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
@@ -99,7 +99,7 @@
break;
}
}
- return Status::OK;
+ return Status::Ok();
}
// Send a byte over UART0. Since this blocks on every byte, it's rather
@@ -112,7 +112,7 @@
while (!(uart0.status_flags & kTxFifoEmptyMask)) {
}
uart0.data_register = static_cast<uint32_t>(b);
- return Status::OK;
+ return Status::Ok();
}
// Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
index 46f5e40..80cb169 100644
--- a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
@@ -175,7 +175,7 @@
break;
}
}
- return Status::OK;
+ return Status::Ok();
}
// Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -188,7 +188,7 @@
while (!(usart1.status & kTxRegisterEmpty)) {
}
usart1.data_register = static_cast<uint32_t>(b);
- return Status::OK;
+ return Status::Ok();
}
// Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_stdio/sys_io.cc b/pw_sys_io_stdio/sys_io.cc
index 65d1a89..04ab9b0 100644
--- a/pw_sys_io_stdio/sys_io.cc
+++ b/pw_sys_io_stdio/sys_io.cc
@@ -20,22 +20,22 @@
Status ReadByte(std::byte* dest) {
if (dest == nullptr) {
- return Status::FAILED_PRECONDITION;
+ return Status::FailedPrecondition();
}
int value = std::getchar();
if (value == EOF) {
- return Status::RESOURCE_EXHAUSTED;
+ return Status::ResourceExhausted();
}
*dest = static_cast<std::byte>(value);
- return Status::OK;
+ return Status::Ok();
}
Status WriteByte(std::byte b) {
if (std::putchar(static_cast<char>(b)) == EOF) {
- return Status::INTERNAL;
+ return Status::Internal();
}
- return Status::OK;
+ return Status::Ok();
}
StatusWithSize WriteLine(const std::string_view& s) {
diff --git a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
index bfa3d8b..ab6e8e6 100644
--- a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
+++ b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
@@ -101,7 +101,7 @@
// start, allowing buffers to allocate the required amount at the start when
// necessary.
//
-// If Status::OK is not returned from Start, the events bytes will be skipped.
+// If Status::Ok() is not returned from Start, the events bytes will be skipped.
//
// NOTE: Called while tracing is locked (which might be a critical section
// depending on application), so quick/simple operations only. One trace event
diff --git a/pw_trace_tokenized/trace_buffer_log.cc b/pw_trace_tokenized/trace_buffer_log.cc
index 3e41c3a..3d9e5a6 100644
--- a/pw_trace_tokenized/trace_buffer_log.cc
+++ b/pw_trace_tokenized/trace_buffer_log.cc
@@ -54,7 +54,7 @@
size_t bytes_read = 0;
PW_LOG_INFO("[TRACE] begin");
while (trace_buffer->PeekFront(std::span(entry_buffer).subspan(1),
- &bytes_read) != pw::Status::OUT_OF_RANGE) {
+ &bytes_read) != pw::Status::OutOfRange()) {
trace_buffer->PopFront();
entry_buffer[0] = static_cast<std::byte>(bytes_read);
// The entry buffer is formatted as (size, entry) with an extra byte as
@@ -78,7 +78,7 @@
PW_LOG_INFO("[TRACE] data: %s", line_builder.c_str());
}
PW_LOG_INFO("[TRACE] end");
- return pw::Status::OK;
+ return pw::Status::Ok();
}
} // namespace trace
diff --git a/pw_trace_tokenized/trace_buffer_test.cc b/pw_trace_tokenized/trace_buffer_test.cc
index 0133c9e..bbe7dc8 100644
--- a/pw_trace_tokenized/trace_buffer_test.cc
+++ b/pw_trace_tokenized/trace_buffer_test.cc
@@ -84,7 +84,7 @@
std::byte value[expected_max_bytes_used];
size_t bytes_read = 0;
EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
- pw::Status::OK);
+ pw::Status::Ok());
// read size is minus 1, since doesn't include varint size
EXPECT_GE(bytes_read, expected_min_bytes_used - 1);
@@ -123,8 +123,8 @@
std::byte value[PW_TRACE_BUFFER_MAX_BLOCK_SIZE_BYTES];
size_t bytes_read = 0;
EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
- pw::Status::OK);
- EXPECT_EQ(buf->PopFront(), pw::Status::OK);
+ pw::Status::Ok());
+ EXPECT_EQ(buf->PopFront(), pw::Status::Ok());
EXPECT_EQ(*reinterpret_cast<size_t*>(&value[bytes_read - sizeof(size_t)]),
expected_count);
expected_count++;
diff --git a/pw_varint/public/pw_varint/varint.h b/pw_varint/public/pw_varint/varint.h
index 9935967..a8db949 100644
--- a/pw_varint/public/pw_varint/varint.h
+++ b/pw_varint/public/pw_varint/varint.h
@@ -119,7 +119,7 @@
// size_t bytes = Decode(data, &value);
//
// if (bytes == 0u) {
-// return Status::DATA_LOSS;
+// return Status::DataLoss();
// }
// results.push_back(value);
// data = data.subspan(bytes)
