pw_status: Enforce [[nodiscard]] on pw::Status in upstream Pigweed

- Enable the [[nodiscard]] flag for the pw_strict_* toolchains.
- Check unused Status or call IgnoreError() and flag with pwbug/387.

Change-Id: Ibef43c09b29a803bc3be17f81e13639d5f908cb2
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/77561
Reviewed-by: Alexei Frolov <frolv@google.com>
Pigweed-Auto-Submit: Wyatt Hepler <hepler@google.com>
Reviewed-by: Keir Mierle <keir@google.com>
Commit-Queue: Auto-Submit <auto-submit@pigweed.google.com.iam.gserviceaccount.com>

23 files changed, 253 insertions, 198 deletions

diff --git a/pw_blob_store/flat_file_system_entry_test.cc b/pw_blob_store/flat_file_system_entry_test.cc
index 3e16063c7..8410deab9 100644
--- a/pw_blob_store/flat_file_system_entry_test.cc
+++ b/pw_blob_store/flat_file_system_entry_test.cc
@@ -153,7 +153,7 @@ TEST_F(FlatFileSystemBlobStoreEntryTest, NoData) {
       FlatFileSystemBlobStoreEntry::FilePermissions::READ;
 
   // Ensure the BlobStore is erased.
-  partition_.Erase();
+  ASSERT_EQ(OkStatus(), partition_.Erase());
 
   sync::VirtualMutex blob_store_mutex;
   FlatFileSystemBlobStoreEntry blob_store_file(
diff --git a/pw_file/flat_file_system.cc b/pw_file/flat_file_system.cc
index ea2447895..0d822dd38 100644
--- a/pw_file/flat_file_system.cc
+++ b/pw_file/flat_file_system.cc
@@ -45,11 +45,13 @@ Status FlatFileSystemService::EnumerateFile(
   {
     pw::file::Path::StreamEncoder encoder = output_encoder.GetPathsEncoder();
 
-    encoder.WritePath(reinterpret_cast<const char*>(file_name_buffer_.data()),
-                      sws.size());
-    encoder.WriteSizeBytes(entry.SizeBytes());
-    encoder.WritePermissions(entry.Permissions());
-    encoder.WriteFileId(entry.FileId());
+    encoder
+        .WritePath(reinterpret_cast<const char*>(file_name_buffer_.data()),
+                   sws.size())
+        .IgnoreError();
+    encoder.WriteSizeBytes(entry.SizeBytes()).IgnoreError();
+    encoder.WritePermissions(entry.Permissions()).IgnoreError();
+    encoder.WriteFileId(entry.FileId()).IgnoreError();
   }
   return output_encoder.status();
 }
@@ -70,11 +72,13 @@ void FlatFileSystemService::EnumerateAllFiles(RawServerWriter& writer) {
 
     Status write_status = writer.Write(encoder);
     if (!write_status.ok()) {
-      writer.Finish(write_status);
+      writer.Finish(write_status)
+          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
       return;
     }
   }
-  writer.Finish(OkStatus());
+  writer.Finish(OkStatus())
+      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
 }
 
 void FlatFileSystemService::List(ConstByteSpan request,
@@ -90,25 +94,29 @@ void FlatFileSystemService::List(ConstByteSpan request,
     std::string_view file_name_view;
     if (!decoder.ReadString(&file_name_view).ok() ||
         file_name_view.length() == 0) {
-      writer.Finish(Status::DataLoss());
+      writer.Finish(Status::DataLoss())
+          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
       return;
     }
 
     // Find and enumerate the file requested.
     Result<Entry*> result = FindFile(file_name_view);
     if (!result.ok()) {
-      writer.Finish(result.status());
+      writer.Finish(result.status())
+          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
       return;
     }
 
     pw::file::ListResponse::MemoryEncoder encoder(encoding_buffer_);
     Status proto_encode_status = EnumerateFile(*result.value(), encoder);
     if (!proto_encode_status.ok()) {
-      writer.Finish(proto_encode_status);
+      writer.Finish(proto_encode_status)
+          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
       return;
     }
 
-    writer.Finish(writer.Write(encoder));
+    writer.Finish(writer.Write(encoder))
+        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
     return;
   }
 
diff --git a/pw_hdlc/rpc_example/hdlc_rpc_server.cc b/pw_hdlc/rpc_example/hdlc_rpc_server.cc
index ef5efb369..b878e64b7 100644
--- a/pw_hdlc/rpc_example/hdlc_rpc_server.cc
+++ b/pw_hdlc/rpc_example/hdlc_rpc_server.cc
@@ -16,6 +16,7 @@
 #include <span>
 #include <string_view>
 
+#include "pw_assert/check.h"
 #include "pw_hdlc/encoder.h"
 #include "pw_hdlc/rpc_packets.h"
 #include "pw_log/log.h"
@@ -41,7 +42,7 @@ void Start() {
   RegisterServices();
 
   PW_LOG_INFO("Starting pw_rpc server");
-  pw::rpc::system_server::Start();
+  PW_CHECK_OK(pw::rpc::system_server::Start());
 }
 
 }  // namespace hdlc_example
diff --git a/pw_log_rpc/log_filter_service_test.cc b/pw_log_rpc/log_filter_service_test.cc
index c42777974..3562c4054 100644
--- a/pw_log_rpc/log_filter_service_test.cc
+++ b/pw_log_rpc/log_filter_service_test.cc
@@ -59,7 +59,7 @@ class FilterServiceTest : public ::testing::Test {
 TEST_F(FilterServiceTest, GetFilterIds) {
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, ListFilterIds, 1)
   context(filter_map_);
-  context.call({});
+  ASSERT_EQ(OkStatus(), context.call({}).status());
   ASSERT_TRUE(context.done());
   ASSERT_EQ(context.responses().size(), 1u);
   protobuf::Decoder decoder(context.responses()[0]);
@@ -79,7 +79,7 @@ TEST_F(FilterServiceTest, GetFilterIds) {
   FilterMap empty_filter_map({});
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, ListFilterIds, 1)
   no_filter_context(empty_filter_map);
-  no_filter_context.call({});
+  ASSERT_EQ(OkStatus(), no_filter_context.call({}).status());
   ASSERT_TRUE(no_filter_context.done());
   ASSERT_EQ(no_filter_context.responses().size(), 1u);
   protobuf::Decoder no_filter_decoder(no_filter_context.responses()[0]);
@@ -168,7 +168,7 @@ TEST_F(FilterServiceTest, SetFilterRules) {
 
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, SetFilter, 1)
   context(filter_map_);
-  context.call(request.value());
+  ASSERT_EQ(OkStatus(), context.call(request.value()).status());
 
   size_t i = 0;
   for (const auto& rule : filters_[0].rules()) {
@@ -213,7 +213,7 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) {
 
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, SetFilter, 1)
   context(filter_map_);
-  context.call(request.value());
+  ASSERT_EQ(OkStatus(), context.call(request.value()).status());
 
   size_t i = 0;
   for (const auto& rule : filter.rules()) {
@@ -223,7 +223,7 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) {
   // An empty request should not modify the filter.
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, SetFilter, 1)
   context_no_filter(filter_map_);
-  context_no_filter.call({});
+  EXPECT_EQ(Status::OutOfRange(), context_no_filter.call({}).status());
   i = 0;
   for (const auto& rule : filter.rules()) {
     VerifyRule(rule, new_filter_rules[i++]);
@@ -266,7 +266,8 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) {
   ASSERT_EQ(second_filter_request.status(), OkStatus());
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, SetFilter, 1)
   context_new_filter(filter_map_);
-  context_new_filter.call(second_filter_request.value());
+  ASSERT_EQ(OkStatus(),
+            context_new_filter.call(second_filter_request.value()).status());
 
   i = 0;
   for (const auto& rule : filter.rules()) {
@@ -331,9 +332,9 @@ TEST_F(FilterServiceTest, GetFilterRules) {
 
   std::byte request_buffer[64];
   log::GetFilterRequest::MemoryEncoder encoder(request_buffer);
-  encoder.WriteFilterId(filter_id1_);
+  ASSERT_EQ(OkStatus(), encoder.WriteFilterId(filter_id1_));
   const auto request = ConstByteSpan(encoder);
-  context.call(request);
+  ASSERT_EQ(OkStatus(), context.call(request).status());
   ASSERT_TRUE(context.done());
   ASSERT_EQ(context.responses().size(), 1u);
 
@@ -353,7 +354,7 @@ TEST_F(FilterServiceTest, GetFilterRules) {
 
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, GetFilter, 1)
   context2(filter_map_);
-  context2.call(request);
+  ASSERT_EQ(OkStatus(), context2.call(request).status());
   ASSERT_EQ(context2.responses().size(), 1u);
   protobuf::Decoder decoder2(context2.responses()[0]);
   VerifyFilterRules(decoder2, rules1_);
@@ -368,7 +369,7 @@ TEST_F(FilterServiceTest, GetFilterRules) {
 
   PW_RAW_TEST_METHOD_CONTEXT(FilterService, GetFilter, 1)
   context3(filter_map_);
-  context3.call(request);
+  ASSERT_EQ(OkStatus(), context3.call(request).status());
   ASSERT_EQ(context3.responses().size(), 1u);
   protobuf::Decoder decoder3(context3.responses()[0]);
   VerifyFilterRules(decoder3, rules1_);
diff --git a/pw_log_rpc/log_service_test.cc b/pw_log_rpc/log_service_test.cc
index 48aa32411..3afb5f482 100644
--- a/pw_log_rpc/log_service_test.cc
+++ b/pw_log_rpc/log_service_test.cc
@@ -209,7 +209,7 @@ TEST_F(LogServiceTest, StartAndEndStream) {
 
   // Not done until the stream is finished.
   ASSERT_FALSE(context.done());
-  active_drain.Close();
+  EXPECT_EQ(OkStatus(), active_drain.Close());
   ASSERT_TRUE(context.done());
 
   EXPECT_EQ(context.status(), OkStatus());
@@ -258,7 +258,7 @@ TEST_F(LogServiceTest, HandleDropped) {
   // Request logs.
   context.call(rpc_request_buffer);
   EXPECT_EQ(active_drain.Flush(encoding_buffer_), OkStatus());
-  active_drain.Close();
+  EXPECT_EQ(OkStatus(), active_drain.Close());
   ASSERT_EQ(context.status(), OkStatus());
   // There is at least 1 response with multiple log entries packed.
   ASSERT_GE(context.responses().size(), 1u);
@@ -309,18 +309,21 @@ TEST_F(LogServiceTest, HandleDroppedBetweenFilteredOutLogs) {
 
   // Force a drop entry in between entries that will be filtered out.
   for (size_t i = 1; i < total_entries; ++i) {
-    AddLogEntry(kMessage, kSampleMetadata, kSampleTimestamp);
+    ASSERT_EQ(
+        OkStatus(),
+        AddLogEntry(kMessage, kSampleMetadata, kSampleTimestamp).status());
     multisink_.HandleDropped(1);
   }
   // Add message that won't be filtered out.
   constexpr auto metadata =
       log_tokenized::Metadata::Set<PW_LOG_LEVEL_DEBUG, 0, 0, __LINE__>();
-  AddLogEntry(kMessage, metadata, kSampleTimestamp);
+  ASSERT_EQ(OkStatus(),
+            AddLogEntry(kMessage, metadata, kSampleTimestamp).status());
 
   // Request logs.
   context.call(rpc_request_buffer);
   EXPECT_EQ(active_drain.Flush(encoding_buffer_), OkStatus());
-  active_drain.Close();
+  EXPECT_EQ(OkStatus(), active_drain.Close());
   ASSERT_EQ(context.status(), OkStatus());
   // There is at least 1 response with multiple log entries packed.
   ASSERT_GE(context.responses().size(), 1u);
@@ -359,7 +362,8 @@ TEST_F(LogServiceTest, HandleSmallLogEntryBuffer) {
   const uint32_t total_drop_count = total_entries - 1;
   AddLogEntries(
       total_entries - 1, kLongMessage, kSampleMetadata, kSampleTimestamp);
-  AddLogEntry(kMessage, kSampleMetadata, kSampleTimestamp);
+  EXPECT_EQ(OkStatus(),
+            AddLogEntry(kMessage, kSampleMetadata, kSampleTimestamp).status());
 
   // Request logs.
   context.call(rpc_request_buffer);
@@ -442,7 +446,7 @@ TEST_F(LogServiceTest, LargeLogEntry) {
   context.set_channel_id(drain_channel_id);
   context.call(rpc_request_buffer);
   ASSERT_EQ(active_drain.Flush(encoding_buffer_), OkStatus());
-  active_drain.Close();
+  EXPECT_EQ(OkStatus(), active_drain.Close());
   ASSERT_EQ(context.status(), OkStatus());
   ASSERT_EQ(context.responses().size(), 1u);
 
diff --git a/pw_log_rpc/rpc_log_drain.cc b/pw_log_rpc/rpc_log_drain.cc
index 41e092fbc..d70b09967 100644
--- a/pw_log_rpc/rpc_log_drain.cc
+++ b/pw_log_rpc/rpc_log_drain.cc
@@ -34,7 +34,7 @@ Result<ConstByteSpan> CreateEncodedDropMessage(
     uint32_t drop_count, ByteSpan encoded_drop_message_buffer) {
   // Encode message in protobuf.
   log::LogEntry::MemoryEncoder encoder(encoded_drop_message_buffer);
-  encoder.WriteDropped(drop_count);
+  encoder.WriteDropped(drop_count).IgnoreError();
   PW_TRY(encoder.status());
   return ConstByteSpan(encoder);
 }
@@ -102,7 +102,8 @@ RpcLogDrain::LogDrainState RpcLogDrain::SendLogs(size_t max_num_bundles,
       continue;
     }
 
-    encoder.WriteFirstEntrySequenceId(sequence_id_);
+    encoder.WriteFirstEntrySequenceId(sequence_id_)
+        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
     sequence_id_ += packed_entry_count;
     const Status status = server_writer_.Write(encoder);
     sent_bundle_count++;
diff --git a/pw_metric/metric_service_nanopb.cc b/pw_metric/metric_service_nanopb.cc
index a69bd847b..0a1e7ccb3 100644
--- a/pw_metric/metric_service_nanopb.cc
+++ b/pw_metric/metric_service_nanopb.cc
@@ -71,7 +71,8 @@ class MetricWriter {
 
   void Flush() {
     if (response_.metrics_count) {
-      response_writer_.Write(response_);
+      response_writer_.Write(response_)
+          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
       response_ = pw_metric_MetricResponse_init_zero;
     }
   }
diff --git a/pw_rpc/client_call.cc b/pw_rpc/client_call.cc
index 567b54863..d8e57e89a 100644
--- a/pw_rpc/client_call.cc
+++ b/pw_rpc/client_call.cc
@@ -18,7 +18,7 @@ namespace pw::rpc::internal {
 
 void ClientCall::CloseClientCall() {
   if (client_stream_open()) {
-    CloseClientStreamLocked();
+    CloseClientStreamLocked().IgnoreError();
   }
   UnregisterAndMarkClosed();
 }
diff --git a/pw_rpc/client_integration_test.cc b/pw_rpc/client_integration_test.cc
index f376efa16..94ce8070c 100644
--- a/pw_rpc/client_integration_test.cc
+++ b/pw_rpc/client_integration_test.cc
@@ -86,7 +86,7 @@ TEST(RawRpcIntegrationTest, BidirectionalStreaming) {
     ASSERT_EQ(OkStatus(), call.Write(std::as_bytes(std::span("Dello"))));
     EXPECT_STREQ(receiver.Wait(), "Dello");
 
-    call.Cancel();
+    ASSERT_EQ(OkStatus(), call.Cancel());
   }
 }
 
diff --git a/pw_rpc/nanopb/client_call_test.cc b/pw_rpc/nanopb/client_call_test.cc
index 4ed3715ee..837620557 100644
--- a/pw_rpc/nanopb/client_call_test.cc
+++ b/pw_rpc/nanopb/client_call_test.cc
@@ -138,7 +138,7 @@ TEST_F(UnaryClientCall, InvokesCallbackOnValidResponse) {
       });
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
-  context.SendResponse(OkStatus(), response);
+  EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response));
 
   ASSERT_EQ(responses_received_, 1);
   EXPECT_EQ(last_status_, OkStatus());
@@ -155,7 +155,7 @@ TEST_F(UnaryClientCall, DoesNothingOnNullCallback) {
       nullptr);
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
-  context.SendResponse(OkStatus(), response);
+  EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response));
 
   ASSERT_EQ(responses_received_, 0);
 }
@@ -176,7 +176,7 @@ TEST_F(UnaryClientCall, InvokesErrorCallbackOnInvalidResponse) {
 
   constexpr std::byte bad_payload[]{
       std::byte{0xab}, std::byte{0xcd}, std::byte{0xef}};
-  context.SendResponse(OkStatus(), bad_payload);
+  EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), bad_payload));
 
   EXPECT_EQ(responses_received_, 0);
   ASSERT_TRUE(last_error_.has_value());
@@ -197,7 +197,9 @@ TEST_F(UnaryClientCall, InvokesErrorCallbackOnServerError) {
       },
       [this](Status status) { last_error_ = status; });
 
-  context.SendPacket(internal::PacketType::SERVER_ERROR, Status::NotFound());
+  EXPECT_EQ(OkStatus(),
+            context.SendPacket(internal::PacketType::SERVER_ERROR,
+                               Status::NotFound()));
 
   EXPECT_EQ(responses_received_, 0);
   EXPECT_EQ(last_error_, Status::NotFound());
@@ -218,7 +220,7 @@ TEST_F(UnaryClientCall, DoesNothingOnErrorWithoutCallback) {
 
   constexpr std::byte bad_payload[]{
       std::byte{0xab}, std::byte{0xcd}, std::byte{0xef}};
-  context.SendResponse(OkStatus(), bad_payload);
+  EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), bad_payload));
 
   EXPECT_EQ(responses_received_, 0);
 }
@@ -237,11 +239,11 @@ TEST_F(UnaryClientCall, OnlyReceivesOneResponse) {
       });
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, r1, .value = 42);
-  context.SendResponse(Status::Unimplemented(), r1);
+  EXPECT_EQ(OkStatus(), context.SendResponse(Status::Unimplemented(), r1));
   PW_ENCODE_PB(pw_rpc_test_TestResponse, r2, .value = 44);
-  context.SendResponse(Status::OutOfRange(), r2);
+  EXPECT_EQ(OkStatus(), context.SendResponse(Status::OutOfRange(), r2));
   PW_ENCODE_PB(pw_rpc_test_TestResponse, r3, .value = 46);
-  context.SendResponse(Status::Internal(), r3);
+  EXPECT_EQ(OkStatus(), context.SendResponse(Status::Internal(), r3));
 
   EXPECT_EQ(responses_received_, 1);
   EXPECT_EQ(last_status_, Status::Unimplemented());
@@ -294,19 +296,19 @@ TEST_F(ServerStreamingClientCall, InvokesCallbackOnValidResponse) {
       });
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
-  context.SendServerStream(r1);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r1));
   EXPECT_TRUE(active_);
   EXPECT_EQ(responses_received_, 1);
   EXPECT_EQ(last_response_number_, 11);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
-  context.SendServerStream(r2);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r2));
   EXPECT_TRUE(active_);
   EXPECT_EQ(responses_received_, 2);
   EXPECT_EQ(last_response_number_, 22);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r3, .chunk = {}, .number = 33u);
-  context.SendServerStream(r3);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r3));
   EXPECT_TRUE(active_);
   EXPECT_EQ(responses_received_, 3);
   EXPECT_EQ(last_response_number_, 33);
@@ -329,18 +331,18 @@ TEST_F(ServerStreamingClientCall, InvokesStreamEndOnFinish) {
       });
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
-  context.SendServerStream(r1);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r1));
   EXPECT_TRUE(active_);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
-  context.SendServerStream(r2);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r2));
   EXPECT_TRUE(active_);
 
   // Close the stream.
-  context.SendResponse(Status::NotFound());
+  EXPECT_EQ(OkStatus(), context.SendResponse(Status::NotFound()));
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r3, .chunk = {}, .number = 33u);
-  context.SendServerStream(r3);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r3));
   EXPECT_FALSE(active_);
 
   EXPECT_EQ(responses_received_, 2);
@@ -361,25 +363,27 @@ TEST_F(ServerStreamingClientCall, InvokesErrorCallbackOnInvalidResponses) {
       [this](Status error) { rpc_error_ = error; });
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
-  context.SendServerStream(r1);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r1));
   EXPECT_TRUE(active_);
   EXPECT_EQ(responses_received_, 1);
   EXPECT_EQ(last_response_number_, 11);
 
   constexpr std::byte bad_payload[]{
       std::byte{0xab}, std::byte{0xcd}, std::byte{0xef}};
-  context.SendServerStream(bad_payload);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(bad_payload));
   EXPECT_EQ(responses_received_, 1);
   ASSERT_TRUE(rpc_error_.has_value());
   EXPECT_EQ(rpc_error_, Status::DataLoss());
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
-  context.SendServerStream(r2);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(r2));
   EXPECT_TRUE(active_);
   EXPECT_EQ(responses_received_, 2);
   EXPECT_EQ(last_response_number_, 22);
 
-  context.SendPacket(internal::PacketType::SERVER_ERROR, Status::NotFound());
+  EXPECT_EQ(OkStatus(),
+            context.SendPacket(internal::PacketType::SERVER_ERROR,
+                               Status::NotFound()));
   EXPECT_EQ(responses_received_, 2);
   EXPECT_EQ(rpc_error_, Status::NotFound());
 }
diff --git a/pw_rpc/nanopb/codegen_test.cc b/pw_rpc/nanopb/codegen_test.cc
index 2b7d69ab5..5d27c1d56 100644
--- a/pw_rpc/nanopb/codegen_test.cc
+++ b/pw_rpc/nanopb/codegen_test.cc
@@ -39,17 +39,21 @@ class TestService final
       const pw_rpc_test_TestRequest& request,
       NanopbUnaryResponder<pw_rpc_test_TestResponse>& responder) {
     pw_rpc_test_TestResponse response{};
-    responder.Finish(response, TestUnaryRpc(request, response));
+    EXPECT_EQ(OkStatus(),
+              responder.Finish(response, TestUnaryRpc(request, response)));
   }
 
   static void TestServerStreamRpc(
       const pw_rpc_test_TestRequest& request,
       ServerWriter<pw_rpc_test_TestStreamResponse>& writer) {
     for (int i = 0; i < request.integer; ++i) {
-      writer.Write({.chunk = {}, .number = static_cast<uint32_t>(i)});
+      EXPECT_EQ(
+          OkStatus(),
+          writer.Write({.chunk = {}, .number = static_cast<uint32_t>(i)}));
     }
 
-    writer.Finish(static_cast<Status::Code>(request.status_code));
+    EXPECT_EQ(OkStatus(),
+              writer.Finish(static_cast<Status::Code>(request.status_code)));
   }
 
   void TestClientStreamRpc(
@@ -137,13 +141,13 @@ TEST(NanopbCodegen, Server_InvokeServerStreamingRpc_ManualWriting) {
 
   auto writer = context.writer();
 
-  writer.Write({.chunk = {}, .number = 3});
-  writer.Write({.chunk = {}, .number = 6});
-  writer.Write({.chunk = {}, .number = 9});
+  EXPECT_EQ(OkStatus(), writer.Write({.chunk = {}, .number = 3}));
+  EXPECT_EQ(OkStatus(), writer.Write({.chunk = {}, .number = 6}));
+  EXPECT_EQ(OkStatus(), writer.Write({.chunk = {}, .number = 9}));
 
   EXPECT_FALSE(context.done());
 
-  writer.Finish(Status::Cancelled());
+  EXPECT_EQ(OkStatus(), writer.Finish(Status::Cancelled()));
   ASSERT_TRUE(context.done());
   EXPECT_EQ(Status::Cancelled(), context.status());
 
@@ -237,7 +241,7 @@ TEST(NanopbCodegen, Client_InvokesUnaryRpcWithCallback) {
   EXPECT_EQ(sent_proto.integer, 123);
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
-  context.SendResponse(OkStatus(), response);
+  EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response));
   EXPECT_EQ(result.last_status, OkStatus());
   EXPECT_EQ(result.response_value, 42);
 
@@ -283,11 +287,11 @@ TEST(NanopbCodegen, Client_InvokesServerStreamingRpcWithCallback) {
 
   PW_ENCODE_PB(
       pw_rpc_test_TestStreamResponse, response, .chunk = {}, .number = 11u);
-  context.SendServerStream(response);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(response));
   EXPECT_TRUE(result.active);
   EXPECT_EQ(result.response_value, 11);
 
-  context.SendResponse(Status::NotFound());
+  EXPECT_EQ(OkStatus(), context.SendResponse(Status::NotFound()));
   EXPECT_FALSE(result.active);
   EXPECT_EQ(result.stream_status, Status::NotFound());
 }
@@ -325,7 +329,7 @@ TEST(NanopbCodegen, Client_StaticMethod_InvokesUnaryRpcWithCallback) {
   EXPECT_EQ(sent_proto.integer, 123);
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
-  context.SendResponse(OkStatus(), response);
+  EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response));
   EXPECT_EQ(result.last_status, OkStatus());
   EXPECT_EQ(result.response_value, 42);
 }
@@ -369,11 +373,11 @@ TEST(NanopbCodegen, Client_StaticMethod_InvokesServerStreamingRpcWithCallback) {
 
   PW_ENCODE_PB(
       pw_rpc_test_TestStreamResponse, response, .chunk = {}, .number = 11u);
-  context.SendServerStream(response);
+  EXPECT_EQ(OkStatus(), context.SendServerStream(response));
   EXPECT_TRUE(result.active);
   EXPECT_EQ(result.response_value, 11);
 
-  context.SendResponse(Status::NotFound());
+  EXPECT_EQ(OkStatus(), context.SendResponse(Status::NotFound()));
   EXPECT_FALSE(result.active);
   EXPECT_EQ(result.stream_status, Status::NotFound());
 }
diff --git a/pw_rpc/nanopb/server_reader_writer_test.cc b/pw_rpc/nanopb/server_reader_writer_test.cc
index e7b43e645..98a3b52bc 100644
--- a/pw_rpc/nanopb/server_reader_writer_test.cc
+++ b/pw_rpc/nanopb/server_reader_writer_test.cc
@@ -189,7 +189,8 @@ TEST(NanopbUnaryResponder, Open_ReturnsUsableResponder) {
       NanopbUnaryResponder<pw_rpc_test_TestResponse>::Open<
           TestService::TestUnaryRpc>(ctx.server, ctx.channel.id(), ctx.service);
 
-  responder.Finish({.value = 4321, .repeated_field = {}});
+  ASSERT_EQ(OkStatus(),
+            responder.Finish({.value = 4321, .repeated_field = {}}));
 
   EXPECT_EQ(ctx.output.last_response<TestService::TestUnaryRpc>().value, 4321);
   EXPECT_EQ(ctx.output.last_status(), OkStatus());
@@ -202,8 +203,8 @@ TEST(NanopbServerWriter, Open_ReturnsUsableWriter) {
           TestService::TestServerStreamRpc>(
           ctx.server, ctx.channel.id(), ctx.service);
 
-  responder.Write({.chunk = {}, .number = 321});
-  responder.Finish();
+  ASSERT_EQ(OkStatus(), responder.Write({.chunk = {}, .number = 321}));
+  ASSERT_EQ(OkStatus(), responder.Finish());
 
   EXPECT_EQ(ctx.output.last_response<TestService::TestServerStreamRpc>().number,
             321u);
@@ -218,7 +219,7 @@ TEST(NanopbServerReader, Open_ReturnsUsableReader) {
           Open<TestService::TestClientStreamRpc>(
               ctx.server, ctx.channel.id(), ctx.service);
 
-  responder.Finish({.chunk = {}, .number = 321});
+  ASSERT_EQ(OkStatus(), responder.Finish({.chunk = {}, .number = 321}));
 
   EXPECT_EQ(ctx.output.last_response<TestService::TestClientStreamRpc>().number,
             321u);
@@ -232,8 +233,8 @@ TEST(NanopbServerReaderWriter, Open_ReturnsUsableReaderWriter) {
           Open<TestService::TestBidirectionalStreamRpc>(
               ctx.server, ctx.channel.id(), ctx.service);
 
-  responder.Write({.chunk = {}, .number = 321});
-  responder.Finish(Status::NotFound());
+  ASSERT_EQ(OkStatus(), responder.Write({.chunk = {}, .number = 321}));
+  ASSERT_EQ(OkStatus(), responder.Finish(Status::NotFound()));
 
   EXPECT_EQ(ctx.output.last_response<TestService::TestBidirectionalStreamRpc>()
                 .number,
diff --git a/pw_rpc/packet.cc b/pw_rpc/packet.cc
index a96e79db2..de37ab1fc 100644
--- a/pw_rpc/packet.cc
+++ b/pw_rpc/packet.cc
@@ -89,28 +89,22 @@ Result<ConstByteSpan> Packet::Encode(ByteSpan buffer) const {
 
   // The payload is encoded first, as it may share the encode buffer.
   if (!payload_.empty()) {
-    rpc_packet.WritePayload(payload_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    rpc_packet.WritePayload(payload_).IgnoreError();
   }
 
-  rpc_packet.WriteType(type_)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  rpc_packet.WriteChannelId(channel_id_)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  rpc_packet.WriteServiceId(service_id_)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  rpc_packet.WriteMethodId(method_id_)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  rpc_packet.WriteType(type_).IgnoreError();
+  rpc_packet.WriteChannelId(channel_id_).IgnoreError();
+  rpc_packet.WriteServiceId(service_id_).IgnoreError();
+  rpc_packet.WriteMethodId(method_id_).IgnoreError();
 
   // Status code 0 is OK. In protobufs, 0 is the default int value, so skip
   // encoding it to save two bytes in the output.
   if (status_.code() != 0) {
-    rpc_packet.WriteStatus(status_.code())
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    rpc_packet.WriteStatus(status_.code()).IgnoreError();
   }
 
   if (call_id_ != 0) {
-    rpc_packet.WriteCallId(call_id_);
+    rpc_packet.WriteCallId(call_id_).IgnoreError();
   }
 
   if (rpc_packet.status().ok()) {
diff --git a/pw_rpc/raw/codegen_test.cc b/pw_rpc/raw/codegen_test.cc
index bc24905b3..5ba9b6a98 100644
--- a/pw_rpc/raw/codegen_test.cc
+++ b/pw_rpc/raw/codegen_test.cc
@@ -77,7 +77,9 @@ class TestService final
       std::byte response[32] = {};
       StatusWithSize sws = TestUnaryRpc(request, response);
 
-      responder.Finish(std::span(response).first(sws.size()), sws.status());
+      EXPECT_EQ(OkStatus(),
+                responder.Finish(std::span(response).first(sws.size()),
+                                 sws.status()));
     }
   }
 
@@ -247,7 +249,7 @@ TEST(RawCodegen, Server_Finish) {
   ctx.call({});
   ASSERT_TRUE(ctx.service().last_responder().active());
 
-  ctx.service().last_responder().Finish({});
+  EXPECT_EQ(OkStatus(), ctx.service().last_responder().Finish({}));
   EXPECT_FALSE(ctx.service().last_responder().active());
 }
 
diff --git a/pw_rpc/raw/server_reader_writer_test.cc b/pw_rpc/raw/server_reader_writer_test.cc
index 16d55292c..64a16c0d2 100644
--- a/pw_rpc/raw/server_reader_writer_test.cc
+++ b/pw_rpc/raw/server_reader_writer_test.cc
@@ -171,7 +171,8 @@ TEST(RawUnaryResponder, Open_ReturnsUsableResponder) {
       ctx.server, ctx.channel.id(), ctx.service);
 
   EXPECT_EQ(call.channel_id(), ctx.channel.id());
-  call.Finish(std::as_bytes(std::span("hello from pw_rpc")));
+  EXPECT_EQ(OkStatus(),
+            call.Finish(std::as_bytes(std::span("hello from pw_rpc"))));
 
   EXPECT_STREQ(
       reinterpret_cast<const char*>(
@@ -223,7 +224,7 @@ TEST(RawServerWriter, Open_ReturnsUsableWriter) {
           ctx.server, ctx.channel.id(), ctx.service);
 
   EXPECT_EQ(call.channel_id(), ctx.channel.id());
-  call.Write(std::as_bytes(std::span("321")));
+  EXPECT_EQ(OkStatus(), call.Write(std::as_bytes(std::span("321"))));
 
   EXPECT_STREQ(reinterpret_cast<const char*>(
                    ctx.output.payloads<TestService::TestServerStreamRpc>()
@@ -239,7 +240,8 @@ TEST(RawServerReader, Open_ReturnsUsableReader) {
           ctx.server, ctx.channel.id(), ctx.service);
 
   EXPECT_EQ(call.channel_id(), ctx.channel.id());
-  call.Finish(std::as_bytes(std::span("This is a message")));
+  EXPECT_EQ(OkStatus(),
+            call.Finish(std::as_bytes(std::span("This is a message"))));
 
   EXPECT_STREQ(reinterpret_cast<const char*>(
                    ctx.output.payloads<TestService::TestClientStreamRpc>()
@@ -255,7 +257,7 @@ TEST(RawServerReaderWriter, Open_ReturnsUsableReaderWriter) {
           ctx.server, ctx.channel.id(), ctx.service);
 
   EXPECT_EQ(call.channel_id(), ctx.channel.id());
-  call.Write(std::as_bytes(std::span("321")));
+  EXPECT_EQ(OkStatus(), call.Write(std::as_bytes(std::span("321"))));
 
   EXPECT_STREQ(
       reinterpret_cast<const char*>(
diff --git a/pw_spi/public/pw_spi/device.h b/pw_spi/public/pw_spi/device.h
index 07a9858ee..db07e9ce9 100644
--- a/pw_spi/public/pw_spi/device.h
+++ b/pw_spi/public/pw_spi/device.h
@@ -92,7 +92,8 @@ class Device {
       if ((selector_ != nullptr) &&
           (behavior_ == ChipSelectBehavior::kPerTransaction) &&
           (!first_write_read_)) {
-        selector_->Deactivate();
+        selector_->Deactivate()
+            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
       }
     }
 
diff --git a/pw_status/docs.rst b/pw_status/docs.rst
index b4a89b6a1..997ca539c 100644
--- a/pw_status/docs.rst
+++ b/pw_status/docs.rst
@@ -214,9 +214,11 @@ Unused result warnings
 If the ``PW_STATUS_CFG_CHECK_IF_USED`` option is enabled, ``pw::Status`` objects
 returned from function calls must be used or it is a compilation error. To
 silence these warnings call ``IgnoreError()`` on the returned status object.
-``PW_STATUS_CFG_CHECK_IF_USED`` defaults to off. Pigweed and projects that use
-it will be updated to compile with this option enabled. After all projects have
-migrated, unused result warnings will be enabled unconditionally.
+
+``PW_STATUS_CFG_CHECK_IF_USED`` defaults to off. Pigweed compiles with this
+option enabled, but projects that use Pigweed will need to be updated to compile
+with this option. After all projects have migrated, unused result warnings will
+be enabled unconditionally.
 
 C compatibility
 ---------------
diff --git a/pw_trace_tokenized/example/rpc.cc b/pw_trace_tokenized/example/rpc.cc
index fdeaec763..5041bc3c2 100644
--- a/pw_trace_tokenized/example/rpc.cc
+++ b/pw_trace_tokenized/example/rpc.cc
@@ -41,6 +41,7 @@ In chrome navigate to chrome://tracing, and load the trace.json file.
 */
 #include <thread>
 
+#include "pw_assert/check.h"
 #include "pw_log/log.h"
 #include "pw_rpc/server.h"
 #include "pw_rpc_system_server/rpc_server.h"
@@ -57,7 +58,7 @@ void RpcThread() {
 
   // Set up the server and start processing data.
   pw::rpc::system_server::Server().RegisterService(trace_service);
-  pw::rpc::system_server::Start();
+  PW_CHECK_OK(pw::rpc::system_server::Start());
 }
 
 }  // namespace
@@ -71,4 +72,4 @@ int main() {
   PW_LOG_INFO("Running basic trace example...\n");
   RunTraceSampleApp();
   return 0;
-}
\ No newline at end of file
+}
diff --git a/pw_trace_tokenized/trace_buffer.cc b/pw_trace_tokenized/trace_buffer.cc
index a7da5a988..31314ec7a 100644
--- a/pw_trace_tokenized/trace_buffer.cc
+++ b/pw_trace_tokenized/trace_buffer.cc
@@ -73,7 +73,8 @@ class TraceBuffer {
   };
 
   ConstByteSpan DeringAndViewRawBuffer() {
-    ring_buffer_.Dering();
+    ring_buffer_.Dering()
+        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
     return ByteSpan(raw_buffer_, ring_buffer_.TotalUsedBytes());
   }
 
diff --git a/pw_trace_tokenized/trace_rpc_service_nanopb.cc b/pw_trace_tokenized/trace_rpc_service_nanopb.cc
index 2abd0ca20..55b3f43f2 100644
--- a/pw_trace_tokenized/trace_rpc_service_nanopb.cc
+++ b/pw_trace_tokenized/trace_rpc_service_nanopb.cc
@@ -45,7 +45,8 @@ void TraceService::GetTraceData(
   while (trace_buffer->PeekFront(
              std::as_writable_bytes(std::span(buffer.data.bytes)), &size) !=
          pw::Status::OutOfRange()) {
-    trace_buffer->PopFront();
+    trace_buffer->PopFront()
+        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
     buffer.data.size = size;
     pw::Status status = writer.Write(buffer);
     if (!status.ok()) {
@@ -54,6 +55,6 @@ void TraceService::GetTraceData(
       break;
     }
   }
-  writer.Finish();
+  writer.Finish().IgnoreError();  // TODO(pwbug/387): Handle Status properly
 }
 }  // namespace pw::trace
diff --git a/pw_transfer/client_test.cc b/pw_transfer/client_test.cc
index 48ed4b608..35a166482 100644
--- a/pw_transfer/client_test.cc
+++ b/pw_transfer/client_test.cc
@@ -75,9 +75,10 @@ TEST_F(ReadTransfer, SingleChunk) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(3, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(3, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
 
   transfer_thread_.WaitUntilEventIsProcessed();
 
@@ -112,9 +113,10 @@ TEST_F(ReadTransfer, MultiChunk) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(4, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(4, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
 
   transfer_thread_.WaitUntilEventIsProcessed();
 
@@ -192,7 +194,7 @@ class ReadTransferMaxBytes32 : public ReadTransfer {
 
 TEST_F(ReadTransferMaxBytes32, SetsPendingBytesFromConstructorArg) {
   stream::MemoryWriterBuffer<64> writer;
-  client_.Read(5, writer, [](Status) {});
+  EXPECT_EQ(OkStatus(), client_.Read(5, writer, [](Status) {}));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -208,7 +210,7 @@ TEST_F(ReadTransferMaxBytes32, SetsPendingBytesFromConstructorArg) {
 
 TEST_F(ReadTransferMaxBytes32, SetsPendingBytesFromWriterLimit) {
   stream::MemoryWriterBuffer<16> small_writer;
-  client_.Read(5, small_writer, [](Status) {});
+  EXPECT_EQ(OkStatus(), client_.Read(5, small_writer, [](Status) {}));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -226,9 +228,10 @@ TEST_F(ReadTransferMaxBytes32, MultiParameters) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(6, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(6, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -278,9 +281,10 @@ TEST_F(ReadTransfer, UnexpectedOffset) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(7, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(7, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -342,9 +346,10 @@ TEST_F(ReadTransferMaxBytes32, TooMuchData) {
   stream::MemoryWriterBuffer<32> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(8, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(8, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -387,9 +392,10 @@ TEST_F(ReadTransfer, ServerError) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(9, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(9, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -417,9 +423,10 @@ TEST_F(ReadTransfer, OnlySendsParametersOnceAfterDrop) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(10, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(10, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -479,9 +486,10 @@ TEST_F(ReadTransfer, ResendsParametersIfSentRepeatedChunkDuringRecovery) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(11, writer, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Read(11, writer, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -564,11 +572,12 @@ TEST_F(ReadTransfer, Timeout_ResendsCurrentParameters) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(
-      12,
-      writer,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Read(
+                12,
+                writer,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -617,11 +626,12 @@ TEST_F(ReadTransfer, Timeout_ResendsUpdatedParameters) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(
-      13,
-      writer,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Read(
+                13,
+                writer,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -679,11 +689,12 @@ TEST_F(ReadTransfer, Timeout_EndsTransferAfterMaxRetries) {
   stream::MemoryWriterBuffer<64> writer;
   Status transfer_status = Status::Unknown();
 
-  client_.Read(
-      14,
-      writer,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Read(
+                14,
+                writer,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // First transfer parameters chunk is sent.
@@ -736,14 +747,16 @@ TEST_F(ReadTransfer, InitialPacketFails_OnCompletedCalledWithDataLoss) {
 
   context_.output().set_send_status(Status::Unauthenticated());
 
-  client_.Read(
-      14,
-      writer,
-      [&transfer_status](Status status) {
-        ASSERT_EQ(transfer_status, Status::Unknown());  // Must only call once
-        transfer_status = status;
-      },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Read(
+                14,
+                writer,
+                [&transfer_status](Status status) {
+                  ASSERT_EQ(transfer_status,
+                            Status::Unknown());  // Must only call once
+                  transfer_status = status;
+                },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   EXPECT_EQ(transfer_status, Status::Internal());
@@ -776,9 +789,10 @@ TEST_F(WriteTransfer, SingleChunk) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(3, reader, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Write(3, reader, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -827,9 +841,10 @@ TEST_F(WriteTransfer, MultiChunk) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(4, reader, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Write(4, reader, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -886,9 +901,10 @@ TEST_F(WriteTransfer, OutOfOrder_SeekSupported) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(5, reader, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Write(5, reader, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -960,9 +976,10 @@ TEST_F(WriteTransfer, OutOfOrder_SeekNotSupported) {
   FakeNonSeekableReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(6, reader, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Write(6, reader, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -997,9 +1014,10 @@ TEST_F(WriteTransfer, ServerError) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(7, reader, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Write(7, reader, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -1025,9 +1043,10 @@ TEST_F(WriteTransfer, MalformedParametersChunk) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(8, reader, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Write(8, reader, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -1059,9 +1078,10 @@ TEST_F(WriteTransfer, AbortIfZeroBytesAreRequested) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(9, reader, [&transfer_status](Status status) {
-    transfer_status = status;
-  });
+  ASSERT_EQ(OkStatus(),
+            client_.Write(9, reader, [&transfer_status](Status status) {
+              transfer_status = status;
+            }));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -1093,11 +1113,12 @@ TEST_F(WriteTransfer, Timeout_RetriesWithInitialChunk) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(
-      10,
-      reader,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Write(
+                10,
+                reader,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -1125,11 +1146,12 @@ TEST_F(WriteTransfer, Timeout_RetriesWithMostRecentChunk) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(
-      11,
-      reader,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Write(
+                11,
+                reader,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -1186,11 +1208,12 @@ TEST_F(WriteTransfer, Timeout_RetriesWithSingleChunkTransfer) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(
-      12,
-      reader,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Write(
+                12,
+                reader,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -1263,11 +1286,12 @@ TEST_F(WriteTransfer, Timeout_EndsTransferAfterMaxRetries) {
   stream::MemoryReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(
-      13,
-      reader,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Write(
+                13,
+                reader,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
@@ -1314,11 +1338,12 @@ TEST_F(WriteTransfer, Timeout_NonSeekableReaderEndsTransfer) {
   FakeNonSeekableReader reader(kData32);
   Status transfer_status = Status::Unknown();
 
-  client_.Write(
-      14,
-      reader,
-      [&transfer_status](Status status) { transfer_status = status; },
-      kTestTimeout);
+  ASSERT_EQ(OkStatus(),
+            client_.Write(
+                14,
+                reader,
+                [&transfer_status](Status status) { transfer_status = status; },
+                kTestTimeout));
   transfer_thread_.WaitUntilEventIsProcessed();
 
   // The client begins by just sending the transfer ID.
diff --git a/pw_transfer/transfer_test.cc b/pw_transfer/transfer_test.cc
index 62098bcf8..4154a9301 100644
--- a/pw_transfer/transfer_test.cc
+++ b/pw_transfer/transfer_test.cc
@@ -84,7 +84,7 @@ class SimpleReadTransfer final : public ReadOnlyHandler {
       return prepare_read_return_status;
     }
 
-    reader_.Seek(0);
+    EXPECT_EQ(reader_.seek_status, reader_.Seek(0));
     set_reader(reader_);
     return OkStatus();
   }
@@ -685,7 +685,7 @@ class SimpleWriteTransfer final : public WriteOnlyHandler {
         writer_(data) {}
 
   Status PrepareWrite() final {
-    writer_.Seek(0);
+    EXPECT_EQ(OkStatus(), writer_.Seek(0));
     set_writer(writer_);
     prepare_write_called = true;
     return OkStatus();
diff --git a/targets/host/target_toolchains.gni b/targets/host/target_toolchains.gni
index f1da1f541..15c08acb4 100644
--- a/targets/host/target_toolchains.gni
+++ b/targets/host/target_toolchains.gni
@@ -294,6 +294,7 @@ pw_target_toolchain_host_list = [
 
 # Additional configuration intended only for upstream Pigweed use.
 _pigweed_internal = {
+  pw_status_CONFIG = "$dir_pw_status:check_if_used"
 }
 
 # Host toolchains exclusively for upstream Pigweed use. To give upstream Pigweed