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

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

@@ -8,9 +8,9 @@
 
 #include "absl/strings/escaping.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_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionFailure;
 using ::testing::AssertionResult;
@@ -32,7 +32,7 @@ template <class T>
 AssertionResult VerifyOptionalEq(const T& opt_a, const T& opt_b) {
   if (opt_a) {
     if (opt_b) {
-      VERIFY_EQ(opt_a.value(), opt_b.value());
+      HTTP2_VERIFY_EQ(opt_a.value(), opt_b.value());
     } else {
       return AssertionFailure()
              << "opt_b is not set; opt_a.value()=" << opt_a.value();
@@ -71,29 +71,29 @@ FrameParts::~FrameParts() = default;
 AssertionResult FrameParts::VerifyEquals(const FrameParts& that) const {
 #define COMMON_MESSAGE "\n  this: " << *this << "\n  that: " << that
 
-  VERIFY_EQ(frame_header_, that.frame_header_) << COMMON_MESSAGE;
-  VERIFY_EQ(payload_, that.payload_) << COMMON_MESSAGE;
-  VERIFY_EQ(padding_, that.padding_) << COMMON_MESSAGE;
-  VERIFY_EQ(altsvc_origin_, that.altsvc_origin_) << COMMON_MESSAGE;
-  VERIFY_EQ(altsvc_value_, that.altsvc_value_) << COMMON_MESSAGE;
-  VERIFY_THAT(settings_, ContainerEq(that.settings_)) << COMMON_MESSAGE;
-
-#define VERIFY_OPTIONAL_FIELD(field_name) \
-  VERIFY_SUCCESS(VerifyOptionalEq(field_name, that.field_name))
-
-  VERIFY_OPTIONAL_FIELD(opt_altsvc_origin_length_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_altsvc_value_length_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_priority_update_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_goaway_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_missing_length_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_pad_length_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_ping_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_priority_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_push_promise_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_rst_stream_error_code_) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_window_update_increment_) << COMMON_MESSAGE;
-
-#undef VERIFY_OPTIONAL_FIELD
+  HTTP2_VERIFY_EQ(frame_header_, that.frame_header_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_EQ(payload_, that.payload_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_EQ(padding_, that.padding_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_EQ(altsvc_origin_, that.altsvc_origin_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_EQ(altsvc_value_, that.altsvc_value_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_EQ(settings_, that.settings_) << COMMON_MESSAGE;
+
+#define HTTP2_VERIFY_OPTIONAL_FIELD(field_name) \
+  HTTP2_VERIFY_SUCCESS(VerifyOptionalEq(field_name, that.field_name))
+
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_altsvc_origin_length_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_altsvc_value_length_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_priority_update_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_goaway_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_missing_length_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_pad_length_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_ping_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_priority_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_push_promise_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_rst_stream_error_code_) << COMMON_MESSAGE;
+  HTTP2_VERIFY_OPTIONAL_FIELD(opt_window_update_increment_) << COMMON_MESSAGE;
+
+#undef HTTP2_VERIFY_OPTIONAL_FIELD
 
   return AssertionSuccess();
 }
@@ -504,31 +504,31 @@ void FrameParts::OutputTo(std::ostream& out) const {
 
 AssertionResult FrameParts::StartFrameOfType(
     const Http2FrameHeader& header, Http2FrameType expected_frame_type) {
-  VERIFY_EQ(header.type, expected_frame_type);
-  VERIFY_FALSE(got_start_callback_);
-  VERIFY_FALSE(got_end_callback_);
-  VERIFY_EQ(frame_header_, header);
+  HTTP2_VERIFY_EQ(header.type, expected_frame_type);
+  HTTP2_VERIFY_FALSE(got_start_callback_);
+  HTTP2_VERIFY_FALSE(got_end_callback_);
+  HTTP2_VERIFY_EQ(frame_header_, header);
   got_start_callback_ = true;
   return AssertionSuccess();
 }
 
 AssertionResult FrameParts::InFrameOfType(Http2FrameType expected_frame_type) {
-  VERIFY_TRUE(got_start_callback_);
-  VERIFY_FALSE(got_end_callback_);
-  VERIFY_EQ(frame_header_.type, expected_frame_type);
+  HTTP2_VERIFY_TRUE(got_start_callback_);
+  HTTP2_VERIFY_FALSE(got_end_callback_);
+  HTTP2_VERIFY_EQ(frame_header_.type, expected_frame_type);
   return AssertionSuccess();
 }
 
 AssertionResult FrameParts::EndFrameOfType(Http2FrameType expected_frame_type) {
-  VERIFY_SUCCESS(InFrameOfType(expected_frame_type));
+  HTTP2_VERIFY_SUCCESS(InFrameOfType(expected_frame_type));
   got_end_callback_ = true;
   return AssertionSuccess();
 }
 
 AssertionResult FrameParts::InPaddedFrame() {
-  VERIFY_TRUE(got_start_callback_);
-  VERIFY_FALSE(got_end_callback_);
-  VERIFY_TRUE(FrameIsPadded(frame_header_));
+  HTTP2_VERIFY_TRUE(got_start_callback_);
+  HTTP2_VERIFY_FALSE(got_end_callback_);
+  HTTP2_VERIFY_TRUE(FrameIsPadded(frame_header_));
   return AssertionSuccess();
 }
 
@@ -537,8 +537,8 @@ AssertionResult FrameParts::AppendString(absl::string_view source,
                                          absl::optional<size_t>* opt_length) {
   target->append(source.data(), source.size());
   if (opt_length != nullptr) {
-    VERIFY_TRUE(*opt_length) << "Length is not set yet\n" << *this;
-    VERIFY_LE(target->size(), opt_length->value())
+    HTTP2_VERIFY_TRUE(*opt_length) << "Length is not set yet\n" << *this;
+    HTTP2_VERIFY_LE(target->size(), opt_length->value())
         << "String too large; source.size() = " << source.size() << "\n"
         << *this;
   }

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

@@ -7,8 +7,8 @@
 #include <algorithm>
 #include <memory>
 
+#include "quiche/http2/test_tools/verify_macros.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -99,17 +99,17 @@ void HpackBlockCollector::AppendToHpackBlockBuilder(
 
 AssertionResult HpackBlockCollector::ValidateSoleIndexedHeader(
     size_t ndx) const {
-  VERIFY_TRUE(pending_entry_.IsClear());
-  VERIFY_EQ(1u, entries_.size());
-  VERIFY_TRUE(entries_.front().ValidateIndexedHeader(ndx));
+  HTTP2_VERIFY_TRUE(pending_entry_.IsClear());
+  HTTP2_VERIFY_EQ(1u, entries_.size());
+  HTTP2_VERIFY_TRUE(entries_.front().ValidateIndexedHeader(ndx));
   return AssertionSuccess();
 }
 AssertionResult HpackBlockCollector::ValidateSoleLiteralValueHeader(
     HpackEntryType expected_type, size_t expected_index,
     bool expected_value_huffman, absl::string_view expected_value) const {
-  VERIFY_TRUE(pending_entry_.IsClear());
-  VERIFY_EQ(1u, entries_.size());
-  VERIFY_TRUE(entries_.front().ValidateLiteralValueHeader(
+  HTTP2_VERIFY_TRUE(pending_entry_.IsClear());
+  HTTP2_VERIFY_EQ(1u, entries_.size());
+  HTTP2_VERIFY_TRUE(entries_.front().ValidateLiteralValueHeader(
       expected_type, expected_index, expected_value_huffman, expected_value));
   return AssertionSuccess();
 }
@@ -117,25 +117,25 @@ AssertionResult HpackBlockCollector::ValidateSoleLiteralNameValueHeader(
     HpackEntryType expected_type, bool expected_name_huffman,
     absl::string_view expected_name, bool expected_value_huffman,
     absl::string_view expected_value) const {
-  VERIFY_TRUE(pending_entry_.IsClear());
-  VERIFY_EQ(1u, entries_.size());
-  VERIFY_TRUE(entries_.front().ValidateLiteralNameValueHeader(
+  HTTP2_VERIFY_TRUE(pending_entry_.IsClear());
+  HTTP2_VERIFY_EQ(1u, entries_.size());
+  HTTP2_VERIFY_TRUE(entries_.front().ValidateLiteralNameValueHeader(
       expected_type, expected_name_huffman, expected_name,
       expected_value_huffman, expected_value));
   return AssertionSuccess();
 }
 AssertionResult HpackBlockCollector::ValidateSoleDynamicTableSizeUpdate(
     size_t size) const {
-  VERIFY_TRUE(pending_entry_.IsClear());
-  VERIFY_EQ(1u, entries_.size());
-  VERIFY_TRUE(entries_.front().ValidateDynamicTableSizeUpdate(size));
+  HTTP2_VERIFY_TRUE(pending_entry_.IsClear());
+  HTTP2_VERIFY_EQ(1u, entries_.size());
+  HTTP2_VERIFY_TRUE(entries_.front().ValidateDynamicTableSizeUpdate(size));
   return AssertionSuccess();
 }
 
 AssertionResult HpackBlockCollector::VerifyEq(
     const HpackBlockCollector& that) const {
-  VERIFY_EQ(pending_entry_, that.pending_entry_);
-  VERIFY_EQ(entries_, that.entries_);
+  HTTP2_VERIFY_EQ(pending_entry_, that.pending_entry_);
+  HTTP2_VERIFY_EQ(entries_, that.entries_);
   return AssertionSuccess();
 }
 

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

@@ -7,9 +7,9 @@
 #include "absl/strings/str_cat.h"
 #include "quiche/http2/hpack/http2_hpack_constants.h"
 #include "quiche/http2/test_tools/hpack_string_collector.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;
 
@@ -150,42 +150,44 @@ bool HpackEntryCollector::LiteralValueExpected() const {
 }
 AssertionResult HpackEntryCollector::ValidateIndexedHeader(
     size_t expected_index) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(HpackEntryType::kIndexedHeader, header_type_);
-  VERIFY_EQ(expected_index, index_);
+  HTTP2_VERIFY_TRUE(started_);
+  HTTP2_VERIFY_TRUE(ended_);
+  HTTP2_VERIFY_EQ(HpackEntryType::kIndexedHeader, header_type_);
+  HTTP2_VERIFY_EQ(expected_index, index_);
   return ::testing::AssertionSuccess();
 }
 AssertionResult HpackEntryCollector::ValidateLiteralValueHeader(
     HpackEntryType expected_type, size_t expected_index,
     bool expected_value_huffman, absl::string_view expected_value) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(expected_type, header_type_);
-  VERIFY_NE(0u, expected_index);
-  VERIFY_EQ(expected_index, index_);
-  VERIFY_TRUE(name_.IsClear());
-  VERIFY_SUCCESS(value_.Collected(expected_value, expected_value_huffman));
+  HTTP2_VERIFY_TRUE(started_);
+  HTTP2_VERIFY_TRUE(ended_);
+  HTTP2_VERIFY_EQ(expected_type, header_type_);
+  HTTP2_VERIFY_NE(0u, expected_index);
+  HTTP2_VERIFY_EQ(expected_index, index_);
+  HTTP2_VERIFY_TRUE(name_.IsClear());
+  HTTP2_VERIFY_SUCCESS(
+      value_.Collected(expected_value, expected_value_huffman));
   return ::testing::AssertionSuccess();
 }
 AssertionResult HpackEntryCollector::ValidateLiteralNameValueHeader(
     HpackEntryType expected_type, bool expected_name_huffman,
     absl::string_view expected_name, bool expected_value_huffman,
     absl::string_view expected_value) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(expected_type, header_type_);
-  VERIFY_EQ(0u, index_);
-  VERIFY_SUCCESS(name_.Collected(expected_name, expected_name_huffman));
-  VERIFY_SUCCESS(value_.Collected(expected_value, expected_value_huffman));
+  HTTP2_VERIFY_TRUE(started_);
+  HTTP2_VERIFY_TRUE(ended_);
+  HTTP2_VERIFY_EQ(expected_type, header_type_);
+  HTTP2_VERIFY_EQ(0u, index_);
+  HTTP2_VERIFY_SUCCESS(name_.Collected(expected_name, expected_name_huffman));
+  HTTP2_VERIFY_SUCCESS(
+      value_.Collected(expected_value, expected_value_huffman));
   return ::testing::AssertionSuccess();
 }
 AssertionResult HpackEntryCollector::ValidateDynamicTableSizeUpdate(
     size_t size) const {
-  VERIFY_TRUE(started_);
-  VERIFY_TRUE(ended_);
-  VERIFY_EQ(HpackEntryType::kDynamicTableSizeUpdate, header_type_);
-  VERIFY_EQ(index_, size);
+  HTTP2_VERIFY_TRUE(started_);
+  HTTP2_VERIFY_TRUE(ended_);
+  HTTP2_VERIFY_EQ(HpackEntryType::kDynamicTableSizeUpdate, header_type_);
+  HTTP2_VERIFY_EQ(index_, size);
   return ::testing::AssertionSuccess();
 }
 

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

@@ -11,8 +11,8 @@
 
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.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 {
@@ -76,10 +76,10 @@ void HpackStringCollector::OnStringEnd() {
 
 ::testing::AssertionResult HpackStringCollector::Collected(
     absl::string_view str, bool is_huffman_encoded) const {
-  VERIFY_TRUE(HasEnded());
-  VERIFY_EQ(str.size(), len);
-  VERIFY_EQ(is_huffman_encoded, huffman_encoded);
-  VERIFY_EQ(str, s);
+  HTTP2_VERIFY_TRUE(HasEnded());
+  HTTP2_VERIFY_EQ(str.size(), len);
+  HTTP2_VERIFY_EQ(is_huffman_encoded, huffman_encoded);
+  HTTP2_VERIFY_EQ(str, s);
   return ::testing::AssertionSuccess();
 }
 

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

@@ -4,6 +4,7 @@
 
 #include "quiche/http2/test_tools/http2_frame_builder.h"
 
+#include "absl/strings/escaping.h"
 #include "quiche/common/platform/api/quiche_test.h"
 
 namespace http2 {
@@ -21,13 +22,12 @@ TEST(Http2FrameBuilderTest, Constructors) {
     Http2FrameBuilder fb(Http2FrameType::DATA, 0, 123);
     EXPECT_EQ(9u, fb.size());
 
-    const char kData[] = {
-        0x00, 0x00, 0x00,        // Payload length: 0 (unset)
-        0x00,                    // Frame type: DATA
-        0x00,                    // Flags: none
-        0x00, 0x00, 0x00, 0x7b,  // Stream ID: 123
-    };
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    const std::string kData = absl::HexStringToBytes(
+        "000000"      // Payload length: 0 (unset)
+        "00"          // Frame type: DATA
+        "00"          // Flags: none
+        "0000007b");  // Stream ID: 123
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameHeader header;
@@ -38,13 +38,12 @@ TEST(Http2FrameBuilderTest, Constructors) {
     Http2FrameBuilder fb(header);
     EXPECT_EQ(9u, fb.size());
 
-    const char kData[] = {
-        0xff, 0xff, 0xff,        // Payload length: 2^24 - 1 (max uint24)
-        0x01,                    // Frame type: HEADER
-        0x04,                    // Flags: END_HEADERS
-        0x7f, 0xff, 0xff, 0xff,  // Stream ID: stream id mask
-    };
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    const std::string kData = absl::HexStringToBytes(
+        "ffffff"      // Payload length: 2^24 - 1 (max uint24)
+        "01"          // Frame type: HEADER
+        "04"          // Flags: END_HEADERS
+        "7fffffff");  // Stream ID: stream id mask
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
@@ -64,23 +63,19 @@ TEST(Http2FrameBuilderTest, SetPayloadLength) {
   fb.SetPayloadLength();
   EXPECT_EQ(70u, fb.size());
 
-  // clang-format off
-  const char kData[] = {
-      0x00, 0x00, 0x3d,              // Payload length: 61
-      0x00,                          // Frame type: DATA
-      0x08,                          // Flags: PADDED
-      0x00, 0x00, 0x4e, 0x20,        // Stream ID: 20000
-      0x32,                          // Padding Length: 50
-      't', 'e', 'n', ' ', 'b',       // "ten b"
-      'y', 't', 'e', 's', '.',       // "ytes."
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Padding bytes
-  };
-  // clang-format on
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "00003d"                  // Payload length: 61
+      "00"                      // Frame type: DATA
+      "08"                      // Flags: PADDED
+      "00004e20"                // Stream ID: 20000
+      "32"                      // Padding Length: 50
+      "74656e2062797465732e"    // "ten bytes."
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000"    // Padding bytes
+      "00000000000000000000");  // Padding bytes
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, Settings) {
@@ -116,66 +111,55 @@ TEST(Http2FrameBuilderTest, Settings) {
 
   fb.SetPayloadLength(payload_size);
 
-  // clang-format off
-  const char kData[] = {
-      0x00, 0x00, 0x24,        // Payload length: 36
-      0x04,                    // Frame type: SETTINGS
-      0x00,                    // Flags: none
-      0x00, 0x00, 0x00, 0x00,  // Stream ID: 0
-      0x00, 0x01,              // HEADER_TABLE_SIZE
-      0x00, 0x00, 0x10, 0x00,  // 4096
-      0x00, 0x02,              // ENABLE_PUSH
-      0x00, 0x00, 0x00, 0x00,  // 0
-      0x00, 0x03,              // MAX_CONCURRENT_STREAMS
-      0xff, 0xff, 0xff, 0xff,  // 0xffffffff (max uint32)
-      0x00, 0x04,              // INITIAL_WINDOW_SIZE
-      0x00, 0x01, 0x00, 0x00,  // 4096
-      0x00, 0x05,              // MAX_FRAME_SIZE
-      0x00, 0x00, 0x40, 0x00,  // 4096
-      0x00, 0x06,              // MAX_HEADER_LIST_SIZE
-      0x00, 0x00, 0x04, 0x00,  // 1024
-  };
-  // clang-format on
-  EXPECT_EQ(absl::string_view(kData, 9), fb.buffer().substr(0, 9));
-  for (int n = 0; n < 6; ++n) {
-    int offset = 9 + n * 6;
-    EXPECT_EQ(absl::string_view(kData + offset, 6),
-              fb.buffer().substr(offset, 6))
-        << "Setting #" << n;
-  }
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "000024"      // Payload length: 36
+      "04"          // Frame type: SETTINGS
+      "00"          // Flags: none
+      "00000000"    // Stream ID: 0
+      "0001"        // HEADER_TABLE_SIZE
+      "00001000"    // 4096
+      "0002"        // ENABLE_PUSH
+      "00000000"    // 0
+      "0003"        // MAX_CONCURRENT_STREAMS
+      "ffffffff"    // 0xffffffff (max uint32)
+      "0004"        // INITIAL_WINDOW_SIZE
+      "00010000"    // 4096
+      "0005"        // MAX_FRAME_SIZE
+      "00004000"    // 4096
+      "0006"        // MAX_HEADER_LIST_SIZE
+      "00000400");  // 1024
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, EnhanceYourCalm) {
-  const char kData[] = {0x00, 0x00, 0x00, 0x0b};
-  const absl::string_view expected(kData, sizeof kData);
+  const std::string kData = absl::HexStringToBytes("0000000b");
   {
     Http2FrameBuilder fb;
     fb.Append(Http2ErrorCode::ENHANCE_YOUR_CALM);
-    EXPECT_EQ(expected, fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameBuilder fb;
     Http2RstStreamFields rsp;
     rsp.error_code = Http2ErrorCode::ENHANCE_YOUR_CALM;
     fb.Append(rsp);
-    EXPECT_EQ(expected, fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
 TEST(Http2FrameBuilderTest, PushPromise) {
-  const char kData[] = {0x7f, 0xff, 0xff, 0xff};
+  const std::string kData = absl::HexStringToBytes("7fffffff");
   {
     Http2FrameBuilder fb;
     fb.Append(Http2PushPromiseFields{0x7fffffff});
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameBuilder fb;
     // Will generate an error if the high-bit of the stream id is set.
     EXPECT_NONFATAL_FAILURE(fb.Append(Http2PushPromiseFields{0xffffffff}),
                             kHighBitSetMsg);
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
@@ -184,29 +168,28 @@ TEST(Http2FrameBuilderTest, Ping) {
   Http2PingFields ping{"8 bytes"};
   fb.Append(ping);
 
-  const char kData[] = {'8', ' ', 'b', 'y', 't', 'e', 's', '\0'};
-  EXPECT_EQ(sizeof kData, Http2PingFields::EncodedSize());
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const absl::string_view kData{"8 bytes\0", 8};
+  EXPECT_EQ(kData.size(), Http2PingFields::EncodedSize());
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, GoAway) {
-  const char kData[] = {
-      0x12, 0x34, 0x56, 0x78,  // Last Stream Id
-      0x00, 0x00, 0x00, 0x01,  // Error code
-  };
-  EXPECT_EQ(sizeof kData, Http2GoAwayFields::EncodedSize());
+  const std::string kData = absl::HexStringToBytes(
+      "12345678"    // Last Stream Id
+      "00000001");  // Error code
+  EXPECT_EQ(kData.size(), Http2GoAwayFields::EncodedSize());
   {
     Http2FrameBuilder fb;
     Http2GoAwayFields ga(0x12345678, Http2ErrorCode::PROTOCOL_ERROR);
     fb.Append(ga);
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
   {
     Http2FrameBuilder fb;
     // Will generate a test failure if the high-bit of the stream id is set.
     Http2GoAwayFields ga(0x92345678, Http2ErrorCode::PROTOCOL_ERROR);
     EXPECT_NONFATAL_FAILURE(fb.Append(ga), kHighBitSetMsg);
-    EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+    EXPECT_EQ(kData, fb.buffer());
   }
 }
 
@@ -221,25 +204,23 @@ TEST(Http2FrameBuilderTest, WindowUpdate) {
   // Will generate a test failure if the increment is zero.
   EXPECT_NONFATAL_FAILURE(fb.Append(Http2WindowUpdateFields{0}), "non-zero");
 
-  const char kData[] = {
-      0x00, 0x01, 0xe2, 0x40,  // Valid Window Size Increment
-      0x00, 0x00, 0x00, 0x01,  // High-bit cleared
-      0x00, 0x00, 0x00, 0x00,  // Invalid Window Size Increment
-  };
-  EXPECT_EQ(sizeof kData, 3 * Http2WindowUpdateFields::EncodedSize());
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "0001e240"    // Valid Window Size Increment
+      "00000001"    // High-bit cleared
+      "00000000");  // Invalid Window Size Increment
+  EXPECT_EQ(kData.size(), 3 * Http2WindowUpdateFields::EncodedSize());
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 TEST(Http2FrameBuilderTest, AltSvc) {
   Http2FrameBuilder fb;
   fb.Append(Http2AltSvcFields{99});
   fb.Append(Http2AltSvcFields{0});  // No optional origin
-  const char kData[] = {
-      0x00, 0x63,  // Has origin.
-      0x00, 0x00,  // Doesn't have origin.
-  };
-  EXPECT_EQ(sizeof kData, 2 * Http2AltSvcFields::EncodedSize());
-  EXPECT_EQ(absl::string_view(kData, sizeof kData), fb.buffer());
+  const std::string kData = absl::HexStringToBytes(
+      "0063"    // Has origin.
+      "0000");  // Doesn't have origin.
+  EXPECT_EQ(kData.size(), 2 * Http2AltSvcFields::EncodedSize());
+  EXPECT_EQ(kData, fb.buffer());
 }
 
 }  // namespace

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

@@ -77,7 +77,7 @@ DecodeStatus PayloadDecoderBaseTest::ResumeDecoding(DecodeBuffer* db) {
 ::testing::AssertionResult
 PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(
     absl::string_view payload, Validator validator) {
-  VERIFY_TRUE(frame_header_is_set_);
+  HTTP2_VERIFY_TRUE(frame_header_is_set_);
   // Cap the payload to be decoded at the declared payload length. This is
   // required by the decoders' preconditions; they are designed on the
   // assumption that they're never passed more than they're permitted to