diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 8aa9615..7e72b34 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -929,7 +929,7 @@
   char packet[] = {0x00};
   QuicEncryptedPacket encrypted(packet, 0, false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
 }
 
 TEST_P(QuicFramerTest, LargePacket) {
@@ -977,7 +977,7 @@
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.header_->destination_connection_id);
   // Make sure the correct error is propagated.
-  EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_PACKET_TOO_LARGE));
   EXPECT_EQ("Packet too large.", framer_.detailed_error());
 }
 
@@ -1006,7 +1006,7 @@
       AssemblePacketFromFragments(fragments));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.header_->destination_connection_id);
@@ -1032,7 +1032,7 @@
       &retry_token, &detailed_error);
   EXPECT_FALSE(retry_token_present);
   EXPECT_FALSE(use_length_prefix);
-  EXPECT_EQ(QUIC_NO_ERROR, error_code);
+  EXPECT_THAT(error_code, IsQuicNoError());
   EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
   EXPECT_FALSE(version_flag);
   EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id.length());
@@ -1071,7 +1071,7 @@
       AssemblePacketFromFragments(packet46));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.header_->destination_connection_id);
@@ -1095,7 +1095,7 @@
       &version_flag, &use_length_prefix, &version_label, &parsed_version,
       &destination_connection_id, &source_connection_id, &retry_token_present,
       &retry_token, &detailed_error);
-  EXPECT_EQ(QUIC_NO_ERROR, error_code);
+  EXPECT_THAT(error_code, IsQuicNoError());
   EXPECT_EQ("", detailed_error);
   EXPECT_FALSE(retry_token_present);
   EXPECT_FALSE(use_length_prefix);
@@ -1175,7 +1175,7 @@
       &version_flag, &use_length_prefix, &version_label, &parsed_version,
       &destination_connection_id, &source_connection_id, &retry_token_present,
       &retry_token, &detailed_error);
-  EXPECT_EQ(QUIC_NO_ERROR, error_code);
+  EXPECT_THAT(error_code, IsQuicNoError());
   EXPECT_FALSE(retry_token_present);
   EXPECT_EQ(framer_.version().HasLengthPrefixedConnectionIds(),
             use_length_prefix);
@@ -1270,7 +1270,7 @@
       &parsed_version, &destination_connection_id, &source_connection_id,
       &long_packet_type, &retry_token_length_length, &retry_token,
       &detailed_error);
-  EXPECT_EQ(QUIC_NO_ERROR, parse_error);
+  EXPECT_THAT(parse_error, IsQuicNoError());
   EXPECT_EQ("", detailed_error);
   EXPECT_EQ(p[0], first_byte);
   EXPECT_TRUE(version_present);
@@ -1339,7 +1339,7 @@
       &has_length_prefix, &version_label, &parsed_version,
       &destination_connection_id, &source_connection_id, &long_packet_type,
       &retry_token_length_length, &retry_token, &detailed_error);
-  EXPECT_EQ(QUIC_NO_ERROR, parse_error);
+  EXPECT_THAT(parse_error, IsQuicNoError());
   EXPECT_EQ("", detailed_error);
   EXPECT_EQ(p[0], first_byte);
   EXPECT_TRUE(version_present);
@@ -1376,7 +1376,7 @@
   // clang-format on
   QuicEncryptedPacket encrypted(AsChars(packet), QUIC_ARRAYSIZE(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_EQ("", framer_.detailed_error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
@@ -1410,7 +1410,7 @@
   // clang-format on
   QuicEncryptedPacket encrypted(AsChars(packet), QUIC_ARRAYSIZE(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_EQ("", framer_.detailed_error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
@@ -1464,7 +1464,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(), visitor_.header_->source_connection_id);
   EXPECT_FALSE(visitor_.header_->reset_flag);
@@ -1545,7 +1545,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.header_->destination_connection_id);
@@ -1607,7 +1607,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.header_->destination_connection_id);
@@ -1671,10 +1671,10 @@
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
     EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-    EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+    EXPECT_THAT(framer_.error(), IsQuicNoError());
   } else {
     EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-    EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   }
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
@@ -1741,10 +1741,10 @@
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
     EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-    EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+    EXPECT_THAT(framer_.error(), IsQuicNoError());
   } else {
     EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-    EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   }
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
@@ -1986,7 +1986,7 @@
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(0, visitor_.frame_count_);
   EXPECT_EQ(1, visitor_.version_mismatch_);
@@ -2090,7 +2090,7 @@
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2210,7 +2210,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2265,7 +2265,7 @@
       AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2360,14 +2360,14 @@
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   if (framer_.version().HasHeaderProtection()) {
-    EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
     EXPECT_EQ("Unable to decrypt header protection.", framer_.detailed_error());
   } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     // Cannot read diversification nonce.
-    EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
     EXPECT_EQ("Unable to read nonce.", framer_.detailed_error());
   } else {
-    EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
   }
 }
 
@@ -2413,7 +2413,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2533,7 +2533,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2653,7 +2653,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2855,7 +2855,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2939,7 +2939,7 @@
                                 false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -2978,7 +2978,7 @@
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_FALSE(visitor_.header_->packet_number.IsInitialized());
 }
@@ -3087,7 +3087,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -3580,7 +3580,7 @@
       AssemblePacketFromFragments(fragments));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_INVALID_ACK_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_ACK_DATA));
 
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
@@ -3689,7 +3689,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -3914,7 +3914,7 @@
   framer_.set_process_timestamps(true);
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4126,7 +4126,7 @@
   if (GetQuicReloadableFlag(quic_do_not_accept_stop_waiting) &&
       version_.transport_version >= QUIC_VERSION_46) {
     EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-    EXPECT_EQ(QUIC_INVALID_STOP_WAITING_DATA, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
     EXPECT_EQ("STOP WAITING not supported in version 44+.",
               framer_.detailed_error());
     return;
@@ -4134,7 +4134,7 @@
 
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4192,7 +4192,7 @@
                                                     : QUIC_ARRAYSIZE(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_INVALID_STOP_WAITING_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
   EXPECT_EQ("Invalid unacked delta.", framer_.detailed_error());
 }
 
@@ -4283,7 +4283,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4394,7 +4394,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4407,8 +4407,8 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     EXPECT_EQ(0x1234u,
               visitor_.connection_close_frame_.transport_close_frame_type);
-    EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING,
-              visitor_.connection_close_frame_.extracted_error_code);
+    EXPECT_THAT(visitor_.connection_close_frame_.extracted_error_code,
+                IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   } else {
     // For Google QUIC closes, the error code is copied into
     // extracted_error_code.
@@ -4528,7 +4528,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4598,7 +4598,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4660,7 +4660,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4757,7 +4757,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4830,7 +4830,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4873,7 +4873,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -4920,7 +4920,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -5002,7 +5002,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -5075,7 +5075,7 @@
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -5124,7 +5124,7 @@
       AssemblePacketFromFragments(packet46));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -5177,7 +5177,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.public_reset_packet_->connection_id);
@@ -5232,7 +5232,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.public_reset_packet_->connection_id);
@@ -5331,7 +5331,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
   EXPECT_EQ(FramerTestConnectionId(),
             visitor_.public_reset_packet_->connection_id);
@@ -5380,7 +5380,7 @@
   // This packet cannot be decrypted because diversification nonce is missing.
   QuicEncryptedPacket encrypted(AsChars(packet), QUIC_ARRAYSIZE(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.stateless_reset_packet_.get());
   EXPECT_EQ(kTestStatelessResetToken,
             visitor_.stateless_reset_packet_->stateless_reset_token);
@@ -5423,7 +5423,7 @@
   // This packet cannot be decrypted because diversification nonce is missing.
   QuicEncryptedPacket encrypted(AsChars(packet), QUIC_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
   ASSERT_FALSE(visitor_.stateless_reset_packet_);
 }
 
@@ -5490,7 +5490,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
   EXPECT_EQ(1u, visitor_.version_negotiation_packet_->versions.size());
   EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
@@ -5549,7 +5549,8 @@
 
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_INVALID_VERSION_NEGOTIATION_PACKET, framer_.error());
+  EXPECT_THAT(framer_.error(),
+              IsError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET));
   EXPECT_EQ("Server received version negotiation packet.",
             framer_.detailed_error());
   EXPECT_FALSE(visitor_.version_negotiation_packet_.get());
@@ -5580,7 +5581,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
   EXPECT_EQ(1u, visitor_.version_negotiation_packet_->versions.size());
   EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
@@ -5646,7 +5647,7 @@
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
 
   ASSERT_TRUE(visitor_.retry_original_connection_id_.get());
@@ -5687,7 +5688,7 @@
   QuicEncryptedPacket encrypted(AsChars(packet), QUIC_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
   EXPECT_EQ("Client-initiated RETRY is invalid.", framer_.detailed_error());
 }
 
@@ -6483,7 +6484,7 @@
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9205,7 +9206,7 @@
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
 }
 
 static char kTestString[] = "At least 20 characters.";
@@ -9260,7 +9261,7 @@
   EXPECT_CALL(visitor, OnPacketComplete()).Times(1);
 
   EXPECT_TRUE(framer_.ProcessPacket(*packet));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
 }
 
 // Verify that the packet returned by ConstructMisFramedEncryptedPacket()
@@ -9302,7 +9303,7 @@
   EXPECT_CALL(visitor, OnPacketComplete()).Times(0);
 
   EXPECT_FALSE(framer_.ProcessPacket(*packet));
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_FRAME_DATA));
 }
 
 TEST_P(QuicFramerTest, IetfBlockedFrame) {
@@ -9336,7 +9337,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9421,7 +9422,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9507,7 +9508,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9548,7 +9549,7 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9590,7 +9591,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9631,7 +9632,7 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9676,7 +9677,7 @@
   QuicEncryptedPacket encrypted(AsChars(packet99), QUIC_ARRAYSIZE(packet99),
                                 false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9715,7 +9716,7 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9754,7 +9755,7 @@
                                 false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9793,7 +9794,7 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9862,7 +9863,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9905,7 +9906,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9948,7 +9949,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -9989,7 +9990,7 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10033,7 +10034,7 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_STREAMS_BLOCKED_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_STREAMS_BLOCKED_DATA));
   EXPECT_EQ(framer_.detailed_error(),
             "STREAMS_BLOCKED stream count exceeds implementation limit.");
 }
@@ -10071,7 +10072,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10293,7 +10294,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10352,7 +10353,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10419,7 +10420,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(packet99));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_INVALID_NEW_CONNECTION_ID_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_NEW_CONNECTION_ID_DATA));
   EXPECT_EQ("Unable to read new connection ID frame connection id.",
             framer_.detailed_error());
 }
@@ -10464,7 +10465,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(packet99));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_INVALID_NEW_CONNECTION_ID_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_NEW_CONNECTION_ID_DATA));
   EXPECT_EQ("Retire_prior_to > sequence_number.", framer_.detailed_error());
 }
 
@@ -10557,7 +10558,7 @@
       AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10650,7 +10651,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10736,7 +10737,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10819,7 +10820,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -10981,7 +10982,7 @@
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_FRAME_DATA));
   EXPECT_EQ("Illegal frame type.", framer_.detailed_error());
 }
 
@@ -11014,7 +11015,7 @@
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_FRAME_DATA));
   EXPECT_EQ("Illegal frame type.", framer_.detailed_error());
 }
 
@@ -11047,7 +11048,7 @@
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_FRAME_DATA));
   EXPECT_EQ("Illegal frame type.", framer_.detailed_error());
 }
 
@@ -11079,7 +11080,7 @@
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_FRAME_DATA));
   EXPECT_EQ("Illegal frame type.", framer_.detailed_error());
 }
 
@@ -11620,7 +11621,7 @@
       AssemblePacketFromFragments(packet99));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
@@ -12083,7 +12084,7 @@
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
@@ -12098,7 +12099,7 @@
   ASSERT_EQ(visitor_.coalesced_packets_.size(), 1u);
   EXPECT_TRUE(framer_.ProcessPacket(*visitor_.coalesced_packets_[0].get()));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
 
   ASSERT_EQ(2u, visitor_.stream_frames_.size());
@@ -12197,18 +12198,18 @@
   // First attempt decryption without the handshake crypter.
   EXPECT_FALSE(
       framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false)));
-  EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
-    ASSERT_EQ(1u, visitor_.undecryptable_packets_.size());
-    ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size());
-    ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size());
-    CompareCharArraysWithHexError(
-        "undecryptable packet", visitor_.undecryptable_packets_[0]->data(),
-        visitor_.undecryptable_packets_[0]->length(), AsChars(p), p_length);
-    if (framer_.version().KnowsWhichDecrypterToUse()) {
-      EXPECT_EQ(ENCRYPTION_HANDSHAKE,
-                visitor_.undecryptable_decryption_levels_[0]);
-    }
-    EXPECT_FALSE(visitor_.undecryptable_has_decryption_keys_[0]);
+  EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
+  ASSERT_EQ(1u, visitor_.undecryptable_packets_.size());
+  ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size());
+  ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size());
+  CompareCharArraysWithHexError(
+      "undecryptable packet", visitor_.undecryptable_packets_[0]->data(),
+      visitor_.undecryptable_packets_[0]->length(), AsChars(p), p_length);
+  if (framer_.version().KnowsWhichDecrypterToUse()) {
+    EXPECT_EQ(ENCRYPTION_HANDSHAKE,
+              visitor_.undecryptable_decryption_levels_[0]);
+  }
+  EXPECT_FALSE(visitor_.undecryptable_has_decryption_keys_[0]);
 }
 
 TEST_P(QuicFramerTest, UndecryptablePacketWithDecrypter) {
@@ -12299,19 +12300,19 @@
 
   EXPECT_FALSE(
       framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false)));
-  EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
-    ASSERT_EQ(1u, visitor_.undecryptable_packets_.size());
-    ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size());
-    ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size());
-    CompareCharArraysWithHexError(
-        "undecryptable packet", visitor_.undecryptable_packets_[0]->data(),
-        visitor_.undecryptable_packets_[0]->length(), AsChars(p), p_length);
-    if (framer_.version().KnowsWhichDecrypterToUse()) {
-      EXPECT_EQ(ENCRYPTION_HANDSHAKE,
-                visitor_.undecryptable_decryption_levels_[0]);
-    }
-    EXPECT_EQ(framer_.version().KnowsWhichDecrypterToUse(),
-              visitor_.undecryptable_has_decryption_keys_[0]);
+  EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
+  ASSERT_EQ(1u, visitor_.undecryptable_packets_.size());
+  ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size());
+  ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size());
+  CompareCharArraysWithHexError(
+      "undecryptable packet", visitor_.undecryptable_packets_[0]->data(),
+      visitor_.undecryptable_packets_[0]->length(), AsChars(p), p_length);
+  if (framer_.version().KnowsWhichDecrypterToUse()) {
+    EXPECT_EQ(ENCRYPTION_HANDSHAKE,
+              visitor_.undecryptable_decryption_levels_[0]);
+  }
+  EXPECT_EQ(framer_.version().KnowsWhichDecrypterToUse(),
+            visitor_.undecryptable_has_decryption_keys_[0]);
 }
 
 TEST_P(QuicFramerTest, UndecryptableCoalescedPacket) {
@@ -12462,20 +12463,19 @@
 
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
 
-    ASSERT_EQ(1u, visitor_.undecryptable_packets_.size());
-    ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size());
-    ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size());
-    // Make sure we only receive the first undecryptable packet and not the
-    // full packet including the second coalesced packet.
-    CompareCharArraysWithHexError("undecryptable packet",
-                                  visitor_.undecryptable_packets_[0]->data(),
-                                  visitor_.undecryptable_packets_[0]->length(),
-                                  AsChars(p), length_of_first_coalesced_packet);
-    EXPECT_EQ(ENCRYPTION_HANDSHAKE,
-              visitor_.undecryptable_decryption_levels_[0]);
-    EXPECT_TRUE(visitor_.undecryptable_has_decryption_keys_[0]);
+  ASSERT_EQ(1u, visitor_.undecryptable_packets_.size());
+  ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size());
+  ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size());
+  // Make sure we only receive the first undecryptable packet and not the
+  // full packet including the second coalesced packet.
+  CompareCharArraysWithHexError("undecryptable packet",
+                                visitor_.undecryptable_packets_[0]->data(),
+                                visitor_.undecryptable_packets_[0]->length(),
+                                AsChars(p), length_of_first_coalesced_packet);
+  EXPECT_EQ(ENCRYPTION_HANDSHAKE, visitor_.undecryptable_decryption_levels_[0]);
+  EXPECT_TRUE(visitor_.undecryptable_has_decryption_keys_[0]);
 
   // Make sure the second coalesced packet is parsed correctly.
   ASSERT_EQ(visitor_.coalesced_packets_.size(), 1u);
@@ -12631,7 +12631,7 @@
   EXPECT_QUIC_PEER_BUG(EXPECT_TRUE(framer_.ProcessPacket(encrypted)),
                        "Server: Received mismatched coalesced header.*");
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
@@ -12737,7 +12737,7 @@
   EXPECT_QUIC_PEER_BUG(EXPECT_TRUE(framer_.ProcessPacket(encrypted)),
                        "Server: Failed to parse received coalesced header.*");
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   ASSERT_TRUE(visitor_.header_.get());
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
@@ -12835,7 +12835,7 @@
   QuicEncryptedPacket encrypted(AsChars(packet), QUIC_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
-  EXPECT_EQ(QUIC_INVALID_VERSION, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_VERSION));
   EXPECT_EQ("Client received unexpected version.", framer_.detailed_error());
 }
 
@@ -12887,10 +12887,10 @@
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
     EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-    EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+    EXPECT_THAT(framer_.error(), IsQuicNoError());
   } else {
     EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-    EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
   }
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(connection_id, visitor_.header_->destination_connection_id);
@@ -12963,7 +12963,7 @@
                             QUIC_ARRAYSIZE(long_header_packet99), false)));
   }
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_FALSE(
       QuicFramerPeer::GetLargestDecryptedPacketNumber(&framer_, INITIAL_DATA)
           .IsInitialized());
@@ -12998,7 +12998,7 @@
   }
   EXPECT_TRUE(framer_.ProcessPacket(short_header_encrypted));
 
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_FALSE(
       QuicFramerPeer::GetLargestDecryptedPacketNumber(&framer_, INITIAL_DATA)
           .IsInitialized());
@@ -13033,7 +13033,7 @@
       AssemblePacketFromFragments(packet46));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
   CheckFramingBoundaries(packet46, QUIC_INVALID_PACKET_HEADER);
 }
 
@@ -13062,7 +13062,7 @@
       AssemblePacketFromFragments(packet));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
   CheckFramingBoundaries(packet, QUIC_INVALID_PACKET_HEADER);
 }
 
@@ -13101,7 +13101,7 @@
       AssemblePacketFromFragments(fragments));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
   EXPECT_EQ("Invalid public header type for expected version.",
             framer_.detailed_error());
   CheckFramingBoundaries(fragments, QUIC_INVALID_PACKET_HEADER);
@@ -13138,7 +13138,7 @@
   framer_.ProcessPacket(*encrypted);
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+  EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
   EXPECT_EQ("Invalid public header type for expected version.",
             framer_.detailed_error());
   CheckFramingBoundaries(packet, QUIC_INVALID_PACKET_HEADER);
@@ -13229,7 +13229,7 @@
       &version_present, &has_length_prefix, &version_label, &parsed_version,
       &destination_connection_id, &source_connection_id, &retry_token_present,
       &retry_token, &detailed_error);
-  EXPECT_EQ(QUIC_NO_ERROR, parse_result);
+  EXPECT_THAT(parse_result, IsQuicNoError());
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
   EXPECT_TRUE(version_present);
   EXPECT_FALSE(has_length_prefix);
@@ -13380,7 +13380,7 @@
       &version_present, &has_length_prefix, &version_label, &parsed_version,
       &destination_connection_id, &source_connection_id, &retry_token_present,
       &retry_token, &detailed_error);
-  EXPECT_EQ(QUIC_NO_ERROR, header_parse_result);
+  EXPECT_THAT(header_parse_result, IsQuicNoError());
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
   EXPECT_TRUE(version_present);
   EXPECT_FALSE(has_length_prefix);
@@ -13459,7 +13459,7 @@
       &version_present, &has_length_prefix, &version_label, &parsed_version,
       &destination_connection_id, &source_connection_id, &retry_token_present,
       &retry_token, &detailed_error);
-  EXPECT_EQ(QUIC_NO_ERROR, header_parse_result);
+  EXPECT_THAT(header_parse_result, IsQuicNoError());
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
   EXPECT_TRUE(version_present);
   EXPECT_TRUE(has_length_prefix);
@@ -13587,12 +13587,12 @@
   if (!QuicUtils::VariableLengthConnectionIdAllowedForVersion(
           framer_.transport_version())) {
     EXPECT_FALSE(parse_success);
-    EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
     EXPECT_EQ("Invalid ConnectionId length.", framer_.detailed_error());
     return;
   }
   EXPECT_TRUE(parse_success);
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_EQ("", framer_.detailed_error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
@@ -13653,19 +13653,19 @@
   if (!QuicUtils::VariableLengthConnectionIdAllowedForVersion(
           framer_.transport_version())) {
     EXPECT_FALSE(parse_success);
-    EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
     EXPECT_EQ("Invalid ConnectionId length.", framer_.detailed_error());
     return;
   }
   if (!framer_.version().SupportsClientConnectionIds()) {
     EXPECT_FALSE(parse_success);
-    EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
+    EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
     EXPECT_EQ("Client connection ID not supported in this version.",
               framer_.detailed_error());
     return;
   }
   EXPECT_TRUE(parse_success);
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  EXPECT_THAT(framer_.error(), IsQuicNoError());
   EXPECT_EQ("", framer_.detailed_error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(FramerTestConnectionId(),
@@ -13757,17 +13757,20 @@
 
   frame.error_details = "this has no error code info in it";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING, frame.extracted_error_code);
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   EXPECT_EQ("this has no error code info in it", frame.error_details);
 
   frame.error_details = "1234this does not have the colon in it";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING, frame.extracted_error_code);
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   EXPECT_EQ("1234this does not have the colon in it", frame.error_details);
 
   frame.error_details = "1a234:this has a colon, but a malformed error number";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING, frame.extracted_error_code);
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   EXPECT_EQ("1a234:this has a colon, but a malformed error number",
             frame.error_details);
 
@@ -13779,14 +13782,16 @@
   frame.error_details =
       "1234 :this is not good, space between last digit and colon";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING, frame.extracted_error_code);
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   EXPECT_EQ("1234 :this is not good, space between last digit and colon",
             frame.error_details);
 
   frame.error_details = "123456789";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING,
-            frame.extracted_error_code);  // Not good, all numbers, no :
+  EXPECT_THAT(
+      frame.extracted_error_code,
+      IsError(QUIC_IETF_GQUIC_ERROR_MISSING));  // Not good, all numbers, no :
   EXPECT_EQ("123456789", frame.error_details);
 
   frame.error_details = "1234:";
@@ -13803,23 +13808,26 @@
 
   frame.error_details = "12345 6789:";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING,
-            frame.extracted_error_code);  // Not good
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));  // Not good
   EXPECT_EQ("12345 6789:", frame.error_details);
 
   frame.error_details = ":no numbers, is not good";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING, frame.extracted_error_code);
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   EXPECT_EQ(":no numbers, is not good", frame.error_details);
 
   frame.error_details = "qwer:also no numbers, is not good";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING, frame.extracted_error_code);
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   EXPECT_EQ("qwer:also no numbers, is not good", frame.error_details);
 
   frame.error_details = " 1234:this is not good, space before first digit";
   MaybeExtractQuicErrorCode(&frame);
-  EXPECT_EQ(QUIC_IETF_GQUIC_ERROR_MISSING, frame.extracted_error_code);
+  EXPECT_THAT(frame.extracted_error_code,
+              IsError(QUIC_IETF_GQUIC_ERROR_MISSING));
   EXPECT_EQ(" 1234:this is not good, space before first digit",
             frame.error_details);
 
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index e13f0db..b07a232 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -85,7 +85,7 @@
       error =
           session()->config()->ProcessPeerHello(msg, CLIENT, &error_details);
     }
-    EXPECT_EQ(QUIC_NO_ERROR, error);
+    EXPECT_THAT(error, IsQuicNoError());
     session()->OnConfigNegotiated();
     session()->connection()->SetDefaultEncryptionLevel(
         ENCRYPTION_FORWARD_SECURE);
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index d209454..0cee1fc 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -418,12 +418,12 @@
 
   QuicStreamPeer::CloseReadSide(stream_);
   stream_->CloseWriteSide();
-  EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
-  EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
+  EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
+  EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
   stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR,
                               ConnectionCloseSource::FROM_SELF);
-  EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
-  EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
+  EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
+  EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
 }
 
 TEST_P(QuicStreamTest, RstAlwaysSentIfNoFinSent) {
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 1bcfa6a..7a88d65 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -23,6 +23,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_sent_packet_manager.h"
 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_storage.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
@@ -1246,6 +1247,46 @@
   return arg >= min && arg <= max;
 }
 
+// A GMock matcher that prints expected and actual QuicErrorCode strings
+// upon failure.  Example usage:
+// EXPECT_THAT(stream_->connection_error()), IsError(QUIC_INTERNAL_ERROR));
+MATCHER_P(IsError,
+          expected,
+          QuicStrCat(negation ? "isn't equal to " : "is equal to ",
+                     QuicErrorCodeToString(expected))) {
+  *result_listener << QuicErrorCodeToString(arg);
+  return arg == expected;
+}
+
+// Shorthand for IsError(QUIC_NO_ERROR).
+// Example usage: EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
+MATCHER(IsQuicNoError,
+        QuicStrCat(negation ? "isn't equal to " : "is equal to ",
+                   QuicErrorCodeToString(QUIC_NO_ERROR))) {
+  *result_listener << QuicErrorCodeToString(arg);
+  return arg == QUIC_NO_ERROR;
+}
+
+// A GMock matcher that prints expected and actual QuicRstStreamErrorCode
+// strings upon failure.  Example usage:
+// EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_INTERNAL_ERROR));
+MATCHER_P(IsStreamError,
+          expected,
+          QuicStrCat(negation ? "isn't equal to " : "is equal to ",
+                     QuicRstStreamErrorCodeToString(expected))) {
+  *result_listener << QuicRstStreamErrorCodeToString(arg);
+  return arg == expected;
+}
+
+// Shorthand for IsStreamError(QUIC_STREAM_NO_ERROR).  Example usage:
+// EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
+MATCHER(IsQuicStreamNoError,
+        QuicStrCat(negation ? "isn't equal to " : "is equal to ",
+                   QuicRstStreamErrorCodeToString(QUIC_STREAM_NO_ERROR))) {
+  *result_listener << QuicRstStreamErrorCodeToString(arg);
+  return arg == QUIC_STREAM_NO_ERROR;
+}
+
 }  // namespace test
 }  // namespace quic