diff --git a/quiche/binary_http/binary_http_message_test.cc b/quiche/binary_http/binary_http_message_test.cc
index d0e0d97..7add275 100644
--- a/quiche/binary_http/binary_http_message_test.cc
+++ b/quiche/binary_http/binary_http_message_test.cc
@@ -31,10 +31,15 @@
 }
 
 template <class T>
-void TestPrintTo(const T& resp) {
+absl::Status TestPrintTo(const T& resp) {
   std::ostringstream os;
   PrintTo(resp, &os);
-  EXPECT_EQ(os.str(), resp.DebugString());
+  if (os.str() != resp.DebugString()) {
+    return absl::FailedPreconditionError(absl::StrCat(
+        "PrintTo output to stream does not match DebugString: stream=",
+        os.str(), ", DebugString=", resp.DebugString()));
+  }
+  return absl::OkStatus();
 }
 
 class RequestMessageSectionTestHandler
@@ -53,39 +58,60 @@
   RequestMessageSectionTestHandler() = default;
   absl::Status OnControlData(
       const BinaryHttpRequest::ControlData& control_data) override {
-    EXPECT_FALSE(message_data_.control_data_.has_value());
+    if (message_data_.control_data_.has_value()) {
+      return absl::FailedPreconditionError(
+          "OnControlData called multiple times");
+    }
     message_data_.control_data_ = control_data;
     return absl::OkStatus();
   }
   absl::Status OnHeader(absl::string_view name,
                         absl::string_view value) override {
-    EXPECT_FALSE(message_data_.headers_done_);
+    if (message_data_.headers_done_) {
+      return absl::FailedPreconditionError(
+          "OnHeader called after OnHeadersDone");
+    }
     message_data_.headers_.push_back({std::string(name), std::string(value)});
     return absl::OkStatus();
   }
   absl::Status OnHeadersDone() override {
-    EXPECT_FALSE(message_data_.headers_done_);
+    if (message_data_.headers_done_) {
+      return absl::FailedPreconditionError(
+          "OnHeadersDone called multiple times");
+    }
     message_data_.headers_done_ = true;
     return absl::OkStatus();
   }
   absl::Status OnBodyChunk(absl::string_view body_chunk) override {
-    EXPECT_FALSE(message_data_.body_chunks_done_);
+    if (message_data_.body_chunks_done_) {
+      return absl::FailedPreconditionError(
+          "OnBodyChunk called after OnBodyChunksDone");
+    }
     message_data_.body_chunks_.push_back(std::string(body_chunk));
     return absl::OkStatus();
   }
   absl::Status OnBodyChunksDone() override {
-    EXPECT_FALSE(message_data_.body_chunks_done_);
+    if (message_data_.body_chunks_done_) {
+      return absl::FailedPreconditionError(
+          "OnBodyChunksDone called multiple times");
+    }
     message_data_.body_chunks_done_ = true;
     return absl::OkStatus();
   }
   absl::Status OnTrailer(absl::string_view name,
                          absl::string_view value) override {
-    EXPECT_FALSE(message_data_.trailers_done_);
+    if (message_data_.trailers_done_) {
+      return absl::FailedPreconditionError(
+          "OnTrailer called after OnTrailersDone");
+    }
     message_data_.trailers_.push_back({std::string(name), std::string(value)});
     return absl::OkStatus();
   }
   absl::Status OnTrailersDone() override {
-    EXPECT_FALSE(message_data_.trailers_done_);
+    if (message_data_.trailers_done_) {
+      return absl::FailedPreconditionError(
+          "OnTrailersDone called multiple times");
+    }
     message_data_.trailers_done_ = true;
     return absl::OkStatus();
   }
@@ -179,7 +205,7 @@
             "libcurl/7.16.3 OpenSSL/0.9.7l "
             "zlib/1.2.3};Field{host=www.example.com};Field{accept-language=en, "
             "mi}}Body{}}}"));
-  TestPrintTo(request);
+  QUICHE_EXPECT_OK(TestPrintTo(request));
 }
 
 TEST(BinaryHttpRequest, DecodeGetNoBody) {
@@ -214,7 +240,7 @@
       {"host", "www.example.com"},
       {"accept-language", "en, mi"}};
   for (const auto& field : expected_fields) {
-    TestPrintTo(field);
+    QUICHE_EXPECT_OK(TestPrintTo(field));
   }
   ASSERT_THAT(request.GetHeaderFields(), ContainerEq(expected_fields));
   ASSERT_EQ(request.body(), "");
@@ -225,7 +251,7 @@
             "libcurl/7.16.3 OpenSSL/0.9.7l "
             "zlib/1.2.3};Field{host=www.example.com};Field{accept-language=en, "
             "mi}}Body{}}}"));
-  TestPrintTo(request);
+  QUICHE_EXPECT_OK(TestPrintTo(request));
 }
 
 TEST(BinaryHttpRequest, EncodeGetNoBodyOrHeaders) {
@@ -257,7 +283,7 @@
   ASSERT_EQ(*result, expected);
   EXPECT_THAT(request.DebugString(),
               StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{}Body{}}}"));
-  TestPrintTo(request);
+  QUICHE_EXPECT_OK(TestPrintTo(request));
 }
 
 TEST(BinaryHttpRequest, DecodeGetNoBodyOrHeaders) {
@@ -280,13 +306,13 @@
                 FieldsAre("GET", "https", "example.com", "/"));
     std::vector<BinaryHttpMessage::Field> expected_fields = {};
     for (const auto& field : expected_fields) {
-      TestPrintTo(field);
+      QUICHE_EXPECT_OK(TestPrintTo(field));
     }
     ASSERT_THAT(request.GetHeaderFields(), ContainerEq(expected_fields));
     ASSERT_EQ(request.body(), "");
     EXPECT_THAT(request.DebugString(),
                 StrEq("BinaryHttpRequest{BinaryHttpMessage{Headers{}Body{}}}"));
-    TestPrintTo(request);
+    QUICHE_EXPECT_OK(TestPrintTo(request));
   }
 }
 
@@ -485,26 +511,43 @@
   EXPECT_NE(request, no_body);
 }
 
-void ExpectRequestMessageSectionHandler(
+absl::Status ExpectRequestMessageSectionHandler(
     const RequestMessageSectionTestHandler::MessageData& message_data) {
-  EXPECT_TRUE(message_data.control_data_.has_value());
-  if (message_data.control_data_.has_value()) {
-    EXPECT_THAT(*message_data.control_data_,
-                FieldsAre("POST", "https", "google.com", "/hello"));
+  if (!message_data.control_data_.has_value()) {
+    return absl::FailedPreconditionError("control_data missing");
+  }
+  if (message_data.control_data_->method != "POST" ||
+      message_data.control_data_->scheme != "https" ||
+      message_data.control_data_->authority != "google.com" ||
+      message_data.control_data_->path != "/hello") {
+    return absl::FailedPreconditionError("control_data mismatch");
   }
   std::vector<std::pair<std::string, std::string>> expected_headers = {
       {"user-agent", "curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"},
       {"accept-language", "en, mi"}};
-  EXPECT_TRUE(message_data.headers_done_);
-  EXPECT_THAT(message_data.headers_, ContainerEq(expected_headers));
+  if (!message_data.headers_done_) {
+    return absl::FailedPreconditionError("headers not done");
+  }
+  if (message_data.headers_ != expected_headers) {
+    return absl::FailedPreconditionError("headers mismatch");
+  }
   std::vector<std::string> expected_body_chunks = {"chunk1", "chunk2",
                                                    "chunk3"};
-  EXPECT_TRUE(message_data.body_chunks_done_);
-  EXPECT_THAT(message_data.body_chunks_, ContainerEq(expected_body_chunks));
+  if (!message_data.body_chunks_done_) {
+    return absl::FailedPreconditionError("body chunks not done");
+  }
+  if (message_data.body_chunks_ != expected_body_chunks) {
+    return absl::FailedPreconditionError("body chunks mismatch");
+  }
   std::vector<std::pair<std::string, std::string>> expected_trailers = {
       {"trailer1", "value1"}, {"trailer2", "value2"}};
-  EXPECT_TRUE(message_data.trailers_done_);
-  EXPECT_THAT(message_data.trailers_, ContainerEq(expected_trailers));
+  if (!message_data.trailers_done_) {
+    return absl::FailedPreconditionError("trailers not done");
+  }
+  if (message_data.trailers_ != expected_trailers) {
+    return absl::FailedPreconditionError("trailers mismatch");
+  }
+  return absl::OkStatus();
 }
 
 TEST(IndeterminateLengthDecoder, FullRequestDecodingSuccess) {
@@ -522,7 +565,8 @@
       BinaryHttpRequest::IndeterminateLengthDecoder::Create(&handler);
   QUICHE_ASSERT_OK(decoder);
   QUICHE_EXPECT_OK(decoder->Decode(request_bytes, /*end_stream=*/true));
-  ExpectRequestMessageSectionHandler(handler.GetMessageData());
+  QUICHE_EXPECT_OK(
+      ExpectRequestMessageSectionHandler(handler.GetMessageData()));
 }
 
 class MockFailingMessageSectionHandler
@@ -674,7 +718,8 @@
   // Decode the last byte, send end_stream.
   QUICHE_EXPECT_OK(decoder->Decode(
       absl::string_view(&request_bytes[request_bytes.size() - 1], 1), true));
-  ExpectRequestMessageSectionHandler(handler.GetMessageData());
+  QUICHE_EXPECT_OK(
+      ExpectRequestMessageSectionHandler(handler.GetMessageData()));
 }
 
 TEST(IndeterminateLengthDecoder,
@@ -722,15 +767,24 @@
   EXPECT_THAT(status, test::StatusIs(absl::StatusCode::kInvalidArgument));
 }
 
-void ExpectTruncatedTrailerSection(
+absl::Status ExpectTruncatedTrailerSection(
     const RequestMessageSectionTestHandler::MessageData& message_data) {
-  EXPECT_TRUE(message_data.headers_done_);
-  EXPECT_TRUE(message_data.trailers_done_);
+  if (!message_data.headers_done_) {
+    return absl::FailedPreconditionError("headers not done");
+  }
+  if (!message_data.trailers_done_) {
+    return absl::FailedPreconditionError("trailers not done");
+  }
   std::vector<std::pair<std::string, std::string>> expected_headers = {
       {"user-agent", "curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"},
       {"accept-language", "en, mi"}};
-  EXPECT_THAT(message_data.headers_, ContainerEq(expected_headers));
-  EXPECT_THAT(message_data.trailers_, testing::IsEmpty());
+  if (message_data.headers_ != expected_headers) {
+    return absl::FailedPreconditionError("headers mismatch");
+  }
+  if (!message_data.trailers_.empty()) {
+    return absl::FailedPreconditionError("trailers not empty");
+  }
+  return absl::OkStatus();
 }
 
 TEST(IndeterminateLengthDecoder, TruncatedBodyAndTrailers) {
@@ -749,7 +803,7 @@
   auto message_data = handler.GetMessageData();
   EXPECT_TRUE(message_data.body_chunks_done_);
   EXPECT_THAT(message_data.body_chunks_, testing::IsEmpty());
-  ExpectTruncatedTrailerSection(message_data);
+  QUICHE_EXPECT_OK(ExpectTruncatedTrailerSection(message_data));
 }
 
 TEST(IndeterminateLengthDecoder, TruncatedBodyAndTrailersSplitEndStream) {
@@ -770,7 +824,7 @@
   auto message_data = handler.GetMessageData();
   EXPECT_TRUE(message_data.body_chunks_done_);
   EXPECT_THAT(message_data.body_chunks_, testing::IsEmpty());
-  ExpectTruncatedTrailerSection(message_data);
+  QUICHE_EXPECT_OK(ExpectTruncatedTrailerSection(message_data));
 }
 
 namespace {
@@ -941,7 +995,8 @@
       BinaryHttpRequest::IndeterminateLengthDecoder::Create(&handler);
   QUICHE_ASSERT_OK(decoder);
   QUICHE_EXPECT_OK(decoder->Decode(encoded_data, /*end_stream=*/true));
-  ExpectRequestMessageSectionHandler(handler.GetMessageData());
+  QUICHE_EXPECT_OK(
+      ExpectRequestMessageSectionHandler(handler.GetMessageData()));
 }
 
 TEST(RequestIndeterminateLengthEncoder, OutOfOrderHeaders) {
@@ -1288,7 +1343,7 @@
   std::vector<std::string> expected_body_chunks = {"chunk1", "chunk2",
                                                    "chunk3"};
   EXPECT_THAT(message_data.body_chunks_, ContainerEq(expected_body_chunks));
-  ExpectTruncatedTrailerSection(message_data);
+  QUICHE_EXPECT_OK(ExpectTruncatedTrailerSection(message_data));
 }
 
 TEST(IndeterminateLengthDecoder, TruncatedTrailersSplitEndStream) {
@@ -1313,7 +1368,7 @@
   std::vector<std::string> expected_body_chunks = {"chunk1", "chunk2",
                                                    "chunk3"};
   EXPECT_THAT(message_data.body_chunks_, ContainerEq(expected_body_chunks));
-  ExpectTruncatedTrailerSection(message_data);
+  QUICHE_EXPECT_OK(ExpectTruncatedTrailerSection(message_data));
 }
 
 TEST(IndeterminateLengthDecoder, InvalidDecodeAfterEndStream) {
@@ -1612,7 +1667,7 @@
           "CRLF.\r\n}}InformationalResponse{Field{running=\"sleep "
           "15\"}};InformationalResponse{Field{link=</style.css>; rel=preload; "
           "as=style};Field{link=</script.js>; rel=preload; as=script}}}"));
-  TestPrintTo(response);
+  QUICHE_EXPECT_OK(TestPrintTo(response));
 }
 
 TEST(BinaryHttpResponse, DecodeMultiInformationalWithBody) {
@@ -1696,7 +1751,7 @@
           "CRLF.\r\n}}InformationalResponse{Field{running=\"sleep "
           "15\"}};InformationalResponse{Field{link=</style.css>; rel=preload; "
           "as=style};Field{link=</script.js>; rel=preload; as=script}}}"));
-  TestPrintTo(response);
+  QUICHE_EXPECT_OK(TestPrintTo(response));
 }
 
 TEST(BinaryHttpMessage, SwapBody) {
@@ -1786,46 +1841,74 @@
 }
 
 template <typename T>
-void TestPadding(T& message) {
+absl::Status TestPadding(T& message) {
   const auto data_so = message.Serialize();
-  ASSERT_TRUE(data_so.ok());
+  if (!data_so.ok()) {
+    return data_so.status();
+  }
   auto data = *data_so;
-  ASSERT_EQ(data.size(), message.EncodedSize());
-
+  if (data.size() != message.EncodedSize()) {
+    return absl::FailedPreconditionError("Incorrect size");
+  }
   message.set_num_padding_bytes(10);
   const auto padded_data_so = message.Serialize();
-  ASSERT_TRUE(padded_data_so.ok());
+  if (!padded_data_so.ok()) {
+    return padded_data_so.status();
+  }
   const auto padded_data = *padded_data_so;
-  ASSERT_EQ(padded_data.size(), message.EncodedSize());
-
+  if (padded_data.size() != message.EncodedSize()) {
+    return absl::FailedPreconditionError("Incorrect padded size");
+  }
   // Check padding size output.
-  ASSERT_EQ(data.size() + 10, padded_data.size());
+  if (data.size() + 10 != padded_data.size()) {
+    return absl::FailedPreconditionError("Padding size mismatch");
+  }
   // Check for valid null byte padding output
   data.resize(data.size() + 10);
-  ASSERT_EQ(data, padded_data);
-
+  if (data != padded_data) {
+    return absl::FailedPreconditionError("Padded data mismatch");
+  }
   // Deserialize padded and not padded, and verify they are the same.
   const auto deserialized_padded_message_so = T::Create(data);
-  ASSERT_TRUE(deserialized_padded_message_so.ok());
+  if (!deserialized_padded_message_so.ok()) {
+    return deserialized_padded_message_so.status();
+  }
   const auto deserialized_padded_message = *deserialized_padded_message_so;
-  ASSERT_EQ(deserialized_padded_message, message);
-  ASSERT_EQ(deserialized_padded_message.num_padding_bytes(), size_t(10));
-
+  if (!(deserialized_padded_message == message)) {
+    return absl::FailedPreconditionError(
+        "Deserialized padded message != message");
+  }
+  if (deserialized_padded_message.num_padding_bytes() != size_t(10)) {
+    return absl::FailedPreconditionError(
+        "Padding bytes mismatch in deserialized");
+  }
   // Invalid padding
   data[data.size() - 1] = 'a';
   const auto bad_so = T::Create(data);
-  ASSERT_FALSE(bad_so.ok());
-
+  if (bad_so.ok()) {
+    return absl::FailedPreconditionError(
+        "Expected bad status for invalid padding");
+  }
   // Check that padding does not impact equality.
   data.resize(data.size() - 10);
   const auto deserialized_message_so = T::Create(data);
-  ASSERT_TRUE(deserialized_message_so.ok());
+  if (!deserialized_message_so.ok()) {
+    return deserialized_message_so.status();
+  }
   const auto deserialized_message = *deserialized_message_so;
-  ASSERT_EQ(deserialized_message.num_padding_bytes(), size_t(0));
+  if (deserialized_message.num_padding_bytes() != size_t(0)) {
+    return absl::FailedPreconditionError("Num padding bytes should be 0");
+  }
   // Confirm that the message payloads are equal, but not fully equivalent due
   // to padding.
-  ASSERT_THAT(deserialized_message, HasEqPayload(deserialized_padded_message));
-  ASSERT_NE(deserialized_message, deserialized_padded_message);
+  if (!deserialized_message.IsPayloadEqual(deserialized_padded_message)) {
+    return absl::FailedPreconditionError("IsPayloadEqual failed");
+  }
+  if (deserialized_message == deserialized_padded_message) {
+    return absl::FailedPreconditionError(
+        "deserialized_message == deserialized_padded_message");
+  }
+  return absl::OkStatus();
 }
 
 TEST(BinaryHttpRequest, Padding) {
@@ -1841,7 +1924,7 @@
                        "curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3"})
       ->AddHeaderField({"Host", "www.example.com"})
       ->AddHeaderField({"Accept-Language", "en, mi"});
-  TestPadding(request);
+  QUICHE_EXPECT_OK(TestPadding(request));
 }
 
 TEST(BinaryHttpResponse, Padding) {
@@ -1854,7 +1937,7 @@
   BinaryHttpResponse response(200);
   response.AddHeaderField({"Server", "Apache"});
   response.set_body("Hello, world!\r\n");
-  TestPadding(response);
+  QUICHE_EXPECT_OK(TestPadding(response));
 }
 
 }  // namespace quiche