@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

package/third_party/quiche/quiche/http2/decoder/payload_decoders/unknown_payload_decoder_test.cc

@@ -16,7 +16,7 @@
 #include "quiche/http2/test_tools/frame_parts_collector.h"
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/decoder/payload_decoders/window_update_payload_decoder_test.cc

@@ -14,7 +14,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
 #include "quiche/http2/test_tools/payload_decoder_base_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_block_decoder_test.cc

@@ -16,9 +16,9 @@
 #include "quiche/http2/test_tools/hpack_block_collector.h"
 #include "quiche/http2/test_tools/hpack_example.h"
 #include "quiche/http2/test_tools/http2_random.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace test {

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_decoder_state_test.cc

@@ -12,9 +12,9 @@
 #include "absl/strings/string_view.h"
 #include "quiche/http2/hpack/http2_hpack_constants.h"
 #include "quiche/http2/http2_constants.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -45,7 +45,7 @@ class MockHpackDecoderListener : public HpackDecoderListener {
 
 enum StringBacking { STATIC, UNBUFFERED, BUFFERED };
 
-class HpackDecoderStateTest : public QuicheTest {
+class HpackDecoderStateTest : public quiche::test::QuicheTest {
  protected:
   HpackDecoderStateTest() : decoder_state_(&listener_) {}
 
@@ -147,25 +147,25 @@ class HpackDecoderStateTest : public QuicheTest {
                               const char* value) {
     const HpackStringPair* entry =
         Lookup(dynamic_index + kFirstDynamicTableIndex - 1);
-    VERIFY_NE(entry, nullptr);
-    VERIFY_EQ(entry->name, name);
-    VERIFY_EQ(entry->value, value);
+    HTTP2_VERIFY_NE(entry, nullptr);
+    HTTP2_VERIFY_EQ(entry->name, name);
+    HTTP2_VERIFY_EQ(entry->value, value);
     return AssertionSuccess();
   }
   AssertionResult VerifyNoEntry(size_t dynamic_index) {
     const HpackStringPair* entry =
         Lookup(dynamic_index + kFirstDynamicTableIndex - 1);
-    VERIFY_EQ(entry, nullptr);
+    HTTP2_VERIFY_EQ(entry, nullptr);
     return AssertionSuccess();
   }
   AssertionResult VerifyDynamicTableContents(
       const std::vector<std::pair<const char*, const char*>>& entries) {
     size_t index = 1;
     for (const auto& entry : entries) {
-      VERIFY_SUCCESS(VerifyEntry(index, entry.first, entry.second));
+      HTTP2_VERIFY_SUCCESS(VerifyEntry(index, entry.first, entry.second));
       ++index;
     }
-    VERIFY_SUCCESS(VerifyNoEntry(index));
+    HTTP2_VERIFY_SUCCESS(VerifyNoEntry(index));
     return AssertionSuccess();
   }
 

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc

@@ -9,9 +9,10 @@
 #include <initializer_list>
 
 #include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -21,7 +22,7 @@ namespace http2 {
 namespace test {
 namespace {
 
-class HpackDecoderStringBufferTest : public QuicheTest {
+class HpackDecoderStringBufferTest : public quiche::test::QuicheTest {
  protected:
   typedef HpackDecoderStringBuffer::State State;
   typedef HpackDecoderStringBuffer::Backing Backing;
@@ -37,7 +38,7 @@ class HpackDecoderStringBufferTest : public QuicheTest {
     buf_.OutputDebugStringTo(ss);
     std::string dbg_str(ss.str());
     for (const auto& expected : strs) {
-      VERIFY_THAT(dbg_str, HasSubstr(expected));
+      HTTP2_VERIFY_TRUE(absl::StrContains(dbg_str, expected));
     }
     return AssertionSuccess();
   }

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_decoder_tables_test.cc

@@ -12,9 +12,9 @@
 #include "quiche/http2/hpack/http2_hpack_constants.h"
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/random_util.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -54,7 +54,7 @@ void ShuffleCollection(C* collection, Http2Random* r) {
   std::shuffle(collection->begin(), collection->end(), *r);
 }
 
-class HpackDecoderStaticTableTest : public QuicheTest {
+class HpackDecoderStaticTableTest : public quiche::test::QuicheTest {
  protected:
   HpackDecoderStaticTableTest() = default;
 
@@ -69,13 +69,13 @@ class HpackDecoderStaticTableTest : public QuicheTest {
   AssertionResult VerifyStaticTableContents() {
     for (const auto& expected : shuffled_static_entries()) {
       const HpackStringPair* found = Lookup(expected.index);
-      VERIFY_NE(found, nullptr);
-      VERIFY_EQ(expected.name, found->name) << expected.index;
-      VERIFY_EQ(expected.value, found->value) << expected.index;
+      HTTP2_VERIFY_NE(found, nullptr);
+      HTTP2_VERIFY_EQ(expected.name, found->name) << expected.index;
+      HTTP2_VERIFY_EQ(expected.value, found->value) << expected.index;
     }
 
     // There should be no entry with index 0.
-    VERIFY_EQ(nullptr, Lookup(0));
+    HTTP2_VERIFY_EQ(nullptr, Lookup(0));
     return AssertionSuccess();
   }
 
@@ -166,27 +166,27 @@ class HpackDecoderTablesTest : public HpackDecoderStaticTableTest {
   // Verify that the contents of the actual dynamic table match those in
   // fake_dynamic_table_.
   AssertionResult VerifyDynamicTableContents() {
-    VERIFY_EQ(current_dynamic_size(), FakeSize());
-    VERIFY_EQ(num_dynamic_entries(), fake_dynamic_table_.size());
+    HTTP2_VERIFY_EQ(current_dynamic_size(), FakeSize());
+    HTTP2_VERIFY_EQ(num_dynamic_entries(), fake_dynamic_table_.size());
 
     for (size_t ndx = 0; ndx < fake_dynamic_table_.size(); ++ndx) {
       const HpackStringPair* found = Lookup(ndx + kFirstDynamicTableIndex);
-      VERIFY_NE(found, nullptr);
+      HTTP2_VERIFY_NE(found, nullptr);
 
       const auto& expected = fake_dynamic_table_[ndx];
-      VERIFY_EQ(Name(expected), found->name);
-      VERIFY_EQ(Value(expected), found->value);
+      HTTP2_VERIFY_EQ(Name(expected), found->name);
+      HTTP2_VERIFY_EQ(Value(expected), found->value);
     }
 
     // Make sure there are no more entries.
-    VERIFY_EQ(nullptr,
-              Lookup(fake_dynamic_table_.size() + kFirstDynamicTableIndex));
+    HTTP2_VERIFY_EQ(
+        nullptr, Lookup(fake_dynamic_table_.size() + kFirstDynamicTableIndex));
     return AssertionSuccess();
   }
 
   // Apply an update to the limit on the maximum size of the dynamic table.
   AssertionResult DynamicTableSizeUpdate(size_t size_limit) {
-    VERIFY_EQ(current_dynamic_size(), FakeSize());
+    HTTP2_VERIFY_EQ(current_dynamic_size(), FakeSize());
     if (size_limit < current_dynamic_size()) {
       // Will need to trim the dynamic table's oldest entries.
       tables_.DynamicTableSizeUpdate(size_limit);
@@ -205,10 +205,10 @@ class HpackDecoderTablesTest : public HpackDecoderStaticTableTest {
     size_t old_count = num_dynamic_entries();
     tables_.Insert(name, value);
     FakeInsert(name, value);
-    VERIFY_EQ(old_count + 1, fake_dynamic_table_.size());
+    HTTP2_VERIFY_EQ(old_count + 1, fake_dynamic_table_.size());
     FakeTrim(dynamic_size_limit());
-    VERIFY_EQ(current_dynamic_size(), FakeSize());
-    VERIFY_EQ(num_dynamic_entries(), fake_dynamic_table_.size());
+    HTTP2_VERIFY_EQ(current_dynamic_size(), FakeSize());
+    HTTP2_VERIFY_EQ(num_dynamic_entries(), fake_dynamic_table_.size());
     return VerifyDynamicTableContents();
   }
 

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_decoder_test.cc

@@ -21,9 +21,9 @@
 #include "quiche/http2/test_tools/hpack_example.h"
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/random_util.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -69,7 +69,7 @@ class MockHpackDecoderListener : public HpackDecoderListener {
               (override));
 };
 
-class HpackDecoderTest : public QuicheTestWithParam<bool>,
+class HpackDecoderTest : public quiche::test::QuicheTestWithParam<bool>,
                          public HpackDecoderListener {
  protected:
   // Note that we initialize the random number generator with the same seed
@@ -124,39 +124,39 @@ class HpackDecoderTest : public QuicheTestWithParam<bool>,
   AssertionResult DecodeBlock(absl::string_view block) {
     QUICHE_VLOG(1) << "HpackDecoderTest::DecodeBlock";
 
-    VERIFY_FALSE(decoder_.DetectError());
-    VERIFY_TRUE(error_messages_.empty());
-    VERIFY_FALSE(saw_start_);
-    VERIFY_FALSE(saw_end_);
+    HTTP2_VERIFY_FALSE(decoder_.DetectError());
+    HTTP2_VERIFY_TRUE(error_messages_.empty());
+    HTTP2_VERIFY_FALSE(saw_start_);
+    HTTP2_VERIFY_FALSE(saw_end_);
     header_entries_.clear();
 
-    VERIFY_FALSE(decoder_.DetectError());
-    VERIFY_TRUE(decoder_.StartDecodingBlock());
-    VERIFY_FALSE(decoder_.DetectError());
+    HTTP2_VERIFY_FALSE(decoder_.DetectError());
+    HTTP2_VERIFY_TRUE(decoder_.StartDecodingBlock());
+    HTTP2_VERIFY_FALSE(decoder_.DetectError());
 
     if (fragment_the_hpack_block_) {
       // See note in ctor regarding RNG.
       while (!block.empty()) {
         size_t fragment_size = random_.RandomSizeSkewedLow(block.size());
         DecodeBuffer db(block.substr(0, fragment_size));
-        VERIFY_TRUE(decoder_.DecodeFragment(&db));
-        VERIFY_EQ(0u, db.Remaining());
+        HTTP2_VERIFY_TRUE(decoder_.DecodeFragment(&db));
+        HTTP2_VERIFY_EQ(0u, db.Remaining());
         block.remove_prefix(fragment_size);
       }
     } else {
       DecodeBuffer db(block);
-      VERIFY_TRUE(decoder_.DecodeFragment(&db));
-      VERIFY_EQ(0u, db.Remaining());
+      HTTP2_VERIFY_TRUE(decoder_.DecodeFragment(&db));
+      HTTP2_VERIFY_EQ(0u, db.Remaining());
     }
-    VERIFY_FALSE(decoder_.DetectError());
+    HTTP2_VERIFY_FALSE(decoder_.DetectError());
 
-    VERIFY_TRUE(decoder_.EndDecodingBlock());
+    HTTP2_VERIFY_TRUE(decoder_.EndDecodingBlock());
     if (saw_end_) {
-      VERIFY_FALSE(decoder_.DetectError());
-      VERIFY_TRUE(error_messages_.empty());
+      HTTP2_VERIFY_FALSE(decoder_.DetectError());
+      HTTP2_VERIFY_TRUE(error_messages_.empty());
     } else {
-      VERIFY_TRUE(decoder_.DetectError());
-      VERIFY_FALSE(error_messages_.empty());
+      HTTP2_VERIFY_TRUE(decoder_.DetectError());
+      HTTP2_VERIFY_FALSE(error_messages_.empty());
     }
 
     saw_start_ = saw_end_ = false;
@@ -184,25 +184,25 @@ class HpackDecoderTest : public QuicheTestWithParam<bool>,
                               const char* value) {
     const HpackStringPair* entry =
         Lookup(dynamic_index + kFirstDynamicTableIndex - 1);
-    VERIFY_NE(entry, nullptr);
-    VERIFY_EQ(entry->name, name);
-    VERIFY_EQ(entry->value, value);
+    HTTP2_VERIFY_NE(entry, nullptr);
+    HTTP2_VERIFY_EQ(entry->name, name);
+    HTTP2_VERIFY_EQ(entry->value, value);
     return AssertionSuccess();
   }
   AssertionResult VerifyNoEntry(size_t dynamic_index) {
     const HpackStringPair* entry =
         Lookup(dynamic_index + kFirstDynamicTableIndex - 1);
-    VERIFY_EQ(entry, nullptr);
+    HTTP2_VERIFY_EQ(entry, nullptr);
     return AssertionSuccess();
   }
   AssertionResult VerifyDynamicTableContents(
       const std::vector<std::pair<const char*, const char*>>& entries) {
     size_t index = 1;
     for (const auto& entry : entries) {
-      VERIFY_SUCCESS(VerifyEntry(index, entry.first, entry.second));
+      HTTP2_VERIFY_SUCCESS(VerifyEntry(index, entry.first, entry.second));
       ++index;
     }
-    VERIFY_SUCCESS(VerifyNoEntry(index));
+    HTTP2_VERIFY_SUCCESS(VerifyNoEntry(index));
     return AssertionSuccess();
   }
 

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_entry_decoder_test.cc

@@ -11,9 +11,9 @@
 #include "quiche/http2/test_tools/hpack_block_builder.h"
 #include "quiche/http2/test_tools/hpack_entry_collector.h"
 #include "quiche/http2/test_tools/http2_random.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace test {

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_entry_type_decoder_test.cc

@@ -7,10 +7,10 @@
 #include <vector>
 
 #include "quiche/http2/test_tools/hpack_block_builder.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionSuccess;
 
@@ -39,8 +39,9 @@ TEST_F(HpackEntryTypeDecoderTest, DynamicTableSizeUpdate) {
     bb.AppendDynamicTableSizeUpdate(size);
     DecodeBuffer db(bb.buffer());
     auto validator = [size, this]() -> AssertionResult {
-      VERIFY_EQ(HpackEntryType::kDynamicTableSizeUpdate, decoder_.entry_type());
-      VERIFY_EQ(size, decoder_.varint());
+      HTTP2_VERIFY_EQ(HpackEntryType::kDynamicTableSizeUpdate,
+                      decoder_.entry_type());
+      HTTP2_VERIFY_EQ(size, decoder_.varint());
       return AssertionSuccess();
     };
     EXPECT_TRUE(DecodeAndValidateSeveralWays(&db, kReturnNonZeroOnFirst,
@@ -66,8 +67,8 @@ TEST_F(HpackEntryTypeDecoderTest, HeaderWithIndex) {
       bb.AppendEntryTypeAndVarint(entry_type, index);
       DecodeBuffer db(bb.buffer());
       auto validator = [entry_type, index, this]() -> AssertionResult {
-        VERIFY_EQ(entry_type, decoder_.entry_type());
-        VERIFY_EQ(index, decoder_.varint());
+        HTTP2_VERIFY_EQ(entry_type, decoder_.entry_type());
+        HTTP2_VERIFY_EQ(index, decoder_.varint());
         return AssertionSuccess();
       };
       EXPECT_TRUE(DecodeAndValidateSeveralWays(&db, kReturnNonZeroOnFirst,

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_string_decoder_test.cc

@@ -11,9 +11,9 @@
 #include "quiche/http2/test_tools/hpack_block_builder.h"
 #include "quiche/http2/test_tools/hpack_string_collector.h"
 #include "quiche/http2/test_tools/http2_random.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace test {
@@ -56,11 +56,11 @@ class HpackStringDecoderTest : public RandomDecoderTest {
                DecodeStatus /*status*/) -> AssertionResult {
       AssertionResult result = Collected(expected_str, expected_huffman);
       if (result) {
-        VERIFY_EQ(collector_,
-                  HpackStringCollector(expected_str, expected_huffman));
+        HTTP2_VERIFY_EQ(collector_,
+                        HpackStringCollector(expected_str, expected_huffman));
       } else {
-        VERIFY_NE(collector_,
-                  HpackStringCollector(expected_str, expected_huffman));
+        HTTP2_VERIFY_NE(collector_,
+                        HpackStringCollector(expected_str, expected_huffman));
       }
       QUICHE_VLOG(2) << collector_.ToString();
       collector_.Clear();

package/third_party/quiche/quiche/http2/hpack/decoder/hpack_whole_entry_buffer_test.cc

@@ -40,7 +40,7 @@ class MockHpackWholeEntryListener : public HpackWholeEntryListener {
               (override));
 };
 
-class HpackWholeEntryBufferTest : public QuicheTest {
+class HpackWholeEntryBufferTest : public quiche::test::QuicheTest {
  protected:
   HpackWholeEntryBufferTest() : entry_buffer_(&listener_, kMaxStringSize) {}
   ~HpackWholeEntryBufferTest() override = default;

package/third_party/quiche/quiche/http2/hpack/huffman/hpack_huffman_decoder_test.cc

@@ -12,9 +12,9 @@
 #include "absl/strings/escaping.h"
 #include "quiche/http2/decoder/decode_buffer.h"
 #include "quiche/http2/decoder/decode_status.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 namespace http2 {
 namespace test {

package/third_party/quiche/quiche/http2/hpack/huffman/hpack_huffman_encoder_test.cc

@@ -11,7 +11,7 @@
 namespace http2 {
 namespace {
 
-class HuffmanEncoderTest : public ::testing::TestWithParam<bool> {
+class HuffmanEncoderTest : public quiche::test::QuicheTestWithParam<bool> {
  protected:
   HuffmanEncoderTest() : use_fast_encoder_(GetParam()) {}
   virtual ~HuffmanEncoderTest() = default;

package/third_party/quiche/quiche/http2/hpack/huffman/hpack_huffman_transcoder_test.cc

@@ -11,7 +11,7 @@
 #include "quiche/http2/decoder/decode_status.h"
 #include "quiche/http2/hpack/huffman/hpack_huffman_decoder.h"
 #include "quiche/http2/hpack/huffman/hpack_huffman_encoder.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/quiche_text_utils.h"
 
@@ -76,14 +76,14 @@ class HpackHuffmanTranscoderTest : public RandomDecoderTest {
     size_t encoded_size = HuffmanSize(plain);
     std::string encoded;
     HuffmanEncode(plain, encoded_size, &encoded);
-    VERIFY_EQ(encoded_size, encoded.size());
+    HTTP2_VERIFY_EQ(encoded_size, encoded.size());
     if (!expected_huffman.empty() || plain.empty()) {
-      VERIFY_EQ(encoded, expected_huffman);
+      HTTP2_VERIFY_EQ(encoded, expected_huffman);
     }
     input_bytes_expected_ = encoded.size();
     auto validator = [plain, this]() -> AssertionResult {
-      VERIFY_EQ(output_buffer_.size(), plain.size());
-      VERIFY_EQ(output_buffer_, plain);
+      HTTP2_VERIFY_EQ(output_buffer_.size(), plain.size());
+      HTTP2_VERIFY_EQ(output_buffer_, plain);
       return AssertionSuccess();
     };
     DecodeBuffer db(encoded);

package/third_party/quiche/quiche/http2/hpack/varint/hpack_varint_decoder_test.cc

@@ -11,10 +11,10 @@
 #include "absl/base/macros.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/string_view.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionSuccess;
 
@@ -36,7 +36,7 @@ class HpackVarintDecoderTest
     Validator validator = [expected_value, this](
                               const DecodeBuffer& /*db*/,
                               DecodeStatus /*status*/) -> AssertionResult {
-      VERIFY_EQ(expected_value, decoder_.value())
+      HTTP2_VERIFY_EQ(expected_value, decoder_.value())
           << "Value doesn't match expected: " << decoder_.value()
           << " != " << expected_value;
       return AssertionSuccess();
@@ -54,7 +54,7 @@ class HpackVarintDecoderTest
   void DecodeExpectError(absl::string_view data, uint32_t prefix_length) {
     Validator validator = [](const DecodeBuffer& /*db*/,
                              DecodeStatus status) -> AssertionResult {
-      VERIFY_EQ(DecodeStatus::kDecodeError, status);
+      HTTP2_VERIFY_EQ(DecodeStatus::kDecodeError, status);
       return AssertionSuccess();
     };
 

package/third_party/quiche/quiche/http2/hpack/varint/hpack_varint_round_trip_test.cc

@@ -17,7 +17,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "quiche/http2/test_tools/hpack_block_builder.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/quiche_text_utils.h"

package/third_party/quiche/quiche/http2/http2_constants_test.cc

@@ -10,7 +10,7 @@ namespace http2 {
 namespace test {
 namespace {
 
-class Http2ConstantsTest : public QuicheTest {};
+class Http2ConstantsTest : public quiche::test::QuicheTest {};
 
 TEST(Http2ConstantsTest, Http2FrameType) {
   EXPECT_EQ(Http2FrameType::DATA, static_cast<Http2FrameType>(0));

package/third_party/quiche/quiche/http2/http2_structures_test.cc

@@ -22,8 +22,8 @@
 #include "absl/strings/str_cat.h"
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -58,20 +58,20 @@ AssertionResult VerifyRandomCalls() {
 
   // The two Randomize calls should have made the same number of calls into
   // the Http2Random implementations.
-  VERIFY_EQ(seq1.Rand64(), seq2.Rand64());
+  HTTP2_VERIFY_EQ(seq1.Rand64(), seq2.Rand64());
 
   // And because Http2Random implementation is returning the same sequence, and
   // Randomize should have been consistent in applying those results, the two
   // Ts should have the same value.
-  VERIFY_EQ(t1, t2);
+  HTTP2_VERIFY_EQ(t1, t2);
 
   Randomize(&t2, &seq2);
-  VERIFY_NE(t1, t2);
+  HTTP2_VERIFY_NE(t1, t2);
 
   Randomize(&t1, &seq1);
-  VERIFY_EQ(t1, t2);
+  HTTP2_VERIFY_EQ(t1, t2);
 
-  VERIFY_EQ(seq1.Rand64(), seq2.Rand64());
+  HTTP2_VERIFY_EQ(seq1.Rand64(), seq2.Rand64());
 
   return AssertionSuccess();
 }
@@ -106,8 +106,9 @@ TEST(Http2FrameHeaderTest, Constructor) {
   } while (frame_type++ != 255);
 
 #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
-  EXPECT_DEBUG_DEATH(Http2FrameHeader(0x01000000, Http2FrameType::DATA, 0, 1),
-                     "payload_length");
+  EXPECT_QUICHE_DEBUG_DEATH(
+      Http2FrameHeader(0x01000000, Http2FrameType::DATA, 0, 1),
+      "payload_length");
 #endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
 }
 
@@ -158,9 +159,10 @@ std::string TestParamToString(const testing::TestParamInfo<TestParams>& info) {
   return absl::StrCat(Http2FrameTypeToString(type), static_cast<int>(flags));
 }
 
-// The tests of the valid frame types include EXPECT_DEBUG_DEATH, which is
-// quite slow, so using value parameterized tests in order to allow sharding.
-class Http2FrameHeaderTypeAndFlagTest : public QuicheTestWithParam<TestParams> {
+// The tests of the valid frame types include EXPECT_QUICHE_DEBUG_DEATH, which
+// is quite slow, so using value parameterized tests in order to allow sharding.
+class Http2FrameHeaderTypeAndFlagTest
+    : public quiche::test::QuicheTestWithParam<TestParams> {
  protected:
   Http2FrameHeaderTypeAndFlagTest()
       : type_(std::get<0>(GetParam())), flags_(std::get<1>(GetParam())) {
@@ -207,7 +209,7 @@ TEST_P(IsEndStreamTest, IsEndStream) {
       }
       break;
     default:
-      EXPECT_DEBUG_DEATH(v.IsEndStream(), "DATA.*HEADERS") << v;
+      EXPECT_QUICHE_DEBUG_DEATH(v.IsEndStream(), "DATA.*HEADERS");
   }
 }
 
@@ -244,7 +246,7 @@ TEST_P(IsACKTest, IsAck) {
       }
       break;
     default:
-      EXPECT_DEBUG_DEATH(v.IsAck(), "SETTINGS.*PING") << v;
+      EXPECT_QUICHE_DEBUG_DEATH(v.IsAck(), "SETTINGS.*PING");
   }
 }
 
@@ -283,9 +285,8 @@ TEST_P(IsEndHeadersTest, IsEndHeaders) {
       }
       break;
     default:
-      EXPECT_DEBUG_DEATH(v.IsEndHeaders(),
-                         "HEADERS.*PUSH_PROMISE.*CONTINUATION")
-          << v;
+      EXPECT_QUICHE_DEBUG_DEATH(v.IsEndHeaders(),
+                                "HEADERS.*PUSH_PROMISE.*CONTINUATION");
   }
 }
 
@@ -324,7 +325,7 @@ TEST_P(IsPaddedTest, IsPadded) {
       }
       break;
     default:
-      EXPECT_DEBUG_DEATH(v.IsPadded(), "DATA.*HEADERS.*PUSH_PROMISE") << v;
+      EXPECT_QUICHE_DEBUG_DEATH(v.IsPadded(), "DATA.*HEADERS.*PUSH_PROMISE");
   }
 }
 
@@ -361,7 +362,7 @@ TEST_P(HasPriorityTest, HasPriority) {
       }
       break;
     default:
-      EXPECT_DEBUG_DEATH(v.HasPriority(), "HEADERS") << v;
+      EXPECT_QUICHE_DEBUG_DEATH(v.HasPriority(), "HEADERS");
   }
 }
 
@@ -378,14 +379,14 @@ TEST(Http2PriorityFieldsTest, Constructor) {
   EXPECT_EQ(is_exclusive, v.is_exclusive);
 
   // The high-bit must not be set on the stream id.
-  EXPECT_DEBUG_DEATH(
+  EXPECT_QUICHE_DEBUG_DEATH(
       Http2PriorityFields(stream_dependency | 0x80000000, weight, is_exclusive),
       "31-bit");
 
   // The weight must be in the range 1-256.
-  EXPECT_DEBUG_DEATH(Http2PriorityFields(stream_dependency, 0, is_exclusive),
-                     "too small");
-  EXPECT_DEBUG_DEATH(
+  EXPECT_QUICHE_DEBUG_DEATH(
+      Http2PriorityFields(stream_dependency, 0, is_exclusive), "too small");
+  EXPECT_QUICHE_DEBUG_DEATH(
       Http2PriorityFields(stream_dependency, weight + 256, is_exclusive),
       "too large");
 

package/third_party/quiche/quiche/http2/test_tools/frame_decoder_state_test_util.cc

@@ -8,7 +8,7 @@
 #include "quiche/http2/test_tools/http2_random.h"
 #include "quiche/http2/test_tools/http2_structure_decoder_test_util.h"
 #include "quiche/http2/test_tools/http2_structures_test_util.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 
 namespace http2 {

package/third_party/quiche/quiche/http2/test_tools/frame_decoder_state_test_util.h

@@ -7,7 +7,7 @@
 
 #include "quiche/http2/decoder/frame_decoder_state.h"
 #include "quiche/http2/http2_structures.h"
-#include "quiche/http2/test_tools/random_decoder_test.h"
+#include "quiche/http2/test_tools/random_decoder_test_base.h"
 #include "quiche/common/platform/api/quiche_export.h"
 
 namespace http2 {