diff --git a/http2/adapter/test_utils.cc b/http2/adapter/test_utils.cc
new file mode 100644
index 0000000..6477e9c
--- /dev/null
+++ b/http2/adapter/test_utils.cc
@@ -0,0 +1,116 @@
+#include "http2/adapter/test_utils.h"
+
+#include "spdy/core/spdy_frame_reader.h"
+
+namespace http2 {
+namespace adapter {
+namespace test {
+namespace {
+
+using TypeAndOptionalLength =
+    std::pair<spdy::SpdyFrameType, absl::optional<size_t>>;
+
+std::vector<std::pair<const char*, std::string>> LogFriendly(
+    const std::vector<TypeAndOptionalLength>& types_and_lengths) {
+  std::vector<std::pair<const char*, std::string>> out;
+  out.reserve(types_and_lengths.size());
+  for (const auto type_and_length : types_and_lengths) {
+    out.push_back({spdy::FrameTypeToString(type_and_length.first),
+                   type_and_length.second
+                       ? absl::StrCat(type_and_length.second.value())
+                       : "<unspecified>"});
+  }
+  return out;
+}
+
+// Custom gMock matcher, used to determine if a particular type of frame
+// is in a string. This is useful in tests where we want to show that a
+// particular control frame type is serialized for sending to the peer.
+class SpdyControlFrameMatcher
+    : public testing::MatcherInterface<const std::string> {
+ public:
+  explicit SpdyControlFrameMatcher(
+      std::vector<TypeAndOptionalLength> types_and_lengths)
+      : expected_types_and_lengths_(std::move(types_and_lengths)) {}
+
+  bool MatchAndExplain(const std::string s,
+                       testing::MatchResultListener* listener) const override {
+    spdy::SpdyFrameReader reader(s.data(), s.size());
+
+    for (TypeAndOptionalLength expected : expected_types_and_lengths_) {
+      if (!MatchAndExplainOneFrame(expected.first, expected.second, &reader,
+                                   listener)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool MatchAndExplainOneFrame(spdy::SpdyFrameType expected_type,
+                               absl::optional<size_t> expected_length,
+                               spdy::SpdyFrameReader* reader,
+                               testing::MatchResultListener* listener) const {
+    uint32_t payload_length;
+    if (!reader->ReadUInt24(&payload_length)) {
+      *listener << "; unable to read length field for expected_type "
+                << FrameTypeToString(expected_type) << ". data too short!";
+      return false;
+    }
+
+    if (expected_length && payload_length != expected_length.value()) {
+      *listener << "; actual length: " << payload_length
+                << " but expected length: " << expected_length.value();
+      return false;
+    }
+
+    uint8_t raw_type;
+    if (!reader->ReadUInt8(&raw_type)) {
+      *listener << "; unable to read type field for expected_type "
+                << FrameTypeToString(expected_type) << ". data too short!";
+      return false;
+    }
+
+    if (!spdy::IsDefinedFrameType(raw_type)) {
+      *listener << "; expected type " << FrameTypeToString(expected_type)
+                << " but raw type " << static_cast<int>(raw_type)
+                << " is not a defined frame type!";
+      return false;
+    }
+
+    spdy::SpdyFrameType actual_type = spdy::ParseFrameType(raw_type);
+    if (actual_type != expected_type) {
+      *listener << "; actual type: " << FrameTypeToString(actual_type)
+                << " but expected type: " << FrameTypeToString(expected_type);
+      return false;
+    }
+
+    // Seek past flags (1B), stream ID (4B), and payload. Reach the next frame.
+    reader->Seek(5 + payload_length);
+    return true;
+  }
+
+  void DescribeTo(std::ostream* os) const override {
+    *os << "Data contains frames of types in sequence "
+        << LogFriendly(expected_types_and_lengths_);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const override {
+    *os << "Data does not contain frames of types in sequence "
+        << LogFriendly(expected_types_and_lengths_);
+  }
+
+ private:
+  const std::vector<TypeAndOptionalLength> expected_types_and_lengths_;
+};
+
+}  // namespace
+
+testing::Matcher<const std::string> ContainsFrames(
+    std::vector<std::pair<spdy::SpdyFrameType, absl::optional<size_t>>>
+        types_and_lengths) {
+  return MakeMatcher(new SpdyControlFrameMatcher(std::move(types_and_lengths)));
+}
+
+}  // namespace test
+}  // namespace adapter
+}  // namespace http2
diff --git a/http2/adapter/test_utils.h b/http2/adapter/test_utils.h
new file mode 100644
index 0000000..6d585ee
--- /dev/null
+++ b/http2/adapter/test_utils.h
@@ -0,0 +1,24 @@
+#ifndef QUICHE_HTTP2_ADAPTER_TEST_UTILS_H_
+#define QUICHE_HTTP2_ADAPTER_TEST_UTILS_H_
+
+#include <string>
+#include <vector>
+
+#include "common/platform/api/quiche_test.h"
+#include "spdy/core/spdy_protocol.h"
+
+namespace http2 {
+namespace adapter {
+namespace test {
+
+// Matcher that checks whether a string contains HTTP/2 frames of the specified
+// ordered sequence of types and lengths.
+testing::Matcher<const std::string> ContainsFrames(
+    std::vector<std::pair<spdy::SpdyFrameType, absl::optional<size_t>>>
+        types_and_lengths);
+
+}  // namespace test
+}  // namespace adapter
+}  // namespace http2
+
+#endif  // QUICHE_HTTP2_ADAPTER_TEST_UTILS_H_
diff --git a/http2/adapter/test_utils_test.cc b/http2/adapter/test_utils_test.cc
new file mode 100644
index 0000000..1f8c557
--- /dev/null
+++ b/http2/adapter/test_utils_test.cc
@@ -0,0 +1,88 @@
+#include "http2/adapter/test_utils.h"
+
+#include "testing/base/public/gunit.h"
+#include "spdy/core/spdy_framer.h"
+
+namespace http2 {
+namespace adapter {
+namespace test {
+namespace {
+
+using spdy::SpdyFramer;
+
+TEST(ContainsFrames, Empty) {
+  EXPECT_THAT("", ContainsFrames({}));
+}
+
+TEST(ContainsFrames, SingleFrameWithLength) {
+  SpdyFramer framer{SpdyFramer::ENABLE_COMPRESSION};
+
+  spdy::SpdyPingIR ping{511};
+  EXPECT_THAT(framer.SerializeFrame(ping),
+              ContainsFrames({{spdy::SpdyFrameType::PING, 8}}));
+
+  spdy::SpdyWindowUpdateIR window_update{1, 101};
+  EXPECT_THAT(framer.SerializeFrame(window_update),
+              ContainsFrames({{spdy::SpdyFrameType::WINDOW_UPDATE, 4}}));
+
+  spdy::SpdyDataIR data{3, "Some example data, ha ha!"};
+  EXPECT_THAT(framer.SerializeFrame(data),
+              ContainsFrames({{spdy::SpdyFrameType::DATA, 25}}));
+}
+
+TEST(ContainsFrames, SingleFrameWithoutLength) {
+  SpdyFramer framer{SpdyFramer::ENABLE_COMPRESSION};
+
+  spdy::SpdyRstStreamIR rst_stream{7, spdy::ERROR_CODE_REFUSED_STREAM};
+  EXPECT_THAT(
+      framer.SerializeFrame(rst_stream),
+      ContainsFrames({{spdy::SpdyFrameType::RST_STREAM, absl::nullopt}}));
+
+  spdy::SpdyGoAwayIR goaway{13, spdy::ERROR_CODE_ENHANCE_YOUR_CALM,
+                            "Consider taking some deep breaths."};
+  EXPECT_THAT(framer.SerializeFrame(goaway),
+              ContainsFrames({{spdy::SpdyFrameType::GOAWAY, absl::nullopt}}));
+
+  spdy::Http2HeaderBlock block;
+  block[":method"] = "GET";
+  block[":path"] = "/example";
+  block[":authority"] = "example.com";
+  spdy::SpdyHeadersIR headers{17, std::move(block)};
+  EXPECT_THAT(framer.SerializeFrame(headers),
+              ContainsFrames({{spdy::SpdyFrameType::HEADERS, absl::nullopt}}));
+}
+
+TEST(ContainsFrames, MultipleFrames) {
+  SpdyFramer framer{SpdyFramer::ENABLE_COMPRESSION};
+
+  spdy::SpdyPingIR ping{511};
+  spdy::SpdyWindowUpdateIR window_update{1, 101};
+  spdy::SpdyDataIR data{3, "Some example data, ha ha!"};
+  spdy::SpdyRstStreamIR rst_stream{7, spdy::ERROR_CODE_REFUSED_STREAM};
+  spdy::SpdyGoAwayIR goaway{13, spdy::ERROR_CODE_ENHANCE_YOUR_CALM,
+                            "Consider taking some deep breaths."};
+  spdy::Http2HeaderBlock block;
+  block[":method"] = "GET";
+  block[":path"] = "/example";
+  block[":authority"] = "example.com";
+  spdy::SpdyHeadersIR headers{17, std::move(block)};
+
+  EXPECT_THAT(
+      absl::StrCat(absl::string_view(framer.SerializeFrame(ping)),
+                   absl::string_view(framer.SerializeFrame(window_update)),
+                   absl::string_view(framer.SerializeFrame(data)),
+                   absl::string_view(framer.SerializeFrame(rst_stream)),
+                   absl::string_view(framer.SerializeFrame(goaway)),
+                   absl::string_view(framer.SerializeFrame(headers))),
+      ContainsFrames({{spdy::SpdyFrameType::PING, absl::nullopt},
+                      {spdy::SpdyFrameType::WINDOW_UPDATE, absl::nullopt},
+                      {spdy::SpdyFrameType::DATA, 25},
+                      {spdy::SpdyFrameType::RST_STREAM, absl::nullopt},
+                      {spdy::SpdyFrameType::GOAWAY, 42},
+                      {spdy::SpdyFrameType::HEADERS, 19}}));
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace adapter
+}  // namespace http2
diff --git a/spdy/core/spdy_protocol.h b/spdy/core/spdy_protocol.h
index fcd6ada..d4a671b 100644
--- a/spdy/core/spdy_protocol.h
+++ b/spdy/core/spdy_protocol.h
@@ -1039,6 +1039,12 @@
   // Returns the actual size of the underlying buffer.
   size_t size() const { return size_; }
 
+  operator absl::string_view() const {
+    return absl::string_view{frame_, size_};
+  }
+
+  operator std::string() const { return std::string{frame_, size_}; }
+
   // Returns a buffer containing the contents of the frame, of which the caller
   // takes ownership, and clears this SpdySerializedFrame.
   char* ReleaseBuffer() {