quiche/http2/adapter/callback_visitor_test.cc - quiche.git - Git at Google


            
            #include "quiche/http2/adapter/callback_visitor.h"


            #include <string>


            #include "absl/container/flat_hash_map.h"

            
            #include "quiche/http2/adapter/http2_protocol.h"

            
            #include "quiche/http2/adapter/mock_nghttp2_callbacks.h"

            
            #include "quiche/http2/adapter/nghttp2_adapter.h"

            
            #include "quiche/http2/adapter/nghttp2_test_utils.h"

            
            #include "quiche/http2/adapter/test_frame_sequence.h"

            
            #include "quiche/http2/adapter/test_utils.h"

            
            #include "quiche/common/platform/api/quiche_test.h"


            namespace http2 {

            
            namespace adapter {

            
            namespace test {

            
            namespace {


            using testing::_;

            
            using testing::IsEmpty;

            
            using testing::Pair;

            
            using testing::UnorderedElementsAre;


            enum FrameType {

            
              DATA,

            
              HEADERS,

            
              PRIORITY,

            
              RST_STREAM,

            
              SETTINGS,

            
              PUSH_PROMISE,

            
              PING,

            
              GOAWAY,

            
              WINDOW_UPDATE,

            
              CONTINUATION,

            
            };


            // Tests connection-level events.

            
            TEST(ClientCallbackVisitorUnitTest, ConnectionFrames) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kClient,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              testing::InSequence seq;


              // SETTINGS

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, SETTINGS, _)));

            
              visitor.OnFrameHeader(0, 0, SETTINGS, 0);


              visitor.OnSettingsStart();

            
              EXPECT_CALL(callbacks, OnFrameRecv(IsSettings(testing::IsEmpty())));

            
              visitor.OnSettingsEnd();


              // PING

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, PING, _)));

            
              visitor.OnFrameHeader(0, 8, PING, 0);


              EXPECT_CALL(callbacks, OnFrameRecv(IsPing(42)));

            
              visitor.OnPing(42, false);


              // WINDOW_UPDATE

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, WINDOW_UPDATE, _)));

            
              visitor.OnFrameHeader(0, 4, WINDOW_UPDATE, 0);


              EXPECT_CALL(callbacks, OnFrameRecv(IsWindowUpdate(1000)));

            
              visitor.OnWindowUpdate(0, 1000);


              // PING ack

            
              EXPECT_CALL(callbacks,

            
                          OnBeginFrame(HasFrameHeader(0, PING, NGHTTP2_FLAG_ACK)));

            
              visitor.OnFrameHeader(0, 8, PING, 1);


              EXPECT_CALL(callbacks, OnFrameRecv(IsPingAck(247)));

            
              visitor.OnPing(247, true);


              // GOAWAY

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, GOAWAY, 0)));

            
              visitor.OnFrameHeader(0, 19, GOAWAY, 0);


              EXPECT_CALL(callbacks, OnFrameRecv(IsGoAway(5, NGHTTP2_ENHANCE_YOUR_CALM,

            
                                                          "calm down!!")));

            
              visitor.OnGoAway(5, Http2ErrorCode::ENHANCE_YOUR_CALM, "calm down!!");


              EXPECT_EQ(visitor.stream_map_size(), 0);

            
            }


            TEST(ClientCallbackVisitorUnitTest, StreamFrames) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kClient,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);

            
              absl::flat_hash_map<Http2StreamId, int> stream_close_counts;

            
              visitor.set_stream_close_listener(

            
                  [&stream_close_counts](Http2StreamId stream_id) {

            
                    ++stream_close_counts[stream_id];

            
                  });


              testing::InSequence seq;


              EXPECT_EQ(visitor.stream_map_size(), 0);


              // HEADERS on stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, _)));

            
              visitor.OnFrameHeader(1, 23, HEADERS, 4);


              EXPECT_CALL(callbacks,

            
                          OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));

            
              visitor.OnBeginHeadersForStream(1);


              EXPECT_EQ(visitor.stream_map_size(), 1);


              EXPECT_CALL(callbacks, OnHeader(_, ":status", "200", _));

            
              visitor.OnHeaderForStream(1, ":status", "200");


              EXPECT_CALL(callbacks, OnHeader(_, "server", "my-fake-server", _));

            
              visitor.OnHeaderForStream(1, "server", "my-fake-server");


              EXPECT_CALL(callbacks,

            
                          OnHeader(_, "date", "Tue, 6 Apr 2021 12:54:01 GMT", _));

            
              visitor.OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT");


              EXPECT_CALL(callbacks, OnHeader(_, "trailer", "x-server-status", _));

            
              visitor.OnHeaderForStream(1, "trailer", "x-server-status");


              EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));

            
              visitor.OnEndHeadersForStream(1);


              // DATA for stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, DATA, 0)));

            
              visitor.OnFrameHeader(1, 26, DATA, 0);


              visitor.OnBeginDataForStream(1, 26);

            
              EXPECT_CALL(callbacks, OnDataChunkRecv(0, 1, "This is the response body."));

            
              EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, 0)));

            
              visitor.OnDataForStream(1, "This is the response body.");


              // Trailers for stream 1, with a different nghttp2 "category".

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, _)));

            
              visitor.OnFrameHeader(1, 23, HEADERS, 4);


              EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_HEADERS)));

            
              visitor.OnBeginHeadersForStream(1);


              EXPECT_CALL(callbacks, OnHeader(_, "x-server-status", "OK", _));

            
              visitor.OnHeaderForStream(1, "x-server-status", "OK");


              EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, _, NGHTTP2_HCAT_HEADERS)));

            
              visitor.OnEndHeadersForStream(1);


              EXPECT_THAT(stream_close_counts, IsEmpty());


              // RST_STREAM on stream 3

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(3, RST_STREAM, 0)));

            
              visitor.OnFrameHeader(3, 4, RST_STREAM, 0);


              // No change in stream map size.

            
              EXPECT_EQ(visitor.stream_map_size(), 1);

            
              EXPECT_THAT(stream_close_counts, IsEmpty());


              EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(3, NGHTTP2_INTERNAL_ERROR)));

            
              visitor.OnRstStream(3, Http2ErrorCode::INTERNAL_ERROR);


              EXPECT_CALL(callbacks, OnStreamClose(3, NGHTTP2_INTERNAL_ERROR));

            
              visitor.OnCloseStream(3, Http2ErrorCode::INTERNAL_ERROR);


              EXPECT_THAT(stream_close_counts, UnorderedElementsAre(Pair(3, 1)));


              // More stream close events

            
              EXPECT_CALL(callbacks,

            
                          OnBeginFrame(HasFrameHeader(1, DATA, NGHTTP2_FLAG_END_STREAM)));

            
              visitor.OnFrameHeader(1, 0, DATA, 1);


              EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, NGHTTP2_FLAG_END_STREAM)));

            
              visitor.OnBeginDataForStream(1, 0);

            
              EXPECT_TRUE(visitor.OnEndStream(1));


              EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));

            
              visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);


              // Stream map is empty again after both streams were closed.

            
              EXPECT_EQ(visitor.stream_map_size(), 0);

            
              EXPECT_THAT(stream_close_counts,

            
                          UnorderedElementsAre(Pair(3, 1), Pair(1, 1)));


              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(5, RST_STREAM, _)));

            
              visitor.OnFrameHeader(5, 4, RST_STREAM, 0);


              EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(5, NGHTTP2_REFUSED_STREAM)));

            
              visitor.OnRstStream(5, Http2ErrorCode::REFUSED_STREAM);


              EXPECT_CALL(callbacks, OnStreamClose(5, NGHTTP2_REFUSED_STREAM));

            
              visitor.OnCloseStream(5, Http2ErrorCode::REFUSED_STREAM);


              EXPECT_EQ(visitor.stream_map_size(), 0);

            
              EXPECT_THAT(stream_close_counts,

            
                          UnorderedElementsAre(Pair(3, 1), Pair(1, 1), Pair(5, 1)));

            
            }


            TEST(ClientCallbackVisitorUnitTest, HeadersWithContinuation) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kClient,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              testing::InSequence seq;


              // HEADERS on stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, 0x0)));

            
              ASSERT_TRUE(visitor.OnFrameHeader(1, 23, HEADERS, 0x0));


              EXPECT_CALL(callbacks,

            
                          OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));

            
              visitor.OnBeginHeadersForStream(1);


              EXPECT_CALL(callbacks, OnHeader(_, ":status", "200", _));

            
              visitor.OnHeaderForStream(1, ":status", "200");


              EXPECT_CALL(callbacks, OnHeader(_, "server", "my-fake-server", _));

            
              visitor.OnHeaderForStream(1, "server", "my-fake-server");


              EXPECT_CALL(callbacks,

            
                          OnBeginFrame(HasFrameHeader(1, CONTINUATION, END_HEADERS_FLAG)));

            
              ASSERT_TRUE(visitor.OnFrameHeader(1, 23, CONTINUATION, END_HEADERS_FLAG));


              EXPECT_CALL(callbacks,

            
                          OnHeader(_, "date", "Tue, 6 Apr 2021 12:54:01 GMT", _));

            
              visitor.OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT");


              EXPECT_CALL(callbacks, OnHeader(_, "trailer", "x-server-status", _));

            
              visitor.OnHeaderForStream(1, "trailer", "x-server-status");


              EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));

            
              visitor.OnEndHeadersForStream(1);

            
            }


            TEST(ClientCallbackVisitorUnitTest, ContinuationNoHeaders) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kClient,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);

            
              // Because no stream precedes the CONTINUATION frame, the stream ID does not

            
              // match, and the method returns false.

            
              EXPECT_FALSE(visitor.OnFrameHeader(1, 23, CONTINUATION, END_HEADERS_FLAG));

            
            }


            TEST(ClientCallbackVisitorUnitTest, ContinuationWrongPrecedingType) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kClient,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, WINDOW_UPDATE, _)));

            
              visitor.OnFrameHeader(1, 4, WINDOW_UPDATE, 0);


              // Because the CONTINUATION frame does not follow HEADERS, the method returns

            
              // false.

            
              EXPECT_FALSE(visitor.OnFrameHeader(1, 23, CONTINUATION, END_HEADERS_FLAG));

            
            }


            TEST(ClientCallbackVisitorUnitTest, ContinuationWrongStream) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kClient,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);

            
              // HEADERS on stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, 0x0)));

            
              ASSERT_TRUE(visitor.OnFrameHeader(1, 23, HEADERS, 0x0));


              EXPECT_CALL(callbacks,

            
                          OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));

            
              visitor.OnBeginHeadersForStream(1);


              EXPECT_CALL(callbacks, OnHeader(_, ":status", "200", _));

            
              visitor.OnHeaderForStream(1, ":status", "200");


              EXPECT_CALL(callbacks, OnHeader(_, "server", "my-fake-server", _));

            
              visitor.OnHeaderForStream(1, "server", "my-fake-server");


              // The CONTINUATION stream ID does not match the one from the HEADERS.

            
              EXPECT_FALSE(visitor.OnFrameHeader(3, 23, CONTINUATION, END_HEADERS_FLAG));

            
            }


            TEST(ClientCallbackVisitorUnitTest, ResetAndGoaway) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kClient,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              testing::InSequence seq;


              // RST_STREAM on stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, RST_STREAM, 0x0)));

            
              EXPECT_TRUE(visitor.OnFrameHeader(1, 13, RST_STREAM, 0x0));


              EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(1, NGHTTP2_INTERNAL_ERROR)));

            
              visitor.OnRstStream(1, Http2ErrorCode::INTERNAL_ERROR);


              EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_INTERNAL_ERROR));

            
              EXPECT_TRUE(visitor.OnCloseStream(1, Http2ErrorCode::INTERNAL_ERROR));


              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, GOAWAY, 0x0)));

            
              EXPECT_TRUE(visitor.OnFrameHeader(0, 13, GOAWAY, 0x0));


              EXPECT_CALL(callbacks,

            
                          OnFrameRecv(IsGoAway(3, NGHTTP2_ENHANCE_YOUR_CALM, "calma te")));

            
              EXPECT_TRUE(

            
                  visitor.OnGoAway(3, Http2ErrorCode::ENHANCE_YOUR_CALM, "calma te"));


              EXPECT_CALL(callbacks, OnStreamClose(5, NGHTTP2_STREAM_CLOSED))

            
                  .WillOnce(testing::Return(NGHTTP2_ERR_CALLBACK_FAILURE));

            
              EXPECT_FALSE(visitor.OnCloseStream(5, Http2ErrorCode::STREAM_CLOSED));

            
            }


            TEST(ServerCallbackVisitorUnitTest, ConnectionFrames) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kServer,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              testing::InSequence seq;


              // SETTINGS

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, SETTINGS, _)));

            
              visitor.OnFrameHeader(0, 0, SETTINGS, 0);


              visitor.OnSettingsStart();

            
              EXPECT_CALL(callbacks, OnFrameRecv(IsSettings(testing::IsEmpty())));

            
              visitor.OnSettingsEnd();


              // PING

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, PING, _)));

            
              visitor.OnFrameHeader(0, 8, PING, 0);


              EXPECT_CALL(callbacks, OnFrameRecv(IsPing(42)));

            
              visitor.OnPing(42, false);


              // WINDOW_UPDATE

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, WINDOW_UPDATE, _)));

            
              visitor.OnFrameHeader(0, 4, WINDOW_UPDATE, 0);


              EXPECT_CALL(callbacks, OnFrameRecv(IsWindowUpdate(1000)));

            
              visitor.OnWindowUpdate(0, 1000);


              // PING ack

            
              EXPECT_CALL(callbacks,

            
                          OnBeginFrame(HasFrameHeader(0, PING, NGHTTP2_FLAG_ACK)));

            
              visitor.OnFrameHeader(0, 8, PING, 1);


              EXPECT_CALL(callbacks, OnFrameRecv(IsPingAck(247)));

            
              visitor.OnPing(247, true);


              EXPECT_EQ(visitor.stream_map_size(), 0);

            
            }


            TEST(ServerCallbackVisitorUnitTest, StreamFrames) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kServer,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              testing::InSequence seq;


              // HEADERS on stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(

            
                                         1, HEADERS, NGHTTP2_FLAG_END_HEADERS)));

            
              visitor.OnFrameHeader(1, 23, HEADERS, 4);


              EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,

            
                                                              NGHTTP2_HCAT_REQUEST)));

            
              visitor.OnBeginHeadersForStream(1);


              EXPECT_EQ(visitor.stream_map_size(), 1);


              EXPECT_CALL(callbacks, OnHeader(_, ":method", "POST", _));

            
              visitor.OnHeaderForStream(1, ":method", "POST");


              EXPECT_CALL(callbacks, OnHeader(_, ":path", "/example/path", _));

            
              visitor.OnHeaderForStream(1, ":path", "/example/path");


              EXPECT_CALL(callbacks, OnHeader(_, ":scheme", "https", _));

            
              visitor.OnHeaderForStream(1, ":scheme", "https");


              EXPECT_CALL(callbacks, OnHeader(_, ":authority", "example.com", _));

            
              visitor.OnHeaderForStream(1, ":authority", "example.com");


              EXPECT_CALL(callbacks, OnHeader(_, "accept", "text/html", _));

            
              visitor.OnHeaderForStream(1, "accept", "text/html");


              EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,

            
                                                           NGHTTP2_HCAT_REQUEST)));

            
              visitor.OnEndHeadersForStream(1);


              // DATA on stream 1

            
              EXPECT_CALL(callbacks,

            
                          OnBeginFrame(HasFrameHeader(1, DATA, NGHTTP2_FLAG_END_STREAM)));

            
              visitor.OnFrameHeader(1, 25, DATA, NGHTTP2_FLAG_END_STREAM);


              visitor.OnBeginDataForStream(1, 25);

            
              EXPECT_CALL(callbacks, OnDataChunkRecv(NGHTTP2_FLAG_END_STREAM, 1,

            
                                                     "This is the request body."));

            
              EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, NGHTTP2_FLAG_END_STREAM)));

            
              visitor.OnDataForStream(1, "This is the request body.");

            
              EXPECT_TRUE(visitor.OnEndStream(1));


              EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));

            
              visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);


              EXPECT_EQ(visitor.stream_map_size(), 0);


              // RST_STREAM on stream 3

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(3, RST_STREAM, 0)));

            
              visitor.OnFrameHeader(3, 4, RST_STREAM, 0);


              EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(3, NGHTTP2_INTERNAL_ERROR)));

            
              visitor.OnRstStream(3, Http2ErrorCode::INTERNAL_ERROR);


              EXPECT_CALL(callbacks, OnStreamClose(3, NGHTTP2_INTERNAL_ERROR));

            
              visitor.OnCloseStream(3, Http2ErrorCode::INTERNAL_ERROR);


              EXPECT_EQ(visitor.stream_map_size(), 0);

            
            }


            TEST(ServerCallbackVisitorUnitTest, DataWithPadding) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kServer,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              const size_t kPaddingLength = 39;

            
              const uint8_t kFlags = NGHTTP2_FLAG_PADDED | NGHTTP2_FLAG_END_STREAM;


              testing::InSequence seq;


              // DATA on stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, DATA, kFlags)));

            
              EXPECT_TRUE(visitor.OnFrameHeader(1, 25 + kPaddingLength, DATA, kFlags));


              EXPECT_TRUE(visitor.OnBeginDataForStream(1, 25 + kPaddingLength));


              // Padding before data.

            
              EXPECT_TRUE(visitor.OnDataPaddingLength(1, kPaddingLength));


              EXPECT_CALL(callbacks,

            
                          OnDataChunkRecv(kFlags, 1, "This is the request body."));

            
              EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, kFlags, kPaddingLength)));

            
              EXPECT_TRUE(visitor.OnDataForStream(1, "This is the request body."));

            
              EXPECT_TRUE(visitor.OnEndStream(1));


              EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));

            
              visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);


              // DATA on stream 3

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(3, DATA, kFlags)));

            
              EXPECT_TRUE(visitor.OnFrameHeader(3, 25 + kPaddingLength, DATA, kFlags));


              EXPECT_TRUE(visitor.OnBeginDataForStream(3, 25 + kPaddingLength));


              // Data before padding.

            
              EXPECT_CALL(callbacks,

            
                          OnDataChunkRecv(kFlags, 3, "This is the request body."));

            
              EXPECT_TRUE(visitor.OnDataForStream(3, "This is the request body."));


              EXPECT_CALL(callbacks, OnFrameRecv(IsData(3, _, kFlags, kPaddingLength)));

            
              EXPECT_TRUE(visitor.OnDataPaddingLength(3, kPaddingLength));

            
              EXPECT_TRUE(visitor.OnEndStream(3));


              EXPECT_CALL(callbacks, OnStreamClose(3, NGHTTP2_NO_ERROR));

            
              visitor.OnCloseStream(3, Http2ErrorCode::HTTP2_NO_ERROR);


              // DATA on stream 5

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(5, DATA, kFlags)));

            
              EXPECT_TRUE(visitor.OnFrameHeader(5, 25 + kPaddingLength, DATA, kFlags));


              EXPECT_TRUE(visitor.OnBeginDataForStream(5, 25 + kPaddingLength));


              // Error during padding.

            
              EXPECT_CALL(callbacks,

            
                          OnDataChunkRecv(kFlags, 5, "This is the request body."));

            
              EXPECT_TRUE(visitor.OnDataForStream(5, "This is the request body."));


              EXPECT_CALL(callbacks, OnFrameRecv(IsData(5, _, kFlags, kPaddingLength)))

            
                  .WillOnce(testing::Return(NGHTTP2_ERR_CALLBACK_FAILURE));

            
              EXPECT_TRUE(visitor.OnDataPaddingLength(5, kPaddingLength));

            
              EXPECT_FALSE(visitor.OnEndStream(3));


              EXPECT_CALL(callbacks, OnStreamClose(5, NGHTTP2_NO_ERROR));

            
              visitor.OnCloseStream(5, Http2ErrorCode::HTTP2_NO_ERROR);

            
            }


            // In the case of a Content-Length mismatch where the header value is larger

            
            // than the actual data for the stream, nghttp2 will call

            
            // `on_begin_frame_callback` and `on_data_chunk_recv_callback`, but not the

            
            // `on_frame_recv_callback`.

            
            TEST(ServerCallbackVisitorUnitTest, MismatchedContentLengthCallbacks) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kServer,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);

            
              auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);


              const std::string frames = TestFrameSequence()

            
                                             .ClientPreface()

            
                                             .Headers(1,

            
                                                      {{":method", "POST"},

            
                                                       {":scheme", "https"},

            
                                                       {":authority", "example.com"},

            
                                                       {":path", "/"},

            
                                                       {"content-length", "50"}},

            
                                                      /*fin=*/false)

            
                                             .Data(1, "Less than 50 bytes.", true)

            
                                             .Serialize();


              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, SETTINGS, _)));


              EXPECT_CALL(callbacks, OnFrameRecv(IsSettings(testing::IsEmpty())));


              // HEADERS on stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(

            
                                         1, HEADERS, NGHTTP2_FLAG_END_HEADERS)));


              EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,

            
                                                              NGHTTP2_HCAT_REQUEST)));


              EXPECT_CALL(callbacks, OnHeader(_, ":method", "POST", _));

            
              EXPECT_CALL(callbacks, OnHeader(_, ":path", "/", _));

            
              EXPECT_CALL(callbacks, OnHeader(_, ":scheme", "https", _));

            
              EXPECT_CALL(callbacks, OnHeader(_, ":authority", "example.com", _));

            
              EXPECT_CALL(callbacks, OnHeader(_, "content-length", "50", _));

            
              EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,

            
                                                           NGHTTP2_HCAT_REQUEST)));


              // DATA on stream 1

            
              EXPECT_CALL(callbacks,

            
                          OnBeginFrame(HasFrameHeader(1, DATA, NGHTTP2_FLAG_END_STREAM)));


              EXPECT_CALL(callbacks, OnDataChunkRecv(NGHTTP2_FLAG_END_STREAM, 1,

            
                                                     "Less than 50 bytes."));


              // Like nghttp2, CallbackVisitor does not pass on a call to OnFrameRecv in the

            
              // case of Content-Length mismatch.


              int64_t result = adapter->ProcessBytes(frames);

            
              EXPECT_EQ(frames.size(), result);

            
            }


            TEST(ServerCallbackVisitorUnitTest, HeadersAfterFin) {

            
              testing::StrictMock<MockNghttp2Callbacks> callbacks;

            
              CallbackVisitor visitor(Perspective::kServer,

            
                                      *MockNghttp2Callbacks::GetCallbacks(), &callbacks);


              testing::InSequence seq;


              // HEADERS on stream 1

            
              EXPECT_CALL(

            
                  callbacks,

            
                  OnBeginFrame(HasFrameHeader(

            
                      1, HEADERS, NGHTTP2_FLAG_END_HEADERS | NGHTTP2_FLAG_END_STREAM)));

            
              visitor.OnFrameHeader(1, 23, HEADERS, 5);


              EXPECT_CALL(callbacks,

            
                          OnBeginHeaders(IsHeaders(

            
                              1, NGHTTP2_FLAG_END_HEADERS | NGHTTP2_FLAG_END_STREAM,

            
                              NGHTTP2_HCAT_REQUEST)));

            
              EXPECT_TRUE(visitor.OnBeginHeadersForStream(1));


              EXPECT_EQ(visitor.stream_map_size(), 1);


              EXPECT_CALL(callbacks, OnHeader).Times(5);

            
              visitor.OnHeaderForStream(1, ":method", "POST");

            
              visitor.OnHeaderForStream(1, ":path", "/example/path");

            
              visitor.OnHeaderForStream(1, ":scheme", "https");

            
              visitor.OnHeaderForStream(1, ":authority", "example.com");

            
              visitor.OnHeaderForStream(1, "accept", "text/html");


              EXPECT_CALL(callbacks,

            
                          OnFrameRecv(IsHeaders(

            
                              1, NGHTTP2_FLAG_END_HEADERS | NGHTTP2_FLAG_END_STREAM,

            
                              NGHTTP2_HCAT_REQUEST)));

            
              visitor.OnEndHeadersForStream(1);


              EXPECT_TRUE(visitor.OnEndStream(1));


              EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));

            
              visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);


              EXPECT_EQ(visitor.stream_map_size(), 0);


              // Invalid repeat HEADERS on closed stream 1

            
              EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(

            
                                         1, HEADERS, NGHTTP2_FLAG_END_HEADERS)));

            
              visitor.OnFrameHeader(1, 23, HEADERS, 4);


              EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,

            
                                                              NGHTTP2_HCAT_HEADERS)));

            
              EXPECT_TRUE(visitor.OnBeginHeadersForStream(1));


              // The visitor should not revive streams that have already been closed.

            
              EXPECT_EQ(visitor.stream_map_size(), 0);

            
            }


            }  // namespace

            
            }  // namespace test

            
            }  // namespace adapter

            
            }  // namespace http2
	#include "quiche/http2/adapter/callback_visitor.h"

	#include <string>

	#include "absl/container/flat_hash_map.h"
	#include "quiche/http2/adapter/http2_protocol.h"
	#include "quiche/http2/adapter/mock_nghttp2_callbacks.h"
	#include "quiche/http2/adapter/nghttp2_adapter.h"
	#include "quiche/http2/adapter/nghttp2_test_utils.h"
	#include "quiche/http2/adapter/test_frame_sequence.h"
	#include "quiche/http2/adapter/test_utils.h"
	#include "quiche/common/platform/api/quiche_test.h"

	namespace http2 {
	namespace adapter {
	namespace test {
	namespace {

	using testing::_;
	using testing::IsEmpty;
	using testing::Pair;
	using testing::UnorderedElementsAre;

	enum FrameType {
	DATA,
	HEADERS,
	PRIORITY,
	RST_STREAM,
	SETTINGS,
	PUSH_PROMISE,
	PING,
	GOAWAY,
	WINDOW_UPDATE,
	CONTINUATION,
	};

	// Tests connection-level events.
	TEST(ClientCallbackVisitorUnitTest, ConnectionFrames) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kClient,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	testing::InSequence seq;

	// SETTINGS
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, SETTINGS, _)));
	visitor.OnFrameHeader(0, 0, SETTINGS, 0);

	visitor.OnSettingsStart();
	EXPECT_CALL(callbacks, OnFrameRecv(IsSettings(testing::IsEmpty())));
	visitor.OnSettingsEnd();

	// PING
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, PING, _)));
	visitor.OnFrameHeader(0, 8, PING, 0);

	EXPECT_CALL(callbacks, OnFrameRecv(IsPing(42)));
	visitor.OnPing(42, false);

	// WINDOW_UPDATE
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, WINDOW_UPDATE, _)));
	visitor.OnFrameHeader(0, 4, WINDOW_UPDATE, 0);

	EXPECT_CALL(callbacks, OnFrameRecv(IsWindowUpdate(1000)));
	visitor.OnWindowUpdate(0, 1000);

	// PING ack
	EXPECT_CALL(callbacks,
	OnBeginFrame(HasFrameHeader(0, PING, NGHTTP2_FLAG_ACK)));
	visitor.OnFrameHeader(0, 8, PING, 1);

	EXPECT_CALL(callbacks, OnFrameRecv(IsPingAck(247)));
	visitor.OnPing(247, true);

	// GOAWAY
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, GOAWAY, 0)));
	visitor.OnFrameHeader(0, 19, GOAWAY, 0);

	EXPECT_CALL(callbacks, OnFrameRecv(IsGoAway(5, NGHTTP2_ENHANCE_YOUR_CALM,
	"calm down!!")));
	visitor.OnGoAway(5, Http2ErrorCode::ENHANCE_YOUR_CALM, "calm down!!");

	EXPECT_EQ(visitor.stream_map_size(), 0);
	}

	TEST(ClientCallbackVisitorUnitTest, StreamFrames) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kClient,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);
	absl::flat_hash_map<Http2StreamId, int> stream_close_counts;
	visitor.set_stream_close_listener(
	[&stream_close_counts](Http2StreamId stream_id) {
	++stream_close_counts[stream_id];
	});

	testing::InSequence seq;

	EXPECT_EQ(visitor.stream_map_size(), 0);

	// HEADERS on stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, _)));
	visitor.OnFrameHeader(1, 23, HEADERS, 4);

	EXPECT_CALL(callbacks,
	OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));
	visitor.OnBeginHeadersForStream(1);

	EXPECT_EQ(visitor.stream_map_size(), 1);

	EXPECT_CALL(callbacks, OnHeader(_, ":status", "200", _));
	visitor.OnHeaderForStream(1, ":status", "200");

	EXPECT_CALL(callbacks, OnHeader(_, "server", "my-fake-server", _));
	visitor.OnHeaderForStream(1, "server", "my-fake-server");

	EXPECT_CALL(callbacks,
	OnHeader(_, "date", "Tue, 6 Apr 2021 12:54:01 GMT", _));
	visitor.OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT");

	EXPECT_CALL(callbacks, OnHeader(_, "trailer", "x-server-status", _));
	visitor.OnHeaderForStream(1, "trailer", "x-server-status");

	EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));
	visitor.OnEndHeadersForStream(1);

	// DATA for stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, DATA, 0)));
	visitor.OnFrameHeader(1, 26, DATA, 0);

	visitor.OnBeginDataForStream(1, 26);
	EXPECT_CALL(callbacks, OnDataChunkRecv(0, 1, "This is the response body."));
	EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, 0)));
	visitor.OnDataForStream(1, "This is the response body.");

	// Trailers for stream 1, with a different nghttp2 "category".
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, _)));
	visitor.OnFrameHeader(1, 23, HEADERS, 4);

	EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_HEADERS)));
	visitor.OnBeginHeadersForStream(1);

	EXPECT_CALL(callbacks, OnHeader(_, "x-server-status", "OK", _));
	visitor.OnHeaderForStream(1, "x-server-status", "OK");

	EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, _, NGHTTP2_HCAT_HEADERS)));
	visitor.OnEndHeadersForStream(1);

	EXPECT_THAT(stream_close_counts, IsEmpty());

	// RST_STREAM on stream 3
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(3, RST_STREAM, 0)));
	visitor.OnFrameHeader(3, 4, RST_STREAM, 0);

	// No change in stream map size.
	EXPECT_EQ(visitor.stream_map_size(), 1);
	EXPECT_THAT(stream_close_counts, IsEmpty());

	EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(3, NGHTTP2_INTERNAL_ERROR)));
	visitor.OnRstStream(3, Http2ErrorCode::INTERNAL_ERROR);

	EXPECT_CALL(callbacks, OnStreamClose(3, NGHTTP2_INTERNAL_ERROR));
	visitor.OnCloseStream(3, Http2ErrorCode::INTERNAL_ERROR);

	EXPECT_THAT(stream_close_counts, UnorderedElementsAre(Pair(3, 1)));

	// More stream close events
	EXPECT_CALL(callbacks,
	OnBeginFrame(HasFrameHeader(1, DATA, NGHTTP2_FLAG_END_STREAM)));
	visitor.OnFrameHeader(1, 0, DATA, 1);

	EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, NGHTTP2_FLAG_END_STREAM)));
	visitor.OnBeginDataForStream(1, 0);
	EXPECT_TRUE(visitor.OnEndStream(1));

	EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));
	visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);

	// Stream map is empty again after both streams were closed.
	EXPECT_EQ(visitor.stream_map_size(), 0);
	EXPECT_THAT(stream_close_counts,
	UnorderedElementsAre(Pair(3, 1), Pair(1, 1)));

	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(5, RST_STREAM, _)));
	visitor.OnFrameHeader(5, 4, RST_STREAM, 0);

	EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(5, NGHTTP2_REFUSED_STREAM)));
	visitor.OnRstStream(5, Http2ErrorCode::REFUSED_STREAM);

	EXPECT_CALL(callbacks, OnStreamClose(5, NGHTTP2_REFUSED_STREAM));
	visitor.OnCloseStream(5, Http2ErrorCode::REFUSED_STREAM);

	EXPECT_EQ(visitor.stream_map_size(), 0);
	EXPECT_THAT(stream_close_counts,
	UnorderedElementsAre(Pair(3, 1), Pair(1, 1), Pair(5, 1)));
	}

	TEST(ClientCallbackVisitorUnitTest, HeadersWithContinuation) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kClient,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	testing::InSequence seq;

	// HEADERS on stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, 0x0)));
	ASSERT_TRUE(visitor.OnFrameHeader(1, 23, HEADERS, 0x0));

	EXPECT_CALL(callbacks,
	OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));
	visitor.OnBeginHeadersForStream(1);

	EXPECT_CALL(callbacks, OnHeader(_, ":status", "200", _));
	visitor.OnHeaderForStream(1, ":status", "200");

	EXPECT_CALL(callbacks, OnHeader(_, "server", "my-fake-server", _));
	visitor.OnHeaderForStream(1, "server", "my-fake-server");

	EXPECT_CALL(callbacks,
	OnBeginFrame(HasFrameHeader(1, CONTINUATION, END_HEADERS_FLAG)));
	ASSERT_TRUE(visitor.OnFrameHeader(1, 23, CONTINUATION, END_HEADERS_FLAG));

	EXPECT_CALL(callbacks,
	OnHeader(_, "date", "Tue, 6 Apr 2021 12:54:01 GMT", _));
	visitor.OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT");

	EXPECT_CALL(callbacks, OnHeader(_, "trailer", "x-server-status", _));
	visitor.OnHeaderForStream(1, "trailer", "x-server-status");

	EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));
	visitor.OnEndHeadersForStream(1);
	}

	TEST(ClientCallbackVisitorUnitTest, ContinuationNoHeaders) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kClient,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);
	// Because no stream precedes the CONTINUATION frame, the stream ID does not
	// match, and the method returns false.
	EXPECT_FALSE(visitor.OnFrameHeader(1, 23, CONTINUATION, END_HEADERS_FLAG));
	}

	TEST(ClientCallbackVisitorUnitTest, ContinuationWrongPrecedingType) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kClient,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, WINDOW_UPDATE, _)));
	visitor.OnFrameHeader(1, 4, WINDOW_UPDATE, 0);

	// Because the CONTINUATION frame does not follow HEADERS, the method returns
	// false.
	EXPECT_FALSE(visitor.OnFrameHeader(1, 23, CONTINUATION, END_HEADERS_FLAG));
	}

	TEST(ClientCallbackVisitorUnitTest, ContinuationWrongStream) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kClient,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);
	// HEADERS on stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, HEADERS, 0x0)));
	ASSERT_TRUE(visitor.OnFrameHeader(1, 23, HEADERS, 0x0));

	EXPECT_CALL(callbacks,
	OnBeginHeaders(IsHeaders(1, _, NGHTTP2_HCAT_RESPONSE)));
	visitor.OnBeginHeadersForStream(1);

	EXPECT_CALL(callbacks, OnHeader(_, ":status", "200", _));
	visitor.OnHeaderForStream(1, ":status", "200");

	EXPECT_CALL(callbacks, OnHeader(_, "server", "my-fake-server", _));
	visitor.OnHeaderForStream(1, "server", "my-fake-server");

	// The CONTINUATION stream ID does not match the one from the HEADERS.
	EXPECT_FALSE(visitor.OnFrameHeader(3, 23, CONTINUATION, END_HEADERS_FLAG));
	}

	TEST(ClientCallbackVisitorUnitTest, ResetAndGoaway) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kClient,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	testing::InSequence seq;

	// RST_STREAM on stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, RST_STREAM, 0x0)));
	EXPECT_TRUE(visitor.OnFrameHeader(1, 13, RST_STREAM, 0x0));

	EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(1, NGHTTP2_INTERNAL_ERROR)));
	visitor.OnRstStream(1, Http2ErrorCode::INTERNAL_ERROR);

	EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_INTERNAL_ERROR));
	EXPECT_TRUE(visitor.OnCloseStream(1, Http2ErrorCode::INTERNAL_ERROR));

	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, GOAWAY, 0x0)));
	EXPECT_TRUE(visitor.OnFrameHeader(0, 13, GOAWAY, 0x0));

	EXPECT_CALL(callbacks,
	OnFrameRecv(IsGoAway(3, NGHTTP2_ENHANCE_YOUR_CALM, "calma te")));
	EXPECT_TRUE(
	visitor.OnGoAway(3, Http2ErrorCode::ENHANCE_YOUR_CALM, "calma te"));

	EXPECT_CALL(callbacks, OnStreamClose(5, NGHTTP2_STREAM_CLOSED))
	.WillOnce(testing::Return(NGHTTP2_ERR_CALLBACK_FAILURE));
	EXPECT_FALSE(visitor.OnCloseStream(5, Http2ErrorCode::STREAM_CLOSED));
	}

	TEST(ServerCallbackVisitorUnitTest, ConnectionFrames) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kServer,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	testing::InSequence seq;

	// SETTINGS
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, SETTINGS, _)));
	visitor.OnFrameHeader(0, 0, SETTINGS, 0);

	visitor.OnSettingsStart();
	EXPECT_CALL(callbacks, OnFrameRecv(IsSettings(testing::IsEmpty())));
	visitor.OnSettingsEnd();

	// PING
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, PING, _)));
	visitor.OnFrameHeader(0, 8, PING, 0);

	EXPECT_CALL(callbacks, OnFrameRecv(IsPing(42)));
	visitor.OnPing(42, false);

	// WINDOW_UPDATE
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, WINDOW_UPDATE, _)));
	visitor.OnFrameHeader(0, 4, WINDOW_UPDATE, 0);

	EXPECT_CALL(callbacks, OnFrameRecv(IsWindowUpdate(1000)));
	visitor.OnWindowUpdate(0, 1000);

	// PING ack
	EXPECT_CALL(callbacks,
	OnBeginFrame(HasFrameHeader(0, PING, NGHTTP2_FLAG_ACK)));
	visitor.OnFrameHeader(0, 8, PING, 1);

	EXPECT_CALL(callbacks, OnFrameRecv(IsPingAck(247)));
	visitor.OnPing(247, true);

	EXPECT_EQ(visitor.stream_map_size(), 0);
	}

	TEST(ServerCallbackVisitorUnitTest, StreamFrames) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kServer,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	testing::InSequence seq;

	// HEADERS on stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(
	1, HEADERS, NGHTTP2_FLAG_END_HEADERS)));
	visitor.OnFrameHeader(1, 23, HEADERS, 4);

	EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,
	NGHTTP2_HCAT_REQUEST)));
	visitor.OnBeginHeadersForStream(1);

	EXPECT_EQ(visitor.stream_map_size(), 1);

	EXPECT_CALL(callbacks, OnHeader(_, ":method", "POST", _));
	visitor.OnHeaderForStream(1, ":method", "POST");

	EXPECT_CALL(callbacks, OnHeader(_, ":path", "/example/path", _));
	visitor.OnHeaderForStream(1, ":path", "/example/path");

	EXPECT_CALL(callbacks, OnHeader(_, ":scheme", "https", _));
	visitor.OnHeaderForStream(1, ":scheme", "https");

	EXPECT_CALL(callbacks, OnHeader(_, ":authority", "example.com", _));
	visitor.OnHeaderForStream(1, ":authority", "example.com");

	EXPECT_CALL(callbacks, OnHeader(_, "accept", "text/html", _));
	visitor.OnHeaderForStream(1, "accept", "text/html");

	EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,
	NGHTTP2_HCAT_REQUEST)));
	visitor.OnEndHeadersForStream(1);

	// DATA on stream 1
	EXPECT_CALL(callbacks,
	OnBeginFrame(HasFrameHeader(1, DATA, NGHTTP2_FLAG_END_STREAM)));
	visitor.OnFrameHeader(1, 25, DATA, NGHTTP2_FLAG_END_STREAM);

	visitor.OnBeginDataForStream(1, 25);
	EXPECT_CALL(callbacks, OnDataChunkRecv(NGHTTP2_FLAG_END_STREAM, 1,
	"This is the request body."));
	EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, NGHTTP2_FLAG_END_STREAM)));
	visitor.OnDataForStream(1, "This is the request body.");
	EXPECT_TRUE(visitor.OnEndStream(1));

	EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));
	visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);

	EXPECT_EQ(visitor.stream_map_size(), 0);

	// RST_STREAM on stream 3
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(3, RST_STREAM, 0)));
	visitor.OnFrameHeader(3, 4, RST_STREAM, 0);

	EXPECT_CALL(callbacks, OnFrameRecv(IsRstStream(3, NGHTTP2_INTERNAL_ERROR)));
	visitor.OnRstStream(3, Http2ErrorCode::INTERNAL_ERROR);

	EXPECT_CALL(callbacks, OnStreamClose(3, NGHTTP2_INTERNAL_ERROR));
	visitor.OnCloseStream(3, Http2ErrorCode::INTERNAL_ERROR);

	EXPECT_EQ(visitor.stream_map_size(), 0);
	}

	TEST(ServerCallbackVisitorUnitTest, DataWithPadding) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kServer,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	const size_t kPaddingLength = 39;
	const uint8_t kFlags = NGHTTP2_FLAG_PADDED \| NGHTTP2_FLAG_END_STREAM;

	testing::InSequence seq;

	// DATA on stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(1, DATA, kFlags)));
	EXPECT_TRUE(visitor.OnFrameHeader(1, 25 + kPaddingLength, DATA, kFlags));

	EXPECT_TRUE(visitor.OnBeginDataForStream(1, 25 + kPaddingLength));

	// Padding before data.
	EXPECT_TRUE(visitor.OnDataPaddingLength(1, kPaddingLength));

	EXPECT_CALL(callbacks,
	OnDataChunkRecv(kFlags, 1, "This is the request body."));
	EXPECT_CALL(callbacks, OnFrameRecv(IsData(1, _, kFlags, kPaddingLength)));
	EXPECT_TRUE(visitor.OnDataForStream(1, "This is the request body."));
	EXPECT_TRUE(visitor.OnEndStream(1));

	EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));
	visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);

	// DATA on stream 3
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(3, DATA, kFlags)));
	EXPECT_TRUE(visitor.OnFrameHeader(3, 25 + kPaddingLength, DATA, kFlags));

	EXPECT_TRUE(visitor.OnBeginDataForStream(3, 25 + kPaddingLength));

	// Data before padding.
	EXPECT_CALL(callbacks,
	OnDataChunkRecv(kFlags, 3, "This is the request body."));
	EXPECT_TRUE(visitor.OnDataForStream(3, "This is the request body."));

	EXPECT_CALL(callbacks, OnFrameRecv(IsData(3, _, kFlags, kPaddingLength)));
	EXPECT_TRUE(visitor.OnDataPaddingLength(3, kPaddingLength));
	EXPECT_TRUE(visitor.OnEndStream(3));

	EXPECT_CALL(callbacks, OnStreamClose(3, NGHTTP2_NO_ERROR));
	visitor.OnCloseStream(3, Http2ErrorCode::HTTP2_NO_ERROR);

	// DATA on stream 5
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(5, DATA, kFlags)));
	EXPECT_TRUE(visitor.OnFrameHeader(5, 25 + kPaddingLength, DATA, kFlags));

	EXPECT_TRUE(visitor.OnBeginDataForStream(5, 25 + kPaddingLength));

	// Error during padding.
	EXPECT_CALL(callbacks,
	OnDataChunkRecv(kFlags, 5, "This is the request body."));
	EXPECT_TRUE(visitor.OnDataForStream(5, "This is the request body."));

	EXPECT_CALL(callbacks, OnFrameRecv(IsData(5, _, kFlags, kPaddingLength)))
	.WillOnce(testing::Return(NGHTTP2_ERR_CALLBACK_FAILURE));
	EXPECT_TRUE(visitor.OnDataPaddingLength(5, kPaddingLength));
	EXPECT_FALSE(visitor.OnEndStream(3));

	EXPECT_CALL(callbacks, OnStreamClose(5, NGHTTP2_NO_ERROR));
	visitor.OnCloseStream(5, Http2ErrorCode::HTTP2_NO_ERROR);
	}

	// In the case of a Content-Length mismatch where the header value is larger
	// than the actual data for the stream, nghttp2 will call
	// `on_begin_frame_callback` and `on_data_chunk_recv_callback`, but not the
	// `on_frame_recv_callback`.
	TEST(ServerCallbackVisitorUnitTest, MismatchedContentLengthCallbacks) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kServer,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);
	auto adapter = NgHttp2Adapter::CreateServerAdapter(visitor);

	const std::string frames = TestFrameSequence()
	.ClientPreface()
	.Headers(1,
	{{":method", "POST"},
	{":scheme", "https"},
	{":authority", "example.com"},
	{":path", "/"},
	{"content-length", "50"}},
	/fin=/false)
	.Data(1, "Less than 50 bytes.", true)
	.Serialize();

	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(0, SETTINGS, _)));

	EXPECT_CALL(callbacks, OnFrameRecv(IsSettings(testing::IsEmpty())));

	// HEADERS on stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(
	1, HEADERS, NGHTTP2_FLAG_END_HEADERS)));

	EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,
	NGHTTP2_HCAT_REQUEST)));

	EXPECT_CALL(callbacks, OnHeader(_, ":method", "POST", _));
	EXPECT_CALL(callbacks, OnHeader(_, ":path", "/", _));
	EXPECT_CALL(callbacks, OnHeader(_, ":scheme", "https", _));
	EXPECT_CALL(callbacks, OnHeader(_, ":authority", "example.com", _));
	EXPECT_CALL(callbacks, OnHeader(_, "content-length", "50", _));
	EXPECT_CALL(callbacks, OnFrameRecv(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,
	NGHTTP2_HCAT_REQUEST)));

	// DATA on stream 1
	EXPECT_CALL(callbacks,
	OnBeginFrame(HasFrameHeader(1, DATA, NGHTTP2_FLAG_END_STREAM)));

	EXPECT_CALL(callbacks, OnDataChunkRecv(NGHTTP2_FLAG_END_STREAM, 1,
	"Less than 50 bytes."));

	// Like nghttp2, CallbackVisitor does not pass on a call to OnFrameRecv in the
	// case of Content-Length mismatch.

	int64_t result = adapter->ProcessBytes(frames);
	EXPECT_EQ(frames.size(), result);
	}

	TEST(ServerCallbackVisitorUnitTest, HeadersAfterFin) {
	testing::StrictMock<MockNghttp2Callbacks> callbacks;
	CallbackVisitor visitor(Perspective::kServer,
	*MockNghttp2Callbacks::GetCallbacks(), &callbacks);

	testing::InSequence seq;

	// HEADERS on stream 1
	EXPECT_CALL(
	callbacks,
	OnBeginFrame(HasFrameHeader(
	1, HEADERS, NGHTTP2_FLAG_END_HEADERS \| NGHTTP2_FLAG_END_STREAM)));
	visitor.OnFrameHeader(1, 23, HEADERS, 5);

	EXPECT_CALL(callbacks,
	OnBeginHeaders(IsHeaders(
	1, NGHTTP2_FLAG_END_HEADERS \| NGHTTP2_FLAG_END_STREAM,
	NGHTTP2_HCAT_REQUEST)));
	EXPECT_TRUE(visitor.OnBeginHeadersForStream(1));

	EXPECT_EQ(visitor.stream_map_size(), 1);

	EXPECT_CALL(callbacks, OnHeader).Times(5);
	visitor.OnHeaderForStream(1, ":method", "POST");
	visitor.OnHeaderForStream(1, ":path", "/example/path");
	visitor.OnHeaderForStream(1, ":scheme", "https");
	visitor.OnHeaderForStream(1, ":authority", "example.com");
	visitor.OnHeaderForStream(1, "accept", "text/html");

	EXPECT_CALL(callbacks,
	OnFrameRecv(IsHeaders(
	1, NGHTTP2_FLAG_END_HEADERS \| NGHTTP2_FLAG_END_STREAM,
	NGHTTP2_HCAT_REQUEST)));
	visitor.OnEndHeadersForStream(1);

	EXPECT_TRUE(visitor.OnEndStream(1));

	EXPECT_CALL(callbacks, OnStreamClose(1, NGHTTP2_NO_ERROR));
	visitor.OnCloseStream(1, Http2ErrorCode::HTTP2_NO_ERROR);

	EXPECT_EQ(visitor.stream_map_size(), 0);

	// Invalid repeat HEADERS on closed stream 1
	EXPECT_CALL(callbacks, OnBeginFrame(HasFrameHeader(
	1, HEADERS, NGHTTP2_FLAG_END_HEADERS)));
	visitor.OnFrameHeader(1, 23, HEADERS, 4);

	EXPECT_CALL(callbacks, OnBeginHeaders(IsHeaders(1, NGHTTP2_FLAG_END_HEADERS,
	NGHTTP2_HCAT_HEADERS)));
	EXPECT_TRUE(visitor.OnBeginHeadersForStream(1));

	// The visitor should not revive streams that have already been closed.
	EXPECT_EQ(visitor.stream_map_size(), 0);
	}

	} // namespace
	} // namespace test
	} // namespace adapter
	} // namespace http2