pw_status: Replace Status::Ok() with OkStatus()
- Mark Status::Ok() and StatusWithSize::Ok() as deprecated.
- Replace Status::Ok() with OkStatus().
- Replace StatusWithSize::Ok() with StatusWithSize().
Change-Id: If7192282446bf6d7f90990bb0b4f1b1b89a9228a
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/29003
Pigweed-Auto-Submit: Wyatt Hepler <hepler@google.com>
Commit-Queue: Auto-Submit <auto-submit@pigweed.google.com.iam.gserviceaccount.com>
Reviewed-by: Keir Mierle <keir@google.com>
diff --git a/pw_allocator/block.cc b/pw_allocator/block.cc
index bbf1a34..0bfa9f9 100644
--- a/pw_allocator/block.cc
+++ b/pw_allocator/block.cc
@@ -46,7 +46,7 @@
#if defined(PW_ALLOCATOR_POISON_ENABLE) && PW_ALLOCATOR_POISON_ENABLE
(*block)->PoisonBlock();
#endif // PW_ALLOCATOR_POISON_ENABLE
- return Status::Ok();
+ return OkStatus();
}
Status Block::Split(size_t head_block_inner_size, Block** new_block) {
@@ -118,7 +118,7 @@
(*new_block)->PoisonBlock();
#endif // PW_ALLOCATOR_POISON_ENABLE
- return Status::Ok();
+ return OkStatus();
}
Status Block::MergeNext() {
@@ -142,7 +142,7 @@
Next()->prev = this;
}
- return Status::Ok();
+ return OkStatus();
}
Status Block::MergePrev() {
diff --git a/pw_allocator/block_test.cc b/pw_allocator/block_test.cc
index 0e09579..fb918ba 100644
--- a/pw_allocator/block_test.cc
+++ b/pw_allocator/block_test.cc
@@ -30,7 +30,7 @@
Block* block = nullptr;
auto status = Block::Init(std::span(bytes, kN), &block);
- ASSERT_EQ(status, Status::Ok());
+ ASSERT_EQ(status, OkStatus());
EXPECT_EQ(block->OuterSize(), kN);
EXPECT_EQ(block->InnerSize(),
kN - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -73,7 +73,7 @@
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
- ASSERT_EQ(status, Status::Ok());
+ ASSERT_EQ(status, OkStatus());
EXPECT_EQ(block->InnerSize(), kSplitN);
EXPECT_EQ(block->OuterSize(),
kSplitN + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -106,7 +106,7 @@
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
- ASSERT_EQ(status, Status::Ok());
+ ASSERT_EQ(status, OkStatus());
EXPECT_EQ(block->InnerSize(), split_len);
EXPECT_EQ(block->OuterSize(),
split_len + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -217,7 +217,7 @@
Block* next_block = nullptr;
auto status = block->Split(0, &next_block);
- ASSERT_EQ(status, Status::Ok());
+ ASSERT_EQ(status, OkStatus());
EXPECT_EQ(block->InnerSize(), static_cast<size_t>(0));
}
@@ -234,7 +234,7 @@
block->InnerSize() - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET,
&next_block);
- ASSERT_EQ(status, Status::Ok());
+ ASSERT_EQ(status, OkStatus());
EXPECT_EQ(next_block->InnerSize(), static_cast<size_t>(0));
}
@@ -287,7 +287,7 @@
Block* block3 = nullptr;
block->Split(kSplit2, &block3);
- EXPECT_EQ(block3->MergeNext(), Status::Ok());
+ EXPECT_EQ(block3->MergeNext(), OkStatus());
EXPECT_EQ(block->Next(), block3);
EXPECT_EQ(block3->Prev(), block);
diff --git a/pw_allocator/freelist.cc b/pw_allocator/freelist.cc
index d46e010..03b514d 100644
--- a/pw_allocator/freelist.cc
+++ b/pw_allocator/freelist.cc
@@ -36,7 +36,7 @@
aliased.node->next = chunks_[chunk_ptr];
chunks_[chunk_ptr] = aliased.node;
- return Status::Ok();
+ return OkStatus();
}
std::span<std::byte> FreeList::FindChunk(size_t size) const {
@@ -92,7 +92,7 @@
if (aliased.data == chunk.data()) {
chunks_[chunk_ptr] = aliased.node->next;
- return Status::Ok();
+ return OkStatus();
}
// No? Walk the nodes.
@@ -103,7 +103,7 @@
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 OkStatus();
}
aliased.node = aliased.node->next;
diff --git a/pw_allocator/freelist_test.cc b/pw_allocator/freelist_test.cc
index 865ea3f..8e0e145 100644
--- a/pw_allocator/freelist_test.cc
+++ b/pw_allocator/freelist_test.cc
@@ -43,7 +43,7 @@
byte data[kN] = {std::byte(0)};
auto status = list.AddChunk(std::span(data, kN));
- EXPECT_EQ(status, Status::Ok());
+ EXPECT_EQ(status, OkStatus());
auto item = list.FindChunk(kN);
EXPECT_EQ(item.size(), kN);
@@ -70,7 +70,7 @@
list.AddChunk(std::span(data, kN));
auto status = list.RemoveChunk(std::span(data, kN));
- EXPECT_EQ(status, Status::Ok());
+ EXPECT_EQ(status, OkStatus());
auto item = list.FindChunk(kN);
EXPECT_EQ(item.size(), static_cast<size_t>(0));
diff --git a/pw_assert/assert_backend_compile_test.cc b/pw_assert/assert_backend_compile_test.cc
index 6e1ac2e..5a98b15 100644
--- a/pw_assert/assert_backend_compile_test.cc
+++ b/pw_assert/assert_backend_compile_test.cc
@@ -216,10 +216,10 @@
CHECK_OK(status, "msg: %d", 5);
// Status from a literal.
- PW_CHECK_OK(pw::Status::Ok());
+ PW_CHECK_OK(pw::OkStatus());
// Status from a function.
- PW_CHECK_OK(MakeStatus(pw::Status::Ok()));
+ PW_CHECK_OK(MakeStatus(pw::OkStatus()));
// 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 083d206..376bdf5 100644
--- a/pw_assert/assert_facade_test.cc
+++ b/pw_assert/assert_facade_test.cc
@@ -477,19 +477,19 @@
TEST_F(AssertFail, StatusNotOK) {
pw::Status status = pw::Status::Unknown();
PW_CHECK_OK(status);
- EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). ");
+ EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == OkStatus() (=OK). ");
}
TEST_F(AssertFail, StatusNotOKMessageNoArguments) {
pw::Status status = pw::Status::Unknown();
PW_CHECK_OK(status, "msg");
- EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg");
+ EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == OkStatus() (=OK). msg");
}
TEST_F(AssertFail, StatusNotOKMessageArguments) {
pw::Status status = pw::Status::Unknown();
PW_CHECK_OK(status, "msg: %d", 5);
- EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg: 5");
+ EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == OkStatus() (=OK). msg: 5");
}
// Example expression for the test below.
@@ -498,13 +498,13 @@
TEST_F(AssertFail, NonTrivialExpression) {
PW_CHECK_OK(DoTheThing());
EXPECT_MESSAGE(
- "Check failed: DoTheThing() (=RESOURCE_EXHAUSTED) == Status::OK (=OK). ");
+ "Check failed: DoTheThing() (=RESOURCE_EXHAUSTED) == OkStatus() (=OK). ");
}
// 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.
-TEST_F(AssertPass, Function) { PW_CHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, Function) { PW_CHECK_OK(pw::OkStatus()); }
TEST_F(AssertPass, Enum) { PW_CHECK_OK(PW_STATUS_OK); }
TEST_F(AssertFail, Function) { PW_CHECK_OK(pw::Status::Unknown()); }
TEST_F(AssertFail, Enum) { PW_CHECK_OK(PW_STATUS_UNKNOWN); }
@@ -512,14 +512,14 @@
#if PW_ASSERT_ENABLE_DEBUG
// In debug mode, the asserts should check their arguments.
-TEST_F(AssertPass, DCheckFunction) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckFunction) { PW_DCHECK_OK(pw::OkStatus()); }
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, DCheckFunction_Ok) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckFunction_Ok) { PW_DCHECK_OK(pw::OkStatus()); }
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); }
diff --git a/pw_assert/docs.rst b/pw_assert/docs.rst
index 2d96c60..aec3343 100644
--- a/pw_assert/docs.rst
+++ b/pw_assert/docs.rst
@@ -149,10 +149,9 @@
tokenizing assert backend. For example, if ``x`` and ``b`` are integers,
use instead ``PW_CHECK_INT_LT(x, b)``.
- Additionally, use ``PW_CHECK_OK(status)`` when checking for a
- ``Status::OK``, since it enables showing a human-readable status string
- rather than an integer (e.g. ``status == RESOURCE_EXHAUSTED`` instead of
- ``status == 5``.
+ Additionally, use ``PW_CHECK_OK(status)`` when checking for an OK status,
+ since it enables showing a human-readable status string rather than an
+ integer (e.g. ``status == RESOURCE_EXHAUSTED`` instead of ``status == 5``.
+------------------------------------+-------------------------------------+
| **Do NOT do this** | **Do this instead** |
@@ -164,7 +163,7 @@
| ``PW_CHECK(Temp() <= 10.0)`` | ``PW_CHECK_FLOAT_EXACT_LE(`` |
| | `` Temp(), 10.0)`` |
+------------------------------------+-------------------------------------+
- | ``PW_CHECK(Foo() == Status::OK)`` | ``PW_CHECK_OK(Foo())`` |
+ | ``PW_CHECK(Foo() == OkStatus())`` | ``PW_CHECK_OK(Foo())`` |
+------------------------------------+-------------------------------------+
.. cpp:function:: PW_CHECK_NOTNULL(ptr)
@@ -367,7 +366,7 @@
.. cpp:function:: PW_DCHECK_OK(status)
.. cpp:function:: PW_DCHECK_OK(status, format, ...)
- Assert that ``status`` evaluates to ``pw::Status::OK`` (in C++) or
+ Assert that ``status`` evaluates to ``pw::OkStatus()`` (in C++) or
``PW_STATUS_OK`` (in C). Optionally include a message with arguments to
report.
@@ -388,7 +387,7 @@
.. note::
- Using ``PW_CHECK_OK(status)`` instead of ``PW_CHECK(status == Status::OK)``
+ Using ``PW_CHECK_OK(status)`` instead of ``PW_CHECK(status == OkStatus())``
enables displaying an error message with a string version of the error
code; for example ``status == RESOURCE_EXHAUSTED`` instead of ``status ==
5``.
diff --git a/pw_assert/public/pw_assert/internal/assert_impl.h b/pw_assert/public/pw_assert/internal/assert_impl.h
index 35eab1e..c13c298 100644
--- a/pw_assert/public/pw_assert/internal/assert_impl.h
+++ b/pw_assert/public/pw_assert/internal/assert_impl.h
@@ -314,14 +314,14 @@
// PW_CHECK_OK version 1: No message or args
#define _PW_CHECK_OK_HAS_MSG_0(status_expr_str, status_value_str, ignored_arg) \
PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE( \
- status_expr_str, status_value_str, "==", "Status::OK", "OK", "%s", "")
+ status_expr_str, status_value_str, "==", "OkStatus()", "OK", "%s", "")
// PW_CHECK_OK version 2: With message (and maybe args)
#define _PW_CHECK_OK_HAS_MSG_1(status_expr_str, status_value_str, ...) \
PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(status_expr_str, \
status_value_str, \
"==", \
- "Status::OK", \
+ "OkStatus()", \
"OK", \
"%s", \
__VA_ARGS__)
diff --git a/pw_blob_store/blob_store.cc b/pw_blob_store/blob_store.cc
index 247886c..2389292 100644
--- a/pw_blob_store/blob_store.cc
+++ b/pw_blob_store/blob_store.cc
@@ -23,7 +23,7 @@
Status BlobStore::Init() {
if (initialized_) {
- return Status::Ok();
+ return OkStatus();
}
PW_LOG_INFO("Init BlobStore");
@@ -44,7 +44,7 @@
PW_LOG_DEBUG("BlobStore init - Have valid blob of %u bytes",
static_cast<unsigned>(write_address_));
- return Status::Ok();
+ return OkStatus();
}
// No saved blob, check for flash being erased.
@@ -59,7 +59,7 @@
} else {
PW_LOG_DEBUG("BlobStore init - not erased");
}
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::LoadMetadata() {
@@ -75,7 +75,7 @@
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
size_t BlobStore::MaxDataSizeBytes() const { return partition_.size_bytes(); }
@@ -97,7 +97,7 @@
Invalidate();
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::OpenRead() {
@@ -118,7 +118,7 @@
PW_LOG_DEBUG("Blob reader open");
readers_open_++;
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::CloseWrite() {
@@ -130,7 +130,7 @@
}
if (write_address_ == 0) {
- return Status::Ok();
+ return OkStatus();
}
PW_LOG_DEBUG(
@@ -169,7 +169,7 @@
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
};
const Status status = do_close_write();
@@ -179,14 +179,14 @@
valid_data_ = false;
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::CloseRead() {
PW_CHECK_UINT_GT(readers_open_, 0);
readers_open_--;
PW_LOG_DEBUG("Blob reader close");
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::Write(ConstByteSpan data) {
@@ -194,7 +194,7 @@
return Status::DataLoss();
}
if (data.size_bytes() == 0) {
- return Status::Ok();
+ return OkStatus();
}
if (WriteBytesRemaining() == 0) {
return Status::OutOfRange();
@@ -238,7 +238,7 @@
// 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 OkStatus();
}
// The write buffer is full, flush to flash.
@@ -275,7 +275,7 @@
write_address_ += data.size_bytes();
}
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::AddToWriteBuffer(ConstByteSpan data) {
@@ -295,7 +295,7 @@
write_buffer_.data() + bytes_in_buffer, data.data(), data.size_bytes());
write_address_ += data.size_bytes();
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::Flush() {
@@ -303,7 +303,7 @@
return Status::DataLoss();
}
if (WriteBufferBytesUsed() == 0) {
- return Status::Ok();
+ return OkStatus();
}
// Don't need to check available space, AddToWriteBuffer() will not enqueue
// more than can be written to flash.
@@ -333,7 +333,7 @@
PW_DCHECK_UINT_EQ(data.size_bytes(), 0);
}
- return Status::Ok();
+ return OkStatus();
}
Status BlobStore::FlushFinalPartialChunk() {
@@ -394,7 +394,7 @@
// Always just erase. Erase is smart enough to only erase if needed.
return Erase();
}
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize BlobStore::Read(size_t offset, ByteSpan dest) const {
@@ -439,7 +439,7 @@
// Erased blobs should be valid as soon as the flash is erased. Even though
// there are 0 bytes written, they are valid.
PW_DCHECK(valid_data_);
- return Status::Ok();
+ return OkStatus();
}
Invalidate();
@@ -468,8 +468,8 @@
Status status = kvs_.Delete(MetadataKey());
- return (status == Status::Ok() || status == Status::NotFound())
- ? Status::Ok()
+ return (status == OkStatus() || status == Status::NotFound())
+ ? OkStatus()
: Status::Internal();
}
@@ -486,7 +486,7 @@
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
PW_LOG_DEBUG("Validate checksum of 0x%08x in flash for blob of %u bytes",
@@ -503,7 +503,7 @@
Status BlobStore::CalculateChecksumFromFlash(size_t bytes_to_check) {
if (checksum_algo_ == nullptr) {
- return Status::Ok();
+ return OkStatus();
}
checksum_algo_->Reset();
@@ -524,7 +524,7 @@
// Safe to ignore the return from Finish, checksum_algo_ keeps the state
// information that it needs.
checksum_algo_->Finish();
- return Status::Ok();
+ return OkStatus();
}
} // 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 49e0016..3dabaa8 100644
--- a/pw_blob_store/blob_store_chunk_write_test.cc
+++ b/pw_blob_store/blob_store_chunk_write_test.cc
@@ -60,11 +60,11 @@
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::Ok(), writer.Open());
- EXPECT_EQ(Status::Ok(), writer.Erase());
+ EXPECT_EQ(OkStatus(), writer.Open());
+ EXPECT_EQ(OkStatus(), writer.Erase());
ByteSpan source = source_buffer_;
while (source.size_bytes() > 0) {
@@ -74,20 +74,20 @@
static_cast<unsigned>(write_size),
static_cast<unsigned>(source.size_bytes()));
- ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
+ ASSERT_EQ(OkStatus(), writer.Write(source.first(write_size)));
source = source.subspan(write_size);
}
- EXPECT_EQ(Status::Ok(), writer.Close());
+ EXPECT_EQ(OkStatus(), writer.Close());
// Use reader to check for valid data.
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::Ok(), reader.Open());
+ ASSERT_EQ(OkStatus(), reader.Open());
Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
ASSERT_TRUE(result.ok());
VerifyFlash(result.value());
- EXPECT_EQ(Status::Ok(), reader.Close());
+ EXPECT_EQ(OkStatus(), 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 bd15ae3..02491e6 100644
--- a/pw_blob_store/blob_store_deferred_write_test.cc
+++ b/pw_blob_store/blob_store_deferred_write_test.cc
@@ -62,10 +62,10 @@
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kWriteSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::DeferredWriter writer(blob);
- EXPECT_EQ(Status::Ok(), writer.Open());
+ EXPECT_EQ(OkStatus(), writer.Open());
ByteSpan source = buffer_;
while (source.size_bytes() > 0) {
@@ -75,7 +75,7 @@
static_cast<unsigned>(write_size),
static_cast<unsigned>(source.size_bytes()));
- ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
+ ASSERT_EQ(OkStatus(), writer.Write(source.first(write_size)));
// TODO: Add check that the write did not go to flash yet.
source = source.subspan(write_size);
@@ -83,19 +83,19 @@
if (bytes_since_flush >= flush_interval) {
bytes_since_flush = 0;
- ASSERT_EQ(Status::Ok(), writer.Flush());
+ ASSERT_EQ(OkStatus(), writer.Flush());
}
}
- EXPECT_EQ(Status::Ok(), writer.Close());
+ EXPECT_EQ(OkStatus(), writer.Close());
// Use reader to check for valid data.
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::Ok(), reader.Open());
+ ASSERT_EQ(OkStatus(), reader.Open());
Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
ASSERT_TRUE(result.ok());
VerifyFlash(result.value());
- EXPECT_EQ(Status::Ok(), reader.Close());
+ EXPECT_EQ(OkStatus(), 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 d2ea203..dcb4bff 100644
--- a/pw_blob_store/blob_store_test.cc
+++ b/pw_blob_store/blob_store_test.cc
@@ -74,22 +74,22 @@
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::OK, writer.Open());
- ASSERT_EQ(Status::OK, writer.Write(write_data));
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(OkStatus(), writer.Open());
+ ASSERT_EQ(OkStatus(), writer.Write(write_data));
+ EXPECT_EQ(OkStatus(), writer.Close());
// Use reader to check for valid data.
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::Ok(), reader.Open());
+ ASSERT_EQ(OkStatus(), reader.Open());
Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
ASSERT_TRUE(result.ok());
EXPECT_EQ(write_size_bytes, result.value().size_bytes());
VerifyFlash(result.value().first(write_size_bytes));
VerifyFlash(flash_.buffer().first(write_size_bytes));
- EXPECT_EQ(Status::OK, reader.Close());
+ EXPECT_EQ(OkStatus(), reader.Close());
}
// Open a new blob instance and read the blob using the given read chunk size.
@@ -102,18 +102,18 @@
constexpr size_t kBufferSize = 16;
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
// Use reader to check for valid data.
BlobStore::BlobReader reader1(blob);
- ASSERT_EQ(Status::Ok(), reader1.Open());
+ ASSERT_EQ(OkStatus(), reader1.Open());
Result<ConstByteSpan> possible_blob = reader1.GetMemoryMappedBlob();
ASSERT_TRUE(possible_blob.ok());
VerifyFlash(possible_blob.value());
- EXPECT_EQ(Status::Ok(), reader1.Close());
+ EXPECT_EQ(OkStatus(), reader1.Close());
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::Ok(), reader.Open());
+ ASSERT_EQ(OkStatus(), reader.Open());
std::array<std::byte, kBlobDataSize> read_buffer;
@@ -127,10 +127,10 @@
ASSERT_EQ(read_span.size_bytes(), reader.ConservativeReadLimit());
auto result = reader.Read(read_span.first(read_size));
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
read_span = read_span.subspan(read_size);
}
- EXPECT_EQ(Status::Ok(), reader.Close());
+ EXPECT_EQ(OkStatus(), reader.Close());
VerifyFlash(read_buffer);
}
@@ -163,38 +163,38 @@
constexpr size_t kBufferSize = 256;
BlobStoreBuffer<kBufferSize> blob(
"Blob_OK", partition_, nullptr, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
}
TEST_F(BlobStoreTest, IsOpen) {
constexpr size_t kBufferSize = 256;
BlobStoreBuffer<kBufferSize> blob(
"Blob_open", partition_, nullptr, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::DeferredWriter deferred_writer(blob);
EXPECT_EQ(false, deferred_writer.IsOpen());
- EXPECT_EQ(Status::OK, deferred_writer.Open());
+ EXPECT_EQ(OkStatus(), deferred_writer.Open());
EXPECT_EQ(true, deferred_writer.IsOpen());
- EXPECT_EQ(Status::OK, deferred_writer.Close());
+ EXPECT_EQ(OkStatus(), deferred_writer.Close());
EXPECT_EQ(false, deferred_writer.IsOpen());
BlobStore::BlobWriter writer(blob);
EXPECT_EQ(false, writer.IsOpen());
- EXPECT_EQ(Status::OK, writer.Open());
+ EXPECT_EQ(OkStatus(), writer.Open());
EXPECT_EQ(true, writer.IsOpen());
// Need to write something, so the blob reader is able to open.
std::array<std::byte, 64> tmp_buffer = {};
- EXPECT_EQ(Status::OK, writer.Write(tmp_buffer));
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(OkStatus(), writer.Write(tmp_buffer));
+ EXPECT_EQ(OkStatus(), writer.Close());
EXPECT_EQ(false, writer.IsOpen());
BlobStore::BlobReader reader(blob);
EXPECT_EQ(false, reader.IsOpen());
- ASSERT_EQ(Status::Ok(), reader.Open());
+ ASSERT_EQ(OkStatus(), reader.Open());
EXPECT_EQ(true, reader.IsOpen());
- EXPECT_EQ(Status::Ok(), reader.Close());
+ EXPECT_EQ(OkStatus(), reader.Close());
EXPECT_EQ(false, reader.IsOpen());
}
@@ -212,23 +212,23 @@
constexpr size_t kBufferSize = 256;
BlobStoreBuffer<kBufferSize> blob(
blob_title, partition_, &checksum, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::OK, blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::OK, writer.Open());
- EXPECT_EQ(Status::OK, writer.Write(tmp_buffer));
+ EXPECT_EQ(OkStatus(), writer.Open());
+ EXPECT_EQ(OkStatus(), writer.Write(tmp_buffer));
// The write does an implicit erase so there should be no key for this blob.
EXPECT_EQ(Status::NOT_FOUND,
kvs::TestKvs().Get(blob_title, tmp_buffer).status());
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(OkStatus(), writer.Close());
- EXPECT_EQ(Status::OK, kvs::TestKvs().Get(blob_title, tmp_buffer).status());
+ EXPECT_EQ(OkStatus(), kvs::TestKvs().Get(blob_title, tmp_buffer).status());
- EXPECT_EQ(Status::OK, writer.Open());
- EXPECT_EQ(Status::OK, writer.Discard());
- EXPECT_EQ(Status::OK, writer.Close());
+ EXPECT_EQ(OkStatus(), writer.Open());
+ EXPECT_EQ(OkStatus(), writer.Discard());
+ EXPECT_EQ(OkStatus(), writer.Close());
EXPECT_EQ(Status::NOT_FOUND,
kvs::TestKvs().Get(blob_title, tmp_buffer).status());
@@ -238,14 +238,14 @@
constexpr size_t kBufferSize = 256;
BlobStoreBuffer<kBufferSize> blob(
"Blob_OK", partition_, nullptr, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::BlobWriter writer(blob);
- EXPECT_EQ(Status::Ok(), writer.Open());
+ EXPECT_EQ(OkStatus(), writer.Open());
- EXPECT_EQ(Status::Ok(), writer.Erase());
- EXPECT_EQ(Status::Ok(), writer.Erase());
- EXPECT_EQ(Status::Ok(), writer.Erase());
+ EXPECT_EQ(OkStatus(), writer.Erase());
+ EXPECT_EQ(OkStatus(), writer.Erase());
+ EXPECT_EQ(OkStatus(), writer.Erase());
}
TEST_F(BlobStoreTest, OffsetRead) {
@@ -261,17 +261,17 @@
constexpr size_t kBufferSize = 16;
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::Ok(), reader.Open(kOffset));
+ ASSERT_EQ(OkStatus(), 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(), OkStatus());
+ EXPECT_EQ(OkStatus(), reader.Close());
VerifyFlash(read_buffer, kOffset);
}
@@ -287,7 +287,7 @@
constexpr size_t kBufferSize = 16;
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::BlobReader reader(blob);
ASSERT_EQ(Status::InvalidArgument(), reader.Open(kOffset));
}
@@ -305,17 +305,17 @@
constexpr size_t kBufferSize = 16;
BlobStoreBuffer<kBufferSize> blob(
name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
- EXPECT_EQ(Status::Ok(), blob.Init());
+ EXPECT_EQ(OkStatus(), blob.Init());
BlobStore::BlobReader reader(blob);
- ASSERT_EQ(Status::Ok(), reader.Open());
+ ASSERT_EQ(OkStatus(), reader.Open());
EXPECT_EQ(kWriteBytes, reader.ConservativeReadLimit());
std::array<std::byte, kWriteBytes + 10> read_buffer;
ByteSpan read_span = read_buffer;
auto result = reader.Read(read_span);
- ASSERT_EQ(result.status(), Status::Ok());
- EXPECT_EQ(Status::Ok(), reader.Close());
+ ASSERT_EQ(result.status(), OkStatus());
+ EXPECT_EQ(OkStatus(), reader.Close());
}
TEST_F(BlobStoreTest, ChunkRead1) {
diff --git a/pw_bytes/byte_builder.cc b/pw_bytes/byte_builder.cc
index ba01c0f..c3f2f7d 100644
--- a/pw_bytes/byte_builder.cc
+++ b/pw_bytes/byte_builder.cc
@@ -39,14 +39,14 @@
}
size_ += bytes_to_append;
- status_ = Status::Ok();
+ status_ = OkStatus();
return bytes_to_append;
}
void ByteBuilder::resize(size_t new_size) {
if (new_size <= size_) {
size_ = new_size;
- status_ = Status::Ok();
+ status_ = OkStatus();
} else {
status_ = Status::OutOfRange();
}
diff --git a/pw_bytes/byte_builder_test.cc b/pw_bytes/byte_builder_test.cc
index d1d1e7b..97e2bb6 100644
--- a/pw_bytes/byte_builder_test.cc
+++ b/pw_bytes/byte_builder_test.cc
@@ -197,7 +197,7 @@
TEST(ByteBuilder, Status_StartsOk) {
ByteBuffer<16> bb;
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
}
TEST(ByteBuilder, Status_StatusUpdate) {
@@ -222,13 +222,13 @@
EXPECT_EQ(Status::ResourceExhausted(), bb.status());
bb.clear_status();
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
}
TEST(ByteBuilder, PushBack) {
ByteBuffer<12> bb;
bb.push_back(byte{0x01});
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
EXPECT_EQ(1u, bb.size());
EXPECT_EQ(byte{0x01}, bb.data()[0]);
}
@@ -236,7 +236,7 @@
TEST(ByteBuilder, PushBack_Full) {
ByteBuffer<1> bb;
bb.push_back(byte{0x01});
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
EXPECT_EQ(1u, bb.size());
}
@@ -256,7 +256,7 @@
bb.append(buffer.data(), 3);
bb.pop_back();
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
EXPECT_EQ(2u, bb.size());
EXPECT_EQ(byte{0x01}, bb.data()[0]);
EXPECT_EQ(byte{0x02}, bb.data()[1]);
@@ -270,7 +270,7 @@
bb.pop_back();
bb.pop_back();
bb.pop_back();
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
EXPECT_EQ(0u, bb.size());
EXPECT_TRUE(bb.empty());
}
@@ -338,7 +338,7 @@
EXPECT_EQ(byte{0x01}, two.data()[0]);
EXPECT_EQ(byte{0x02}, two.data()[1]);
- EXPECT_EQ(Status::Ok(), two.status());
+ EXPECT_EQ(OkStatus(), two.status());
}
TEST(ByteBuilder, ResizeError_NoDataAddedAfter) {
@@ -372,7 +372,7 @@
EXPECT_EQ(byte{0xFE}, bb.data()[0]);
EXPECT_EQ(byte{0x02}, bb.data()[1]);
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
}
TEST(ByteBuffer, Putting8ByteInts_Exhausted) {
@@ -396,7 +396,7 @@
EXPECT_EQ(byte{0x08}, bb.data()[2]);
EXPECT_EQ(byte{0x00}, bb.data()[3]);
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
}
TEST(ByteBuffer, Putting16ByteInts_Exhausted_kBigEndian) {
@@ -428,7 +428,7 @@
EXPECT_EQ(byte{0x00}, bb.data()[6]);
EXPECT_EQ(byte{0x00}, bb.data()[7]);
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
}
TEST(ByteBuffer, Putting32ByteInts_Exhausted_kBigEndian) {
@@ -472,7 +472,7 @@
EXPECT_EQ(byte{0xFF}, bb.data()[14]);
EXPECT_EQ(byte{0xFF}, bb.data()[15]);
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), bb.status());
}
TEST(ByteBuffer, Putting64ByteInts_Exhausted_kBigEndian) {
@@ -527,7 +527,7 @@
EXPECT_EQ(byte{0x17}, bb.data()[14]);
EXPECT_EQ(byte{0xFB}, bb.data()[15]);
- EXPECT_EQ(Status::Ok(), bb.status());
+ EXPECT_EQ(OkStatus(), 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 f046cb0..a145353 100644
--- a/pw_bytes/public/pw_bytes/byte_builder.h
+++ b/pw_bytes/public/pw_bytes/byte_builder.h
@@ -228,7 +228,7 @@
return StatusWithSize(status_, size_);
}
- // True if status() is Status::Ok().
+ // True if status() is OkStatus().
bool ok() const { return status_.ok(); }
// True if the bytes builder is empty.
@@ -243,11 +243,11 @@
// Clears the bytes and resets its error state.
void clear() {
size_ = 0;
- status_ = Status::Ok();
+ status_ = OkStatus();
};
- // Sets the statuses to Status::Ok();
- void clear_status() { status_ = Status::Ok(); }
+ // Sets the statuses to OkStatus();
+ void clear_status() { status_ = OkStatus(); }
// 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 086652d..ea6774e 100644
--- a/pw_cpu_exception_armv7m/proto_dump.cc
+++ b/pw_cpu_exception_armv7m/proto_dump.cc
@@ -58,7 +58,7 @@
return status == Status::ResourceExhausted() ? Status::ResourceExhausted()
: Status::Unknown();
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::cpu_exception
diff --git a/pw_hdlc_lite/decoder.cc b/pw_hdlc_lite/decoder.cc
index fc96824..76d7ca0 100644
--- a/pw_hdlc_lite/decoder.cc
+++ b/pw_hdlc_lite/decoder.cc
@@ -125,7 +125,7 @@
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
bool Decoder::VerifyFrameCheckSequence() const {
diff --git a/pw_hdlc_lite/decoder_test.cc b/pw_hdlc_lite/decoder_test.cc
index b8400e2..a74b34c 100644
--- a/pw_hdlc_lite/decoder_test.cc
+++ b/pw_hdlc_lite/decoder_test.cc
@@ -52,7 +52,7 @@
bytes::String("~1234\xa3\xe0\xe3\x9b~"),
[&status](const Result<Frame>& result) { status = result.status(); });
- EXPECT_EQ(Status::Ok(), status);
+ EXPECT_EQ(OkStatus(), status);
}
TEST(Decoder, ExactFit) {
@@ -62,7 +62,7 @@
EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
auto result = decoder.Process(kFlag);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), 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'});
@@ -76,7 +76,7 @@
}
auto result = decoder.Process(kFlag);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(result.value().data().size(), 0u);
}
@@ -121,7 +121,7 @@
for (byte b : bytes::String("1234\xa3\xe0\xe3\x9b")) {
EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
}
- EXPECT_EQ(Status::Ok(), decoder.Process(kFlag).status());
+ EXPECT_EQ(OkStatus(), decoder.Process(kFlag).status());
}
} // namespace
diff --git a/pw_hdlc_lite/encoder.cc b/pw_hdlc_lite/encoder.cc
index 01b73f6..0602481 100644
--- a/pw_hdlc_lite/encoder.cc
+++ b/pw_hdlc_lite/encoder.cc
@@ -99,7 +99,7 @@
}
if (end == data.end()) {
fcs_.Update(data);
- return Status::Ok();
+ return OkStatus();
}
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 7c03bb5..195f3e4 100644
--- a/pw_hdlc_lite/encoder_test.cc
+++ b/pw_hdlc_lite/encoder_test.cc
@@ -51,20 +51,19 @@
constexpr byte kUnnumberedControl = byte{0x3};
TEST_F(WriteUnnumberedFrame, EmptyPayload) {
- ASSERT_EQ(Status::Ok(), WriteUIFrame(kAddress, std::span<byte>(), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, std::span<byte>(), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(
kFlag, kAddress, kUnnumberedControl, uint32_t{0x141BE378}, kFlag));
}
TEST_F(WriteUnnumberedFrame, OneBytePayload) {
- ASSERT_EQ(Status::Ok(), WriteUIFrame(kAddress, bytes::String("A"), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("A"), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(
kFlag, kAddress, kUnnumberedControl, 'A', uint32_t{0x8D137C66}, kFlag));
}
TEST_F(WriteUnnumberedFrame, OneBytePayload_Escape0x7d) {
- ASSERT_EQ(Status::Ok(),
- WriteUIFrame(kAddress, bytes::Array<0x7d>(), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::Array<0x7d>(), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
kAddress,
kUnnumberedControl,
@@ -75,8 +74,7 @@
}
TEST_F(WriteUnnumberedFrame, OneBytePayload_Escape0x7E) {
- ASSERT_EQ(Status::Ok(),
- WriteUIFrame(kAddress, bytes::Array<0x7e>(), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::Array<0x7e>(), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
kAddress,
kUnnumberedControl,
@@ -87,7 +85,7 @@
}
TEST_F(WriteUnnumberedFrame, AddressNeedsEscaping) {
- ASSERT_EQ(Status::Ok(), WriteUIFrame(0x7d, bytes::String("A"), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(0x7d, bytes::String("A"), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
kEscape,
byte{0x5d},
@@ -98,7 +96,7 @@
}
TEST_F(WriteUnnumberedFrame, Crc32NeedsEscaping) {
- ASSERT_EQ(Status::Ok(), WriteUIFrame(kAddress, bytes::String("a"), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("a"), writer_));
// The CRC-32 is 0xB67D5CAE, so the 0x7D must be escaped.
constexpr auto expected_crc32 = bytes::Array<0xae, 0x5c, 0x7d, 0x5d, 0xb6>();
@@ -111,10 +109,8 @@
}
TEST_F(WriteUnnumberedFrame, MultiplePayloads) {
- ASSERT_EQ(Status::Ok(),
- WriteUIFrame(kAddress, bytes::String("ABC"), writer_));
- ASSERT_EQ(Status::Ok(),
- WriteUIFrame(kAddress, bytes::String("DEF"), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("ABC"), writer_));
+ ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("DEF"), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
kAddress,
kUnnumberedControl,
@@ -131,7 +127,7 @@
TEST_F(WriteUnnumberedFrame, PayloadWithNoEscapes) {
ASSERT_EQ(
- Status::Ok(),
+ OkStatus(),
WriteUIFrame(kAddress, bytes::String("1995 toyota corolla"), writer_));
EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
@@ -144,7 +140,7 @@
TEST_F(WriteUnnumberedFrame, PayloadWithMultipleEscapes) {
ASSERT_EQ(
- Status::Ok(),
+ OkStatus(),
WriteUIFrame(kAddress,
bytes::Array<0x7E, 0x7B, 0x61, 0x62, 0x63, 0x7D, 0x7E>(),
writer_));
diff --git a/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h b/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h
index 049b1f7..a0ae997 100644
--- a/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h
+++ b/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h
@@ -47,7 +47,7 @@
Status SendAndReleaseBuffer(std::span<const std::byte> buffer) override {
PW_DASSERT(buffer.data() == buffer_.data());
if (buffer.empty()) {
- return Status::Ok();
+ return OkStatus();
}
return hdlc_lite::WriteUIFrame(address_, buffer, writer_);
}
@@ -75,7 +75,7 @@
Status SendAndReleaseBuffer(std::span<const std::byte> buffer) override {
PW_DASSERT(buffer.data() == buffer_.data());
if (buffer.empty()) {
- return Status::Ok();
+ return OkStatus();
}
return hdlc_lite::WriteUIFrame(address_, buffer, writer_);
}
diff --git a/pw_hdlc_lite/py/decode_test.py b/pw_hdlc_lite/py/decode_test.py
index ae90d69..9881bec 100755
--- a/pw_hdlc_lite/py/decode_test.py
+++ b/pw_hdlc_lite/py/decode_test.py
@@ -225,7 +225,7 @@
if (std::holds_alternative<Status>(expected)) {{
EXPECT_EQ(Status::DATA_LOSS, result.status());
}} else {{
- ASSERT_EQ(Status::OK, result.status());
+ ASSERT_EQ(OkStatus(), result.status());
const Frame& decoded_frame = result.value();
const Frame& expected_frame = std::get<Frame>(expected);
diff --git a/pw_hdlc_lite/rpc_channel_test.cc b/pw_hdlc_lite/rpc_channel_test.cc
index a7d4af3..4f40ba2 100644
--- a/pw_hdlc_lite/rpc_channel_test.cc
+++ b/pw_hdlc_lite/rpc_channel_test.cc
@@ -62,7 +62,7 @@
constexpr auto expected = bytes::Concat(
kFlag, kAddress, kControl, 'A', uint32_t{0x8D137C66}, kFlag);
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
output.SendAndReleaseBuffer(buffer.first(sizeof(test_data))));
ASSERT_EQ(memory_writer.bytes_written(), expected.size());
@@ -90,7 +90,7 @@
byte{0x7d} ^ byte{0x20},
uint32_t{0xA27C00E1},
kFlag);
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
output.SendAndReleaseBuffer(buffer.first(test_data.size())));
ASSERT_EQ(memory_writer.bytes_written(), 10u);
@@ -113,7 +113,7 @@
constexpr auto expected = bytes::Concat(
kFlag, kAddress, kControl, 'A', uint32_t{0x8D137C66}, kFlag);
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
output.SendAndReleaseBuffer(buffer.first(sizeof(test_data))));
ASSERT_EQ(memory_writer.bytes_written(), expected.size());
diff --git a/pw_hex_dump/hex_dump.cc b/pw_hex_dump/hex_dump.cc
index ae979df..67f0f3c 100644
--- a/pw_hex_dump/hex_dump.cc
+++ b/pw_hex_dump/hex_dump.cc
@@ -215,7 +215,7 @@
return Status::InvalidArgument();
}
dest_ = dest;
- return ValidateBufferSize().ok() ? Status::Ok() : Status::ResourceExhausted();
+ return ValidateBufferSize().ok() ? OkStatus() : Status::ResourceExhausted();
}
Status FormattedHexDumper::BeginDump(ConstByteSpan data) {
@@ -227,8 +227,7 @@
if (dest_.data() != nullptr && dest_.size_bytes() > 0) {
dest_[0] = 0;
}
- return ValidateBufferSize().ok() ? Status::Ok()
- : Status::FailedPrecondition();
+ return ValidateBufferSize().ok() ? OkStatus() : Status::FailedPrecondition();
}
Status FormattedHexDumper::ValidateBufferSize() {
@@ -254,7 +253,7 @@
return Status::ResourceExhausted();
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::dump
diff --git a/pw_hex_dump/hex_dump_test.cc b/pw_hex_dump/hex_dump_test.cc
index 1b10251..f374431 100644
--- a/pw_hex_dump/hex_dump_test.cc
+++ b/pw_hex_dump/hex_dump_test.cc
@@ -100,7 +100,7 @@
TEST_F(HexDump, DumpAddr_ZeroSizeT) {
constexpr const char* expected = EXPECTED_SIGNIFICANT_BYTES("00000000");
size_t zero = 0;
- EXPECT_EQ(DumpAddr(dest_, zero), Status::Ok());
+ EXPECT_EQ(DumpAddr(dest_, zero), OkStatus());
EXPECT_STREQ(expected, dest_.data());
}
diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
index 536de87..fca1a7f 100644
--- a/pw_kvs/alignment_test.cc
+++ b/pw_kvs/alignment_test.cc
@@ -141,26 +141,26 @@
AlignedWriterBuffer<32> writer(kAlignment, check_against_data);
// Write values smaller than the alignment.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(0, 1)).status());
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(1, 9)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(0, 1)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(1, 9)).status());
// Write values larger than the alignment but smaller than the buffer.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(10, 11)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(10, 11)).status());
// Exactly fill the remainder of the buffer.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(21, 11)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(21, 11)).status());
// Fill the buffer more than once.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(32, 66)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(32, 66)).status());
// Write nothing.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 0)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(98, 0)).status());
// Write the remaining data.
- EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 2)).status());
+ EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(98, 2)).status());
auto result = writer.Flush();
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(kData.size(), result.size());
}
@@ -222,7 +222,7 @@
TEST(AlignedWriter, Write_ReturnsTotalBytesWritten) {
static Status return_status;
- return_status = Status::Ok();
+ return_status = OkStatus();
OutputToFunction output([](std::span<const byte> data) {
return StatusWithSize(return_status, data.size());
@@ -232,11 +232,11 @@
StatusWithSize result =
writer.Write(std::as_bytes(std::span("12345678901"sv)));
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(0u, result.size()); // No writes; haven't filled buffer.
result = writer.Write(std::as_bytes(std::span("2345678901"sv)));
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(20u, result.size());
return_status = Status::PermissionDenied();
@@ -252,11 +252,11 @@
AlignedWriterBuffer<4> writer(2, output);
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
writer.Write(std::as_bytes(std::span("12345678901"sv))).status());
StatusWithSize result = writer.Flush();
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(12u, result.size());
}
@@ -306,11 +306,11 @@
InputWithErrorInjection input;
StatusWithSize result = writer.Write(input, kData.size());
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_LE(result.size(), kData.size()); // May not have written it all yet.
result = writer.Flush();
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(kData.size(), result.size());
}
diff --git a/pw_kvs/checksum.cc b/pw_kvs/checksum.cc
index 08f59b8..4215406 100644
--- a/pw_kvs/checksum.cc
+++ b/pw_kvs/checksum.cc
@@ -27,7 +27,7 @@
if (std::memcmp(state_.data(), checksum.data(), size_bytes()) != 0) {
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::kvs
diff --git a/pw_kvs/checksum_test.cc b/pw_kvs/checksum_test.cc
index 4fffae0..17e8f01 100644
--- a/pw_kvs/checksum_test.cc
+++ b/pw_kvs/checksum_test.cc
@@ -32,8 +32,7 @@
ChecksumAlgorithm& algo = crc16_algo;
algo.Update(kString.data(), kString.size());
- EXPECT_EQ(Status::Ok(),
- algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
+ EXPECT_EQ(OkStatus(), algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
}
TEST(Checksum, Verify_Failure) {
@@ -56,7 +55,7 @@
algo.Update(std::as_bytes(std::span(kString)));
- EXPECT_EQ(Status::Ok(), algo.Verify(crc));
+ EXPECT_EQ(OkStatus(), algo.Verify(crc));
}
TEST(Checksum, Reset) {
@@ -72,20 +71,20 @@
TEST(IgnoreChecksum, NeverUpdate_VerifyWithoutData) {
IgnoreChecksum checksum;
- EXPECT_EQ(Status::Ok(), checksum.Verify({}));
+ EXPECT_EQ(OkStatus(), checksum.Verify({}));
}
TEST(IgnoreChecksum, NeverUpdate_VerifyWithData) {
IgnoreChecksum checksum;
- EXPECT_EQ(Status::Ok(), checksum.Verify(std::as_bytes(std::span(kString))));
+ EXPECT_EQ(OkStatus(), checksum.Verify(std::as_bytes(std::span(kString))));
}
TEST(IgnoreChecksum, AfterUpdate_Verify) {
IgnoreChecksum checksum;
checksum.Update(std::as_bytes(std::span(kString)));
- EXPECT_EQ(Status::Ok(), checksum.Verify({}));
+ EXPECT_EQ(OkStatus(), checksum.Verify({}));
}
constexpr size_t kAlignment = 10;
@@ -144,7 +143,7 @@
EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(state.data()),
state.size()),
kData);
- EXPECT_EQ(Status::Ok(), checksum.Verify(kBytes));
+ EXPECT_EQ(OkStatus(), checksum.Verify(kBytes));
}
} // namespace
diff --git a/pw_kvs/entry.cc b/pw_kvs/entry.cc
index 18fa216..fc01b0c 100644
--- a/pw_kvs/entry.cc
+++ b/pw_kvs/entry.cc
@@ -58,7 +58,7 @@
}
*entry = Entry(&partition, address, *format, header);
- return Status::Ok();
+ return OkStatus();
}
Status Entry::ReadKey(FlashPartition& partition,
@@ -183,12 +183,12 @@
value_ptr += read_size;
}
- return Status::Ok();
+ return OkStatus();
}
Status Entry::VerifyChecksum(Key key, std::span<const byte> value) const {
if (checksum_algo_ == nullptr) {
- return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
+ return header_.checksum == 0 ? OkStatus() : Status::DataLoss();
}
CalculateChecksum(key, value);
return checksum_algo_->Verify(checksum_bytes());
@@ -218,7 +218,7 @@
}
if (checksum_algo_ == nullptr) {
- return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
+ return header_.checksum == 0 ? OkStatus() : Status::DataLoss();
}
// The checksum is calculated as if the header's checksum field were 0.
@@ -279,7 +279,7 @@
header_.checksum = 0;
if (checksum_algo_ == nullptr) {
- return Status::Ok();
+ return OkStatus();
}
checksum_algo_->Reset();
@@ -305,7 +305,7 @@
std::memcpy(&header_.checksum,
checksum.data(),
std::min(checksum.size(), sizeof(header_.checksum)));
- return Status::Ok();
+ return OkStatus();
}
void Entry::AddPaddingBytesToChecksum() const {
diff --git a/pw_kvs/entry_cache.cc b/pw_kvs/entry_cache.cc
index c63e349..e71d42e 100644
--- a/pw_kvs/entry_cache.cc
+++ b/pw_kvs/entry_cache.cc
@@ -107,7 +107,7 @@
} else if (key == read_key) {
PW_LOG_DEBUG("Found match for key hash 0x%08" PRIx32, hash);
*metadata = EntryMetadata(descriptors_[i], addresses(i));
- return StatusWithSize::Ok(error_val);
+ return StatusWithSize(error_val);
} else {
PW_LOG_WARN("Found key hash collision for 0x%08" PRIx32, hash);
return StatusWithSize::AlreadyExists(error_val);
@@ -142,14 +142,14 @@
return Status::ResourceExhausted();
}
AddNew(descriptor, address);
- return Status::Ok();
+ return OkStatus();
}
// Existing entry is old; replace the existing entry with the new one.
if (descriptor.transaction_id > descriptors_[index].transaction_id) {
descriptors_[index] = descriptor;
ResetAddresses(index, address);
- return Status::Ok();
+ return OkStatus();
}
// If the entries have a duplicate transaction ID, add the new (redundant)
@@ -177,7 +177,7 @@
} else {
PW_LOG_DEBUG("Found stale entry when appending; ignoring");
}
- return Status::Ok();
+ return OkStatus();
}
size_t EntryCache::present_entries() const {
diff --git a/pw_kvs/entry_cache_test.cc b/pw_kvs/entry_cache_test.cc
index 7d6a25f..6b7c9fa 100644
--- a/pw_kvs/entry_cache_test.cc
+++ b/pw_kvs/entry_cache_test.cc
@@ -83,7 +83,7 @@
}
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -98,7 +98,7 @@
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry_Full) {
for (uint32_t i = 0; i < kMaxEntries; ++i) {
ASSERT_EQ( // Fill up the cache
- Status::Ok(),
+ OkStatus(),
entries_.AddNewOrUpdateExisting({i, i, EntryState::kValid}, i, 1));
}
ASSERT_EQ(kMaxEntries, entries_.total_entries());
@@ -113,7 +113,7 @@
KeyDescriptor kd = kDescriptor;
kd.transaction_id += 3;
- ASSERT_EQ(Status::Ok(), entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
+ ASSERT_EQ(OkStatus(), entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -125,15 +125,15 @@
}
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntry) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 3000, 2000));
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 7000, 2000));
// Duplicates beyond the redundancy are ignored.
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 9000, 2000));
EXPECT_EQ(1u, entries_.present_entries());
@@ -150,7 +150,7 @@
}
TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntryInSameSector) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 1000));
EXPECT_EQ(Status::DataLoss(),
entries_.AddNewOrUpdateExisting(kDescriptor, 1950, 1000));
@@ -320,7 +320,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(Hash(kTheKey), metadata.hash());
EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -337,7 +337,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(1u, result.size());
EXPECT_EQ(Hash(kTheKey), metadata.hash());
EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -364,7 +364,7 @@
StatusWithSize result =
entries_.Find(partition_, sectors_, format_, "delorted", &metadata);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(Hash("delorted"), metadata.hash());
EXPECT_EQ(EntryState::kDeleted, metadata.state());
diff --git a/pw_kvs/entry_test.cc b/pw_kvs/entry_test.cc
index 8ac1d1a..f9496e3 100644
--- a/pw_kvs/entry_test.cc
+++ b/pw_kvs/entry_test.cc
@@ -116,7 +116,7 @@
class ValidEntryInFlash : public ::testing::Test {
protected:
ValidEntryInFlash() : flash_(kEntry1), partition_(&flash_) {
- EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
+ EXPECT_EQ(OkStatus(), Entry::Read(partition_, 0, kFormats, &entry_));
}
FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -125,8 +125,8 @@
};
TEST_F(ValidEntryInFlash, PassesChecksumVerification) {
- EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
- EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("key45", kValue1));
+ EXPECT_EQ(OkStatus(), entry_.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), entry_.VerifyChecksum("key45", kValue1));
}
TEST_F(ValidEntryInFlash, HeaderContents) {
@@ -141,7 +141,7 @@
Entry::KeyBuffer key = {};
auto result = entry_.ReadKey(key);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(result.size(), entry_.key_length());
EXPECT_STREQ(key.data(), "key45");
}
@@ -150,7 +150,7 @@
char value[32] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(result.size(), entry_.value_size());
EXPECT_STREQ(value, "VALUE!");
}
@@ -170,7 +170,7 @@
char value[3] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 3);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(3u, result.size());
EXPECT_EQ(value[0], 'U');
EXPECT_EQ(value[1], 'E');
@@ -190,7 +190,7 @@
char value[16] = {'?'};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 6);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(0u, result.size());
EXPECT_EQ(value[0], '?');
}
@@ -211,7 +211,7 @@
partition, 64, kFormatWithChecksum, "key45", kValue1, kTransactionId1);
auto result = entry.Write("key45", kValue1);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(32u, result.size());
EXPECT_EQ(std::memcmp(&flash.buffer()[64], kEntry1.data(), kEntry1.size()),
0);
@@ -233,7 +233,7 @@
protected:
TombstoneEntryInFlash()
: flash_(bytes::Concat(kHeader2, kKeyAndPadding2)), partition_(&flash_) {
- EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
+ EXPECT_EQ(OkStatus(), Entry::Read(partition_, 0, kFormats, &entry_));
}
FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -242,8 +242,8 @@
};
TEST_F(TombstoneEntryInFlash, PassesChecksumVerification) {
- EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
- EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("K", {}));
+ EXPECT_EQ(OkStatus(), entry_.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), entry_.VerifyChecksum("K", {}));
}
TEST_F(TombstoneEntryInFlash, HeaderContents) {
@@ -258,7 +258,7 @@
Entry::KeyBuffer key = {};
auto result = entry_.ReadKey(key);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(result.size(), entry_.key_length());
EXPECT_STREQ(key.data(), "K");
}
@@ -267,7 +267,7 @@
char value[32] = {};
auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(0u, result.size());
}
@@ -280,7 +280,7 @@
Entry::Tombstone(partition, 16, kFormatWithChecksum, "K", 0x03020100);
auto result = entry.Write("K", {});
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(32u, result.size());
EXPECT_EQ(std::memcmp(&flash.buffer()[16],
bytes::Concat(kHeader2, kKeyAndPadding2).data(),
@@ -296,15 +296,15 @@
const EntryFormat format{kMagicWithChecksum, nullptr};
const internal::EntryFormats formats(format);
- ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
+ ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, formats, &entry));
EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksum({}, {}));
std::memset(&flash.buffer()[4], 0, 4); // set the checksum field to 0
- ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
- EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
- EXPECT_EQ(Status::Ok(), entry.VerifyChecksum({}, {}));
+ ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, formats, &entry));
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksum({}, {}));
}
TEST(Entry, Checksum_ChecksPadding) {
@@ -312,20 +312,20 @@
bytes::Concat(kHeader1, kKey1, kValue1, bytes::String("\0\0\0\0\1")));
FlashPartition partition(&flash);
Entry entry;
- ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
+ ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
// Last byte in padding is a 1; should fail.
EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
// The in-memory verification fills in 0s for the padding.
- EXPECT_EQ(Status::Ok(), entry.VerifyChecksum("key45", kValue1));
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksum("key45", kValue1));
flash.buffer()[kEntry1.size() - 1] = byte{0};
- EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
}
TEST_F(ValidEntryInFlash, Update_SameFormat_TransactionIdIsUpdated) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
entry_.Update(kFormatWithChecksum, kTransactionId1 + 3));
EXPECT_EQ(kFormatWithChecksum.magic, entry_.magic());
@@ -336,7 +336,7 @@
TEST_F(ValidEntryInFlash,
Update_DifferentFormat_MagicAndTransactionIdAreUpdated) {
- ASSERT_EQ(Status::Ok(), entry_.Update(kFormat, kTransactionId1 + 6));
+ ASSERT_EQ(OkStatus(), entry_.Update(kFormat, kTransactionId1 + 6));
EXPECT_EQ(kFormat.magic, entry_.magic());
EXPECT_EQ(0u, entry_.address());
@@ -359,14 +359,13 @@
TEST_F(ValidEntryInFlash, Update_ReadError_NoChecksumIsOkay) {
flash_.InjectReadError(FlashError::Unconditional(Status::Aborted()));
- EXPECT_EQ(Status::Ok(),
- entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+ EXPECT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
}
TEST_F(ValidEntryInFlash, Copy) {
auto result = entry_.Copy(123);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(entry_.size(), result.size());
EXPECT_EQ(0,
std::memcmp(
@@ -436,10 +435,10 @@
TEST_F(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSmallerAlignment) {
// Uses 16-bit alignment, smaller than the original entry's alignment.
- ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry_.Copy(kEntry1.size());
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(kEntry1.size(), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<16>();
@@ -450,9 +449,9 @@
std::memcmp(
&flash_.buffer()[kEntry1.size()], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
Entry::Read(partition_, 32, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kFormatWithSum.magic, new_entry.magic());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -462,12 +461,12 @@
FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
FlashPartition partition(&flash, 0, 4, 32);
Entry entry;
- ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
+ ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
- ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry.Copy(32);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(AlignUp(kEntry1.size(), 32), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<32>();
@@ -477,9 +476,9 @@
std::memcmp(&flash.buffer()[32], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
Entry::Read(partition, 32, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -488,12 +487,12 @@
FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
FlashPartition partition(&flash, 0, 4, 64);
Entry entry;
- ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
+ ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
- ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
StatusWithSize result = entry.Copy(64);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(AlignUp(kEntry1.size(), 64), result.size());
constexpr auto new_data = MakeNewFormatWithSumEntry<64>();
@@ -503,9 +502,9 @@
std::memcmp(&flash.buffer()[64], new_data.data(), new_data.size()));
Entry new_entry;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
Entry::Read(partition, 64, kFormatsWithSum, &new_entry));
- EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
}
@@ -514,10 +513,10 @@
// readable 4 bytes. See pw_kvs/format.h for more information.
constexpr EntryFormat no_checksum{.magic = 0x43fae18f, .checksum = nullptr};
- ASSERT_EQ(Status::Ok(), entry_.Update(no_checksum, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry_.Update(no_checksum, kTransactionId1 + 1));
auto result = entry_.Copy(kEntry1.size());
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(kEntry1.size(), result.size());
constexpr auto kNewHeader1 =
@@ -537,23 +536,23 @@
}
TEST_F(ValidEntryInFlash, UpdateAndCopyMultple_DifferentFormat) {
- ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+ ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
FlashPartition::Address new_address = entry_.size();
for (int i = 0; i < 10; i++) {
StatusWithSize copy_result = entry_.Copy(new_address + (i * entry_.size()));
- ASSERT_EQ(Status::Ok(), copy_result.status());
+ ASSERT_EQ(OkStatus(), copy_result.status());
ASSERT_EQ(kEntry1.size(), copy_result.size());
}
for (int j = 0; j < 10; j++) {
Entry entry;
FlashPartition::Address read_address = (new_address + (j * entry_.size()));
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
Entry::Read(partition_, read_address, kFormatsWithSum, &entry));
- EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+ EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
EXPECT_EQ(kFormatWithSum.magic, entry.magic());
EXPECT_EQ(read_address, entry.address());
EXPECT_EQ(kTransactionId1 + 6, entry.transaction_id());
@@ -562,12 +561,12 @@
}
TEST_F(ValidEntryInFlash, DifferentFormat_UpdatedCopy_FailsWithWrongMagic) {
- ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+ ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
FlashPartition::Address new_address = entry_.size();
StatusWithSize copy_result = entry_.Copy(new_address);
- ASSERT_EQ(Status::Ok(), copy_result.status());
+ ASSERT_EQ(OkStatus(), copy_result.status());
ASSERT_EQ(kEntry1.size(), copy_result.size());
Entry entry;
@@ -578,8 +577,7 @@
TEST_F(ValidEntryInFlash, UpdateAndCopy_WriteError) {
flash_.InjectWriteError(FlashError::Unconditional(Status::Cancelled()));
- ASSERT_EQ(Status::Ok(),
- entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+ ASSERT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
auto result = entry_.Copy(kEntry1.size());
EXPECT_EQ(Status::Cancelled(), result.status());
diff --git a/pw_kvs/fake_flash_memory.cc b/pw_kvs/fake_flash_memory.cc
index 7796a72..4c30913 100644
--- a/pw_kvs/fake_flash_memory.cc
+++ b/pw_kvs/fake_flash_memory.cc
@@ -31,23 +31,23 @@
}
}
- return Status::Ok();
+ return OkStatus();
}
Status FlashError::Check(FlashMemory::Address start_address, size_t size) {
// Check if the event overlaps with this address range.
if (begin_ != kAnyAddress &&
(start_address >= end_ || (start_address + size) <= begin_)) {
- return Status::Ok();
+ return OkStatus();
}
if (delay_ > 0u) {
delay_ -= 1;
- return Status::Ok();
+ return OkStatus();
}
if (remaining_ == 0u) {
- return Status::Ok();
+ return OkStatus();
}
if (remaining_ != kAlways) {
@@ -76,7 +76,7 @@
std::memset(
&buffer_[address], int(kErasedValue), sector_size_bytes() * num_sectors);
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize FakeFlashMemory::Read(Address address,
diff --git a/pw_kvs/flash_memory.cc b/pw_kvs/flash_memory.cc
index 93e08d7..1bcacf6 100644
--- a/pw_kvs/flash_memory.cc
+++ b/pw_kvs/flash_memory.cc
@@ -125,7 +125,7 @@
for (byte b : std::span(buffer, read_size)) {
if (b != erased_byte) {
// Detected memory chunk is not entirely erased
- return Status::Ok();
+ return OkStatus();
}
}
@@ -133,7 +133,7 @@
length -= read_size;
}
*is_erased = true;
- return Status::Ok();
+ return OkStatus();
}
bool FlashPartition::AppearsErased(std::span<const byte> data) const {
@@ -154,7 +154,7 @@
unsigned(length));
return Status::OutOfRange();
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::kvs
diff --git a/pw_kvs/flash_partition_test.cc b/pw_kvs/flash_partition_test.cc
index b9a2299..193f3d2 100644
--- a/pw_kvs/flash_partition_test.cc
+++ b/pw_kvs/flash_partition_test.cc
@@ -37,7 +37,7 @@
const size_t alignment = partition.alignment_bytes();
- ASSERT_EQ(Status::Ok(), partition.Erase(0, partition.sector_count()));
+ ASSERT_EQ(OkStatus(), partition.Erase(0, partition.sector_count()));
const size_t chunks_per_sector = partition.sector_size_bytes() / alignment;
@@ -53,7 +53,7 @@
chunk_index++) {
StatusWithSize status =
partition.Write(address, as_bytes(std::span(test_data, alignment)));
- ASSERT_EQ(Status::Ok(), status.status());
+ ASSERT_EQ(OkStatus(), status.status());
ASSERT_EQ(alignment, status.size());
address += alignment;
}
@@ -71,7 +71,7 @@
memset(test_data, 0, sizeof(test_data));
StatusWithSize status = partition.Read(address, alignment, test_data);
- EXPECT_EQ(Status::Ok(), status.status());
+ EXPECT_EQ(OkStatus(), status.status());
EXPECT_EQ(alignment, status.size());
if (!status.ok() || (alignment != status.size())) {
error_count++;
@@ -140,8 +140,7 @@
std::min(sizeof(test_data), test_partition.sector_size_bytes());
auto data_span = std::span(test_data, block_size);
- ASSERT_EQ(Status::Ok(),
- test_partition.Erase(0, test_partition.sector_count()));
+ ASSERT_EQ(OkStatus(), test_partition.Erase(0, test_partition.sector_count()));
// Write to the first page of each sector.
for (size_t sector_index = 0; sector_index < test_partition.sector_count();
@@ -150,20 +149,20 @@
sector_index * test_partition.sector_size_bytes();
StatusWithSize status = test_partition.Write(address, as_bytes(data_span));
- ASSERT_EQ(Status::Ok(), status.status());
+ ASSERT_EQ(OkStatus(), status.status());
ASSERT_EQ(block_size, status.size());
}
// Preset the flag to make sure the check actually sets it.
bool is_erased = true;
- ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+ ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
ASSERT_EQ(false, is_erased);
- ASSERT_EQ(Status::Ok(), test_partition.Erase());
+ ASSERT_EQ(OkStatus(), test_partition.Erase());
// Preset the flag to make sure the check actually sets it.
is_erased = false;
- ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+ ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
ASSERT_EQ(true, is_erased);
// Read the first page of each sector and make sure it has been erased.
@@ -174,7 +173,7 @@
StatusWithSize status =
test_partition.Read(address, data_span.size_bytes(), data_span.data());
- EXPECT_EQ(Status::Ok(), status.status());
+ EXPECT_EQ(OkStatus(), status.status());
EXPECT_EQ(data_span.size_bytes(), status.size());
EXPECT_EQ(true, test_partition.AppearsErased(as_bytes(data_span)));
@@ -243,10 +242,10 @@
// Make sure the partition is big enough to do this test.
ASSERT_GE(test_partition.size_bytes(), 3 * kMaxFlashAlignment);
- ASSERT_EQ(Status::Ok(), test_partition.Erase());
+ ASSERT_EQ(OkStatus(), test_partition.Erase());
bool is_erased = true;
- ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+ ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
ASSERT_EQ(true, is_erased);
static const uint8_t fill_byte = 0x55;
@@ -256,26 +255,26 @@
// Write the chunk with fill byte.
StatusWithSize status = test_partition.Write(alignment, as_bytes(data_span));
- ASSERT_EQ(Status::Ok(), status.status());
+ ASSERT_EQ(OkStatus(), status.status());
ASSERT_EQ(data_span.size_bytes(), status.size());
- EXPECT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+ EXPECT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
EXPECT_EQ(false, is_erased);
// Check the chunk that was written.
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
test_partition.IsRegionErased(
alignment, data_span.size_bytes(), &is_erased));
EXPECT_EQ(false, is_erased);
// Check a region that starts erased but later has been written.
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
test_partition.IsRegionErased(0, 2 * alignment, &is_erased));
EXPECT_EQ(false, is_erased);
// Check erased for a region smaller than kMaxFlashAlignment. This has been a
// bug in the past.
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
test_partition.IsRegionErased(0, alignment, &is_erased));
EXPECT_EQ(true, is_erased);
}
diff --git a/pw_kvs/flash_partition_with_stats.cc b/pw_kvs/flash_partition_with_stats.cc
index 6b2431b..26b0eee 100644
--- a/pw_kvs/flash_partition_with_stats.cc
+++ b/pw_kvs/flash_partition_with_stats.cc
@@ -29,7 +29,7 @@
const char* label) {
// If size is zero saving stats is disabled so do not save any stats.
if (sector_counters_.size() == 0) {
- return Status::Ok();
+ return OkStatus();
}
KeyValueStore::StorageStats stats = kvs.GetStorageStats();
@@ -67,7 +67,7 @@
std::fprintf(out_file, "\n");
std::fclose(out_file);
- return Status::Ok();
+ return OkStatus();
}
Status FlashPartitionWithStats::Erase(Address address, size_t num_sectors) {
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 77ed52d..6c2a1a6 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -134,7 +134,7 @@
return Status::DataLoss();
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::InitializeMetadata() {
@@ -295,7 +295,7 @@
unsigned(entry_copies_missing));
return Status::FailedPrecondition();
}
- return Status::Ok();
+ return OkStatus();
}
KeyValueStore::StorageStats KeyValueStore::GetStorageStats() const {
@@ -394,7 +394,7 @@
if (formats_.KnownMagic(magic)) {
DBG("Found entry magic at address %u", unsigned(address));
*next_entry_address = address;
- return Status::Ok();
+ return OkStatus();
}
}
@@ -605,7 +605,7 @@
if (!initialized()) {
return Status::FailedPrecondition();
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::CheckReadOperation(Key key) const {
@@ -618,7 +618,7 @@
if (initialized_ == InitializationState::kNotInitialized) {
return Status::FailedPrecondition();
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::WriteEntryForExistingKey(EntryMetadata& metadata,
@@ -659,7 +659,7 @@
// keep the existing entry.
DBG("Write for key 0x%08x with matching value skipped",
unsigned(prior_metadata->hash()));
- return Status::Ok();
+ return OkStatus();
}
// List of addresses for sectors with space for this entry.
@@ -686,7 +686,7 @@
PW_TRY(AppendEntry(entry, key, value));
new_metadata.AddNewAddress(reserved_addresses[i]);
}
- return Status::Ok();
+ return OkStatus();
}
KeyValueStore::EntryMetadata KeyValueStore::CreateOrUpdateKeyDescriptor(
@@ -730,7 +730,7 @@
unsigned(write_addresses[i]));
}
- return Status::Ok();
+ return OkStatus();
}
// Finds a sector to use for writing a new entry to. Does automatic garbage
@@ -813,7 +813,7 @@
sector.RemoveWritableBytes(result.size());
sector.AddValidBytes(result.size());
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize KeyValueStore::CopyEntryToSector(Entry& entry,
@@ -864,7 +864,7 @@
sectors_.FromAddress(address).RemoveValidBytes(result_size);
address = new_address;
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::FullMaintenanceHelper(MaintenanceType maintenance_type) {
@@ -976,7 +976,7 @@
}
}
- return Status::Ok();
+ return OkStatus();
};
Status KeyValueStore::GarbageCollectSector(
@@ -1008,7 +1008,7 @@
}
DBG(" Garbage Collect sector %u complete", sectors_.Index(sector_to_gc));
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize KeyValueStore::UpdateEntriesToPrimaryFormat() {
@@ -1078,7 +1078,7 @@
metadata.AddNewAddress(new_address);
}
- return Status::Ok();
+ return OkStatus();
}
Status KeyValueStore::RepairCorruptSectors() {
@@ -1086,7 +1086,7 @@
// sector failed on the first pass, then do a second pass, since a later
// sector might have cleared up space or otherwise unblocked the earlier
// failed sector.
- Status repair_status = Status::Ok();
+ Status repair_status = OkStatus();
size_t loop_count = 0;
do {
@@ -1094,7 +1094,7 @@
// Error of RESOURCE_EXHAUSTED indicates no space found for relocation.
// Reset back to OK for the next pass.
if (repair_status == Status::ResourceExhausted()) {
- repair_status = Status::Ok();
+ repair_status = OkStatus();
}
DBG(" Pass %u", unsigned(loop_count));
@@ -1117,7 +1117,7 @@
}
Status KeyValueStore::EnsureFreeSectorExists() {
- Status repair_status = Status::Ok();
+ Status repair_status = OkStatus();
bool empty_sector_found = false;
DBG(" Find empty sector");
@@ -1141,11 +1141,11 @@
}
Status KeyValueStore::EnsureEntryRedundancy() {
- Status repair_status = Status::Ok();
+ Status repair_status = OkStatus();
if (redundancy() == 1) {
DBG(" Redundancy not in use, nothting to check");
- return Status::Ok();
+ return OkStatus();
}
DBG(" Write any needed additional duplicate copies of keys to fulfill %u"
diff --git a/pw_kvs/key_value_store_binary_format_test.cc b/pw_kvs/key_value_store_binary_format_test.cc
index 76c0667..1fb046a 100644
--- a/pw_kvs/key_value_store_binary_format_test.cc
+++ b/pw_kvs/key_value_store_binary_format_test.cc
@@ -189,10 +189,10 @@
TEST_F(KvsErrorHandling, Init_Ok) {
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
byte buffer[64];
- EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorHandling, Init_DuplicateEntries_ReturnsDataLossButReadsEntry) {
@@ -200,7 +200,7 @@
EXPECT_EQ(Status::DataLoss(), kvs_.Init());
byte buffer[64];
- EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
}
@@ -213,7 +213,7 @@
ASSERT_EQ(Status::DataLoss(), kvs_.Init());
byte buffer[64];
ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ ASSERT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
// One valid entry.
@@ -236,9 +236,9 @@
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("4k", buffer).status());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(64u, stats.in_use_bytes);
@@ -276,7 +276,7 @@
EXPECT_EQ(1u, kvs_.size());
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(32u, stats.in_use_bytes);
@@ -314,8 +314,8 @@
byte buffer[64];
EXPECT_EQ(2u, kvs_.size());
EXPECT_EQ(true, kvs_.error_detected());
- EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -341,7 +341,7 @@
EXPECT_EQ(1u, kvs_.size());
auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -352,7 +352,7 @@
// the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
// configurations).
TEST_F(KvsErrorHandling, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
@@ -367,7 +367,7 @@
// The bytes were marked used, so a new key should not overlap with the bytes
// from the failed Put.
- EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
+ EXPECT_EQ(OkStatus(), kvs_.Put("key1", bytes::String("value1")));
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -397,21 +397,21 @@
TEST_F(KvsErrorRecovery, Init_Ok) {
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
byte buffer[64];
- EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
}
TEST_F(KvsErrorRecovery, Init_DuplicateEntries_RecoversDuringInit) {
InitFlashTo(bytes::Concat(kEntry1, kEntry1));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.corrupt_sectors_recovered, 1u);
byte buffer[64];
- EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
}
@@ -421,10 +421,10 @@
InitFlashTo(bytes::Concat(kEntry1, kEntry2));
flash_.buffer()[i] = byte(int(flash_.buffer()[i]) + 1);
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
byte buffer[64];
ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ ASSERT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
// One valid entry.
@@ -442,15 +442,15 @@
flash_.buffer()[9] = byte(0xef);
flash_.buffer()[67] = byte(0xef);
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
EXPECT_EQ(2u, kvs_.size());
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("4k", buffer).status());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(64u, stats.in_use_bytes);
@@ -465,7 +465,7 @@
flash_.InjectReadError(
FlashError::InRange(Status::Unauthenticated(), kEntry1.size()));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
EXPECT_TRUE(kvs_.initialized());
auto stats = kvs_.GetStorageStats();
ASSERT_EQ(32u, stats.in_use_bytes);
@@ -484,15 +484,15 @@
flash_.buffer()[513] = byte(0xef);
flash_.buffer()[1025] = byte(0xef);
- ASSERT_EQ(Status::Ok(), kvs_.Init());
- EXPECT_EQ(Status::Ok(), kvs_.Put("hello", bytes::String("world")));
- EXPECT_EQ(Status::Ok(), kvs_.Put("a", bytes::String("b")));
+ ASSERT_EQ(OkStatus(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Put("hello", bytes::String("world")));
+ EXPECT_EQ(OkStatus(), kvs_.Put("a", bytes::String("b")));
// Existing valid entries should still be readable.
EXPECT_EQ(3u, kvs_.size());
byte buffer[64];
EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(96u, stats.in_use_bytes);
@@ -512,7 +512,7 @@
flash_.buffer()[1025] = byte(0xef);
flash_.buffer()[1537] = byte(0xef);
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -528,12 +528,12 @@
TEST_F(KvsErrorRecovery, DISABLED_Init_OkWithWriteErrorOnFlash) {
InitFlashTo(bytes::Concat(kEntry1, kEmpty32Bytes, kEntry2));
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
byte buffer[64];
EXPECT_EQ(2u, kvs_.size());
EXPECT_EQ(false, kvs_.error_detected());
- EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
- EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+ EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
auto stats = kvs_.GetStorageStats();
EXPECT_EQ(64u, stats.in_use_bytes);
@@ -554,14 +554,14 @@
// Corrupt a byte of entry version 8 (addresses 32-63).
flash_.buffer()[34] = byte(0xef);
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
char buffer[64] = {};
EXPECT_EQ(1u, kvs_.size());
auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -572,7 +572,7 @@
// the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
// configurations).
TEST_F(KvsErrorRecovery, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
@@ -590,7 +590,7 @@
// The bytes were marked used, so a new key should not overlap with the bytes
// from the failed Put.
- EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
+ EXPECT_EQ(OkStatus(), kvs_.Put("key1", bytes::String("value1")));
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -647,7 +647,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -660,7 +660,7 @@
char val[sizeof(str_value)] = {}; \
StatusWithSize stat = \
kvs_.Get(key, std::as_writable_bytes(std::span(val))); \
- ASSERT_EQ(Status::Ok(), stat.status()); \
+ ASSERT_EQ(OkStatus(), stat.status()); \
ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
ASSERT_STREQ(str_value, val); \
} while (0)
@@ -681,7 +681,7 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- EXPECT_EQ(Status::Ok(), partition_.Erase(0, 1));
+ EXPECT_EQ(OkStatus(), partition_.Erase(0, 1));
ASSERT_CONTAINS_ENTRY("key1", "value1");
ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -698,7 +698,7 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (192u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -715,7 +715,7 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- EXPECT_EQ(Status::Ok(), partition_.Erase(partition_.sector_size_bytes(), 1));
+ EXPECT_EQ(OkStatus(), partition_.Erase(partition_.sector_size_bytes(), 1));
ASSERT_CONTAINS_ENTRY("key1", "value1");
ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -725,7 +725,7 @@
EXPECT_EQ(false, kvs_.error_detected());
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (192u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -773,10 +773,10 @@
char val[20] = {};
EXPECT_EQ(
- Status::Ok(),
+ OkStatus(),
kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (224u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -785,12 +785,12 @@
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
EXPECT_EQ(
- Status::Ok(),
+ OkStatus(),
kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
}
TEST_F(InitializedRedundantMultiMagicKvs, DataLossAfterLosingBothCopies) {
- EXPECT_EQ(Status::Ok(), partition_.Erase(0, 2));
+ EXPECT_EQ(OkStatus(), partition_.Erase(0, 2));
char val[20] = {};
EXPECT_EQ(Status::DataLoss(),
@@ -815,7 +815,7 @@
}
TEST_F(InitializedRedundantMultiMagicKvs, PutNewEntry_UsesFirstFormat) {
- EXPECT_EQ(Status::Ok(), kvs_.Put("new key", bytes::String("abcd?")));
+ EXPECT_EQ(OkStatus(), kvs_.Put("new key", bytes::String("abcd?")));
constexpr auto kNewEntry =
MakeValidEntry(kMagic, 129, "new key", bytes::String("abcd?"));
@@ -827,7 +827,7 @@
}
TEST_F(InitializedRedundantMultiMagicKvs, PutExistingEntry_UsesFirstFormat) {
- EXPECT_EQ(Status::Ok(), kvs_.Put("A Key", bytes::String("New value!")));
+ EXPECT_EQ(OkStatus(), kvs_.Put("A Key", bytes::String("New value!")));
constexpr auto kNewEntry =
MakeValidEntry(kMagic, 129, "A Key", bytes::String("New value!"));
@@ -843,20 +843,20 @@
char val[sizeof(str_value)] = {}; \
StatusWithSize stat = \
kvs.Get(key, std::as_writable_bytes(std::span(val))); \
- ASSERT_EQ(Status::Ok(), stat.status()); \
+ ASSERT_EQ(OkStatus(), stat.status()); \
ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
ASSERT_STREQ(str_value, val); \
} while (0)
TEST_F(InitializedRedundantMultiMagicKvs, UpdateEntryFormat) {
- ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ ASSERT_EQ(OkStatus(), kvs_.FullMaintenance());
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 2, 1> local_kvs(
&partition_,
{.magic = kMagic, .checksum = &default_checksum},
kNoGcOptions);
- ASSERT_EQ(Status::Ok(), local_kvs.Init());
+ ASSERT_EQ(OkStatus(), local_kvs.Init());
EXPECT_EQ(false, local_kvs.error_detected());
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -885,7 +885,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -906,14 +906,14 @@
// Similar to test for InitializedRedundantMultiMagicKvs. Doing similar test
// with different KVS configuration.
TEST_F(InitializedMultiMagicKvs, UpdateEntryFormat) {
- ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ ASSERT_EQ(OkStatus(), kvs_.FullMaintenance());
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 1, 1> local_kvs(
&partition_,
{.magic = kMagic, .checksum = &default_checksum},
kNoGcOptions);
- ASSERT_EQ(Status::Ok(), local_kvs.Init());
+ ASSERT_EQ(OkStatus(), local_kvs.Init());
EXPECT_EQ(false, local_kvs.error_detected());
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -938,7 +938,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -947,7 +947,7 @@
};
TEST_F(InitializedRedundantLazyRecoveryKvs, WriteAfterDataLoss) {
- EXPECT_EQ(Status::Ok(), partition_.Erase(0, 4));
+ EXPECT_EQ(OkStatus(), partition_.Erase(0, 4));
char val[20] = {};
EXPECT_EQ(Status::DataLoss(),
@@ -970,7 +970,7 @@
ASSERT_EQ(Status::DataLoss(), kvs_.Put("key1", 1000));
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, 0u);
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1005,7 +1005,7 @@
ASSERT_CONTAINS_ENTRY("k3y", "value3");
ASSERT_CONTAINS_ENTRY("4k", "value4");
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.in_use_bytes, (128u * kvs_.redundancy()));
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1030,7 +1030,7 @@
kInitialContents.data(),
kInitialContents.size());
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
}
FakeFlashMemoryBuffer<512, 8> flash_;
@@ -1066,17 +1066,17 @@
// Add a near-sector size key entry to fill the KVS with a valid large entry
// and stale data. Modify the value in between Puts so it actually writes
// (identical value writes are skipped).
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
test_data[0]++;
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
// Instantiate a new KVS with redundancy of 2. This KVS should add an extra
// copy of each valid key as part of the init process. Because there is not
@@ -1086,7 +1086,7 @@
&partition_,
{.magic = kMagic, .checksum = &default_checksum},
kRecoveryLazyGcOptions);
- ASSERT_EQ(Status::Ok(), local_kvs.Init());
+ ASSERT_EQ(OkStatus(), local_kvs.Init());
// Verify no errors found in the new KVS and all the entries are present.
EXPECT_EQ(false, local_kvs.error_detected());
@@ -1095,7 +1095,7 @@
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k3y", "value3");
ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "4k", "value4");
StatusWithSize big_key_size = local_kvs.ValueSize("big_key");
- EXPECT_EQ(Status::Ok(), big_key_size.status());
+ EXPECT_EQ(OkStatus(), big_key_size.status());
EXPECT_EQ(sizeof(test_data), big_key_size.size());
// Verify that storage stats of the new redundant KVS match expected values.
diff --git a/pw_kvs/key_value_store_fuzz_test.cc b/pw_kvs/key_value_store_fuzz_test.cc
index 4fd86bc..6a257d6 100644
--- a/pw_kvs/key_value_store_fuzz_test.cc
+++ b/pw_kvs/key_value_store_fuzz_test.cc
@@ -46,7 +46,7 @@
EmptyInitializedKvs()
: kvs_(&test_partition, {.magic = 0x873a9b50, .checksum = &checksum}) {
test_partition.Erase(0, test_partition.sector_count());
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
}
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -63,7 +63,7 @@
for (int i = 0; i < kFuzzIterations; ++i) {
for (unsigned key_size = 1; key_size < sizeof(value); ++key_size) {
for (unsigned value_size = 0; value_size < sizeof(value); ++value_size) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put(std::string_view(value, key_size),
std::as_bytes(std::span(value, value_size))));
}
diff --git a/pw_kvs/key_value_store_initialized_test.cc b/pw_kvs/key_value_store_initialized_test.cc
index 7ea3fd9..9994fb6 100644
--- a/pw_kvs/key_value_store_initialized_test.cc
+++ b/pw_kvs/key_value_store_initialized_test.cc
@@ -83,7 +83,7 @@
protected:
EmptyInitializedKvs() : kvs_(&test_partition, default_format) {
test_partition.Erase();
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
}
// Intention of this is to put and erase key-val to fill up sectors. It's a
@@ -107,7 +107,7 @@
while (size_to_fill > 0) {
// Changing buffer value so put actually does something
buffer[0] = static_cast<byte>(static_cast<uint8_t>(buffer[0]) + 1);
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put(key,
std::span(buffer.data(),
chunk_len - kvs_attr.ChunkHeaderSize() -
@@ -115,7 +115,7 @@
size_to_fill -= chunk_len;
chunk_len = std::min(size_to_fill, kMaxPutSize);
}
- ASSERT_EQ(Status::Ok(), kvs_.Delete(key));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(key));
}
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -127,7 +127,7 @@
std::array<char, 8> value{'v', 'a', 'l', 'u', 'e', '6', '7', '\0'};
for (int i = 0; i < 1000; ++i) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put("The Key!", std::as_bytes(std::span(value))));
}
}
@@ -136,7 +136,7 @@
std::array<char, 7> value{'v', 'a', 'l', 'u', 'e', '6', '\0'};
for (int i = 0; i < 1000; ++i) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put("The Key!", std::as_bytes(std::span(value))));
}
}
@@ -146,27 +146,27 @@
for (int i = 0; i < 100; ++i) {
for (unsigned size = 0; size < value.size(); ++size) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("The Key!", i));
+ ASSERT_EQ(OkStatus(), kvs_.Put("The Key!", i));
}
}
}
TEST_F(EmptyInitializedKvs, PutAndGetByValue_ConvertibleToSpan) {
constexpr float input[] = {1.0, -3.5};
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", input));
float output[2] = {};
- ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+ ASSERT_EQ(OkStatus(), kvs_.Get("key", &output));
EXPECT_EQ(input[0], output[0]);
EXPECT_EQ(input[1], output[1]);
}
TEST_F(EmptyInitializedKvs, PutAndGetByValue_Span) {
float input[] = {1.0, -3.5};
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", std::span(input)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", std::span(input)));
float output[2] = {};
- ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+ ASSERT_EQ(OkStatus(), kvs_.Get("key", &output));
EXPECT_EQ(input[0], output[0]);
EXPECT_EQ(input[1], output[1]);
}
@@ -178,39 +178,39 @@
};
const TestStruct input{-1234.5, true};
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", input));
TestStruct output;
- ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+ ASSERT_EQ(OkStatus(), kvs_.Get("key", &output));
EXPECT_EQ(input.a, output.a);
EXPECT_EQ(input.b, output.b);
}
TEST_F(EmptyInitializedKvs, Get_Simple) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
auto result = kvs_.Get("Charles", std::as_writable_bytes(std::span(value)));
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(sizeof("Mingus"), result.size());
EXPECT_STREQ("Mingus", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
auto result =
kvs_.Get("Charles", std::as_writable_bytes(std::span(value)), 4);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(sizeof("Mingus") - 4, result.size());
EXPECT_STREQ("us", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset_FillBuffer) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[4] = {};
@@ -222,7 +222,7 @@
}
TEST_F(EmptyInitializedKvs, Get_WithOffset_PastEnd) {
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
@@ -234,15 +234,15 @@
}
TEST_F(EmptyInitializedKvs, GetValue) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint32_t value = 0;
- EXPECT_EQ(Status::Ok(), kvs_.Get("key", &value));
+ EXPECT_EQ(OkStatus(), kvs_.Get("key", &value));
EXPECT_EQ(uint32_t(0xfeedbeef), value);
}
TEST_F(EmptyInitializedKvs, GetValue_TooSmall) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint8_t value = 0;
EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
@@ -250,7 +250,7 @@
}
TEST_F(EmptyInitializedKvs, GetValue_TooLarge) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
uint64_t value = 0;
EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
@@ -258,37 +258,36 @@
}
TEST_F(EmptyInitializedKvs, Delete_GetDeletedKey_ReturnsNotFound) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+ ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
EXPECT_EQ(Status::NotFound(), kvs_.Get("kEy", {}).status());
EXPECT_EQ(Status::NotFound(), kvs_.ValueSize("kEy").status());
}
TEST_F(EmptyInitializedKvs, Delete_AddBackKey_PersistsAfterInitialization) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+ ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
- EXPECT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
+ EXPECT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
char data[6] = {};
- ASSERT_EQ(Status::Ok(), kvs_.Get("kEy", &data));
+ ASSERT_EQ(OkStatus(), kvs_.Get("kEy", &data));
EXPECT_STREQ(data, "45678");
// Ensure that the re-added key is still present after reinitialization.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> new_kvs(&test_partition,
default_format);
- ASSERT_EQ(Status::Ok(), new_kvs.Init());
+ ASSERT_EQ(OkStatus(), new_kvs.Init());
- EXPECT_EQ(Status::Ok(),
- new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
+ EXPECT_EQ(OkStatus(), new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
char new_data[6] = {};
- EXPECT_EQ(Status::Ok(), new_kvs.Get("kEy", &new_data));
+ EXPECT_EQ(OkStatus(), new_kvs.Get("kEy", &new_data));
EXPECT_STREQ(data, "45678");
}
TEST_F(EmptyInitializedKvs, Delete_AllItems_KvsIsEmpty) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+ ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
EXPECT_EQ(0u, kvs_.size());
EXPECT_TRUE(kvs_.empty());
@@ -299,12 +298,12 @@
constexpr std::string_view key1 = "D4";
constexpr std::string_view key2 = "dFU6S";
- ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key1, 1000));
EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
int value = 0;
- EXPECT_EQ(Status::Ok(), kvs_.Get(key1, &value));
+ EXPECT_EQ(OkStatus(), kvs_.Get(key1, &value));
EXPECT_EQ(1000, value);
EXPECT_EQ(Status::NotFound(), kvs_.Get(key2, &value));
@@ -317,8 +316,8 @@
constexpr std::string_view key1 = "1U2";
constexpr std::string_view key2 = "ahj9d";
- ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
- ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key1, 1000));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(key1));
// key2 collides with key1's tombstone.
EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
@@ -346,42 +345,41 @@
}
TEST_F(EmptyInitializedKvs, Iteration_OneItem) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
for (KeyValueStore::Item entry : kvs_) {
EXPECT_STREQ(entry.key(), "kEy"); // Make sure null-terminated.
char temp[sizeof("123")] = {};
- EXPECT_EQ(Status::Ok(), entry.Get(&temp));
+ EXPECT_EQ(OkStatus(), entry.Get(&temp));
EXPECT_STREQ("123", temp);
}
}
TEST_F(EmptyInitializedKvs, Iteration_GetWithOffset) {
- ASSERT_EQ(Status::Ok(),
- kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
for (KeyValueStore::Item entry : kvs_) {
char temp[5];
auto result = entry.Get(std::as_writable_bytes(std::span(temp)), 4);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(5u, result.size());
EXPECT_STREQ("bad!", temp);
}
}
TEST_F(EmptyInitializedKvs, Iteration_GetValue) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint32_t value = 0;
- EXPECT_EQ(Status::Ok(), entry.Get(&value));
+ EXPECT_EQ(OkStatus(), entry.Get(&value));
EXPECT_EQ(uint32_t(0xfeedbeef), value);
}
}
TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooSmall) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint8_t value = 0;
@@ -391,7 +389,7 @@
}
TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooLarge) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
for (KeyValueStore::Item entry : kvs_) {
uint64_t value = 0;
@@ -401,8 +399,8 @@
}
TEST_F(EmptyInitializedKvs, Iteration_EmptyAfterDeletion) {
- ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
- ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+ ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+ ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
for (KeyValueStore::Item entry : kvs_) {
static_cast<void>(entry);
@@ -425,10 +423,10 @@
std::memset(buf2, 2, sizeof(buf2));
// Start with things in KVS
- ASSERT_EQ(Status::Ok(), kvs_.Put(key1, buf1));
- ASSERT_EQ(Status::Ok(), kvs_.Put(key2, buf2));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key1, buf1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key2, buf2));
for (size_t j = 0; j < keys.size(); j++) {
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[j], j));
}
for (size_t i = 0; i < 100; i++) {
@@ -437,28 +435,28 @@
size_t size2 = (kLargestBufSize) / (100 - i);
for (size_t j = 0; j < 50; j++) {
// Rewrite a single key many times, can fill up a sector
- ASSERT_EQ(Status::Ok(), kvs_.Put("some_data", j));
+ ASSERT_EQ(OkStatus(), kvs_.Put("some_data", j));
}
// Delete and re-add everything
- ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
- ASSERT_EQ(Status::Ok(), kvs_.Put(key1, std::span(buf1, size1)));
- ASSERT_EQ(Status::Ok(), kvs_.Delete(key2));
- ASSERT_EQ(Status::Ok(), kvs_.Put(key2, std::span(buf2, size2)));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(key1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key1, std::span(buf1, size1)));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(key2));
+ ASSERT_EQ(OkStatus(), kvs_.Put(key2, std::span(buf2, size2)));
for (size_t j = 0; j < keys.size(); j++) {
- ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[j]));
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(keys[j]));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[j], j));
}
// Re-enable and verify
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
static byte buf[4 * 1024];
- ASSERT_EQ(Status::Ok(), kvs_.Get(key1, std::span(buf, size1)).status());
+ ASSERT_EQ(OkStatus(), kvs_.Get(key1, std::span(buf, size1)).status());
ASSERT_EQ(std::memcmp(buf, buf1, size1), 0);
- ASSERT_EQ(Status::Ok(), kvs_.Get(key2, std::span(buf, size2)).status());
+ ASSERT_EQ(OkStatus(), kvs_.Get(key2, std::span(buf, size2)).status());
ASSERT_EQ(std::memcmp(buf2, buf2, size2), 0);
for (size_t j = 0; j < keys.size(); j++) {
size_t ret = 1000;
- ASSERT_EQ(Status::Ok(), kvs_.Get(keys[j], &ret));
+ ASSERT_EQ(OkStatus(), kvs_.Get(keys[j], &ret));
ASSERT_EQ(ret, j);
}
}
@@ -468,28 +466,28 @@
// Add some data
uint8_t value1 = 0xDA;
ASSERT_EQ(
- Status::Ok(),
+ OkStatus(),
kvs_.Put(keys[0], std::as_bytes(std::span(&value1, sizeof(value1)))));
uint32_t value2 = 0xBAD0301f;
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], value2));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[1], value2));
// Verify data
uint32_t test2;
- EXPECT_EQ(Status::Ok(), kvs_.Get(keys[1], &test2));
+ EXPECT_EQ(OkStatus(), kvs_.Get(keys[1], &test2));
uint8_t test1;
- ASSERT_EQ(Status::Ok(), kvs_.Get(keys[0], &test1));
+ ASSERT_EQ(OkStatus(), kvs_.Get(keys[0], &test1));
EXPECT_EQ(test1, value1);
EXPECT_EQ(test2, value2);
// Delete a key
- EXPECT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
+ EXPECT_EQ(OkStatus(), kvs_.Delete(keys[0]));
// Verify it was erased
EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NotFound());
test2 = 0;
- ASSERT_EQ(Status::Ok(),
+ ASSERT_EQ(OkStatus(),
kvs_.Get(keys[1],
std::span(reinterpret_cast<byte*>(&test2), sizeof(test2)))
.status());
diff --git a/pw_kvs/key_value_store_map_test.cc b/pw_kvs/key_value_store_map_test.cc
index 27b961c..0ae42f3 100644
--- a/pw_kvs/key_value_store_map_test.cc
+++ b/pw_kvs/key_value_store_map_test.cc
@@ -88,9 +88,9 @@
// For KVS magic value always use a random 32 bit integer rather than a
// human readable 4 bytes. See pw_kvs/format.h for more information.
kvs_(&partition_, {.magic = 0xc857e51d, .checksum = nullptr}) {
- EXPECT_EQ(Status::Ok(), partition_.Erase());
+ EXPECT_EQ(OkStatus(), partition_.Erase());
Status result = kvs_.Init();
- EXPECT_EQ(Status::Ok(), result);
+ EXPECT_EQ(OkStatus(), result);
if (!result.ok()) {
std::abort();
@@ -250,7 +250,7 @@
EXPECT_EQ(map_entry->first, item.key());
char value[kMaxValueLength + 1] = {};
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
item.Get(std::as_writable_bytes(std::span(value))).status());
EXPECT_EQ(map_entry->second, std::string(value));
}
@@ -315,14 +315,14 @@
void Init() {
StartOperation("Init");
Status status = kvs_.Init();
- EXPECT_EQ(Status::Ok(), status);
+ EXPECT_EQ(OkStatus(), status);
FinishOperation("Init", status);
}
void GCFull() {
StartOperation("GCFull");
Status status = kvs_.FullMaintenance();
- EXPECT_EQ(Status::Ok(), status);
+ EXPECT_EQ(OkStatus(), status);
KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
if (post_stats.in_use_bytes > ((partition_.size_bytes() * 70) / 100)) {
@@ -338,7 +338,7 @@
Status status = kvs_.PartialMaintenance();
KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
if (pre_stats.reclaimable_bytes != 0) {
- EXPECT_EQ(Status::Ok(), status);
+ EXPECT_EQ(OkStatus(), status);
EXPECT_LT(post_stats.reclaimable_bytes, pre_stats.reclaimable_bytes);
} else {
EXPECT_EQ(Status::NotFound(), status);
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 73b1a12..967cf1e 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -69,7 +69,7 @@
std::vector<std::byte> out_vec(memory.size_bytes());
Status status =
memory.Read(0, std::span<std::byte>(out_vec.data(), out_vec.size()));
- if (status != Status::Ok()) {
+ if (status != OkStatus()) {
fclose(out_file);
return status;
}
@@ -83,14 +83,14 @@
status = Status::DataLoss();
} else {
PW_LOG_INFO("Dumped to %s", filename);
- status = Status::Ok();
+ status = OkStatus();
}
fclose(out_file);
return status;
}
#else
- Status Dump(const char*) { return Status::Ok(); }
+ Status Dump(const char*) { return OkStatus(); }
#endif // DUMP_KVS_STATE_TO_FILE
};
@@ -156,8 +156,8 @@
EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
}
-#define ASSERT_OK(expr) ASSERT_EQ(Status::Ok(), expr)
-#define EXPECT_OK(expr) EXPECT_EQ(Status::Ok(), expr)
+#define ASSERT_OK(expr) ASSERT_EQ(OkStatus(), expr)
+#define EXPECT_OK(expr) EXPECT_EQ(OkStatus(), expr)
TEST(InMemoryKvs, WriteOneKeyMultipleTimes) {
// Create and erase the fake flash. It will persist across reloads.
@@ -301,7 +301,7 @@
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+ ASSERT_EQ(OkStatus(), flash.partition.Erase());
// Create and initialize the KVS.
// For KVS magic value always use a random 32 bit integer rather than a
@@ -336,7 +336,7 @@
TEST(InMemoryKvs, CallingEraseTwice_NothingWrittenToFlash) {
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+ ASSERT_EQ(OkStatus(), flash.partition.Erase());
// Create and initialize the KVS.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -344,8 +344,8 @@
ASSERT_OK(kvs.Init());
const uint8_t kValue = 0xDA;
- ASSERT_EQ(Status::Ok(), kvs.Put(keys[0], kValue));
- ASSERT_EQ(Status::Ok(), kvs.Delete(keys[0]));
+ ASSERT_EQ(OkStatus(), kvs.Put(keys[0], kValue));
+ ASSERT_EQ(OkStatus(), kvs.Delete(keys[0]));
// Compare before / after checksums to verify that nothing was written.
const uint16_t crc = checksum::Crc16Ccitt::Calculate(flash.memory.buffer());
@@ -358,8 +358,8 @@
class LargeEmptyInitializedKvs : public ::testing::Test {
protected:
LargeEmptyInitializedKvs() : kvs_(&large_test_partition, default_format) {
- ASSERT_EQ(Status::Ok(), large_test_partition.Erase());
- ASSERT_EQ(Status::Ok(), kvs_.Init());
+ ASSERT_EQ(OkStatus(), large_test_partition.Erase());
+ ASSERT_EQ(OkStatus(), kvs_.Init());
}
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -369,14 +369,14 @@
const uint8_t kValue1 = 0xDA;
const uint8_t kValue2 = 0x12;
uint8_t value;
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue1));
EXPECT_EQ(kvs_.size(), 1u);
- ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(keys[0]));
EXPECT_EQ(kvs_.Get(keys[0], &value), Status::NotFound());
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], kValue1));
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[2], kValue2));
- ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[1]));
- EXPECT_EQ(Status::Ok(), kvs_.Get(keys[2], &value));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[1], kValue1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[2], kValue2));
+ ASSERT_EQ(OkStatus(), kvs_.Delete(keys[1]));
+ EXPECT_EQ(OkStatus(), kvs_.Get(keys[2], &value));
EXPECT_EQ(kValue2, value);
ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NotFound());
EXPECT_EQ(kvs_.size(), 1u);
@@ -388,8 +388,8 @@
// Write a key and write again with a different value, resulting in a stale
// entry from the first write.
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
- ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue2));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue1));
+ ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue2));
EXPECT_EQ(kvs_.size(), 1u);
KeyValueStore::StorageStats stats = kvs_.GetStorageStats();
@@ -398,14 +398,14 @@
// Do regular FullMaintenance, which should not touch the sector with valid
// data.
- EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.sector_erase_count, 0u);
EXPECT_GT(stats.reclaimable_bytes, 0u);
// Do aggressive FullMaintenance, which should GC the sector with valid data,
// resulting in no reclaimable bytes and an erased sector.
- EXPECT_EQ(Status::Ok(), kvs_.HeavyMaintenance());
+ EXPECT_EQ(OkStatus(), kvs_.HeavyMaintenance());
stats = kvs_.GetStorageStats();
EXPECT_EQ(stats.sector_erase_count, 1u);
EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -414,7 +414,7 @@
TEST(InMemoryKvs, Put_MaxValueSize) {
// Create and erase the fake flash.
Flash flash;
- ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+ ASSERT_EQ(OkStatus(), flash.partition.Erase());
// Create and initialize the KVS.
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -434,7 +434,7 @@
ASSERT_GT(sizeof(large_test_flash), max_value_size + 2 * sizeof(EntryHeader));
auto big_data = std::as_bytes(std::span(&large_test_flash, 1));
- EXPECT_EQ(Status::Ok(), kvs.Put("K", big_data.subspan(0, max_value_size)));
+ EXPECT_EQ(OkStatus(), kvs.Put("K", big_data.subspan(0, max_value_size)));
// Larger than maximum is rejected.
EXPECT_EQ(Status::InvalidArgument(),
diff --git a/pw_kvs/key_value_store_wear_test.cc b/pw_kvs/key_value_store_wear_test.cc
index d272535..4110c16 100644
--- a/pw_kvs/key_value_store_wear_test.cc
+++ b/pw_kvs/key_value_store_wear_test.cc
@@ -35,7 +35,7 @@
: flash_(internal::Entry::kMinAlignmentBytes),
partition_(&flash_, 0, flash_.sector_count()),
kvs_(&partition_, format) {
- EXPECT_EQ(Status::Ok(), kvs_.Init());
+ EXPECT_EQ(OkStatus(), kvs_.Init());
}
static constexpr size_t kSectors = 16;
@@ -92,7 +92,7 @@
test_data[0]++;
EXPECT_EQ(
- Status::Ok(),
+ OkStatus(),
kvs_.Put("key",
std::as_bytes(std::span(test_data, sizeof(test_data) - 70))));
}
@@ -105,7 +105,7 @@
test_data[0]++;
printf("Add entry %zu\n", i);
- EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+ EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
}
EXPECT_EQ(2u, kvs_.size());
diff --git a/pw_kvs/public/pw_kvs/fake_flash_memory.h b/pw_kvs/public/pw_kvs/fake_flash_memory.h
index 9795e01..e892d92 100644
--- a/pw_kvs/public/pw_kvs/fake_flash_memory.h
+++ b/pw_kvs/public/pw_kvs/fake_flash_memory.h
@@ -97,9 +97,9 @@
write_errors_(write_errors) {}
// The fake flash is always enabled.
- Status Enable() override { return Status::Ok(); }
+ Status Enable() override { return OkStatus(); }
- Status Disable() override { return Status::Ok(); }
+ Status Disable() override { return OkStatus(); }
bool IsEnabled() const override { return true; }
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index 3b25d88..28fd043 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -187,7 +187,7 @@
virtual ~FlashPartition() = default;
// Performs any required partition or flash-level initialization.
- virtual Status Init() { return Status::Ok(); }
+ virtual Status Init() { return OkStatus(); }
// Erase num_sectors starting at a given address. Blocking call.
// Address must be on a sector boundary. Returns:
diff --git a/pw_kvs/public/pw_kvs/io.h b/pw_kvs/public/pw_kvs/io.h
index 341b80a..193427c 100644
--- a/pw_kvs/public/pw_kvs/io.h
+++ b/pw_kvs/public/pw_kvs/io.h
@@ -73,7 +73,7 @@
// Output adapter that calls a method on a class with a std::span of bytes. If
// the method returns void instead of the expected Status, Write always returns
-// Status::Ok().
+// OkStatus().
template <typename T, T kMethod>
class OutputToMethod final : public Output {
using Class = typename internal::FunctionTraits<decltype(kMethod)>::Class;
diff --git a/pw_kvs/sectors.cc b/pw_kvs/sectors.cc
index e8d91b7..67ede37 100644
--- a/pw_kvs/sectors.cc
+++ b/pw_kvs/sectors.cc
@@ -111,7 +111,7 @@
if ((find_mode == kAppendEntry) ||
(sector->RecoverableBytes(sector_size_bytes) == 0)) {
*found_sector = sector;
- return Status::Ok();
+ return OkStatus();
} else {
if ((non_empty_least_reclaimable_sector == nullptr) ||
(non_empty_least_reclaimable_sector->RecoverableBytes(
@@ -140,7 +140,7 @@
Index(first_empty_sector));
last_new_ = first_empty_sector;
*found_sector = first_empty_sector;
- return Status::Ok();
+ return OkStatus();
}
// Tier 3 check: If we got this far, use the sector with least recoverable
@@ -150,7 +150,7 @@
DBG(" Found a usable sector %u, with %u B recoverable, in GC",
Index(*found_sector),
unsigned((*found_sector)->RecoverableBytes(sector_size_bytes)));
- return Status::Ok();
+ return OkStatus();
}
// No sector was found.
diff --git a/pw_kvs/test_key_value_store_test.cc b/pw_kvs/test_key_value_store_test.cc
index af6d4a9..97ececd 100644
--- a/pw_kvs/test_key_value_store_test.cc
+++ b/pw_kvs/test_key_value_store_test.cc
@@ -24,10 +24,10 @@
// Simple test to verify that the TestKvs() does basic function.
TEST(TestKvs, PutGetValue) {
KeyValueStore& kvs = TestKvs();
- ASSERT_EQ(Status::Ok(), kvs.Put("key", uint32_t(0xfeedbeef)));
+ ASSERT_EQ(OkStatus(), kvs.Put("key", uint32_t(0xfeedbeef)));
uint32_t value = 0;
- EXPECT_EQ(Status::Ok(), kvs.Get("key", &value));
+ EXPECT_EQ(OkStatus(), kvs.Get("key", &value));
EXPECT_EQ(uint32_t(0xfeedbeef), value);
}
diff --git a/pw_log_multisink/log_queue.cc b/pw_log_multisink/log_queue.cc
index 65411eb..6a528ea 100644
--- a/pw_log_multisink/log_queue.cc
+++ b/pw_log_multisink/log_queue.cc
@@ -79,7 +79,7 @@
}
dropped_entries_ = 0;
- return Status::Ok();
+ return OkStatus();
}
Result<LogEntries> LogQueue::Pop(LogEntriesBuffer entry_buffer) {
diff --git a/pw_log_multisink/log_queue_test.cc b/pw_log_multisink/log_queue_test.cc
index 7fe3fd6..b9243b5 100644
--- a/pw_log_multisink/log_queue_test.cc
+++ b/pw_log_multisink/log_queue_test.cc
@@ -87,7 +87,7 @@
std::byte log_buffer[kLogBufferSize];
LogQueueWithEncodeBuffer<kEncodeBufferSize> log_queue(log_buffer);
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(OkStatus(),
log_queue.PushTokenizedMessage(
std::as_bytes(std::span(kTokenizedMessage)),
kFlags,
@@ -118,7 +118,7 @@
LogQueueWithEncodeBuffer<kEncodeBufferSize> log_queue(log_buffer);
for (size_t i = 0; i < kEntryCount; i++) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(OkStatus(),
log_queue.PushTokenizedMessage(
std::as_bytes(std::span(kTokenizedMessage)),
kFlags,
@@ -152,7 +152,7 @@
LogQueueWithEncodeBuffer<kEncodeBufferSize> log_queue(log_buffer);
for (size_t i = 0; i < kEntryCount; i++) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(OkStatus(),
log_queue.PushTokenizedMessage(
std::as_bytes(std::span(kTokenizedMessage)),
kFlags,
diff --git a/pw_log_multisink/public/pw_log_multisink/log_queue.h b/pw_log_multisink/public/pw_log_multisink/log_queue.h
index 450d0fa..f358abb 100644
--- a/pw_log_multisink/public/pw_log_multisink/log_queue.h
+++ b/pw_log_multisink/public/pw_log_multisink/log_queue.h
@@ -58,7 +58,7 @@
LogQueue(ByteSpan log_buffer,
ByteSpan encode_buffer,
size_t max_log_entry_size = kLogEntryMaxSize)
- : pop_status_for_test_(Status::Ok()),
+ : pop_status_for_test_(OkStatus()),
max_log_entry_size_(max_log_entry_size),
encode_buffer_(encode_buffer),
ring_buffer_(true) {
diff --git a/pw_log_rpc/logs_rpc.cc b/pw_log_rpc/logs_rpc.cc
index ada5470..c790b222 100644
--- a/pw_log_rpc/logs_rpc.cc
+++ b/pw_log_rpc/logs_rpc.cc
@@ -39,7 +39,7 @@
// If the response writer was not initialized or has since been closed,
// ignore the flush operation.
if (!response_writer_.open()) {
- return Status::Ok();
+ return OkStatus();
}
// If previous calls to flush resulted in dropped entries, generate a
@@ -59,7 +59,7 @@
Result possible_logs = log_queue_.PopMultiple(payload);
PW_TRY(possible_logs.status());
if (possible_logs.value().entry_count == 0) {
- return Status::Ok();
+ return OkStatus();
}
Status status = response_writer_.Write(possible_logs.value().entries);
@@ -69,7 +69,7 @@
return status;
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::log_rpc
diff --git a/pw_log_rpc/logs_rpc_test.cc b/pw_log_rpc/logs_rpc_test.cc
index 50541bb..88a3f50 100644
--- a/pw_log_rpc/logs_rpc_test.cc
+++ b/pw_log_rpc/logs_rpc_test.cc
@@ -45,7 +45,7 @@
constexpr char kTokenizedMessage[] = "message";
for (size_t i = 0; i < log_count; i++) {
EXPECT_EQ(
- Status::Ok(),
+ OkStatus(),
log_queue_.PushTokenizedMessage(
std::as_bytes(std::span(kTokenizedMessage)), 0, 0, 0, 0, 0));
}
@@ -72,7 +72,7 @@
GetLogs(context).Finish();
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
// Although |kLogEntryCount| messages were in the queue, they are batched
// before being written to the client, so there is only one response.
@@ -94,7 +94,7 @@
GetLogs(context).Finish();
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
EXPECT_EQ(kFlushCount, context.total_responses());
}
@@ -108,7 +108,7 @@
GetLogs(context).Finish();
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
EXPECT_EQ(0U, context.total_responses());
}
@@ -124,7 +124,7 @@
GetLogs(context).Finish();
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
EXPECT_EQ(0U, context.total_responses());
}
diff --git a/pw_metric/metric_service_nanopb_test.cc b/pw_metric/metric_service_nanopb_test.cc
index b2c3966..5810982 100644
--- a/pw_metric/metric_service_nanopb_test.cc
+++ b/pw_metric/metric_service_nanopb_test.cc
@@ -33,7 +33,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
// No metrics should be in the response.
EXPECT_EQ(0u, context.responses().size());
@@ -52,7 +52,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
// All of the responses should have fit in one proto.
EXPECT_EQ(1u, context.responses().size());
@@ -77,7 +77,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
// All of the responses should fit in one proto.
EXPECT_EQ(1u, context.responses().size());
@@ -111,7 +111,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
// The response had to be split into two parts; check that they have the
// appropriate sizes.
@@ -171,7 +171,7 @@
MetricMethodContext context(root.metrics(), root.children());
context.call({});
EXPECT_TRUE(context.done());
- EXPECT_EQ(Status::Ok(), context.status());
+ EXPECT_EQ(OkStatus(), context.status());
// The metrics should fit in one batch.
EXPECT_EQ(1u, context.responses().size());
diff --git a/pw_protobuf/codegen_test.cc b/pw_protobuf/codegen_test.cc
index 72e11a7..385de2f 100644
--- a/pw_protobuf/codegen_test.cc
+++ b/pw_protobuf/codegen_test.cc
@@ -167,7 +167,7 @@
// clang-format on
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(
result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -187,7 +187,7 @@
0x08, 0x00, 0x08, 0x10, 0x08, 0x20, 0x08, 0x30};
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(
result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -204,7 +204,7 @@
constexpr uint8_t expected_proto[] = {0x0a, 0x04, 0x00, 0x10, 0x20, 0x30};
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(
result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -225,7 +225,7 @@
0x1a, 0x03, 't', 'h', 'e', 0x1a, 0x5, 'q', 'u', 'i', 'c', 'k',
0x1a, 0x5, 'b', 'r', 'o', 'w', 'n', 0x1a, 0x3, 'f', 'o', 'x'};
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(
result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -250,7 +250,7 @@
// clang-format on
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(
result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -275,7 +275,7 @@
0x08, 0x03, 0x1a, 0x06, 0x0a, 0x04, 0xde, 0xad, 0xbe, 0xef};
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(
result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -299,7 +299,7 @@
end.WriteNanoseconds(490367432);
}
- EXPECT_EQ(encoder.Encode().status(), Status::Ok());
+ EXPECT_EQ(encoder.Encode().status(), OkStatus());
}
TEST(Codegen, NonPigweedPackage) {
@@ -311,7 +311,7 @@
packed.WriteRep(std::span<const int64_t>(repeated));
packed.WritePacked("packed");
- EXPECT_EQ(encoder.Encode().status(), Status::Ok());
+ EXPECT_EQ(encoder.Encode().status(), OkStatus());
}
} // namespace
diff --git a/pw_protobuf/decoder.cc b/pw_protobuf/decoder.cc
index 70880ad..332f49a 100644
--- a/pw_protobuf/decoder.cc
+++ b/pw_protobuf/decoder.cc
@@ -30,7 +30,7 @@
return Status::OutOfRange();
}
previous_field_consumed_ = false;
- return FieldSize() == 0 ? Status::DataLoss() : Status::Ok();
+ return FieldSize() == 0 ? Status::DataLoss() : OkStatus();
}
Status Decoder::SkipField() {
@@ -44,7 +44,7 @@
}
proto_ = proto_.subspan(bytes_to_skip);
- return proto_.empty() ? Status::OutOfRange() : Status::Ok();
+ return proto_.empty() ? Status::OutOfRange() : OkStatus();
}
uint32_t Decoder::FieldNumber() const {
@@ -63,7 +63,7 @@
return Status::OutOfRange();
}
*out = value;
- return Status::Ok();
+ return OkStatus();
}
Status Decoder::ReadSint32(int32_t* out) {
@@ -76,7 +76,7 @@
return Status::OutOfRange();
}
*out = value;
- return Status::Ok();
+ return OkStatus();
}
Status Decoder::ReadSint64(int64_t* out) {
@@ -86,7 +86,7 @@
return status;
}
*out = varint::ZigZagDecode(value);
- return Status::Ok();
+ return OkStatus();
}
Status Decoder::ReadBool(bool* out) {
@@ -96,7 +96,7 @@
return status;
}
*out = value;
- return Status::Ok();
+ return OkStatus();
}
Status Decoder::ReadString(std::string_view* out) {
@@ -107,7 +107,7 @@
}
*out = std::string_view(reinterpret_cast<const char*>(bytes.data()),
bytes.size());
- return Status::Ok();
+ return OkStatus();
}
size_t Decoder::FieldSize() const {
@@ -169,7 +169,7 @@
// Advance past the key.
proto_ = proto_.subspan(bytes_read);
- return Status::Ok();
+ return OkStatus();
}
Status Decoder::ReadVarint(uint64_t* out) {
@@ -185,7 +185,7 @@
// Advance to the next field.
proto_ = proto_.subspan(bytes_read);
previous_field_consumed_ = true;
- return Status::Ok();
+ return OkStatus();
}
Status Decoder::ReadFixed(std::byte* out, size_t size) {
@@ -204,7 +204,7 @@
proto_ = proto_.subspan(size);
previous_field_consumed_ = true;
- return Status::Ok();
+ return OkStatus();
}
Status Decoder::ReadDelimited(std::span<const std::byte>* out) {
@@ -228,7 +228,7 @@
proto_ = proto_.subspan(length);
previous_field_consumed_ = true;
- return Status::Ok();
+ return OkStatus();
}
Status CallbackDecoder::Decode(std::span<const std::byte> proto) {
@@ -269,7 +269,7 @@
}
state_ = kReady;
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::protobuf
diff --git a/pw_protobuf/decoder_test.cc b/pw_protobuf/decoder_test.cc
index 0b4f6ff..c77e990 100644
--- a/pw_protobuf/decoder_test.cc
+++ b/pw_protobuf/decoder_test.cc
@@ -50,7 +50,7 @@
}
called = true;
- return Status::Ok();
+ return OkStatus();
}
bool called = false;
@@ -83,40 +83,40 @@
Decoder decoder(std::as_bytes(std::span(encoded_proto)));
int32_t v1 = 0;
- EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), OkStatus());
ASSERT_EQ(decoder.FieldNumber(), 1u);
- EXPECT_EQ(decoder.ReadInt32(&v1), Status::Ok());
+ EXPECT_EQ(decoder.ReadInt32(&v1), OkStatus());
EXPECT_EQ(v1, 42);
int32_t v2 = 0;
- EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), OkStatus());
ASSERT_EQ(decoder.FieldNumber(), 2u);
- EXPECT_EQ(decoder.ReadSint32(&v2), Status::Ok());
+ EXPECT_EQ(decoder.ReadSint32(&v2), OkStatus());
EXPECT_EQ(v2, -13);
bool v3 = true;
- EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), OkStatus());
ASSERT_EQ(decoder.FieldNumber(), 3u);
- EXPECT_EQ(decoder.ReadBool(&v3), Status::Ok());
+ EXPECT_EQ(decoder.ReadBool(&v3), OkStatus());
EXPECT_FALSE(v3);
double v4 = 0;
- EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), OkStatus());
ASSERT_EQ(decoder.FieldNumber(), 4u);
- EXPECT_EQ(decoder.ReadDouble(&v4), Status::Ok());
+ EXPECT_EQ(decoder.ReadDouble(&v4), OkStatus());
EXPECT_EQ(v4, 3.14159);
uint32_t v5 = 0;
- EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), OkStatus());
ASSERT_EQ(decoder.FieldNumber(), 5u);
- EXPECT_EQ(decoder.ReadFixed32(&v5), Status::Ok());
+ EXPECT_EQ(decoder.ReadFixed32(&v5), OkStatus());
EXPECT_EQ(v5, 0xdeadbeef);
std::string_view v6;
char buffer[16];
- EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), OkStatus());
ASSERT_EQ(decoder.FieldNumber(), 6u);
- EXPECT_EQ(decoder.ReadString(&v6), Status::Ok());
+ EXPECT_EQ(decoder.ReadString(&v6), OkStatus());
std::memcpy(buffer, v6.data(), v6.size());
buffer[v6.size()] = '\0';
EXPECT_STREQ(buffer, "Hello world");
@@ -146,13 +146,13 @@
// 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(), OkStatus());
+ EXPECT_EQ(decoder.Next(), OkStatus());
+ EXPECT_EQ(decoder.Next(), OkStatus());
+ EXPECT_EQ(decoder.Next(), OkStatus());
ASSERT_EQ(decoder.FieldNumber(), 4u);
- EXPECT_EQ(decoder.Next(), Status::Ok());
- EXPECT_EQ(decoder.Next(), Status::Ok());
+ EXPECT_EQ(decoder.Next(), OkStatus());
+ EXPECT_EQ(decoder.Next(), OkStatus());
EXPECT_EQ(decoder.Next(), Status::OutOfRange());
}
@@ -179,7 +179,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::Ok());
+ OkStatus());
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.test_int32, 42);
EXPECT_EQ(handler.test_sint32, -13);
@@ -206,7 +206,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::Ok());
+ OkStatus());
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.test_int32, 44);
}
@@ -216,7 +216,7 @@
TestDecodeHandler handler;
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(std::span<std::byte>()), Status::Ok());
+ EXPECT_EQ(decoder.Decode(std::span<std::byte>()), OkStatus());
EXPECT_FALSE(handler.called);
EXPECT_EQ(handler.test_int32, 0);
EXPECT_EQ(handler.test_sint32, 0);
@@ -241,10 +241,10 @@
uint32_t field_number) override {
switch (field_number) {
case 1:
- EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
+ EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
break;
case 3:
- EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
+ EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
break;
default:
// Do nothing.
@@ -252,7 +252,7 @@
}
called = true;
- return Status::Ok();
+ return OkStatus();
}
bool called = false;
@@ -286,7 +286,7 @@
decoder.set_handler(&handler);
EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
- Status::Ok());
+ OkStatus());
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.field_one, 42);
EXPECT_EQ(handler.field_three, 99);
@@ -299,17 +299,17 @@
uint32_t field_number) override {
switch (field_number) {
case 1:
- EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
+ EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
return Status::Cancelled();
case 3:
- EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
+ EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
break;
default:
// Do nothing.
break;
}
- return Status::Ok();
+ return OkStatus();
}
int32_t field_one = 0;
diff --git a/pw_protobuf/encoder.cc b/pw_protobuf/encoder.cc
index 6ff8c7c..807a78b 100644
--- a/pw_protobuf/encoder.cc
+++ b/pw_protobuf/encoder.cc
@@ -43,7 +43,7 @@
}
cursor_ += written;
- return Status::Ok();
+ return OkStatus();
}
Status Encoder::WriteRawBytes(const std::byte* ptr, size_t size) {
@@ -61,7 +61,7 @@
std::memmove(cursor_, ptr, size);
cursor_ += size;
- return Status::Ok();
+ return OkStatus();
}
Status Encoder::Push(uint32_t field_number) {
@@ -105,7 +105,7 @@
blob_stack_[depth_++] = size_cursor;
cursor_ += sizeof(*size_cursor);
- return Status::Ok();
+ return OkStatus();
}
Status Encoder::Pop() {
@@ -130,7 +130,7 @@
}
blob_count_--;
- return Status::Ok();
+ return OkStatus();
}
Result<ConstByteSpan> Encoder::Encode() { return EncodeFrom(0); }
diff --git a/pw_protobuf/encoder_test.cc b/pw_protobuf/encoder_test.cc
index a7d04b6..bb41875 100644
--- a/pw_protobuf/encoder_test.cc
+++ b/pw_protobuf/encoder_test.cc
@@ -85,16 +85,16 @@
std::byte encode_buffer[32];
NestedEncoder encoder(encode_buffer);
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
- EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
+ EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), OkStatus());
EXPECT_EQ(encoder.WriteFixed64(kTestProtoCyclesField, 0xdeadbeef8badf00d),
- Status::Ok());
- EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), Status::Ok());
+ OkStatus());
+ EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), OkStatus());
EXPECT_EQ(encoder.WriteString(kTestProtoErrorMessageField, "broken 💩"),
- Status::Ok());
+ OkStatus());
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
EXPECT_EQ(
std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -106,9 +106,9 @@
NestedEncoder encoder(encode_buffer);
// 2 bytes.
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
// 2 bytes.
- EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
+ EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), OkStatus());
// 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),
@@ -124,7 +124,7 @@
std::byte encode_buffer[12];
NestedEncoder encoder(encode_buffer);
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
// Invalid proto field numbers.
EXPECT_EQ(encoder.WriteUint32(0, 1337), Status::InvalidArgument());
encoder.Clear();
@@ -142,48 +142,47 @@
// TestProto test_proto;
// test_proto.magic_number = 42;
- EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+ EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
{
// NestedProto& nested_proto = test_proto.nested;
- EXPECT_EQ(encoder.Push(kTestProtoNestedField), Status::Ok());
+ EXPECT_EQ(encoder.Push(kTestProtoNestedField), OkStatus());
// nested_proto.hello = "world";
- EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"),
- Status::Ok());
+ EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"), OkStatus());
// nested_proto.id = 999;
- EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), Status::Ok());
+ EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), OkStatus());
{
// DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
- EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
+ EXPECT_EQ(encoder.Push(kNestedProtoPairField), OkStatus());
// double_nested_proto.key = "version";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "version"),
- Status::Ok());
+ OkStatus());
// double_nested_proto.value = "2.9.1";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "2.9.1"),
- Status::Ok());
+ OkStatus());
- EXPECT_EQ(encoder.Pop(), Status::Ok());
+ EXPECT_EQ(encoder.Pop(), OkStatus());
} // end DoubleNestedProto
{
// DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
- EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
+ EXPECT_EQ(encoder.Push(kNestedProtoPairField), OkStatus());
// double_nested_proto.key = "device";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "device"),
- Status::Ok());
+ OkStatus());
// double_nested_proto.value = "left-soc";
EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "left-soc"),
- Status::Ok());
+ OkStatus());
- EXPECT_EQ(encoder.Pop(), Status::Ok());
+ EXPECT_EQ(encoder.Pop(), OkStatus());
} // end DoubleNestedProto
- EXPECT_EQ(encoder.Pop(), Status::Ok());
+ EXPECT_EQ(encoder.Pop(), OkStatus());
} // end NestedProto
// test_proto.ziggy = -13;
- EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
+ EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), OkStatus());
// clang-format off
constexpr uint8_t encoded_proto[] = {
@@ -213,7 +212,7 @@
// clang-format on
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
EXPECT_EQ(
std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -225,9 +224,9 @@
NestedEncoder<2, 2> encoder(encode_buffer);
// One level of nesting.
- EXPECT_EQ(encoder.Push(2), Status::Ok());
+ EXPECT_EQ(encoder.Push(2), OkStatus());
// Two levels of nesting.
- EXPECT_EQ(encoder.Push(1), Status::Ok());
+ EXPECT_EQ(encoder.Push(1), OkStatus());
// Three levels of nesting: error!
EXPECT_EQ(encoder.Push(1), Status::ResourceExhausted());
@@ -242,22 +241,22 @@
NestedEncoder<3, 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), OkStatus());
+ EXPECT_EQ(encoder.Pop(), OkStatus());
// Write second blob.
- EXPECT_EQ(encoder.Push(2), Status::Ok());
+ EXPECT_EQ(encoder.Push(2), OkStatus());
// Write nested third blob.
- EXPECT_EQ(encoder.Push(3), Status::Ok());
- EXPECT_EQ(encoder.Pop(), Status::Ok());
+ EXPECT_EQ(encoder.Push(3), OkStatus());
+ EXPECT_EQ(encoder.Pop(), OkStatus());
// End second blob.
- EXPECT_EQ(encoder.Pop(), Status::Ok());
+ EXPECT_EQ(encoder.Pop(), OkStatus());
// Write fourth blob: OK
- EXPECT_EQ(encoder.Push(4), Status::Ok());
- EXPECT_EQ(encoder.Pop(), Status::Ok());
+ EXPECT_EQ(encoder.Push(4), OkStatus());
+ EXPECT_EQ(encoder.Pop(), OkStatus());
}
TEST(Encoder, RepeatedField) {
@@ -274,7 +273,7 @@
0x08, 0x00, 0x08, 0x32, 0x08, 0x64, 0x08, 0x96, 0x01, 0x08, 0xc8, 0x01};
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
EXPECT_EQ(
std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -294,7 +293,7 @@
// key size v[0] v[1] v[2] v[3] v[4]
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
EXPECT_EQ(
std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -329,7 +328,7 @@
0x12, 0x08, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01};
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
EXPECT_EQ(
std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -348,7 +347,7 @@
0x0a, 0x09, 0xc7, 0x01, 0x31, 0x01, 0x00, 0x02, 0x32, 0xc8, 0x01};
Result result = encoder.Encode();
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
EXPECT_EQ(
std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
diff --git a/pw_protobuf/find.cc b/pw_protobuf/find.cc
index 635f50b..0082726 100644
--- a/pw_protobuf/find.cc
+++ b/pw_protobuf/find.cc
@@ -20,7 +20,7 @@
uint32_t field_number) {
if (field_number != field_number_) {
// Continue to the next field.
- return Status::Ok();
+ return OkStatus();
}
found_ = true;
diff --git a/pw_protobuf/public/pw_protobuf/decoder.h b/pw_protobuf/public/pw_protobuf/decoder.h
index 6cb402e..baa076c 100644
--- a/pw_protobuf/public/pw_protobuf/decoder.h
+++ b/pw_protobuf/public/pw_protobuf/decoder.h
@@ -192,7 +192,7 @@
// break;
// }
//
-// return Status::Ok();
+// return OkStatus();
// }
//
// int bar;
@@ -303,7 +303,7 @@
// 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
+ // If the status returned is not OkStatus(), 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,
diff --git a/pw_protobuf/public/pw_protobuf/encoder.h b/pw_protobuf/public/pw_protobuf/encoder.h
index 4277672..51c335d 100644
--- a/pw_protobuf/public/pw_protobuf/encoder.h
+++ b/pw_protobuf/public/pw_protobuf/encoder.h
@@ -42,7 +42,7 @@
blob_count_(0),
blob_stack_(stack),
depth_(0),
- encode_status_(Status::Ok()) {}
+ encode_status_(OkStatus()) {}
// Disallow copy/assign to avoid confusion about who owns the buffer.
Encoder(const Encoder& other) = delete;
@@ -261,7 +261,7 @@
// obtained from Encode().
void Clear() {
cursor_ = buffer_.data();
- encode_status_ = Status::Ok();
+ encode_status_ = OkStatus();
blob_count_ = 0;
depth_ = 0;
}
@@ -278,7 +278,7 @@
return result.status();
}
*out = result.value();
- return Status::Ok();
+ return OkStatus();
}
private:
diff --git a/pw_random/xor_shift_test.cc b/pw_random/xor_shift_test.cc
index 6b7e379..a653584 100644
--- a/pw_random/xor_shift_test.cc
+++ b/pw_random/xor_shift_test.cc
@@ -44,7 +44,7 @@
XorShiftStarRng64 rng(seed1);
for (size_t i = 0; i < result1_count; ++i) {
uint64_t val = 0;
- EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+ EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
EXPECT_EQ(val, result1[i]);
}
}
@@ -53,7 +53,7 @@
XorShiftStarRng64 rng(seed2);
for (size_t i = 0; i < result2_count; ++i) {
uint64_t val = 0;
- EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+ EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
EXPECT_EQ(val, result2[i]);
}
}
@@ -62,7 +62,7 @@
XorShiftStarRng64 rng(seed1);
uint64_t val = 0;
rng.InjectEntropyBits(0x1, 1);
- EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+ EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
EXPECT_NE(val, result1[0]);
}
@@ -72,14 +72,14 @@
XorShiftStarRng64 rng_1(seed1);
uint64_t first_val = 0;
rng_1.InjectEntropyBits(0x1, 1);
- EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
+ EXPECT_EQ(rng_1.GetInt(first_val).status(), OkStatus());
// 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(), OkStatus());
EXPECT_NE(first_val, second_val);
}
@@ -91,7 +91,7 @@
XorShiftStarRng64 rng_1(seed1);
uint64_t first_val = 0;
rng_1.InjectEntropyBits(0x6, 3);
- EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
+ EXPECT_EQ(rng_1.GetInt(first_val).status(), OkStatus());
// Use the same starting seed.
XorShiftStarRng64 rng_2(seed1);
@@ -100,7 +100,7 @@
rng_2.InjectEntropyBits(0x1, 1);
rng_2.InjectEntropyBits(0x1, 1);
rng_2.InjectEntropyBits(0x0, 1);
- EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::Ok());
+ EXPECT_EQ(rng_2.GetInt(second_val).status(), OkStatus());
EXPECT_EQ(first_val, second_val);
}
@@ -114,7 +114,7 @@
std::byte(0x17),
std::byte(0x02)};
rng.InjectEntropy(entropy);
- EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+ EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
EXPECT_NE(val, result1[0]);
}
diff --git a/pw_result/public/pw_result/result.h b/pw_result/public/pw_result/result.h
index 7093551..a55c2b4 100644
--- a/pw_result/public/pw_result/result.h
+++ b/pw_result/public/pw_result/result.h
@@ -26,20 +26,17 @@
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_(OkStatus()) {}
+ constexpr Result(const T& value) : value_(value), status_(OkStatus()) {}
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_(OkStatus()) {}
// 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_ != OkStatus()); }
// 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_ != OkStatus()); }
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 ef913fd..e9095f5 100644
--- a/pw_result/result_test.cc
+++ b/pw_result/result_test.cc
@@ -22,7 +22,7 @@
TEST(Result, CreateOk) {
Result<const char*> res("hello");
EXPECT_TRUE(res.ok());
- EXPECT_EQ(res.status(), Status::Ok());
+ EXPECT_EQ(res.status(), OkStatus());
EXPECT_EQ(res.value(), "hello");
}
diff --git a/pw_result/size_report/pointer_noinline.cc b/pw_result/size_report/pointer_noinline.cc
index 522c9fe..1318fec 100644
--- a/pw_result/size_report/pointer_noinline.cc
+++ b/pw_result/size_report/pointer_noinline.cc
@@ -21,7 +21,7 @@
return pw::Status::InvalidArgument();
}
*out = a / b;
- return pw::Status::Ok();
+ return pw::OkStatus();
}
int volatile* unoptimizable;
diff --git a/pw_result/size_report/pointer_read.cc b/pw_result/size_report/pointer_read.cc
index fb4f948..130cb56 100644
--- a/pw_result/size_report/pointer_read.cc
+++ b/pw_result/size_report/pointer_read.cc
@@ -38,7 +38,7 @@
}
*out = std::span<const std::byte>(std::data(kArray) + offset, size);
- return pw::Status::Ok();
+ return pw::OkStatus();
}
} // namespace
diff --git a/pw_result/size_report/pointer_simple.cc b/pw_result/size_report/pointer_simple.cc
index 7c1440e..599ca77 100644
--- a/pw_result/size_report/pointer_simple.cc
+++ b/pw_result/size_report/pointer_simple.cc
@@ -20,7 +20,7 @@
return pw::Status::InvalidArgument();
}
*out = a / b;
- return pw::Status::Ok();
+ return pw::OkStatus();
}
int volatile* unoptimizable;
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer.cc b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
index d122162..82f76d0 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
@@ -40,7 +40,7 @@
buffer_bytes_ = buffer.size_bytes();
Clear();
- return Status::Ok();
+ return OkStatus();
}
Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data,
@@ -80,7 +80,7 @@
RawWrite(std::span(varint_buf, varint_bytes));
RawWrite(data);
entry_count_++;
- return Status::Ok();
+ return OkStatus();
}
auto GetOutput(std::span<byte> data_out, size_t* write_index) {
@@ -90,7 +90,7 @@
memcpy(data_out.data() + *write_index, src.data(), copy_size);
*write_index += copy_size;
- return (copy_size == src.size_bytes()) ? Status::Ok()
+ return (copy_size == src.size_bytes()) ? OkStatus()
: Status::ResourceExhausted();
};
}
@@ -161,7 +161,7 @@
size_t entry_bytes = info.preamble_bytes + info.data_bytes;
read_idx_ = IncrementIndex(read_idx_, entry_bytes);
entry_count_--;
- return Status::Ok();
+ return OkStatus();
}
Status PrefixedEntryRingBuffer::Dering() {
@@ -170,7 +170,7 @@
}
// Check if by luck we're already deringed.
if (read_idx_ == 0) {
- return Status::Ok();
+ return OkStatus();
}
auto buffer_span = std::span(buffer_, buffer_bytes_);
@@ -184,7 +184,7 @@
}
write_idx_ -= read_idx_;
read_idx_ = 0;
- return Status::Ok();
+ return OkStatus();
}
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 6469f42..18382d3 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
@@ -83,7 +83,7 @@
// 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), OkStatus());
EXPECT_EQ(ring.EntryCount(), 0u);
EXPECT_EQ(ring.PopFront(), Status::OutOfRange());
@@ -115,12 +115,12 @@
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
- Status::Ok());
+ OkStatus());
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), OkStatus());
ASSERT_EQ(read_size, data_size);
// ASSERT_THAT(std::span(expect_buffer).last(data_size),
@@ -131,10 +131,9 @@
0);
read_size = 500U;
- ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size),
- Status::Ok());
+ ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size), OkStatus());
ASSERT_EQ(read_size, single_entry_total_size);
- ASSERT_EQ(ring.PopFront(), Status::Ok());
+ ASSERT_EQ(ring.PopFront(), OkStatus());
if (user_data) {
expect_buffer[0] = byte(i);
@@ -168,7 +167,7 @@
PrefixedEntryRingBuffer ring(user_data);
byte test_buffer[single_entry_test_buffer_size];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+ EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
EXPECT_EQ(ring.EntryCount(), 0u);
constexpr size_t data_size = sizeof(single_entry_data) - (user_data ? 1 : 0);
@@ -182,7 +181,7 @@
for (j = 0; j < kSingleEntryCycles; j++) {
memset(write_buffer, j + seed, sizeof(write_buffer));
- ASSERT_EQ(ring.PushBack(write_buffer), Status::Ok());
+ ASSERT_EQ(ring.PushBack(write_buffer), OkStatus());
size_t expected_count = (j < kCountingUpMaxExpectedEntries)
? j + 1
@@ -196,11 +195,11 @@
byte read_buffer[sizeof(write_buffer)];
size_t read_size;
memset(write_buffer, fill_val + j, sizeof(write_buffer));
- ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::Ok());
+ ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), OkStatus());
ASSERT_EQ(memcmp(write_buffer, read_buffer, data_size), 0);
- ASSERT_EQ(ring.PopFront(), Status::Ok());
+ ASSERT_EQ(ring.PopFront(), OkStatus());
}
}
}
@@ -222,13 +221,13 @@
PrefixedEntryRingBuffer ring(user_data);
byte test_buffer[single_entry_test_buffer_size];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+ EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
auto output = [](std::span<const byte> src) -> Status {
for (byte b : src) {
read_buffer.push_back(b);
}
- return Status::Ok();
+ return OkStatus();
};
size_t user_preamble_bytes = (user_data ? 1 : 0);
@@ -244,12 +243,12 @@
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
- Status::Ok());
+ OkStatus());
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), OkStatus());
ASSERT_EQ(read_buffer.size(), data_size);
ASSERT_EQ(memcmp(std::span(expect_buffer).last(data_size).data(),
@@ -258,9 +257,9 @@
0);
read_buffer.clear();
- ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
+ ASSERT_EQ(ring.PeekFrontWithPreamble(output), OkStatus());
ASSERT_EQ(read_buffer.size(), single_entry_total_size);
- ASSERT_EQ(ring.PopFront(), Status::Ok());
+ ASSERT_EQ(ring.PopFront(), OkStatus());
if (user_data) {
expect_buffer[0] = byte(i);
@@ -293,7 +292,7 @@
PrefixedEntryRingBuffer ring;
byte test_buffer[kTestBufferSize];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+ EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
// Entry data is entry size - preamble (single byte in this case).
byte single_entry_buffer[kEntrySizeBytes - 1u];
@@ -336,7 +335,7 @@
EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
EXPECT_EQ(expected_result.size(), ring.TotalUsedBytes());
- ASSERT_EQ(ring.Dering(), Status::Ok());
+ ASSERT_EQ(ring.Dering(), OkStatus());
// Check values after doing the dering.
EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
@@ -348,11 +347,11 @@
for (byte b : src) {
actual_result.push_back(b);
}
- return Status::Ok();
+ return OkStatus();
};
while (ring.EntryCount()) {
- ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
- ASSERT_EQ(ring.PopFront(), Status::Ok());
+ ASSERT_EQ(ring.PeekFrontWithPreamble(output), OkStatus());
+ ASSERT_EQ(ring.PopFront(), OkStatus());
}
// Ensure the actual result out of the ring buffer matches our manually
@@ -405,7 +404,7 @@
TEST(PrefixedEntryRingBuffer, TryPushBack) {
PrefixedEntryRingBuffer ring;
byte test_buffer[kTestBufferSize];
- EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+ EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
// Fill up the ring buffer with a constant.
int total_items = 0;
@@ -428,7 +427,7 @@
// 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), OkStatus());
}
EXPECT_EQ(PeekFront<int>(ring), 100);
}
diff --git a/pw_rpc/base_server_writer.cc b/pw_rpc/base_server_writer.cc
index 1d9ea4d..478c67a 100644
--- a/pw_rpc/base_server_writer.cc
+++ b/pw_rpc/base_server_writer.cc
@@ -94,7 +94,7 @@
}
call_.channel().Release(response_);
- return Status::Ok();
+ return OkStatus();
}
void BaseServerWriter::Close() {
diff --git a/pw_rpc/base_server_writer_test.cc b/pw_rpc/base_server_writer_test.cc
index d5767df..4314cff 100644
--- a/pw_rpc/base_server_writer_test.cc
+++ b/pw_rpc/base_server_writer_test.cc
@@ -122,7 +122,7 @@
EXPECT_EQ(packet.service_id(), context.kServiceId);
EXPECT_EQ(packet.method_id(), context.get().method().id());
EXPECT_TRUE(packet.payload().empty());
- EXPECT_EQ(packet.status(), Status::Ok());
+ EXPECT_EQ(packet.status(), OkStatus());
}
TEST(ServerWriter, Close) {
@@ -152,11 +152,11 @@
FakeServerWriter writer(context.get());
constexpr byte data[] = {byte{0xf0}, byte{0x0d}};
- ASSERT_EQ(Status::Ok(), writer.Write(data));
+ ASSERT_EQ(OkStatus(), writer.Write(data));
byte encoded[64];
auto result = context.packet(data).Encode(encoded);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
EXPECT_EQ(result.value().size(), context.output().sent_data().size());
EXPECT_EQ(
diff --git a/pw_rpc/channel_test.cc b/pw_rpc/channel_test.cc
index a40e591..5e16ee6 100644
--- a/pw_rpc/channel_test.cc
+++ b/pw_rpc/channel_test.cc
@@ -29,7 +29,7 @@
NameTester(const char* name) : ChannelOutput(name) {}
std::span<std::byte> AcquireBuffer() override { return {}; }
Status SendAndReleaseBuffer(std::span<const std::byte>) override {
- return Status::Ok();
+ return OkStatus();
}
};
@@ -74,7 +74,7 @@
EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
- EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
+ EXPECT_EQ(OkStatus(), channel.Send(output_buffer, kTestPacket));
}
TEST(Channel, OutputBuffer_PayloadDoesNotFit_ReportsError) {
@@ -98,7 +98,7 @@
EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
- EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
+ EXPECT_EQ(OkStatus(), channel.Send(output_buffer, kTestPacket));
}
TEST(Channel, OutputBuffer_ReturnsStatusFromChannelOutputSend) {
diff --git a/pw_rpc/client.cc b/pw_rpc/client.cc
index 07c26ee..b5f3f5d 100644
--- a/pw_rpc/client.cc
+++ b/pw_rpc/client.cc
@@ -79,7 +79,7 @@
return Status::Unimplemented();
}
- return Status::Ok();
+ return OkStatus();
}
Status Client::RegisterCall(BaseClientCall& call) {
@@ -95,7 +95,7 @@
}
calls_.push_front(call);
- return Status::Ok();
+ return OkStatus();
}
} // namespace pw::rpc
diff --git a/pw_rpc/client_test.cc b/pw_rpc/client_test.cc
index 3174cfc..9249877 100644
--- a/pw_rpc/client_test.cc
+++ b/pw_rpc/client_test.cc
@@ -49,7 +49,7 @@
TestClientCall call(
&context.channel(), context.kServiceId, context.kMethodId);
- EXPECT_EQ(context.SendResponse(Status::Ok(), {}), Status::Ok());
+ EXPECT_EQ(context.SendResponse(OkStatus(), {}), OkStatus());
EXPECT_TRUE(call.invoked());
}
@@ -57,7 +57,7 @@
TEST(Client, ProcessPacket_SendsClientErrorOnUnregisteredCall) {
ClientContextForTest context;
- EXPECT_EQ(context.SendResponse(Status::OK, {}), Status::NotFound());
+ EXPECT_EQ(context.SendResponse(OkStatus(), {}), Status::NotFound());
ASSERT_EQ(context.output().packet_count(), 1u);
const Packet& packet = context.output().sent_packet();
diff --git a/pw_rpc/docs.rst b/pw_rpc/docs.rst
index 47eb235..c44b017 100644
--- a/pw_rpc/docs.rst
+++ b/pw_rpc/docs.rst
@@ -109,7 +109,7 @@
const foo_bar_Request& request,
foo_bar_Response& response) {
// implementation
- return pw::Status::Ok();
+ return pw::OkStatus();
}
void MethodTwo(ServerContext& ctx,
diff --git a/pw_rpc/nanopb/codegen_test.cc b/pw_rpc/nanopb/codegen_test.cc
index c43ccef..5b7241a 100644
--- a/pw_rpc/nanopb/codegen_test.cc
+++ b/pw_rpc/nanopb/codegen_test.cc
@@ -56,8 +56,8 @@
TEST(NanopbCodegen, Server_InvokeUnaryRpc) {
PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestRpc) context;
- EXPECT_EQ(Status::Ok(),
- context.call({.integer = 123, .status_code = Status::Ok().code()}));
+ EXPECT_EQ(OkStatus(),
+ context.call({.integer = 123, .status_code = OkStatus().code()}));
EXPECT_EQ(124, context.response().value);
@@ -77,7 +77,7 @@
EXPECT_TRUE(context.responses().empty());
EXPECT_EQ(0u, context.total_responses());
- context.call({.integer = 4, .status_code = Status::Ok().code()});
+ context.call({.integer = 4, .status_code = OkStatus().code()});
ASSERT_EQ(4u, context.responses().size());
ASSERT_EQ(4u, context.total_responses());
@@ -86,7 +86,7 @@
EXPECT_EQ(context.responses()[i].number, i);
}
- EXPECT_EQ(Status::Ok().code(), context.status());
+ EXPECT_EQ(OkStatus().code(), context.status());
}
TEST(NanopbCodegen,
@@ -152,9 +152,9 @@
EXPECT_EQ(sent_proto.integer, 123);
PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
- context.SendResponse(Status::Ok(), response);
+ context.SendResponse(OkStatus(), response);
ASSERT_EQ(handler.responses_received(), 1u);
- EXPECT_EQ(handler.last_status(), Status::Ok());
+ EXPECT_EQ(handler.last_status(), OkStatus());
EXPECT_EQ(handler.last_response().value, 42);
}
@@ -177,7 +177,7 @@
PW_ENCODE_PB(
pw_rpc_test_TestStreamResponse, response, .chunk = {}, .number = 11u);
- context.SendResponse(Status::Ok(), response);
+ context.SendResponse(OkStatus(), response);
ASSERT_EQ(handler.responses_received(), 1u);
EXPECT_EQ(handler.last_response().number, 11u);
diff --git a/pw_rpc/nanopb/docs.rst b/pw_rpc/nanopb/docs.rst
index 5e3b0d2..0d61766 100644
--- a/pw_rpc/nanopb/docs.rst
+++ b/pw_rpc/nanopb/docs.rst
@@ -114,7 +114,7 @@
Writes a single response message to the stream. The returned status indicates
whether the write was successful.
-.. cpp:function:: void ServerWriter::Finish(Status status = Status::OK)
+.. cpp:function:: void ServerWriter::Finish(Status status = OkStatus())
Closes the stream and sends back the RPC's overall status to the client.
diff --git a/pw_rpc/nanopb/echo_service_test.cc b/pw_rpc/nanopb/echo_service_test.cc
index 31fbb7f..11a0608 100644
--- a/pw_rpc/nanopb/echo_service_test.cc
+++ b/pw_rpc/nanopb/echo_service_test.cc
@@ -21,13 +21,13 @@
TEST(EchoService, Echo_EchoesRequestMessage) {
PW_NANOPB_TEST_METHOD_CONTEXT(EchoService, Echo) context;
- ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), Status::Ok());
+ ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), OkStatus());
EXPECT_STREQ(context.response().msg, "Hello, world");
}
TEST(EchoService, Echo_EmptyRequest) {
PW_NANOPB_TEST_METHOD_CONTEXT(EchoService, Echo) context;
- ASSERT_EQ(context.call({.msg = {}}), Status::Ok());
+ ASSERT_EQ(context.call({.msg = {}}), OkStatus());
EXPECT_STREQ(context.response().msg, "");
}
diff --git a/pw_rpc/nanopb/nanopb_client_call_test.cc b/pw_rpc/nanopb/nanopb_client_call_test.cc
index 4659b95..171ae28 100644
--- a/pw_rpc/nanopb/nanopb_client_call_test.cc
+++ b/pw_rpc/nanopb/nanopb_client_call_test.cc
@@ -87,10 +87,10 @@
context.channel(), {.integer = 123, .status_code = 0}, handler);
PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
- context.SendResponse(Status::Ok(), response);
+ context.SendResponse(OkStatus(), response);
ASSERT_EQ(handler.responses_received(), 1u);
- EXPECT_EQ(handler.last_status(), Status::Ok());
+ EXPECT_EQ(handler.last_status(), OkStatus());
EXPECT_EQ(handler.last_response().value, 42);
}
@@ -103,7 +103,7 @@
constexpr std::byte bad_payload[]{
std::byte{0xab}, std::byte{0xcd}, std::byte{0xef}};
- context.SendResponse(Status::Ok(), bad_payload);
+ context.SendResponse(OkStatus(), bad_payload);
EXPECT_EQ(handler.responses_received(), 0u);
EXPECT_EQ(handler.rpc_error(), Status::DataLoss());
@@ -168,19 +168,19 @@
context.channel(), {.integer = 71, .status_code = 0}, handler);
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
- context.SendResponse(Status::Ok(), r1);
+ context.SendResponse(OkStatus(), r1);
EXPECT_TRUE(handler.active());
EXPECT_EQ(handler.responses_received(), 1u);
EXPECT_EQ(handler.last_response().number, 11u);
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
- context.SendResponse(Status::Ok(), r2);
+ context.SendResponse(OkStatus(), r2);
EXPECT_TRUE(handler.active());
EXPECT_EQ(handler.responses_received(), 2u);
EXPECT_EQ(handler.last_response().number, 22u);
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r3, .chunk = {}, .number = 33u);
- context.SendResponse(Status::Ok(), r3);
+ context.SendResponse(OkStatus(), r3);
EXPECT_TRUE(handler.active());
EXPECT_EQ(handler.responses_received(), 3u);
EXPECT_EQ(handler.last_response().number, 33u);
@@ -195,11 +195,11 @@
context.channel(), {.integer = 71, .status_code = 0}, handler);
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
- context.SendResponse(Status::Ok(), r1);
+ context.SendResponse(OkStatus(), r1);
EXPECT_TRUE(handler.active());
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
- context.SendResponse(Status::Ok(), r2);
+ context.SendResponse(OkStatus(), r2);
EXPECT_TRUE(handler.active());
// Close the stream.
@@ -207,7 +207,7 @@
Status::NotFound());
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r3, .chunk = {}, .number = 33u);
- context.SendResponse(Status::Ok(), r3);
+ context.SendResponse(OkStatus(), r3);
EXPECT_FALSE(handler.active());
EXPECT_EQ(handler.responses_received(), 2u);
@@ -222,19 +222,19 @@
context.channel(), {.integer = 71, .status_code = 0}, handler);
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
- context.SendResponse(Status::Ok(), r1);
+ context.SendResponse(OkStatus(), r1);
EXPECT_TRUE(handler.active());
EXPECT_EQ(handler.responses_received(), 1u);
EXPECT_EQ(handler.last_response().number, 11u);
constexpr std::byte bad_payload[]{
std::byte{0xab}, std::byte{0xcd}, std::byte{0xef}};
- context.SendResponse(Status::Ok(), bad_payload);
+ context.SendResponse(OkStatus(), bad_payload);
EXPECT_EQ(handler.responses_received(), 1u);
EXPECT_EQ(handler.rpc_error(), Status::DataLoss());
PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
- context.SendResponse(Status::Ok(), r2);
+ context.SendResponse(OkStatus(), r2);
EXPECT_TRUE(handler.active());
EXPECT_EQ(handler.responses_received(), 2u);
EXPECT_EQ(handler.last_response().number, 22u);
diff --git a/pw_rpc/nanopb/nanopb_common.cc b/pw_rpc/nanopb/nanopb_common.cc
index d3339c6..4f90e1b 100644
--- a/pw_rpc/nanopb/nanopb_common.cc
+++ b/pw_rpc/nanopb/nanopb_common.cc
@@ -41,7 +41,7 @@
return StatusWithSize::Internal();
}
- return StatusWithSize::Ok(output.bytes_written);
+ return StatusWithSize(output.bytes_written);
}
bool NanopbMethodSerde::Decode(NanopbMessageDescriptor fields,
diff --git a/pw_rpc/nanopb/nanopb_method_test.cc b/pw_rpc/nanopb/nanopb_method_test.cc
index 98e3d54..e0e4a76 100644
--- a/pw_rpc/nanopb/nanopb_method_test.cc
+++ b/pw_rpc/nanopb/nanopb_method_test.cc
@@ -185,12 +185,12 @@
method.Invoke(context.get(), context.packet({}));
- EXPECT_EQ(Status::Ok(), last_writer.Write({.value = 100}));
+ EXPECT_EQ(OkStatus(), 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(OkStatus(), encoded.status());
ASSERT_EQ(encoded.value().size(), context.output().sent_data().size());
EXPECT_EQ(0,
@@ -225,12 +225,12 @@
// 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(OkStatus(), encoded.status());
ASSERT_EQ(kNoPayloadPacketSize, encoded.value().size());
method.Invoke(context.get(), context.packet({}));
- EXPECT_EQ(Status::Ok(), last_writer.Write({})); // Barely fits
+ EXPECT_EQ(OkStatus(), last_writer.Write({})); // Barely fits
EXPECT_EQ(Status::Internal(), last_writer.Write({.value = 1})); // Too big
}
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 127c712..7e64895 100644
--- a/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
+++ b/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
@@ -25,7 +25,7 @@
const pw_rpc_EchoMessage& request,
pw_rpc_EchoMessage& response) {
std::strncpy(response.msg, request.msg, sizeof(response.msg));
- return Status::Ok();
+ return OkStatus();
}
};
diff --git a/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h b/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h
index 08572e6..ba2e482 100644
--- a/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h
+++ b/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h
@@ -36,7 +36,7 @@
// struct can be accessed via context.response().
//
// PW_NANOPB_TEST_METHOD_CONTEXT(my::CoolService, TheMethod) context;
-// EXPECT_EQ(Status::Ok(), context.call({.some_arg = 123}));
+// EXPECT_EQ(OkStatus(), context.call({.some_arg = 123}));
// EXPECT_EQ(500, context.response().some_response_value);
//
// For a server streaming RPC, context.call(request) invokes the method. As in a
@@ -47,7 +47,7 @@
// context.call({.some_arg = 123});
//
// EXPECT_TRUE(context.done()); // Check that the RPC completed
-// EXPECT_EQ(Status::Ok(), context.status()); // Check the status
+// EXPECT_EQ(OkStatus(), context.status()); // Check the status
//
// EXPECT_EQ(3u, context.responses().size());
// EXPECT_EQ(123, context.responses()[0].value); // check individual responses
@@ -278,7 +278,7 @@
PW_ASSERT(buffer.data() == buffer_.data());
if (buffer.empty()) {
- return Status::Ok();
+ return OkStatus();
}
Result<internal::Packet> result = internal::Packet::FromBuffer(buffer);
@@ -301,7 +301,7 @@
default:
PW_CRASH("Unhandled PacketType");
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace internal::test::nanopb
diff --git a/pw_rpc/packet_test.cc b/pw_rpc/packet_test.cc
index 9f6d7ea..534fb87 100644
--- a/pw_rpc/packet_test.cc
+++ b/pw_rpc/packet_test.cc
@@ -76,7 +76,7 @@
Packet packet(PacketType::RESPONSE, 1, 42, 100, kPayload);
auto result = packet.Encode(buffer);
- ASSERT_EQ(Status::Ok(), result.status());
+ ASSERT_EQ(OkStatus(), result.status());
ASSERT_EQ(kEncoded.size(), result.value().size());
EXPECT_EQ(std::memcmp(kEncoded.data(), buffer, kEncoded.size()), 0);
}
@@ -122,7 +122,7 @@
byte buffer[128];
Result result = packet.Encode(buffer);
- ASSERT_EQ(result.status(), Status::Ok());
+ ASSERT_EQ(result.status(), OkStatus());
std::span<byte> packet_data(buffer, result.value().size());
auto decode_result = Packet::FromBuffer(packet_data);
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 d47c3dc..67bf7aa 100644
--- a/pw_rpc/public/pw_rpc/internal/base_server_writer.h
+++ b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
@@ -59,7 +59,7 @@
uint32_t method_id() const;
// Closes the ServerWriter, if it is open.
- void Finish(Status status = Status::Ok());
+ void Finish(Status status = OkStatus());
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 c67d86a..9eb58a1 100644
--- a/pw_rpc/public/pw_rpc/internal/packet.h
+++ b/pw_rpc/public/pw_rpc/internal/packet.h
@@ -34,7 +34,7 @@
// Creates an RPC packet with the channel, service, and method ID of the
// provided packet.
static constexpr Packet Response(const Packet& request,
- Status status = Status::Ok()) {
+ Status status = OkStatus()) {
return Packet(PacketType::RESPONSE,
request.channel_id(),
request.service_id(),
@@ -74,7 +74,7 @@
uint32_t service_id,
uint32_t method_id,
ConstByteSpan payload = {},
- Status status = Status::Ok())
+ Status status = OkStatus())
: 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 cf1899e..f9b227d 100644
--- a/pw_rpc/pw_rpc_private/internal_test_utils.h
+++ b/pw_rpc/pw_rpc_private/internal_test_utils.h
@@ -42,7 +42,7 @@
Status SendAndReleaseBuffer(std::span<const std::byte> buffer) override {
if (buffer.empty()) {
- return Status::Ok();
+ return OkStatus();
}
PW_ASSERT(buffer.data() == buffer_.data());
@@ -50,7 +50,7 @@
packet_count_ += 1;
sent_data_ = buffer;
Result<internal::Packet> result = internal::Packet::FromBuffer(sent_data_);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
sent_packet_ = result.value_or(internal::Packet());
return send_status_;
}
@@ -108,7 +108,7 @@
kServiceId,
context_.method().id(),
payload,
- Status::Ok());
+ OkStatus());
}
internal::ServerCall& get() { return context_; }
@@ -146,13 +146,13 @@
// Sends a packet to be processed by the client. Returns the client's
// ProcessPacket status.
Status SendPacket(internal::PacketType type,
- Status status = Status::Ok(),
+ Status status = OkStatus(),
std::span<const std::byte> payload = {}) {
internal::Packet packet(
type, kChannelId, kServiceId, kMethodId, payload, status);
std::byte buffer[input_buffer_size];
Result result = packet.Encode(buffer);
- EXPECT_EQ(result.status(), Status::Ok());
+ EXPECT_EQ(result.status(), OkStatus());
return client_.ProcessPacket(result.value_or(ConstByteSpan()));
}
diff --git a/pw_rpc/raw/codegen_test.cc b/pw_rpc/raw/codegen_test.cc
index 722c5de..57e82bd 100644
--- a/pw_rpc/raw/codegen_test.cc
+++ b/pw_rpc/raw/codegen_test.cc
@@ -95,10 +95,10 @@
protobuf::NestedEncoder encoder(buffer);
test::TestRequest::Encoder test_request(&encoder);
test_request.WriteInteger(123);
- test_request.WriteStatusCode(Status::Ok().code());
+ test_request.WriteStatusCode(OkStatus().code());
auto sws = context.call(encoder.Encode().value());
- EXPECT_EQ(Status::Ok(), sws.status());
+ EXPECT_EQ(OkStatus(), sws.status());
protobuf::Decoder decoder(context.response());
diff --git a/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h b/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h
index 5e13a95..9a4f399 100644
--- a/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h
+++ b/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h
@@ -35,7 +35,7 @@
// struct can be accessed via context.response().
//
// PW_RAW_TEST_METHOD_CONTEXT(my::CoolService, TheMethod) context;
-// EXPECT_EQ(Status::Ok(), context.call(encoded_request).status());
+// EXPECT_EQ(OkStatus(), context.call(encoded_request).status());
// EXPECT_EQ(0,
// std::memcmp(encoded_response,
// context.response().data(),
@@ -49,7 +49,7 @@
// context.call(encoded_response);
//
// EXPECT_TRUE(context.done()); // Check that the RPC completed
-// EXPECT_EQ(Status::Ok(), context.status()); // Check the status
+// EXPECT_EQ(OkStatus(), context.status()); // Check the status
//
// EXPECT_EQ(3u, context.responses().size());
// ByteSpan& response = context.responses()[0]; // check individual responses
@@ -273,7 +273,7 @@
PW_ASSERT(buffer.data() == packet_buffer_.data());
if (buffer.empty()) {
- return Status::Ok();
+ return OkStatus();
}
Result<internal::Packet> result = internal::Packet::FromBuffer(buffer);
@@ -299,7 +299,7 @@
default:
PW_CRASH("Unhandled PacketType");
}
- return Status::Ok();
+ return OkStatus();
}
} // namespace internal::test::raw
diff --git a/pw_rpc/raw/raw_method_test.cc b/pw_rpc/raw/raw_method_test.cc
index 0008222..c72dcfe 100644
--- a/pw_rpc/raw/raw_method_test.cc
+++ b/pw_rpc/raw/raw_method_test.cc
@@ -143,7 +143,7 @@
protobuf::Decoder decoder(response.payload());
ASSERT_TRUE(decoder.Next().ok());
int64_t value;
- EXPECT_EQ(decoder.ReadInt64(&value), Status::Ok());
+ EXPECT_EQ(decoder.ReadInt64(&value), OkStatus());
EXPECT_EQ(value, 461);
}
@@ -177,7 +177,7 @@
constexpr auto data = bytes::Array<0x0d, 0x06, 0xf0, 0x0d>();
std::memcpy(buffer.data(), data.data(), data.size());
- EXPECT_EQ(last_writer.Write(buffer.first(data.size())), Status::Ok());
+ EXPECT_EQ(last_writer.Write(buffer.first(data.size())), OkStatus());
const internal::Packet& packet = context.output().sent_packet();
EXPECT_EQ(packet.type(), internal::PacketType::RESPONSE);
@@ -185,7 +185,7 @@
EXPECT_EQ(packet.service_id(), context.kServiceId);
EXPECT_EQ(packet.method_id(), context.get().method().id());
EXPECT_EQ(std::memcmp(packet.payload().data(), data.data(), data.size()), 0);
- EXPECT_EQ(packet.status(), Status::Ok());
+ EXPECT_EQ(packet.status(), OkStatus());
}
TEST(RawServerWriter, Write_SendsExternalBuffer) {
@@ -195,7 +195,7 @@
method.Invoke(context.get(), context.packet({}));
constexpr auto data = bytes::Array<0x0d, 0x06, 0xf0, 0x0d>();
- EXPECT_EQ(last_writer.Write(data), Status::Ok());
+ EXPECT_EQ(last_writer.Write(data), OkStatus());
const internal::Packet& packet = context.output().sent_packet();
EXPECT_EQ(packet.type(), internal::PacketType::RESPONSE);
@@ -203,7 +203,7 @@
EXPECT_EQ(packet.service_id(), context.kServiceId);
EXPECT_EQ(packet.method_id(), context.get().method().id());
EXPECT_EQ(std::memcmp(packet.payload().data(), data.data(), data.size()), 0);
- EXPECT_EQ(packet.status(), Status::Ok());
+ EXPECT_EQ(packet.status(), OkStatus());
}
TEST(RawServerWriter, Write_Closed_ReturnsFailedPrecondition) {
diff --git a/pw_rpc/raw/raw_method_union_test.cc b/pw_rpc/raw/raw_method_union_test.cc
index 77cfd5d..0a67d65 100644
--- a/pw_rpc/raw/raw_method_union_test.cc
+++ b/pw_rpc/raw/raw_method_union_test.cc
@@ -118,7 +118,7 @@
protobuf::Decoder decoder(response.payload());
ASSERT_TRUE(decoder.Next().ok());
int64_t value;
- EXPECT_EQ(decoder.ReadInt64(&value), Status::Ok());
+ EXPECT_EQ(decoder.ReadInt64(&value), OkStatus());
EXPECT_EQ(value, 461);
}
diff --git a/pw_rpc/server.cc b/pw_rpc/server.cc
index 845a64f..59da7d2 100644
--- a/pw_rpc/server.cc
+++ b/pw_rpc/server.cc
@@ -86,7 +86,7 @@
internal::Channel temp_channel(packet.channel_id(), &interface);
temp_channel.Send(
Packet::ServerError(packet, Status::ResourceExhausted()));
- return Status::Ok(); // OK since the packet was handled
+ return OkStatus(); // OK since the packet was handled
}
}
@@ -94,7 +94,7 @@
if (method == nullptr) {
channel->Send(Packet::ServerError(packet, Status::NotFound()));
- return Status::Ok();
+ return OkStatus();
}
switch (packet.type()) {
@@ -118,7 +118,7 @@
PW_LOG_WARN("Unable to handle packet of type %u",
unsigned(packet.type()));
}
- return Status::Ok();
+ return OkStatus();
}
std::tuple<Service*, const internal::Method*> Server::FindMethod(
diff --git a/pw_rpc/server_test.cc b/pw_rpc/server_test.cc
index e109edf..685e4fc 100644
--- a/pw_rpc/server_test.cc
+++ b/pw_rpc/server_test.cc
@@ -82,7 +82,7 @@
std::span<const byte> payload = kDefaultPayload) {
auto result = Packet(type, channel_id, service_id, method_id, payload)
.Encode(request_buffer_);
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
return result.value_or(ConstByteSpan());
}
@@ -96,7 +96,7 @@
};
TEST_F(BasicServer, ProcessPacket_ValidMethod_InvokesMethod) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, 1, 42, 100), output_));
@@ -151,7 +151,7 @@
}
TEST_F(BasicServer, ProcessPacket_InvalidMethod_NothingIsInvoked) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, 1, 42, 101), output_));
@@ -160,7 +160,7 @@
}
TEST_F(BasicServer, ProcessPacket_InvalidMethod_SendsError) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 27),
output_));
@@ -173,7 +173,7 @@
}
TEST_F(BasicServer, ProcessPacket_InvalidService_SendsError) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 43, 27),
output_));
@@ -187,7 +187,7 @@
TEST_F(BasicServer, ProcessPacket_UnassignedChannel_AssignsToAvailableSlot) {
TestOutput<128> unassigned_output;
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 100),
unassigned_output));
@@ -198,7 +198,7 @@
ProcessPacket_UnassignedChannel_SendsResourceExhaustedIfCannotAssign) {
channels_[2] = Channel::Create<3>(&output_); // Occupy only available channel
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 27),
output_));
@@ -212,7 +212,7 @@
TEST_F(BasicServer, ProcessPacket_Cancel_MethodNotActive_SendsError) {
// Set up a fake ServerWriter representing an ongoing RPC.
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
output_));
@@ -241,7 +241,7 @@
};
TEST_F(MethodPending, ProcessPacket_Cancel_ClosesServerWriter) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
output_));
@@ -250,7 +250,7 @@
}
TEST_F(MethodPending, ProcessPacket_Cancel_SendsStreamEndPacket) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
output_));
@@ -266,7 +266,7 @@
TEST_F(MethodPending,
ProcessPacket_ClientError_ClosesServerWriterWithoutStreamEnd) {
- EXPECT_EQ(Status::OK,
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::CLIENT_ERROR, 1, 42, 100), output_));
@@ -275,7 +275,7 @@
}
TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectChannel) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 2, 42, 100),
output_));
@@ -286,7 +286,7 @@
}
TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectService) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 43, 100),
output_));
@@ -299,7 +299,7 @@
}
TEST_F(MethodPending, ProcessPacket_CancelIncorrectMethod) {
- EXPECT_EQ(Status::Ok(),
+ EXPECT_EQ(OkStatus(),
server_.ProcessPacket(
EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 101),
output_));
diff --git a/pw_status/public/pw_status/status.h b/pw_status/public/pw_status/status.h
index f9227d7..e142699 100644
--- a/pw_status/public/pw_status/status.h
+++ b/pw_status/public/pw_status/status.h
@@ -248,7 +248,7 @@
// Functions that create a Status with the specified code.
// clang-format off
- [[nodiscard]] static constexpr Status Ok() {
+ [[deprecated("Use pw::StatusOk()"), nodiscard]] static constexpr Status Ok() {
return PW_STATUS_OK;
}
[[nodiscard]] static constexpr Status Cancelled() {
diff --git a/pw_status/public/pw_status/status_with_size.h b/pw_status/public/pw_status/status_with_size.h
index 895ab99..e305995 100644
--- a/pw_status/public/pw_status/status_with_size.h
+++ b/pw_status/public/pw_status/status_with_size.h
@@ -100,7 +100,9 @@
// Functions that create a StatusWithSize with the specified status code. For
// codes other than OK, the size defaults to 0.
- static constexpr StatusWithSize Ok(size_t size) {
+ [[deprecated(
+ "Use the StatusWithSize constructor")]] static constexpr StatusWithSize
+ Ok(size_t size) {
return StatusWithSize(size);
}
static constexpr StatusWithSize Cancelled(size_t size = 0) {
@@ -152,10 +154,10 @@
return StatusWithSize(Status::DataLoss(), size);
}
- // Creates a StatusWithSize with Status::Ok() and a size of 0.
+ // Creates a StatusWithSize with OkStatus() and a size of 0.
explicit constexpr StatusWithSize() : size_(0) {}
- // Creates a StatusWithSize with Status::Ok() and the provided size.
+ // Creates a StatusWithSize with status OK and the provided size.
// std::enable_if is used to prevent enum types (e.g. Status) from being used.
// TODO(hepler): Add debug-only assert that size <= max_size().
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
@@ -178,7 +180,7 @@
// The maximum valid value for size.
static constexpr size_t max_size() { return kSizeMask; }
- // True if status() == Status::Ok().
+ // True if status() == OkStatus().
constexpr bool ok() const { return (size_ & kStatusMask) == 0u; }
constexpr Status status() const {
diff --git a/pw_status/status_test.cc b/pw_status/status_test.cc
index eb45758..f6ca551 100644
--- a/pw_status/status_test.cc
+++ b/pw_status/status_test.cc
@@ -178,7 +178,7 @@
TEST(Status, DeprecatedAliases) {
// TODO(pwbug/268): Remove this test after migrating from these aliases.
- static_assert(PW_STATUS_OK == Status::OK);
+ static_assert(PW_STATUS_OK == OkStatus());
static_assert(PW_STATUS_CANCELLED == Status::CANCELLED);
static_assert(PW_STATUS_UNKNOWN == Status::UNKNOWN);
static_assert(PW_STATUS_INVALID_ARGUMENT == Status::INVALID_ARGUMENT);
diff --git a/pw_status/status_with_size_test.cc b/pw_status/status_with_size_test.cc
index ef0f1cf..44d6c5a 100644
--- a/pw_status/status_with_size_test.cc
+++ b/pw_status/status_with_size_test.cc
@@ -26,14 +26,14 @@
TEST(StatusWithSize, Default) {
StatusWithSize result;
EXPECT_TRUE(result.ok());
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(Status(), result.status());
EXPECT_EQ(0u, result.size());
}
TEST(StatusWithSize, ConstructWithSize) {
StatusWithSize result = StatusWithSize(456);
EXPECT_TRUE(result.ok());
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(Status(), result.status());
EXPECT_EQ(456u, result.size());
}
@@ -45,9 +45,9 @@
}
TEST(StatusWithSize, ConstructWithOkAndSize) {
- StatusWithSize result(Status::Ok(), 99);
+ StatusWithSize result(Status(), 99);
EXPECT_TRUE(result.ok());
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(Status(), result.status());
EXPECT_EQ(99u, result.size());
}
@@ -99,7 +99,7 @@
result = StatusWithSize(300);
EXPECT_TRUE(result.ok());
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(Status(), result.status());
EXPECT_EQ(300u, result.size());
}
@@ -112,7 +112,7 @@
TEST(StatusWithSize, Functions_Status) {
// clang-format off
- static_assert(StatusWithSize::Ok(0).status() == Status::Ok());
+ static_assert(StatusWithSize(0).status() == Status());
static_assert(StatusWithSize::Cancelled().status() == Status::Cancelled());
static_assert(StatusWithSize::Unknown().status() == Status::Unknown());
static_assert(StatusWithSize::InvalidArgument().status() == Status::InvalidArgument());
@@ -130,7 +130,7 @@
static_assert(StatusWithSize::Unavailable().status() == Status::Unavailable());
static_assert(StatusWithSize::DataLoss().status() == Status::DataLoss());
- static_assert(StatusWithSize::Ok(123).status() == Status::Ok());
+ static_assert(StatusWithSize(123).status() == Status());
static_assert(StatusWithSize::Cancelled(123).status() == Status::Cancelled());
static_assert(StatusWithSize::Unknown(123).status() == Status::Unknown());
static_assert(StatusWithSize::InvalidArgument(123).status() == Status::InvalidArgument());
@@ -170,7 +170,7 @@
}
TEST(StatusWithSize, Functions_SpecifiedSize) {
- static_assert(StatusWithSize::Ok(123).size() == 123u);
+ static_assert(StatusWithSize(123).size() == 123u);
static_assert(StatusWithSize::Cancelled(123).size() == 123u);
static_assert(StatusWithSize::Unknown(123).size() == 123u);
static_assert(StatusWithSize::InvalidArgument(123).size() == 123u);
@@ -209,22 +209,22 @@
}
TEST(StatusWithSize, IsNotError) {
- static_assert(!StatusWithSize::Ok(0).IsCancelled());
- static_assert(!StatusWithSize::Ok(0).IsUnknown());
- static_assert(!StatusWithSize::Ok(0).IsInvalidArgument());
- static_assert(!StatusWithSize::Ok(0).IsDeadlineExceeded());
- static_assert(!StatusWithSize::Ok(0).IsNotFound());
- static_assert(!StatusWithSize::Ok(0).IsAlreadyExists());
- static_assert(!StatusWithSize::Ok(0).IsPermissionDenied());
- static_assert(!StatusWithSize::Ok(0).IsUnauthenticated());
- static_assert(!StatusWithSize::Ok(0).IsResourceExhausted());
- static_assert(!StatusWithSize::Ok(0).IsFailedPrecondition());
- static_assert(!StatusWithSize::Ok(0).IsAborted());
- static_assert(!StatusWithSize::Ok(0).IsOutOfRange());
- static_assert(!StatusWithSize::Ok(0).IsUnimplemented());
- static_assert(!StatusWithSize::Ok(0).IsInternal());
- static_assert(!StatusWithSize::Ok(0).IsUnavailable());
- static_assert(!StatusWithSize::Ok(0).IsDataLoss());
+ static_assert(!StatusWithSize(0).IsCancelled());
+ static_assert(!StatusWithSize(0).IsUnknown());
+ static_assert(!StatusWithSize(0).IsInvalidArgument());
+ static_assert(!StatusWithSize(0).IsDeadlineExceeded());
+ static_assert(!StatusWithSize(0).IsNotFound());
+ static_assert(!StatusWithSize(0).IsAlreadyExists());
+ static_assert(!StatusWithSize(0).IsPermissionDenied());
+ static_assert(!StatusWithSize(0).IsUnauthenticated());
+ static_assert(!StatusWithSize(0).IsResourceExhausted());
+ static_assert(!StatusWithSize(0).IsFailedPrecondition());
+ static_assert(!StatusWithSize(0).IsAborted());
+ static_assert(!StatusWithSize(0).IsOutOfRange());
+ static_assert(!StatusWithSize(0).IsUnimplemented());
+ static_assert(!StatusWithSize(0).IsInternal());
+ static_assert(!StatusWithSize(0).IsUnavailable());
+ static_assert(!StatusWithSize(0).IsDataLoss());
}
} // namespace
} // namespace pw
diff --git a/pw_status/try_test.cc b/pw_status/try_test.cc
index b84258b..a69cd95 100644
--- a/pw_status/try_test.cc
+++ b/pw_status/try_test.cc
@@ -26,7 +26,7 @@
PW_TRY(ReturnStatus(status));
// Any status other than OK should have already returned.
- EXPECT_EQ(status, Status::Ok());
+ EXPECT_EQ(status, OkStatus());
return status;
}
@@ -34,12 +34,12 @@
PW_TRY(ReturnStatusWithSize(status));
// Any status other than OK should have already returned.
- EXPECT_EQ(status.status(), Status::Ok());
+ EXPECT_EQ(status.status(), OkStatus());
return status.status();
}
TEST(Status, Try_Status) {
- EXPECT_EQ(TryStatus(Status::Ok()), Status::Ok());
+ EXPECT_EQ(TryStatus(OkStatus()), OkStatus());
// Don't need all the status types, just pick a few not-ok ones.
EXPECT_EQ(TryStatus(Status::Cancelled()), Status::Cancelled());
@@ -49,8 +49,8 @@
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(OkStatus(), 0);
+ EXPECT_EQ(TryStatus(val), OkStatus());
}
}
@@ -73,7 +73,7 @@
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(), OkStatus());
EXPECT_EQ(size_val, status.size());
return status.status();
}
@@ -82,8 +82,8 @@
size_t size_val = 0;
for (size_t i = 1; i < 32; ++i) {
- StatusWithSize val(Status::Ok(), i);
- EXPECT_EQ(TryStatusAssign(size_val, val), Status::Ok());
+ StatusWithSize val(OkStatus(), i);
+ EXPECT_EQ(TryStatusAssign(size_val, val), OkStatus());
EXPECT_EQ(size_val, i);
}
}
@@ -110,15 +110,15 @@
PW_TRY_WITH_SIZE(ReturnStatus(status));
// Any status other than OK should have already returned.
- EXPECT_EQ(status, Status::Ok());
+ EXPECT_EQ(status, OkStatus());
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(OkStatus());
+ EXPECT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.size(), 0u);
}
@@ -130,8 +130,8 @@
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(OkStatus(), i);
+ EXPECT_EQ(TryStatusWithSize(val).status(), OkStatus());
EXPECT_EQ(TryStatusWithSize(val).size(), i);
}
}
diff --git a/pw_stream/memory_stream.cc b/pw_stream/memory_stream.cc
index 8f7e29e..0a44810 100644
--- a/pw_stream/memory_stream.cc
+++ b/pw_stream/memory_stream.cc
@@ -33,7 +33,7 @@
std::memcpy(dest_.data() + bytes_written_, data.data(), bytes_to_write);
bytes_written_ += bytes_to_write;
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize MemoryReader::DoRead(ByteSpan dest) {
diff --git a/pw_stream/memory_stream_test.cc b/pw_stream/memory_stream_test.cc
index 51c9a38..b4a1395 100644
--- a/pw_stream/memory_stream_test.cc
+++ b/pw_stream/memory_stream_test.cc
@@ -38,7 +38,7 @@
EXPECT_EQ(memory_writer.bytes_written(), 0u);
Status status =
memory_writer.Write(&kExpectedStruct, sizeof(kExpectedStruct));
- EXPECT_EQ(status, Status::Ok());
+ EXPECT_EQ(status, OkStatus());
EXPECT_EQ(memory_writer.bytes_written(), sizeof(kExpectedStruct));
} // namespace
@@ -68,7 +68,7 @@
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)), OkStatus());
}
EXPECT_GT(memory_writer.ConservativeWriteLimit(), 0u);
@@ -99,7 +99,7 @@
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());
+ OkStatus());
}
EXPECT_EQ(memory_writer.ConservativeWriteLimit(), 0u);
@@ -116,7 +116,7 @@
std::byte buffer[5] = {};
MemoryWriter memory_writer(memory_buffer);
- EXPECT_EQ(memory_writer.Write(buffer, 0), Status::Ok());
+ EXPECT_EQ(memory_writer.Write(buffer, 0), OkStatus());
EXPECT_EQ(memory_writer.bytes_written(), 0u);
}
@@ -171,7 +171,7 @@
// Read exactly the available bytes.
EXPECT_EQ(memory_reader.ConservativeReadLimit(), dest.size());
Result<ByteSpan> result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::Ok());
+ EXPECT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size_bytes(), dest.size());
ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -197,7 +197,7 @@
// Read exactly the available bytes.
Result<ByteSpan> result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::Ok());
+ EXPECT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size_bytes(), 0u);
EXPECT_EQ(result.value().data(), dest.data());
@@ -220,7 +220,7 @@
// Try and read double the bytes available. Use the pointer/size version of
// the API.
Result<ByteSpan> result = memory_reader.Read(dest.data(), dest.size());
- EXPECT_EQ(result.status(), Status::Ok());
+ EXPECT_EQ(result.status(), OkStatus());
EXPECT_EQ(result.value().size_bytes(), source.size());
ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -255,7 +255,7 @@
// Try and read a chunk of bytes.
Result<ByteSpan> result = memory_reader.Read(dest);
- EXPECT_EQ(result.status(), Status::Ok());
+ EXPECT_EQ(result.status(), OkStatus());
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/null_stream.h b/pw_stream/public/pw_stream/null_stream.h
index eda1209..b3db9c5 100644
--- a/pw_stream/public/pw_stream/null_stream.h
+++ b/pw_stream/public/pw_stream/null_stream.h
@@ -26,7 +26,7 @@
// Stream writer which quietly drops all of the data, similar to /dev/null.
class NullWriter final : public Writer {
private:
- Status DoWrite(ConstByteSpan) final { return Status::Ok(); }
+ Status DoWrite(ConstByteSpan) final { return OkStatus(); }
};
// Stream reader which never reads any bytes. Always returns OUT_OF_RANGE, which
diff --git a/pw_stream/public/pw_stream/stream.h b/pw_stream/public/pw_stream/stream.h
index 9bbb069..2fcde9c 100644
--- a/pw_stream/public/pw_stream/stream.h
+++ b/pw_stream/public/pw_stream/stream.h
@@ -74,7 +74,7 @@
// 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().
+ // OkStatus().
//
// Returns std::numeric_limits<size_t>::max() if the implementation has no
// limits on write sizes.
@@ -132,7 +132,7 @@
// 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().
+ // OkStatus().
//
// Returns std::numeric_limits<size_t>::max() if the implementation imposes no
// limits on read sizes.
diff --git a/pw_stream/socket_stream.cc b/pw_stream/socket_stream.cc
index 1146797..5599307 100644
--- a/pw_stream/socket_stream.cc
+++ b/pw_stream/socket_stream.cc
@@ -48,7 +48,7 @@
if (conn_fd_ < 0) {
return Status::Internal();
}
- return Status::Ok();
+ return OkStatus();
}
Status SocketStream::DoWrite(std::span<const std::byte> data) {
@@ -57,7 +57,7 @@
if (bytes_sent < 0 || static_cast<uint64_t>(bytes_sent) != data.size()) {
return Status::Internal();
}
- return Status::Ok();
+ return OkStatus();
}
StatusWithSize SocketStream::DoRead(ByteSpan dest) {
@@ -65,7 +65,7 @@
if (bytes_rcvd < 0) {
return StatusWithSize::Internal();
}
- return StatusWithSize::Ok(bytes_rcvd);
+ return StatusWithSize(bytes_rcvd);
}
-}; // namespace pw::stream
\ No newline at end of file
+}; // namespace pw::stream
diff --git a/pw_string/format_test.cc b/pw_string/format_test.cc
index b7aab52..9aef419 100644
--- a/pw_string/format_test.cc
+++ b/pw_string/format_test.cc
@@ -26,7 +26,7 @@
char buffer[32];
auto result = Format(buffer, "-_-");
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(3u, result.size());
EXPECT_STREQ("-_-", buffer);
}
@@ -35,7 +35,7 @@
char buffer[32];
auto result = Format(buffer, "%d4%s", 123, "5");
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_EQ(5u, result.size());
EXPECT_STREQ("12345", buffer);
}
@@ -81,7 +81,7 @@
char buffer[8];
auto result = CallFormatWithVaList(buffer, "Yo%s", "?!");
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), 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 f3aa337..9499eb2 100644
--- a/pw_string/public/pw_string/format.h
+++ b/pw_string/public/pw_string/format.h
@@ -35,7 +35,7 @@
//
// The status is
//
-// Status::Ok() if the operation succeeded,
+// OkStatus() if the operation succeeded,
// Status::ResourceExhausted() if the buffer was too small to fit the output,
// Status::InvalidArgument() if there was a formatting error.
//
diff --git a/pw_string/public/pw_string/string_builder.h b/pw_string/public/pw_string/string_builder.h
index 425fbfb..7d2c5a4 100644
--- a/pw_string/public/pw_string/string_builder.h
+++ b/pw_string/public/pw_string/string_builder.h
@@ -135,7 +135,7 @@
// The status from the last operation. May be OK while status() is not OK.
Status last_status() const { return last_status_; }
- // True if status() is Status::Ok().
+ // True if status() is OkStatus().
bool ok() const { return status_.ok(); }
// True if the string is empty.
@@ -150,10 +150,10 @@
// Clears the string and resets its error state.
void clear();
- // Sets the statuses to Status::Ok();
+ // Sets the statuses to OkStatus();
void clear_status() {
- status_ = Status::Ok();
- last_status_ = Status::Ok();
+ status_ = OkStatus();
+ last_status_ = OkStatus();
}
// 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 1bc3b1f..60879a9 100644
--- a/pw_string/string_builder.cc
+++ b/pw_string/string_builder.cc
@@ -24,8 +24,8 @@
void StringBuilder::clear() {
size_ = 0;
NullTerminate();
- status_ = Status::Ok();
- last_status_ = Status::Ok();
+ status_ = OkStatus();
+ last_status_ = OkStatus();
}
StringBuilder& StringBuilder::append(size_t count, char ch) {
@@ -70,7 +70,7 @@
if (buffer_.empty() || chars_to_append != copied) {
SetErrorStatus(Status::ResourceExhausted());
} else {
- last_status_ = Status::Ok();
+ last_status_ = OkStatus();
}
return copied;
}
@@ -79,7 +79,7 @@
if (new_size <= size_) {
size_ = new_size;
NullTerminate();
- last_status_ = Status::Ok();
+ last_status_ = OkStatus();
} else {
SetErrorStatus(Status::OutOfRange());
}
diff --git a/pw_string/string_builder_test.cc b/pw_string/string_builder_test.cc
index cfef0e7..22378cc 100644
--- a/pw_string/string_builder_test.cc
+++ b/pw_string/string_builder_test.cc
@@ -102,8 +102,8 @@
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(OkStatus(), sb.last_status());
+ EXPECT_EQ(OkStatus(), sb.status());
sb << "";
@@ -113,8 +113,8 @@
TEST(StringBuilder, Status_StartsOk) {
StringBuffer<16> sb;
- EXPECT_EQ(Status::Ok(), sb.status());
- EXPECT_EQ(Status::Ok(), sb.last_status());
+ EXPECT_EQ(OkStatus(), sb.status());
+ EXPECT_EQ(OkStatus(), sb.last_status());
}
TEST(StringBuilder, Status_StatusAndLastStatusUpdate) {
@@ -129,7 +129,7 @@
sb << "";
EXPECT_EQ(Status::OutOfRange(), sb.status());
- EXPECT_EQ(Status::Ok(), sb.last_status());
+ EXPECT_EQ(OkStatus(), sb.last_status());
}
TEST(StringBuilder, Status_ClearStatus_SetsStatuesToOk) {
@@ -138,8 +138,8 @@
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(OkStatus(), sb.status());
+ EXPECT_EQ(OkStatus(), sb.last_status());
}
TEST(StringBuilder, StreamOutput_OutputSelf) {
@@ -153,7 +153,7 @@
TEST(StringBuilder, PushBack) {
StringBuffer<12> sb;
sb.push_back('?');
- EXPECT_EQ(Status::Ok(), sb.last_status());
+ EXPECT_EQ(OkStatus(), sb.last_status());
EXPECT_EQ(1u, sb.size());
EXPECT_STREQ("?", sb.data());
}
@@ -168,7 +168,7 @@
TEST(StringBuilder, PopBack) {
auto sb = MakeString<12>("Welcome!");
sb.pop_back();
- EXPECT_EQ(Status::Ok(), sb.last_status());
+ EXPECT_EQ(OkStatus(), sb.last_status());
EXPECT_EQ(7u, sb.size());
EXPECT_STREQ("Welcome", sb.data());
}
@@ -362,7 +362,7 @@
constexpr std::string_view hello("hello");
buffer << hello;
- EXPECT_EQ(Status::Ok(), buffer.status());
+ EXPECT_EQ(OkStatus(), buffer.status());
EXPECT_STREQ("hello", buffer.data());
}
@@ -422,7 +422,7 @@
two << "";
ASSERT_STREQ("What heck", two.data());
ASSERT_EQ(Status::ResourceExhausted(), two.status());
- ASSERT_EQ(Status::Ok(), two.last_status());
+ ASSERT_EQ(OkStatus(), two.last_status());
}
TEST(StringBuffer, CopyConstructFromSmaller) {
diff --git a/pw_string/to_string_test.cc b/pw_string/to_string_test.cc
index 2f3608d..347010a 100644
--- a/pw_string/to_string_test.cc
+++ b/pw_string/to_string_test.cc
@@ -101,7 +101,7 @@
auto result = ToString(MyEnum::kLuckyNumber, buffer);
EXPECT_EQ(1u, result.size());
- EXPECT_EQ(Status::Ok(), result.status());
+ EXPECT_EQ(OkStatus(), result.status());
EXPECT_STREQ("8", buffer);
}
diff --git a/pw_string/type_to_string.cc b/pw_string/type_to_string.cc
index 483d10e..4872504 100644
--- a/pw_string/type_to_string.cc
+++ b/pw_string/type_to_string.cc
@@ -190,7 +190,7 @@
buffer[copied] = '\0';
return StatusWithSize(
- copied == value.size() ? Status::Ok() : Status::ResourceExhausted(),
+ copied == value.size() ? OkStatus() : Status::ResourceExhausted(),
copied);
}
diff --git a/pw_sys_io/docs.rst b/pw_sys_io/docs.rst
index cde6a3c..3a1a6c4 100644
--- a/pw_sys_io/docs.rst
+++ b/pw_sys_io/docs.rst
@@ -10,7 +10,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
+``OkStatus()`` 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
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 477c719..f93e64a 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
+// OkStatus() 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,14 +51,14 @@
// This function will block until it either succeeds or fails to read a byte
// from the pw_sys_io backend.
//
-// Returns Status::Ok() - A byte was successfully read.
+// Returns OkStatus() - A byte was successfully read.
// Status::ResourceExhausted() - if the underlying source vanished.
Status ReadByte(std::byte* dest);
// Read a single byte from the sys io backend, if available.
// Implemented by: Backend
//
-// Returns Status::Ok() - A byte was successfully read, and is in dest.
+// Returns OkStatus() - A byte was successfully read, and is in dest.
// Status::Unavailable() - No byte is available to read; try later.
// Status::Unimplemented() - Not supported on this target.
Status TryReadByte(std::byte* dest);
@@ -69,7 +69,7 @@
// This function will block until it either succeeds or fails to write a byte
// out the pw_sys_io backend.
//
-// Returns Status::Ok() if a byte was successfully read.
+// Returns OkStatus() if a byte was successfully read.
Status WriteByte(std::byte b);
// Write a string out the sys io backend.
@@ -79,7 +79,7 @@
// backend, adding any platform-specific newline character(s) (these are
// accounted for in the returned StatusWithSize).
//
-// Return status is Status::Ok() if all the bytes from the source string were
+// Return status is OkStatus() 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);
@@ -93,7 +93,7 @@
// 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
+// Return status is OkStatus() 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);
@@ -107,7 +107,7 @@
// either an error occurs, or all bytes are successfully read from the backend's
// WriteByte() implementation.
//
-// Return status is Status::Ok() if all the bytes from the source span were
+// Return status is OkStatus() 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 fbbc7bc..9e86c73 100644
--- a/pw_sys_io_arduino/sys_io_arduino.cc
+++ b/pw_sys_io_arduino/sys_io_arduino.cc
@@ -31,7 +31,7 @@
Status ReadByte(std::byte* dest) {
while (true) {
if (TryReadByte(dest).ok()) {
- return Status::Ok();
+ return OkStatus();
}
}
}
@@ -41,7 +41,7 @@
return Status::Unavailable();
}
*dest = static_cast<std::byte>(Serial.read());
- return Status::Ok();
+ return OkStatus();
}
// Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -54,7 +54,7 @@
while (Serial.availableForWrite() < 1) {
}
Serial.write((uint8_t)b);
- return Status::Ok();
+ return OkStatus();
}
// 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 86cc341..1c1ccbc 100644
--- a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
@@ -91,7 +91,7 @@
Status ReadByte(std::byte* dest) {
while (true) {
if (TryReadByte(dest).ok()) {
- return Status::Ok();
+ return OkStatus();
}
}
}
@@ -105,7 +105,7 @@
return Status::Unavailable();
}
*dest = static_cast<std::byte>(uart0.data_register);
- return Status::Ok();
+ return OkStatus();
}
// Send a byte over UART0. Since this blocks on every byte, it's rather
@@ -118,7 +118,7 @@
while (!(uart0.status_flags & kTxFifoEmptyMask)) {
}
uart0.data_register = static_cast<uint32_t>(b);
- return Status::Ok();
+ return OkStatus();
}
// 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 846e34c..915fd67 100644
--- a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
@@ -171,7 +171,7 @@
Status ReadByte(std::byte* dest) {
while (true) {
if (TryReadByte(dest).ok()) {
- return Status::Ok();
+ return OkStatus();
}
}
}
@@ -184,7 +184,7 @@
return Status::Unavailable();
}
*dest = static_cast<std::byte>(usart1.data_register);
- return Status::Ok();
+ return OkStatus();
}
// Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -197,7 +197,7 @@
while (!(usart1.status & kTxRegisterEmpty)) {
}
usart1.data_register = static_cast<uint32_t>(b);
- return Status::Ok();
+ return OkStatus();
}
// 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 53c9d5e..333b18f 100644
--- a/pw_sys_io_stdio/sys_io.cc
+++ b/pw_sys_io_stdio/sys_io.cc
@@ -28,7 +28,7 @@
return Status::ResourceExhausted();
}
*dest = static_cast<std::byte>(value);
- return Status::Ok();
+ return OkStatus();
}
Status TryReadByte(std::byte*) {
@@ -40,7 +40,7 @@
if (std::putchar(static_cast<char>(b)) == EOF) {
return Status::Internal();
}
- return Status::Ok();
+ return OkStatus();
}
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 426820c..90d119d 100644
--- a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
+++ b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
@@ -89,7 +89,7 @@
// start, allowing buffers to allocate the required amount at the start when
// necessary.
//
-// If Status::Ok() is not returned from Start, the events bytes will be skipped.
+// If OkStatus() 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/public/pw_trace_tokenized/trace_tokenized.h b/pw_trace_tokenized/public/pw_trace_tokenized/trace_tokenized.h
index a7e5ca4..56516e3 100644
--- a/pw_trace_tokenized/public/pw_trace_tokenized/trace_tokenized.h
+++ b/pw_trace_tokenized/public/pw_trace_tokenized/trace_tokenized.h
@@ -77,7 +77,7 @@
}
head_ = (head_ + 1) % kSize;
is_empty_ = false;
- return pw::Status::OK;
+ return pw::OkStatus();
}
const volatile QueueEventBlock* PeekFront() const {
diff --git a/pw_trace_tokenized/trace_buffer_log.cc b/pw_trace_tokenized/trace_buffer_log.cc
index 3d9e5a6..adaf17a 100644
--- a/pw_trace_tokenized/trace_buffer_log.cc
+++ b/pw_trace_tokenized/trace_buffer_log.cc
@@ -78,7 +78,7 @@
PW_LOG_INFO("[TRACE] data: %s", line_builder.c_str());
}
PW_LOG_INFO("[TRACE] end");
- return pw::Status::Ok();
+ return pw::OkStatus();
}
} // namespace trace
diff --git a/pw_trace_tokenized/trace_buffer_test.cc b/pw_trace_tokenized/trace_buffer_test.cc
index bbe7dc8..410db74f 100644
--- a/pw_trace_tokenized/trace_buffer_test.cc
+++ b/pw_trace_tokenized/trace_buffer_test.cc
@@ -84,7 +84,7 @@
std::byte value[expected_max_bytes_used];
size_t bytes_read = 0;
EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
- pw::Status::Ok());
+ pw::OkStatus());
// read size is minus 1, since doesn't include varint size
EXPECT_GE(bytes_read, expected_min_bytes_used - 1);
@@ -123,8 +123,8 @@
std::byte value[PW_TRACE_BUFFER_MAX_BLOCK_SIZE_BYTES];
size_t bytes_read = 0;
EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
- pw::Status::Ok());
- EXPECT_EQ(buf->PopFront(), pw::Status::Ok());
+ pw::OkStatus());
+ EXPECT_EQ(buf->PopFront(), pw::OkStatus());
EXPECT_EQ(*reinterpret_cast<size_t*>(&value[bytes_read - sizeof(size_t)]),
expected_count);
expected_count++;
diff --git a/pw_trace_tokenized/trace_test.cc b/pw_trace_tokenized/trace_test.cc
index 5e6d2a4..104dce8 100644
--- a/pw_trace_tokenized/trace_test.cc
+++ b/pw_trace_tokenized/trace_test.cc
@@ -578,7 +578,7 @@
constexpr size_t kQueueSize = 5;
pw::trace::internal::TraceQueue<kQueueSize> queue;
for (size_t i = 0; i < kQueueSize; i++) {
- EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::Status::OK);
+ EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::OkStatus());
}
EXPECT_FALSE(queue.IsEmpty());
EXPECT_TRUE(queue.IsFull());
@@ -598,7 +598,7 @@
constexpr size_t kQueueSize = 5;
pw::trace::internal::TraceQueue<kQueueSize> queue;
for (size_t i = 0; i < kQueueSize; i++) {
- EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::Status::OK);
+ EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::OkStatus());
}
EXPECT_FALSE(queue.IsEmpty());
EXPECT_TRUE(queue.IsFull());
