diff options
110 files changed, 1279 insertions, 1268 deletions
diff --git a/pw_allocator/block.cc b/pw_allocator/block.cc index 6b7b7fd88..67b0a7b46 100644 --- a/pw_allocator/block.cc +++ b/pw_allocator/block.cc @@ -21,11 +21,11 @@ namespace pw::allocator { 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 @@ Status Block::Init(const std::span<std::byte> region, Block** block) { #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 @@ Status Block::Split(size_t head_block_inner_size, Block** new_block) { // (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 @@ Status Block::Split(size_t head_block_inner_size, Block** new_block) { // 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 @@ Status Block::Split(size_t head_block_inner_size, Block** new_block) { (*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 @@ Status Block::MergeNext() { 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 c71cd3824..0fd5d3915 100644 --- a/pw_allocator/block_test.cc +++ b/pw_allocator/block_test.cc @@ -30,7 +30,7 @@ TEST(Block, CanCreateSingleBlock) { 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 @@ TEST(Block, CannotCreateUnalignedSingleBlock) { 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 @@ TEST(Block, CannotCreateTooSmallBlock) { 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 @@ TEST(Block, CanSplitBlock) { 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 @@ TEST(Block, CanSplitBlockUnaligned) { 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 @@ TEST(Block, CannotSplitBlockWithoutHeaderSpace) { 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 @@ TEST(Block, MustProvideNextBlockPointer) { 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 @@ TEST(Block, CannotMakeBlockLargerInSplit) { 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 @@ TEST(Block, CannotMakeSecondBlockLargerInSplit) { 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 @@ TEST(Block, CanMakeZeroSizeFirstBlock) { 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 @@ TEST(Block, CanMakeZeroSizeSecondBlock) { 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 @@ TEST(Block, CannotSplitUsedBlock) { 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 @@ TEST(Block, CanMergeWithNextBlock) { 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 @@ TEST(Block, CannotMergeWithFirstOrLastBlock) { 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 @@ TEST(Block, CannotMergeUsedBlock) { 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 4629a4f15..d46e0102e 100644 --- a/pw_allocator/freelist.cc +++ b/pw_allocator/freelist.cc @@ -19,7 +19,7 @@ namespace pw::allocator { 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 @@ Status FreeList::AddChunk(std::span<std::byte> chunk) { 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 @@ Status FreeList::RemoveChunk(std::span<std::byte> chunk) { // 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 @@ Status FreeList::RemoveChunk(std::span<std::byte> chunk) { 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 0484a7a33..865ea3f0d 100644 --- a/pw_allocator/freelist_test.cc +++ b/pw_allocator/freelist_test.cc @@ -43,7 +43,7 @@ TEST(FreeList, CanRetrieveAddedMember) { 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 @@ TEST(FreeList, CanRemoveItem) { 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 @@ TEST(FreeList, RemoveUnknownChunkReturnsNotFound) { 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 da19e3425..6e1ac2e6a 100644 --- a/pw_assert/assert_backend_compile_test.cc +++ b/pw_assert/assert_backend_compile_test.cc @@ -203,7 +203,7 @@ pw::Status MakeStatus(pw::Status status) { return status; } 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 @@ TEST(Check, CheckOkMacrosCompile) { 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 34faecb9d..083d206dc 100644 --- a/pw_assert/assert_facade_test.cc +++ b/pw_assert/assert_facade_test.cc @@ -421,32 +421,32 @@ TEST(AssertFail, DCheckEnabledBinaryOpTwoSideEffectingCalls) { // 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 @@ TEST(Check, ShortNamesWork) { // 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 @@ TEST_F(AssertFail, NonTrivialExpression) { // 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 96a40f86c..5e1f54303 100644 --- a/pw_blob_store/blob_store.cc +++ b/pw_blob_store/blob_store.cc @@ -23,7 +23,7 @@ namespace pw::blob_store { Status BlobStore::Init() { if (initialized_) { - return Status::OK; + return Status::Ok(); } PW_LOG_INFO("Init BlobStore"); @@ -46,7 +46,7 @@ Status BlobStore::Init() { 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 @@ Status BlobStore::Init() { } 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 @@ Status BlobStore::OpenWrite() { 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 @@ Status BlobStore::CloseWrite() { // 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 @@ Status BlobStore::CloseWrite() { 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 @@ Status BlobStore::CloseWrite() { 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 @@ Status BlobStore::Write(ConstByteSpan data) { // 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 BlobStore::Write(ConstByteSpan data) { 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 @@ Status BlobStore::Write(ConstByteSpan data) { 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 @@ Status BlobStore::AddToWriteBuffer(ConstByteSpan data) { 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 BlobStore::Flush() { 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 BlobStore::Flush() { 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 @@ Status BlobStore::Flush() { PW_DCHECK_UINT_EQ(data.size_bytes(), 0); } - return Status::OK; + return Status::Ok(); } Status BlobStore::FlushFinalPartialChunk() { @@ -406,15 +406,15 @@ Status BlobStore::EraseIfNeeded() { // 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 @@ StatusWithSize BlobStore::Read(size_t offset, ByteSpan dest) const { 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 @@ Status BlobStore::Erase() { // 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 BlobStore::Invalidate() { 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::ValidateChecksum() { 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 @@ Status BlobStore::CalculateChecksumFromFlash(size_t bytes_to_check) { // 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 ccbd26dcd..cf7219d46 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 @@ class BlobStoreChunkTest : public ::testing::Test { 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 @@ class BlobStoreChunkTest : public ::testing::Test { 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 4f3d581d4..71996e1d1 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 @@ class DeferredWriteTest : public ::testing::Test { 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 @@ class DeferredWriteTest : public ::testing::Test { 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 @@ class DeferredWriteTest : public ::testing::Test { 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 d21bd9d94..880c516ed 100644 --- a/pw_blob_store/blob_store_test.cc +++ b/pw_blob_store/blob_store_test.cc @@ -61,21 +61,21 @@ class BlobStoreTest : public ::testing::Test { 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 @@ class BlobStoreTest : public ::testing::Test { 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 @@ class BlobStoreTest : public ::testing::Test { 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 @@ class BlobStoreTest : public ::testing::Test { 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 @@ TEST_F(BlobStoreTest, Discard) { 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 @@ TEST_F(BlobStoreTest, OffsetRead) { 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 @@ TEST_F(BlobStoreTest, InvalidReadOffset) { 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 1fd526374..e8b1db05a 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 @@ class BlobStore { 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 bcfc9de88..ba01c0faa 100644 --- a/pw_bytes/byte_builder.cc +++ b/pw_bytes/byte_builder.cc @@ -34,21 +34,21 @@ size_t ByteBuilder::ResizeForAppend(size_t bytes_to_append) { } 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 2f81de756..d1d1e7b54 100644 --- a/pw_bytes/byte_builder_test.cc +++ b/pw_bytes/byte_builder_test.cc @@ -99,7 +99,7 @@ TEST(ByteBuilder, NonEmptyBufferOfSize0_Append_Partial_ResourceExhausted) { 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_Full) { 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 @@ TEST(ByteBuilder, EmptyBuffer_Resize_Larger_Fails) { 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 @@ TEST(ByteBuilder, Resize_Larger_Fails) { 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 @@ TEST(ByteBuilder, Status_StatusUpdate) { 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 @@ TEST(ByteBuilder, Status_ClearStatus_SetsStatusToOk) { 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) { 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 @@ TEST(ByteBuilder, PushBack_Full_ResourceExhausted) { 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 @@ TEST(ByteBuilder, PopBack) { 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 @@ TEST(ByteBuilder, PopBack_Empty) { 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 @@ TEST(ByteBuffer, Assign) { 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 @@ TEST(ByteBuffer, CopyConstructFromSmaller) { 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 @@ TEST(ByteBuilder, ResizeError_NoDataAddedAfter) { 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 @@ TEST(ByteBuffer, Putting8ByteInts_Full) { 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 @@ TEST(ByteBuffer, Putting8ByteInts_Exhausted) { 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 @@ TEST(ByteBuffer, Putting16ByteInts_Full_kLittleEndian) { 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 @@ TEST(ByteBuffer, Putting16ByteInts_Exhausted_kBigEndian) { 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 @@ TEST(ByteBuffer, Putting32ByteInts_Full_kLittleEndian) { 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 @@ TEST(ByteBuffer, Putting32ByteInts_Exhausted_kBigEndian) { 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 @@ TEST(ByteBuffer, Putting64ByteInts_Full_kLittleEndian) { 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 @@ TEST(ByteBuffer, Putting64ByteInts_Exhausted_kBigEndian) { 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 @@ TEST(ByteBuffer, PuttingInts_MixedTypes_MixedEndian) { 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 70c0876be..f046cb02b 100644 --- a/pw_bytes/public/pw_bytes/byte_builder.h +++ b/pw_bytes/public/pw_bytes/byte_builder.h @@ -228,7 +228,7 @@ class ByteBuilder { 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 @@ class ByteBuilder { // 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 894b2c06b..086652dec 100644 --- a/pw_cpu_exception_armv7m/proto_dump.cc +++ b/pw_cpu_exception_armv7m/proto_dump.cc @@ -55,10 +55,10 @@ Status DumpCpuStateProto(protobuf::Encoder& dest, // 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 37c0023b0..fc968241a 100644 --- a/pw_hdlc_lite/decoder.cc +++ b/pw_hdlc_lite/decoder.cc @@ -38,13 +38,13 @@ Result<Frame> Decoder::Process(const byte new_byte) { // 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 @@ Result<Frame> Decoder::Process(const byte new_byte) { } 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 @@ Result<Frame> Decoder::Process(const byte new_byte) { state_ = State::kFrame; AppendByte(new_byte ^ kUnescapeConstant); } - return Status::UNAVAILABLE; + return Status::Unavailable(); } } PW_CRASH("Bad decoder state"); @@ -104,28 +104,28 @@ void Decoder::AppendByte(byte new_byte) { 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 787fbf1a1..b8400e2c6 100644 --- a/pw_hdlc_lite/decoder_test.cc +++ b/pw_hdlc_lite/decoder_test.cc @@ -46,23 +46,23 @@ TEST(Decoder, Clear) { [](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 @@ TEST(Decoder, MinimumSizedBuffer) { 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 @@ TEST(Decoder, TooLargeForBuffer_ReportsResourceExhausted) { 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 @@ TEST(Decoder, TooLargeForBuffer_StaysWithinBufferBoundaries) { 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 dde255634..4a785ee67 100644 --- a/pw_hdlc_lite/encoder.cc +++ b/pw_hdlc_lite/encoder.cc @@ -83,7 +83,7 @@ Status Encoder::WriteData(ConstByteSpan data) { } 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 0321c86c0..72a66ce4c 100644 --- a/pw_hdlc_lite/encoder_test.cc +++ b/pw_hdlc_lite/encoder_test.cc @@ -50,21 +50,21 @@ class WriteInfoFrame : public ::testing::Test { } 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_Escape0x7d) { } 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, OneBytePayload_Escape0x7E) { } 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, Crc32NeedsEscaping) { } 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, MultiplePayloads) { } 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, PayloadWithNoEscapes) { } 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, PayloadWithMultipleEscapes) { 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 1b88bb53a..1e140664a 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 @@ class Decoder { 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 c98d656ec..7e0d0dd76 100644 --- a/pw_hdlc_lite/rpc_channel_test.cc +++ b/pw_hdlc_lite/rpc_channel_test.cc @@ -61,7 +61,7 @@ TEST(RpcChannelOutput, 1BytePayload) { 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 @@ TEST(RpcChannelOutput, EscapingPayloadTest) { 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 @@ TEST(RpcChannelOutputBuffer, 1BytePayload) { 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 fef1a90bb..ae979df0b 100644 --- a/pw_hex_dump/hex_dump.cc +++ b/pw_hex_dump/hex_dump.cc @@ -48,11 +48,11 @@ char PrintableChar(std::byte b) { 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::PrintFormatHeader() { 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::DumpLine() { 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 @@ Status FormattedHexDumper::ValidateBufferSize() { } 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 51ad7fabd..1b102515e 100644 --- a/pw_hex_dump/hex_dump_test.cc +++ b/pw_hex_dump/hex_dump_test.cc @@ -100,7 +100,7 @@ class SmallBuffer : public ::testing::Test { 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 @@ TEST_F(HexDump, FormattedHexDump_DumpEntireBuffer) { 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 @@ TEST_F(HexDump, FormattedHexDump_LogDump) { 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 @@ TEST_F(SmallBuffer, TooManyBytesPerLine) { 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 @@ TEST_F(SmallBuffer, SpacesIncreaseBufferRequirement) { 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 @@ TEST_F(SmallBuffer, PrefixIncreasesBufferRequirement) { 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_F(SmallBuffer, PrefixIncreasesBufferRequirement) { 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 0f3dc89e9..536de873a 100644 --- a/pw_kvs/alignment_test.cc +++ b/pw_kvs/alignment_test.cc @@ -141,26 +141,26 @@ TEST(AlignedWriter, Write_VaryingLengths) { 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 @@ struct OutputWithErrorInjection final : public Output { ADD_FAILURE(); break; } - return StatusWithSize(Status::UNKNOWN, data.size()); + return StatusWithSize::Unknown(data.size()); } }; @@ -213,7 +213,7 @@ TEST(AlignedWriter, Write_NoFurtherWritesOnFailure) { 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_NoFurtherWritesOnFailure) { 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 @@ TEST(AlignedWriter, Write_ReturnsTotalBytesWritten) { 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 @@ TEST(AlignedWriter, Flush_Ok_ReturnsTotalBytesWritten) { 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 @@ TEST(AlignedWriter, Flush_Error_ReturnsTotalBytesWritten) { 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 @@ class InputWithErrorInjection final : public Input { 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 @@ TEST(AlignedWriter, WriteFromInput_Successful) { 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 @@ TEST(AlignedWriter, WriteFromInput_InputError) { 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 @@ TEST(AlignedWriter, WriteFromInput_OutputError) { 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 0a885f75f..08f59b85d 100644 --- a/pw_kvs/checksum.cc +++ b/pw_kvs/checksum.cc @@ -22,12 +22,12 @@ using std::byte; 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 0db5ed214..4fffae0bd 100644 --- a/pw_kvs/checksum_test.cc +++ b/pw_kvs/checksum_test.cc @@ -32,19 +32,20 @@ TEST(Checksum, UpdateAndVerify) { 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 @@ TEST(Checksum, Verify_LargerState_ComparesToTruncatedData) { 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(Checksum, Reset) { 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 @@ TEST(AlignedChecksum, MaintainsAlignment) { 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 cfa9e7616..0fa68da0c 100644 --- a/pw_kvs/entry.cc +++ b/pw_kvs/entry.cc @@ -43,10 +43,10 @@ Status Entry::Read(FlashPartition& partition, 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 @@ Status Entry::Read(FlashPartition& partition, 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 @@ Status Entry::ReadKey(FlashPartition& partition, 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::Copy(Address new_address) const { 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 @@ StatusWithSize Entry::ReadValue(std::span<byte> buffer, 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 @@ Status Entry::ValueMatches(std::span<const std::byte> value) const { 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 @@ Status Entry::VerifyChecksumInFlash() const { 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 @@ Status Entry::CalculateChecksumFromFlash() { header_.checksum = 0; if (checksum_algo_ == nullptr) { - return Status::OK; + return Status::Ok(); } checksum_algo_->Reset(); @@ -307,7 +307,7 @@ Status Entry::CalculateChecksumFromFlash() { 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 c6d58a8eb..b6245a4d5 100644 --- a/pw_kvs/entry_cache.cc +++ b/pw_kvs/entry_cache.cc @@ -103,18 +103,18 @@ StatusWithSize EntryCache::Find(FlashPartition& partition, 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 @@ Status EntryCache::AddNewOrUpdateExisting(const KeyDescriptor& descriptor, // 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 @@ Status EntryCache::AddNewOrUpdateExisting(const KeyDescriptor& descriptor, " 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 @@ Status EntryCache::AddNewOrUpdateExisting(const KeyDescriptor& descriptor, 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 @@ Status EntryCache::AddNewOrUpdateExisting(const KeyDescriptor& descriptor, } 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 2bdedf4f3..7d6a25f0a 100644 --- a/pw_kvs/entry_cache_test.cc +++ b/pw_kvs/entry_cache_test.cc @@ -83,7 +83,7 @@ TEST_F(EmptyEntryCache, EntryMetadata_Reset) { } 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) { 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 @@ TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_UpdatedEntry) { 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_UpdatedEntry) { } 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_AddDuplicateEntry) { } 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 @@ TEST_F(InitializedEntryCache, Find_PresentEntry) { 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_PresentEntry) { 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_PresentEntryWithSingleReadError) { } 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 @@ TEST_F(InitializedEntryCache, Find_DeletedEntry) { 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 @@ TEST_F(InitializedEntryCache, Find_MissingEntry) { 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 @@ TEST_F(InitializedEntryCache, Find_Collision) { 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 411f241b5..8ac1d1aa2 100644 --- a/pw_kvs/entry_test.cc +++ b/pw_kvs/entry_test.cc @@ -116,7 +116,7 @@ constexpr internal::EntryFormats kFormats(kFormatWithChecksum); 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 @@ class ValidEntryInFlash : public ::testing::Test { }; 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 @@ TEST_F(ValidEntryInFlash, ReadKey) { 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 @@ TEST_F(ValidEntryInFlash, ReadValue) { 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 @@ TEST_F(ValidEntryInFlash, ReadValue_BufferTooSmall) { 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 @@ TEST_F(ValidEntryInFlash, ReadValue_WithOffset) { 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 @@ TEST_F(ValidEntryInFlash, ReadValue_WithOffset_BufferTooSmall) { 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 @@ TEST_F(ValidEntryInFlash, ReadValue_WithOffset_EmptyRead) { 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 @@ TEST_F(ValidEntryInFlash, ReadValue_WithOffset_PastEnd) { 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 @@ TEST(ValidEntry, Write) { 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 @@ class TombstoneEntryInFlash : public ::testing::Test { 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 @@ class TombstoneEntryInFlash : public ::testing::Test { }; 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 @@ TEST_F(TombstoneEntryInFlash, ReadKey) { 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 @@ TEST_F(TombstoneEntryInFlash, ReadValue) { 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 @@ TEST(TombstoneEntry, Write) { 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 @@ TEST(Entry, Checksum_NoChecksumRequiresZero) { 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 @@ TEST(Entry, Checksum_ChecksPadding) { 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_SameFormat_TransactionIdIsUpdated) { 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, } 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 @@ constexpr EntryFormat kNoChecksumFormat{.magic = 0x721bad24, .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) { } 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 @@ constexpr auto MakeNewFormatWithSumEntry() { 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 @@ TEST_F(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSmallerAlignment) { 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 @@ TEST(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSameAlignment) { 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 @@ TEST(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSameAlignment) { 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 @@ TEST(ValidEntryInFlash, UpdateAndCopy_DifferentFormatLargerAlignment) { 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 @@ TEST(ValidEntryInFlash, UpdateAndCopy_DifferentFormatLargerAlignment) { 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 @@ TEST_F(ValidEntryInFlash, UpdateAndCopy_NoChecksum_UpdatesToNewFormat) { // 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, UpdateAndCopy_NoChecksum_UpdatesToNewFormat) { } 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, UpdateAndCopyMultple_DifferentFormat) { } 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 217870cc5..b64956725 100644 --- a/pw_kvs/fake_flash_memory.cc +++ b/pw_kvs/fake_flash_memory.cc @@ -29,23 +29,23 @@ Status FlashError::Check(std::span<FlashError> errors, } } - 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 @@ Status FakeFlashMemory::Erase(Address address, size_t num_sectors) { 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 @@ Status FakeFlashMemory::Erase(Address address, size_t num_sectors) { "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 @@ StatusWithSize FakeFlashMemory::Write(Address address, 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 @@ StatusWithSize FakeFlashMemory::Write(Address address, 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 @@ StatusWithSize FakeFlashMemory::Write(Address address, 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 5da2f85d6..ceb2d3e94 100644 --- a/pw_kvs/flash_memory.cc +++ b/pw_kvs/flash_memory.cc @@ -43,7 +43,7 @@ StatusWithSize FlashPartition::Input::DoRead(std::span<byte> data) { 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::Read(Address address, std::span<byte> output) { 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 @@ Status FlashPartition::IsRegionErased(Address source_flash_address, 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 @@ Status FlashPartition::IsRegionErased(Address source_flash_address, 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 @@ Status FlashPartition::IsRegionErased(Address source_flash_address, 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 @@ Status FlashPartition::IsRegionErased(Address source_flash_address, 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 @@ Status FlashPartition::CheckBounds(Address address, size_t length) const { "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 dd562547a..aa7a12d5a 100644 --- a/pw_kvs/flash_partition_test.cc +++ b/pw_kvs/flash_partition_test.cc @@ -37,7 +37,7 @@ void WriteData(FlashPartition& partition, uint8_t fill_byte) { 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 @@ void WriteData(FlashPartition& partition, uint8_t fill_byte) { 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 @@ void WriteData(FlashPartition& partition, uint8_t fill_byte) { 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 @@ TEST(FlashPartitionTest, EraseTest) { 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 @@ TEST(FlashPartitionTest, EraseTest) { 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 @@ TEST(FlashPartitionTest, EraseTest) { 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 @@ TEST(FlashPartitionTest, IsErased) { // 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 @@ TEST(FlashPartitionTest, IsErased) { // 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 25e60ad0a..d6fe2839e 100644 --- a/pw_kvs/flash_partition_with_stats.cc +++ b/pw_kvs/flash_partition_with_stats.cc @@ -27,7 +27,7 @@ Status FlashPartitionWithStats::SaveStorageStats(const KeyValueStore& kvs, 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 @@ Status FlashPartitionWithStats::SaveStorageStats(const KeyValueStore& kvs, 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 @@ Status FlashPartitionWithStats::SaveStorageStats(const KeyValueStore& kvs, 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 05441d913..71da37839 100644 --- a/pw_kvs/key_value_store.cc +++ b/pw_kvs/key_value_store.cc @@ -67,14 +67,14 @@ Status KeyValueStore::Init() { "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 @@ Status KeyValueStore::Init() { "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 KeyValueStore::Init() { 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 @@ Status KeyValueStore::Init() { 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 @@ Status KeyValueStore::Init() { 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 @@ Status KeyValueStore::InitializeMetadata() { 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 @@ Status KeyValueStore::InitializeMetadata() { 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 @@ Status KeyValueStore::InitializeMetadata() { 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 @@ Status KeyValueStore::ScanForEntry(const SectorDescriptor& sector, 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 @@ Status KeyValueStore::PutBytes(string_view key, std::span<const byte> value) { 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 @@ Status KeyValueStore::PutBytes(string_view key, std::span<const byte> value) { return WriteEntryForExistingKey(metadata, EntryState::kValid, key, value); } - if (status == Status::NOT_FOUND) { + if (status == Status::NotFound()) { return WriteEntryForNewKey(key, value); } @@ -495,7 +495,7 @@ StatusWithSize KeyValueStore::ValueSize(string_view key) const { 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 @@ Status KeyValueStore::FindExisting(string_view key, // 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 @@ Status KeyValueStore::FixedSizeGet(std::string_view key, 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 @@ StatusWithSize KeyValueStore::ValueSize(const EntryMetadata& metadata) const { 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 @@ Status KeyValueStore::WriteEntryForNewKey(string_view key, 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 @@ Status KeyValueStore::WriteEntry(string_view key, // 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 @@ Status KeyValueStore::WriteEntry(string_view key, 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 @@ Status KeyValueStore::GetAddressesForWrite(Address* write_addresses, 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 @@ Status KeyValueStore::GetSectorForWrite(SectorDescriptor** sector, 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 @@ Status KeyValueStore::GetSectorForWrite(SectorDescriptor** sector, // 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 @@ Status KeyValueStore::GetSectorForWrite(SectorDescriptor** sector, // 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 @@ Status KeyValueStore::AppendEntry(const Entry& entry, sector.RemoveWritableBytes(result.size()); sector.AddValidBytes(result.size()); - return Status::OK; + return Status::Ok(); } StatusWithSize KeyValueStore::CopyEntryToSector(Entry& entry, @@ -864,12 +864,12 @@ Status KeyValueStore::RelocateEntry( 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::FullMaintenance() { Status KeyValueStore::PartialMaintenance() { if (initialized_ == InitializationState::kNotInitialized) { - return Status::FAILED_PRECONDITION; + return Status::FailedPrecondition(); } CheckForErrors(); @@ -955,7 +955,7 @@ Status KeyValueStore::GarbageCollect( 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 @@ Status KeyValueStore::RelocateKeyAddressesInSector( } } - return Status::OK; + return Status::Ok(); }; Status KeyValueStore::GarbageCollectSector( @@ -994,7 +994,7 @@ Status KeyValueStore::GarbageCollectSector( 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 @@ Status KeyValueStore::GarbageCollectSector( 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 @@ Status KeyValueStore::AddRedundantEntries(EntryMetadata& metadata) { metadata.AddNewAddress(new_address); } - return Status::OK; + return Status::Ok(); } Status KeyValueStore::RepairCorruptSectors() { @@ -1081,15 +1081,15 @@ Status KeyValueStore::RepairCorruptSectors() { // 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 @@ Status KeyValueStore::RepairCorruptSectors() { 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::RepairCorruptSectors() { } 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::EnsureFreeSectorExists() { } 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 ba2964a56..ea1b5964f 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 @@ class KvsErrorHandling : public ::testing::Test { 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 @@ TEST_F(KvsErrorHandling, Init_CorruptEntry_FindsSubsequentValidEntry) { 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 @@ TEST_F(KvsErrorHandling, Init_CorruptEntry_CorrectlyAccountsForSectorSize) { 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 @@ TEST_F(KvsErrorHandling, Init_ReadError_InitializedWithSingleEntryError) { 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 @@ TEST_F(KvsErrorHandling, Init_CorruptSectors_ShouldBeUnwritable) { 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 @@ TEST_F(KvsErrorHandling, Init_CorruptSectors_ShouldRecoverOne) { 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, Init_CorruptSectors_ShouldRecoverOne) { 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 @@ TEST_F(KvsErrorHandling, Init_CorruptKey_RevertsToPreviousVersion) { // 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 @@ TEST_F(KvsErrorHandling, Init_CorruptKey_RevertsToPreviousVersion) { // 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 @@ TEST_F(KvsErrorHandling, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) { // 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 @@ class KvsErrorRecovery : public ::testing::Test { 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 @@ TEST_F(KvsErrorRecovery, Init_CorruptEntry_FindsSubsequentValidEntry) { 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 @@ TEST_F(KvsErrorRecovery, Init_CorruptEntry_CorrectlyAccountsForSectorSize) { 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 @@ TEST_F(KvsErrorRecovery, Init_ReadError_InitializedWithSingleEntryError) { 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 @@ TEST_F(KvsErrorRecovery, Init_CorruptSectors_ShouldBeUnwritable) { 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 @@ TEST_F(KvsErrorRecovery, Init_CorruptSectors_ShouldRecoverOne) { 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, Init_CorruptSectors_ShouldRecoverOne) { 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 @@ TEST_F(KvsErrorRecovery, Init_CorruptKey_RevertsToPreviousVersion) { // 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 @@ TEST_F(KvsErrorRecovery, Init_CorruptKey_RevertsToPreviousVersion) { // 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 @@ TEST_F(KvsErrorRecovery, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) { // 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 @@ class InitializedRedundantMultiMagicKvs : public ::testing::Test { 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 @@ class InitializedRedundantMultiMagicKvs : public ::testing::Test { 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 @@ TEST_F(InitializedRedundantMultiMagicKvs, RecoversLossOfFirstSector) { 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 @@ TEST_F(InitializedRedundantMultiMagicKvs, RecoversLossOfFirstSector) { 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 @@ TEST_F(InitializedRedundantMultiMagicKvs, RecoversLossOfSecondSector) { 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, RecoversLossOfSecondSector) { 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, SingleReadErrors) { } 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 @@ TEST_F(InitializedRedundantMultiMagicKvs, SingleWriteError) { 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 @@ TEST_F(InitializedRedundantMultiMagicKvs, SingleWriteError) { 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, DataLossAfterLosingBothCopies) { } 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, PutNewEntry_UsesFirstFormat) { } 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 @@ TEST_F(InitializedRedundantMultiMagicKvs, PutExistingEntry_UsesFirstFormat) { 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 @@ class InitializedMultiMagicKvs : public ::testing::Test { 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 @@ TEST_F(InitializedMultiMagicKvs, AllEntriesArePresent) { // 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 @@ class InitializedRedundantLazyRecoveryKvs : public ::testing::Test { 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 @@ class InitializedRedundantLazyRecoveryKvs : public ::testing::Test { }; 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 @@ TEST_F(InitializedRedundantLazyRecoveryKvs, WriteAfterDataLoss) { 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 @@ TEST_F(InitializedRedundantLazyRecoveryKvs, TwoSectorsCorruptWithGoodEntries) { 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 @@ class InitializedLazyRecoveryKvs : public ::testing::Test { kInitialContents.data(), kInitialContents.size()); - EXPECT_EQ(Status::OK, kvs_.Init()); + EXPECT_EQ(Status::Ok(), kvs_.Init()); } FakeFlashMemoryBuffer<512, 8> flash_; @@ -1066,17 +1066,17 @@ TEST_F(InitializedLazyRecoveryKvs, AddRedundancyToKvsFullOfStaleData) { // 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 @@ TEST_F(InitializedLazyRecoveryKvs, AddRedundancyToKvsFullOfStaleData) { &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 @@ TEST_F(InitializedLazyRecoveryKvs, AddRedundancyToKvsFullOfStaleData) { 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 fcfca4cb5..4fd86bcce 100644 --- a/pw_kvs/key_value_store_fuzz_test.cc +++ b/pw_kvs/key_value_store_fuzz_test.cc @@ -46,7 +46,7 @@ class EmptyInitializedKvs : public ::testing::Test { 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 @@ TEST_F(EmptyInitializedKvs, Put_VaryingKeysAndValues) { 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 6ed0b525b..7ea3fd9a2 100644 --- a/pw_kvs/key_value_store_initialized_test.cc +++ b/pw_kvs/key_value_store_initialized_test.cc @@ -83,7 +83,7 @@ class EmptyInitializedKvs : public ::testing::Test { 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 @@ class EmptyInitializedKvs : public ::testing::Test { 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 @@ class EmptyInitializedKvs : public ::testing::Test { 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 @@ TEST_F(EmptyInitializedKvs, Put_SameKeySameValueRepeatedly_AlignedEntries) { 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 @@ TEST_F(EmptyInitializedKvs, Put_SameKeySameValueRepeatedly_UnalignedEntries) { 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 @@ TEST_F(EmptyInitializedKvs, Put_SameKeyDifferentValuesRepeatedly) { 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 @@ TEST_F(EmptyInitializedKvs, PutAndGetByValue_NotConvertibleToSpan) { }; 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 @@ TEST_F(EmptyInitializedKvs, Collision_WithPresentKey) { 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 @@ TEST_F(EmptyInitializedKvs, Collision_WithDeletedKey) { 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_Empty_ByValue) { } 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 @@ TEST_F(EmptyInitializedKvs, FuzzTest) { 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 @@ TEST_F(EmptyInitializedKvs, FuzzTest) { 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 @@ TEST_F(EmptyInitializedKvs, Basic) { // 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 87d0dee68..27b961cdb 100644 --- a/pw_kvs/key_value_store_map_test.cc +++ b/pw_kvs/key_value_store_map_test.cc @@ -88,9 +88,9 @@ class KvsTester { // 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 @@ class KvsTester { 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 @@ class KvsTester { 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 @@ class KvsTester { 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 @@ class KvsTester { } 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 @@ class KvsTester { 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 @@ class KvsTester { 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 e02aa9125..28207939f 100644 --- a/pw_kvs/key_value_store_test.cc +++ b/pw_kvs/key_value_store_test.cc @@ -121,12 +121,12 @@ struct FlashWithPartitionFake { 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 @@ struct FlashWithPartitionFake { 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 @@ TEST(InitCheck, TooFewSectors) { 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 @@ TEST(InitCheck, ZeroSectors) { 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 @@ TEST(InitCheck, TooManySectors) { 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 @@ TEST(InMemoryKvs, Basic) { // 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, Basic) { 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 @@ TEST(InMemoryKvs, CallingEraseTwice_NothingWrittenToFlash) { 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 @@ TEST(InMemoryKvs, CallingEraseTwice_NothingWrittenToFlash) { 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 @@ TEST_F(LargeEmptyInitializedKvs, Basic) { 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 @@ TEST(InMemoryKvs, Put_MaxValueSize) { 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 d6cadc4d6..d2725355d 100644 --- a/pw_kvs/key_value_store_wear_test.cc +++ b/pw_kvs/key_value_store_wear_test.cc @@ -35,7 +35,7 @@ class WearTest : public ::testing::Test { : 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_F(WearTest, TwoPassFillWithLargeAndLarger) { 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_F(WearTest, TwoPassFillWithLargeAndLarger) { 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 e8cf191ed..56d0c083a 100644 --- a/pw_kvs/public/pw_kvs/alignment.h +++ b/pw_kvs/public/pw_kvs/alignment.h @@ -116,7 +116,7 @@ StatusWithSize AlignedWrite(Output& output, // 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 c1b0bbe8b..9795e0120 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 @@ class FakeFlashMemory : public FlashMemory { 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 a486889a0..029fba265 100644 --- a/pw_kvs/public/pw_kvs/flash_memory.h +++ b/pw_kvs/public/pw_kvs/flash_memory.h @@ -59,7 +59,7 @@ class FlashMemory { 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 @@ class FlashPartition { 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 167182f64..80a0ef0e3 100644 --- a/pw_kvs/public/pw_kvs/io.h +++ b/pw_kvs/public/pw_kvs/io.h @@ -71,7 +71,7 @@ class Input { // 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 7377a11fd..94ff16e0a 100644 --- a/pw_kvs/sectors.cc +++ b/pw_kvs/sectors.cc @@ -108,7 +108,7 @@ Status Sectors::Find(FindMode find_mode, 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 @@ Status Sectors::Find(FindMode find_mode, 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 @@ Status Sectors::Find(FindMode find_mode, 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 521992522..af6d4a906 100644 --- a/pw_kvs/test_key_value_store_test.cc +++ b/pw_kvs/test_key_value_store_test.cc @@ -24,10 +24,10 @@ namespace { // 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 b8b15b0d1..094826103 100644 --- a/pw_metric/metric_service_nanopb_test.cc +++ b/pw_metric/metric_service_nanopb_test.cc @@ -33,7 +33,7 @@ TEST(MetricService, EmptyGroupAndNoMetrics) { 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 @@ TEST(MetricService, FlatMetricsNoGroupsOneResponseOnly) { 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 @@ TEST(MetricService, NestedGroupsButOnlyOneBatch) { 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 @@ TEST(MetricService, NestedGroupsWithBatches) { 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 c9845c9f6..0b2665713 100644 --- a/pw_protobuf/codegen_test.cc +++ b/pw_protobuf/codegen_test.cc @@ -167,7 +167,7 @@ TEST(Codegen, Codegen) { // 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 @@ TEST(CodegenRepeated, NonPackedScalar) { 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 @@ TEST(CodegenRepeated, PackedScalar) { 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 @@ TEST(CodegenRepeated, NonScalar) { 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 @@ TEST(CodegenRepeated, Message) { // 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 @@ TEST(Codegen, Proto2) { 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 @@ TEST(Codegen, Import) { } 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 @@ TEST(Codegen, NonPigweedPackage) { 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 72127bea5..70880ad99 100644 --- a/pw_protobuf/decoder.cc +++ b/pw_protobuf/decoder.cc @@ -27,24 +27,24 @@ Status Decoder::Next() { } } 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 @@ Status Decoder::ReadUint32(uint32_t* out) { 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 @@ Status Decoder::ReadSint32(int32_t* out) { 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 @@ Status Decoder::ReadSint64(int64_t* out) { return status; } *out = varint::ZigZagDecode(value); - return Status::OK; + return Status::Ok(); } Status Decoder::ReadBool(bool* out) { @@ -96,7 +96,7 @@ Status Decoder::ReadBool(bool* out) { return status; } *out = value; - return Status::OK; + return Status::Ok(); } Status Decoder::ReadString(std::string_view* out) { @@ -107,7 +107,7 @@ Status Decoder::ReadString(std::string_view* out) { } *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 @@ Status Decoder::ConsumeKey(WireType expected_type) { 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 @@ Status Decoder::ReadVarint(uint64_t* out) { 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 @@ Status Decoder::ReadFixed(std::byte* out, size_t size) { } 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 @@ Status Decoder::ReadDelimited(std::span<const std::byte>* out) { 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 @@ Status CallbackDecoder::Decode(std::span<const std::byte> proto) { // 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 CallbackDecoder::Decode(std::span<const std::byte> proto) { 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 @@ Status CallbackDecoder::Decode(std::span<const std::byte> proto) { } 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 7dad4b2d0..0b4f6ffe4 100644 --- a/pw_protobuf/decoder_test.cc +++ b/pw_protobuf/decoder_test.cc @@ -50,7 +50,7 @@ class TestDecodeHandler : public DecodeHandler { } called = true; - return Status::OK; + return Status::Ok(); } bool called = false; @@ -83,45 +83,45 @@ TEST(Decoder, Decode) { 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 @@ TEST(Decoder, Decode_SkipsUnusedFields) { // 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 @@ TEST(CallbackDecoder, Decode) { 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 @@ TEST(CallbackDecoder, Decode_OverridesDuplicateFields) { 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 @@ TEST(CallbackDecoder, Decode_Empty) { 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 @@ TEST(CallbackDecoder, Decode_BadData) { 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 @@ class OneThreeDecodeHandler : public DecodeHandler { 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 @@ class OneThreeDecodeHandler : public DecodeHandler { } called = true; - return Status::OK; + return Status::Ok(); } bool called = false; @@ -286,7 +286,7 @@ TEST(CallbackDecoder, Decode_SkipsUnprocessedFields) { 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 @@ class ExitOnOneDecoder : public DecodeHandler { 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 @@ TEST(CallbackDecoder, Decode_StopsOnNonOkStatus) { 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 96b9b7ddc..6a5ecebfb 100644 --- a/pw_protobuf/encoder.cc +++ b/pw_protobuf/encoder.cc @@ -32,18 +32,18 @@ Status Encoder::WriteVarint(uint64_t value) { 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 @@ Status Encoder::WriteRawBytes(const std::byte* ptr, size_t size) { } if (size > RemainingSize()) { - encode_status_ = Status::RESOURCE_EXHAUSTED; + encode_status_ = Status::ResourceExhausted(); return encode_status_; } @@ -61,7 +61,7 @@ Status Encoder::WriteRawBytes(const std::byte* ptr, size_t size) { std::memmove(cursor_, ptr, size); cursor_ += size; - return Status::OK; + return Status::Ok(); } Status Encoder::Push(uint32_t field_number) { @@ -70,7 +70,7 @@ Status Encoder::Push(uint32_t field_number) { } 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 @@ Status Encoder::Push(uint32_t field_number) { 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 @@ Status Encoder::Push(uint32_t field_number) { blob_stack_[depth_++] = size_cursor; cursor_ += sizeof(*size_cursor); - return Status::OK; + return Status::Ok(); } Status Encoder::Pop() { @@ -114,7 +114,7 @@ Status Encoder::Pop() { } if (depth_ == 0) { - encode_status_ = Status::FAILED_PRECONDITION; + encode_status_ = Status::FailedPrecondition(); return encode_status_; } @@ -123,7 +123,7 @@ Status Encoder::Pop() { 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 @@ Status Encoder::Encode(std::span<const std::byte>* out) { 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 @@ Status Encoder::Encode(std::span<const std::byte>* out) { // 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 8a86057ae..109943db0 100644 --- a/pw_protobuf/encoder_test.cc +++ b/pw_protobuf/encoder_test.cc @@ -85,16 +85,16 @@ TEST(Encoder, EncodePrimitives) { 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 @@ TEST(Encoder, EncodeInsufficientSpace) { 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 @@ TEST(Encoder, EncodeInvalidArguments) { 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 @@ TEST(Encoder, Nested) { // 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 @@ TEST(Encoder, Nested) { // 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 @@ TEST(Encoder, NestedDepthLimit) { 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 @@ TEST(Encoder, NestedBlobLimit) { 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 @@ TEST(Encoder, RepeatedField) { 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 @@ TEST(Encoder, PackedVarint) { // 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 @@ TEST(Encoder, PackedVarintInsufficientSpace) { 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 @@ TEST(Encoder, PackedFixed) { 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 @@ TEST(Encoder, PackedZigzag) { 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 923097a82..635f50b0b 100644 --- a/pw_protobuf/find.cc +++ b/pw_protobuf/find.cc @@ -20,12 +20,12 @@ Status FindDecodeHandler::ProcessField(CallbackDecoder& decoder, 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 595bc9aec..6cb402eb0 100644 --- a/pw_protobuf/public/pw_protobuf/decoder.h +++ b/pw_protobuf/public/pw_protobuf/decoder.h @@ -192,7 +192,7 @@ class DecodeHandler; // break; // } // -// return Status::OK; +// return Status::Ok(); // } // // int bar; @@ -303,8 +303,8 @@ class DecodeHandler { // 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 3e86368c6..14483d2f1 100644 --- a/pw_protobuf/public/pw_protobuf/encoder.h +++ b/pw_protobuf/public/pw_protobuf/encoder.h @@ -40,7 +40,7 @@ class Encoder { 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 @@ class Encoder { // 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 @@ class Encoder { // 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 660c98148..6b7e3794d 100644 --- a/pw_random/xor_shift_test.cc +++ b/pw_random/xor_shift_test.cc @@ -44,7 +44,7 @@ TEST(XorShiftStarRng64, ValidateSeries1) { 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 @@ TEST(XorShiftStarRng64, ValidateSeries2) { 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 @@ TEST(XorShiftStarRng64, InjectEntropyBits) { 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 @@ TEST(XorShiftStarRng64, EntropyBitCount) { 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 @@ TEST(XorShiftStarRng64, IncrementalEntropy) { 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 @@ TEST(XorShiftStarRng64, IncrementalEntropy) { 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 @@ TEST(XorShiftStarRng64, InjectEntropy) { 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 60bcc0561..70935511e 100644 --- a/pw_result/public/pw_result/result.h +++ b/pw_result/public/pw_result/result.h @@ -26,17 +26,20 @@ namespace pw { 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 b29c24001..ef913fde2 100644 --- a/pw_result/result_test.cc +++ b/pw_result/result_test.cc @@ -22,19 +22,19 @@ namespace { 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 @@ TEST(Result, ConstructType) { 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, ReturnOk) { 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 7c77de695..522c9fe5b 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 e3464525c..fb4f94810 100644 --- a/pw_result/size_report/pointer_read.cc +++ b/pw_result/size_report/pointer_read.cc @@ -34,11 +34,11 @@ PW_NO_INLINE pw::Status Read(size_t offset, 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 eb536d407..7c1440ed4 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 c099dc52f..b008e52da 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 9bc9ffd03..351be041a 100644 --- a/pw_result/size_report/result_read.cc +++ b/pw_result/size_report/result_read.cc @@ -33,7 +33,7 @@ constexpr auto kArray = pw::bytes::Array< 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 91772b98b..333eca821 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 31eb222bc..d12216243 100644 --- a/pw_ring_buffer/prefixed_entry_ring_buffer.cc +++ b/pw_ring_buffer/prefixed_entry_ring_buffer.cc @@ -33,24 +33,24 @@ Status PrefixedEntryRingBuffer::SetBuffer(std::span<byte> buffer) { 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 @@ Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data, 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 @@ Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data, } } 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 @@ Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data, 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 @@ auto GetOutput(std::span<byte> data_out, size_t* write_index) { 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 @@ Status PrefixedEntryRingBuffer::PeekFrontWithPreamble(ReadOutput output) { 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::InternalRead(T read_output, bool get_preamble) { 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 @@ Status PrefixedEntryRingBuffer::PopFront() { 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 @@ Status PrefixedEntryRingBuffer::Dering() { } 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 271ce74ed..5838ca4b8 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 @@ TEST(PrefixedEntryRingBuffer, NoBuffer) { 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 @@ void SingleEntryWriteReadTest(bool user_data) { // 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 @@ void SingleEntryWriteReadTest(bool user_data) { 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 @@ void SingleEntryWriteReadTest(bool user_data) { 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 @@ void CountingUpWriteReadTest() { 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 @@ void CountingUpWriteReadTest() { 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 @@ void CountingUpWriteReadTest() { 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 @@ void SingleEntryWriteReadWithSectionWriterTest(bool user_data) { 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 @@ void SingleEntryWriteReadWithSectionWriterTest(bool user_data) { 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 @@ void SingleEntryWriteReadWithSectionWriterTest(bool user_data) { 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 @@ void DeringTest(bool preload) { 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 @@ void DeringTest(bool preload) { 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 @@ void DeringTest(bool preload) { 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 PeekFront(PrefixedEntryRingBuffer& ring) { 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 @@ T PeekFront(PrefixedEntryRingBuffer& ring) { 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 @@ TEST(PrefixedEntryRingBuffer, TryPushBack) { if (status.ok()) { total_items++; } else { - EXPECT_EQ(status, Status::RESOURCE_EXHAUSTED); + EXPECT_EQ(status, Status::ResourceExhausted()); break; } } @@ -421,13 +422,13 @@ TEST(PrefixedEntryRingBuffer, TryPushBack) { // 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 5e33aa9e8..1e3c39680 100644 --- a/pw_rpc/base_server_writer.cc +++ b/pw_rpc/base_server_writer.cc @@ -74,7 +74,7 @@ std::span<std::byte> BaseServerWriter::AcquirePayloadBuffer() { 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 1a7dae0ad..bb6b8a22a 100644 --- a/pw_rpc/base_server_writer_test.cc +++ b/pw_rpc/base_server_writer_test.cc @@ -119,7 +119,7 @@ TEST(ServerWriter, Finish_SendsCancellationPacket) { 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 @@ TEST(ServerWriter, Open_SendsPacketWithPayload) { 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 @@ TEST(ServerWriter, Closed_IgnoresPacket) { 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 1074ceae7..8771109d5 100644 --- a/pw_rpc/channel.cc +++ b/pw_rpc/channel.cc @@ -34,7 +34,7 @@ Status Channel::Send(OutputBuffer& buffer, const internal::Packet& packet) { 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 b160729dd..cdddc142e 100644 --- a/pw_rpc/channel_test.cc +++ b/pw_rpc/channel_test.cc @@ -28,7 +28,7 @@ TEST(ChannelOutput, Name) { 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 @@ TEST(Channel, OutputBuffer_TooSmall) { 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 @@ TEST(Channel, OutputBuffer_ExactFit) { 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 @@ TEST(Channel, OutputBuffer_PayloadDoesNotFit_ReportsError) { 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 @@ TEST(Channel, OutputBuffer_ExtraRoom) { 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 @@ TEST(Channel, OutputBuffer_ReturnsStatusFromChannelOutputSend) { 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 a65ff9dca..10ab42a79 100644 --- a/pw_rpc/nanopb/codegen_test.cc +++ b/pw_rpc/nanopb/codegen_test.cc @@ -53,28 +53,28 @@ TEST(NanopbCodegen, CompilesProperly) { 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 @@ TEST(NanopbCodegen, InvokeStreamingRpc) { 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 @@ TEST(NanopbCodegen, InvokeStreamingRpc_ContextKeepsFixedNumberOfResponses) { 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 @@ TEST(NanopbCodegen, InvokeStreamingRpc_ManualWriting) { 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 4f6953304..2d4b6f231 100644 --- a/pw_rpc/nanopb/echo_service_test.cc +++ b/pw_rpc/nanopb/echo_service_test.cc @@ -21,13 +21,13 @@ namespace { 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 72a0d7a78..bc96dc9f9 100644 --- a/pw_rpc/nanopb/nanopb_method.cc +++ b/pw_rpc/nanopb/nanopb_method.cc @@ -55,7 +55,7 @@ bool NanopbMethod::DecodeRequest(Channel& channel, 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 @@ void NanopbMethod::SendResponse(Channel& channel, 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 31b23978d..a98ea509c 100644 --- a/pw_rpc/nanopb/nanopb_method_test.cc +++ b/pw_rpc/nanopb/nanopb_method_test.cc @@ -77,13 +77,13 @@ class FakeGeneratedServiceImpl 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 @@ TEST(NanopbMethod, UnaryRpc_SendsResponse) { 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 @@ TEST(NanopbMethod, UnaryRpc_InvalidPayload_SendsError) { 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 @@ TEST(NanopbMethod, UnaryRpc_BufferTooSmallForResponse_SendsInternalError) { 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 @@ TEST(NanopbMethod, ServerWriter_SendsResponse) { 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 @@ TEST(NanopbMethod, // 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 0ce388c6f..127c71274 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 @@ class EchoService final : public generated::EchoService<EchoService> { 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 3a1508ca4..3a97cff08 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 @@ Status ServerWriter<T>::Write(const T& response) { } 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 07fdd3cf3..c30941b73 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 @@ namespace pw::rpc { // 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 @@ namespace pw::rpc { // 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 @@ void MessageOutput<Response>::clear() { responses_.clear(); total_responses_ = 0; stream_ended_ = false; - last_status_ = Status::UNKNOWN; + last_status_ = Status::Unknown(); } template <typename Response> @@ -245,7 +245,7 @@ Status MessageOutput<Response>::SendAndReleaseBuffer(size_t size) { PW_CHECK(!stream_ended_); if (size == 0u) { - return Status::OK; + return Status::Ok(); } internal::Packet packet; @@ -268,7 +268,7 @@ Status MessageOutput<Response>::SendAndReleaseBuffer(size_t size) { 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 dfbdb5075..56969cae2 100644 --- a/pw_rpc/packet.cc +++ b/pw_rpc/packet.cc @@ -64,7 +64,7 @@ Status Packet::FromBuffer(std::span<const byte> data, Packet& packet) { } } - 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 44b2df918..2fd53a215 100644 --- a/pw_rpc/packet_test.cc +++ b/pw_rpc/packet_test.cc @@ -87,12 +87,12 @@ TEST(Packet, Encode_BufferTooSmall) { 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 @@ TEST(Packet, Decode_InvalidPacket) { 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 @@ TEST(Packet, EncodeDecode) { 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 @@ TEST(Packet, EncodeDecode) { 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 1ace1e69e..295cd4cea 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 @@ class BaseServerWriter : public IntrusiveList<BaseServerWriter>::Item { 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 a6feddfbc..f88118744 100644 --- a/pw_rpc/public/pw_rpc/internal/packet.h +++ b/pw_rpc/public/pw_rpc/internal/packet.h @@ -33,7 +33,7 @@ class Packet { // 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 @@ class Packet { 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 c3f958de5..aeb2237ad 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 @@ class TestOutput : public ChannelOutput { 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 @@ class ServerContextForTest { kServiceId, context_.method().id(), payload, - Status::OK); + Status::Ok()); } internal::ServerCall& get() { return context_; } @@ -144,13 +144,13 @@ class ClientContextForTest { // 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 109221da7..f7afeeafc 100644 --- a/pw_rpc/server.cc +++ b/pw_rpc/server.cc @@ -45,7 +45,7 @@ bool DecodePacket(ChannelOutput& interface, // 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 @@ Status Server::ProcessPacket(std::span<const byte> data, 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 @@ Status Server::ProcessPacket(std::span<const byte> data, // 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 @@ Status Server::ProcessPacket(std::span<const byte> data, 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 @@ void Server::HandleCancelPacket(const Packet& packet, }); 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 7c7a0fd33..44a7888d7 100644 --- a/pw_rpc/server_test.cc +++ b/pw_rpc/server_test.cc @@ -81,7 +81,7 @@ class BasicServer : public ::testing::Test { 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 @@ class BasicServer : public ::testing::Test { }; 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_ValidMethod_InvokesMethod) { } 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_IncompletePacket_NothingIsInvoked) { } 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_NoChannel_SendsNothing) { } 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_NothingIsInvoked) { } 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 @@ TEST_F(BasicServer, ProcessPacket_InvalidMethod_SendsError) { 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 @@ TEST_F(BasicServer, ProcessPacket_InvalidService_SendsError) { 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 @@ TEST_F(BasicServer, 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, 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 @@ TEST_F(BasicServer, ProcessPacket_Cancel_MethodNotActive_SendsError) { 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 @@ class MethodPending : public BasicServer { }; 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_ClosesServerWriter) { } 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 @@ TEST_F(MethodPending, ProcessPacket_Cancel_SendsStreamEndPacket) { 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 d4c591e45..2a463358d 100644 --- a/pw_status/public/pw_status/status.h +++ b/pw_status/public/pw_status/status.h @@ -27,39 +27,39 @@ extern "C" { // 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 @@ typedef enum { // 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 @@ typedef enum { // 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 @@ typedef enum { // 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 @@ typedef enum { // // 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 @@ const char* pw_StatusString(pw_Status status); 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 @@ class Status { // 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 6064dc3d1..8c79e8cf5 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 @@ class StatusWithSize { 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 @@ class StatusWithSize { // 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 4d52e5aa9..b84258bef 100644 --- a/pw_status/try_test.cc +++ b/pw_status/try_test.cc @@ -26,7 +26,7 @@ Status TryStatus(Status status) { 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 @@ Status TryStatus(StatusWithSize status) { 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 @@ TEST(Status, TryAssignOk) { 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 @@ TEST(Status, TryAssignError) { 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 @@ StatusWithSize TryStatusWithSize(Status status) { 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 b0a9c36e4..8f7e29eab 100644 --- a/pw_stream/memory_stream.cc +++ b/pw_stream/memory_stream.cc @@ -23,22 +23,22 @@ namespace pw::stream { 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 e08a299a4..0a0241ebc 100644 --- a/pw_stream/memory_stream_test.cc +++ b/pw_stream/memory_stream_test.cc @@ -38,7 +38,7 @@ TEST(MemoryWriter, BytesWritten) { 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 @@ TEST(MemoryWriter, MultipleWrites) { 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 @@ TEST(MemoryWriter, FullWriter) { 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 @@ TEST(MemoryWriter, EmptyData) { 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 @@ TEST(MemoryReader, SingleFullRead) { // 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 @@ TEST(MemoryReader, SingleFullRead) { // 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 @@ TEST(MemoryReader, EmptySpanRead) { // 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 @@ TEST(MemoryReader, SinglePartialRead) { // 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 @@ TEST(MemoryReader, SinglePartialRead) { // 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 @@ TEST(MemoryReader, MultipleReads) { // 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 980381a52..299fb3abd 100644 --- a/pw_stream/public/pw_stream/memory_stream.h +++ b/pw_stream/public/pw_stream/memory_stream.h @@ -41,7 +41,7 @@ class MemoryWriter : public Writer { // 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 b5482c3db..70048dc17 100644 --- a/pw_stream/public/pw_stream/null_stream.h +++ b/pw_stream/public/pw_stream/null_stream.h @@ -33,7 +33,7 @@ class NullWriter final : public Writer { } 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 66a5955d1..5e0a0c039 100644 --- a/pw_stream/public/pw_stream/stream.h +++ b/pw_stream/public/pw_stream/stream.h @@ -73,7 +73,8 @@ class Writer { // 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 @@ class Reader { // 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 c9ed3797d..c08bf3c03 100644 --- a/pw_string/format.cc +++ b/pw_string/format.cc @@ -31,7 +31,7 @@ StatusWithSize FormatVaList(std::span<char> buffer, 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 @@ StatusWithSize FormatVaList(std::span<char> buffer, // 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 dfaac7bc0..b7aab52c6 100644 --- a/pw_string/format_test.cc +++ b/pw_string/format_test.cc @@ -26,7 +26,7 @@ TEST(Format, ValidFormatString_Succeeds) { 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 @@ TEST(Format, ValidFormatStringAndArguments_Succeeds) { 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, ValidFormatStringAndArguments_Succeeds) { 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 @@ TEST(Format, FormatLargerThanBuffer_ReturnsResourceExhausted) { 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 @@ TEST(Format, ArgumentLargerThanBuffer_ReturnsResourceExhausted) { 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 @@ TEST(Format, CallFormatWithVaList_CallsCorrectFormatOverload) { 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 5c0adfe85..f3aa337f8 100644 --- a/pw_string/public/pw_string/format.h +++ b/pw_string/public/pw_string/format.h @@ -35,9 +35,9 @@ namespace pw::string { // // 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 21769b3a5..425fbfb63 100644 --- a/pw_string/public/pw_string/string_builder.h +++ b/pw_string/public/pw_string/string_builder.h @@ -135,7 +135,7 @@ class StringBuilder { // 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 @@ class StringBuilder { // 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 b433e7f31..1bc3b1fbd 100644 --- a/pw_string/string_builder.cc +++ b/pw_string/string_builder.cc @@ -24,8 +24,8 @@ namespace pw { 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 @@ StringBuilder& StringBuilder::append(const std::string_view& str, size_t pos, size_t count) { if (pos > str.size()) { - SetErrorStatus(Status::OUT_OF_RANGE); + SetErrorStatus(Status::OutOfRange()); return *this; } @@ -68,9 +68,9 @@ size_t StringBuilder::ResizeAndTerminate(size_t chars_to_append) { 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 @@ void StringBuilder::resize(size_t new_size) { 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 d07829930..cfef0e738 100644 --- a/pw_string/string_builder_test.cc +++ b/pw_string/string_builder_test.cc @@ -75,7 +75,7 @@ TEST(StringBuilder, EmptyBuffer_StreamOutput_WritesNothing) { 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_Resize_WritesNothing) { 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, StreamOutput_OutputSelf) { 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) { 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) { 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 @@ TEST(StringBuilder, Append_NonTerminatedString) { 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) { 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) { 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 @@ TEST(StringBuilder, Resize_Larger_Fails) { 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_Normal) { 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 @@ TEST(StringBuilder, StreamOutput_FullBufferIgnoresExtraStrings) { 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 @@ TEST(StringBuilder, StreamOutput_ExhaustBuffer_InTwoStrings) { 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 @@ TEST(StringBuilder, StreamOutput_NonTerminatedString) { 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 @@ TEST(StringBuilder, SteamOutput_StringView) { 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 @@ TEST(StringBuffer, Assign) { 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 @@ TEST(StringBuffer, CopyConstructFromSameSize) { 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 @@ TEST(StringBuffer, CopyConstructFromSmaller) { 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, DefaultSizeString_FitsWholeString) { 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 6f4a4da44..2f3608d85 100644 --- a/pw_string/to_string_test.cc +++ b/pw_string/to_string_test.cc @@ -43,13 +43,13 @@ StatusWithSize ToString(const CustomType&, std::span<char> buffer) { 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 @@ TEST(ToString, ScopedEnum) { 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, Status) { 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 ce417e19e..483d10e61 100644 --- a/pw_string/type_to_string.cc +++ b/pw_string/type_to_string.cc @@ -51,7 +51,7 @@ StatusWithSize HandleExhaustedBuffer(std::span<char> buffer) { if (!buffer.empty()) { buffer[0] = '\0'; } - return StatusWithSize::RESOURCE_EXHAUSTED; + return StatusWithSize::ResourceExhausted(); } } // namespace @@ -183,14 +183,15 @@ StatusWithSize PointerToString(const void* pointer, std::span<char> buffer) { 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 5f545b316..5973579fc 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 @@ namespace pw::sys_io { // 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 @@ Status ReadByte(std::byte* dest); // 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 @@ Status WriteByte(std::byte b); // 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 @@ StatusWithSize WriteLine(const std::string_view& s); // 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 @@ StatusWithSize ReadBytes(std::span<std::byte> dest); // 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 b63e21f5c..c06f3a913 100644 --- a/pw_sys_io_arduino/sys_io_arduino.cc +++ b/pw_sys_io_arduino/sys_io_arduino.cc @@ -40,7 +40,7 @@ Status ReadByte(std::byte* dest) { 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 @@ Status WriteByte(std::byte b) { 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 253b0c52e..ddf901e37 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 @@ Status ReadByte(std::byte* dest) { 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 @@ Status WriteByte(std::byte b) { 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 46f5e40b9..80cb1699b 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 @@ Status ReadByte(std::byte* dest) { 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 @@ Status WriteByte(std::byte b) { 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 65d1a8914..04ab9b038 100644 --- a/pw_sys_io_stdio/sys_io.cc +++ b/pw_sys_io_stdio/sys_io.cc @@ -20,22 +20,22 @@ namespace pw::sys_io { 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 bfa3d8be4..ab6e8e62e 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 @@ pw_Status pw_trace_UnregisterEventCallback(pw_trace_EventCallbackHandle handle); // 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 3e41c3abd..3d9e5a6d8 100644 --- a/pw_trace_tokenized/trace_buffer_log.cc +++ b/pw_trace_tokenized/trace_buffer_log.cc @@ -54,7 +54,7 @@ pw::Status DumpTraceBufferToLog() { 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::Status DumpTraceBufferToLog() { 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 0133c9ed2..bbe7dc84f 100644 --- a/pw_trace_tokenized/trace_buffer_test.cc +++ b/pw_trace_tokenized/trace_buffer_test.cc @@ -84,7 +84,7 @@ TEST(TokenizedTrace, Data) { 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 @@ TEST(TokenizedTrace, Overflow) { 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 99359672f..a8db949cc 100644 --- a/pw_varint/public/pw_varint/varint.h +++ b/pw_varint/public/pw_varint/varint.h @@ -119,7 +119,7 @@ size_t Encode(T integer, const std::span<std::byte>& output) { // size_t bytes = Decode(data, &value); // // if (bytes == 0u) { -// return Status::DATA_LOSS; +// return Status::DataLoss(); // } // results.push_back(value); // data = data.subspan(bytes) |