| // Copyright (c) 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "quiche/quic/core/http/quic_spdy_stream_body_manager.h" |
| |
| #include <algorithm> |
| #include <numeric> |
| #include <string> |
| |
| #include "absl/base/macros.h" |
| #include "absl/strings/string_view.h" |
| #include "quiche/quic/platform/api/quic_expect_bug.h" |
| #include "quiche/quic/platform/api/quic_logging.h" |
| #include "quiche/quic/platform/api/quic_test.h" |
| |
| namespace quic { |
| |
| namespace test { |
| |
| namespace { |
| |
| class QuicSpdyStreamBodyManagerTest : public QuicTest { |
| protected: |
| QuicSpdyStreamBodyManager body_manager_; |
| }; |
| |
| TEST_F(QuicSpdyStreamBodyManagerTest, HasBytesToRead) { |
| EXPECT_FALSE(body_manager_.HasBytesToRead()); |
| EXPECT_EQ(0u, body_manager_.total_body_bytes_received()); |
| |
| const QuicByteCount header_length = 3; |
| EXPECT_EQ(header_length, body_manager_.OnNonBody(header_length)); |
| |
| EXPECT_FALSE(body_manager_.HasBytesToRead()); |
| EXPECT_EQ(0u, body_manager_.total_body_bytes_received()); |
| |
| std::string body(1024, 'a'); |
| body_manager_.OnBody(body); |
| |
| EXPECT_TRUE(body_manager_.HasBytesToRead()); |
| EXPECT_EQ(1024u, body_manager_.total_body_bytes_received()); |
| } |
| |
| TEST_F(QuicSpdyStreamBodyManagerTest, ConsumeMoreThanAvailable) { |
| std::string body(1024, 'a'); |
| body_manager_.OnBody(body); |
| size_t bytes_to_consume = 0; |
| EXPECT_QUIC_BUG(bytes_to_consume = body_manager_.OnBodyConsumed(2048), |
| "Not enough available body to consume."); |
| EXPECT_EQ(0u, bytes_to_consume); |
| } |
| |
| TEST_F(QuicSpdyStreamBodyManagerTest, OnBodyConsumed) { |
| struct { |
| std::vector<QuicByteCount> frame_header_lengths; |
| std::vector<const char*> frame_payloads; |
| std::vector<QuicByteCount> body_bytes_to_read; |
| std::vector<QuicByteCount> expected_return_values; |
| } const kOnBodyConsumedTestData[] = { |
| // One frame consumed in one call. |
| {{2}, {"foobar"}, {6}, {6}}, |
| // Two frames consumed in one call. |
| {{3, 5}, {"foobar", "baz"}, {9}, {14}}, |
| // One frame consumed in two calls. |
| {{2}, {"foobar"}, {4, 2}, {4, 2}}, |
| // Two frames consumed in two calls matching frame boundaries. |
| {{3, 5}, {"foobar", "baz"}, {6, 3}, {11, 3}}, |
| // Two frames consumed in two calls, |
| // the first call only consuming part of the first frame. |
| {{3, 5}, {"foobar", "baz"}, {5, 4}, {5, 9}}, |
| // Two frames consumed in two calls, |
| // the first call consuming the entire first frame and part of the second. |
| {{3, 5}, {"foobar", "baz"}, {7, 2}, {12, 2}}, |
| }; |
| |
| for (size_t test_case_index = 0; |
| test_case_index < ABSL_ARRAYSIZE(kOnBodyConsumedTestData); |
| ++test_case_index) { |
| const std::vector<QuicByteCount>& frame_header_lengths = |
| kOnBodyConsumedTestData[test_case_index].frame_header_lengths; |
| const std::vector<const char*>& frame_payloads = |
| kOnBodyConsumedTestData[test_case_index].frame_payloads; |
| const std::vector<QuicByteCount>& body_bytes_to_read = |
| kOnBodyConsumedTestData[test_case_index].body_bytes_to_read; |
| const std::vector<QuicByteCount>& expected_return_values = |
| kOnBodyConsumedTestData[test_case_index].expected_return_values; |
| |
| for (size_t frame_index = 0; frame_index < frame_header_lengths.size(); |
| ++frame_index) { |
| // Frame header of first frame can immediately be consumed, but not the |
| // other frames. Each test case start with an empty |
| // QuicSpdyStreamBodyManager. |
| EXPECT_EQ(frame_index == 0 ? frame_header_lengths[frame_index] : 0u, |
| body_manager_.OnNonBody(frame_header_lengths[frame_index])); |
| body_manager_.OnBody(frame_payloads[frame_index]); |
| } |
| |
| for (size_t call_index = 0; call_index < body_bytes_to_read.size(); |
| ++call_index) { |
| EXPECT_EQ(expected_return_values[call_index], |
| body_manager_.OnBodyConsumed(body_bytes_to_read[call_index])); |
| } |
| |
| EXPECT_FALSE(body_manager_.HasBytesToRead()); |
| } |
| } |
| |
| TEST_F(QuicSpdyStreamBodyManagerTest, PeekBody) { |
| struct { |
| std::vector<QuicByteCount> frame_header_lengths; |
| std::vector<const char*> frame_payloads; |
| size_t iov_len; |
| } const kPeekBodyTestData[] = { |
| // No frames, more iovecs than frames. |
| {{}, {}, 1}, |
| // One frame, same number of iovecs. |
| {{3}, {"foobar"}, 1}, |
| // One frame, more iovecs than frames. |
| {{3}, {"foobar"}, 2}, |
| // Two frames, fewer iovecs than frames. |
| {{3, 5}, {"foobar", "baz"}, 1}, |
| // Two frames, same number of iovecs. |
| {{3, 5}, {"foobar", "baz"}, 2}, |
| // Two frames, more iovecs than frames. |
| {{3, 5}, {"foobar", "baz"}, 3}, |
| }; |
| |
| for (size_t test_case_index = 0; |
| test_case_index < ABSL_ARRAYSIZE(kPeekBodyTestData); ++test_case_index) { |
| const std::vector<QuicByteCount>& frame_header_lengths = |
| kPeekBodyTestData[test_case_index].frame_header_lengths; |
| const std::vector<const char*>& frame_payloads = |
| kPeekBodyTestData[test_case_index].frame_payloads; |
| size_t iov_len = kPeekBodyTestData[test_case_index].iov_len; |
| |
| QuicSpdyStreamBodyManager body_manager; |
| |
| for (size_t frame_index = 0; frame_index < frame_header_lengths.size(); |
| ++frame_index) { |
| // Frame header of first frame can immediately be consumed, but not the |
| // other frames. Each test case uses a new QuicSpdyStreamBodyManager |
| // instance. |
| EXPECT_EQ(frame_index == 0 ? frame_header_lengths[frame_index] : 0u, |
| body_manager.OnNonBody(frame_header_lengths[frame_index])); |
| body_manager.OnBody(frame_payloads[frame_index]); |
| } |
| |
| std::vector<iovec> iovecs; |
| iovecs.resize(iov_len); |
| size_t iovs_filled = std::min(frame_payloads.size(), iov_len); |
| ASSERT_EQ(iovs_filled, |
| static_cast<size_t>(body_manager.PeekBody(&iovecs[0], iov_len))); |
| for (size_t iovec_index = 0; iovec_index < iovs_filled; ++iovec_index) { |
| EXPECT_EQ(frame_payloads[iovec_index], |
| absl::string_view( |
| static_cast<const char*>(iovecs[iovec_index].iov_base), |
| iovecs[iovec_index].iov_len)); |
| } |
| } |
| } |
| |
| TEST_F(QuicSpdyStreamBodyManagerTest, ReadBody) { |
| struct { |
| std::vector<QuicByteCount> frame_header_lengths; |
| std::vector<const char*> frame_payloads; |
| std::vector<std::vector<QuicByteCount>> iov_lengths; |
| std::vector<QuicByteCount> expected_total_bytes_read; |
| std::vector<QuicByteCount> expected_return_values; |
| } const kReadBodyTestData[] = { |
| // One frame, one read with smaller iovec. |
| {{4}, {"foo"}, {{2}}, {2}, {2}}, |
| // One frame, one read with same size iovec. |
| {{4}, {"foo"}, {{3}}, {3}, {3}}, |
| // One frame, one read with larger iovec. |
| {{4}, {"foo"}, {{5}}, {3}, {3}}, |
| // One frame, one read with two iovecs, smaller total size. |
| {{4}, {"foobar"}, {{2, 3}}, {5}, {5}}, |
| // One frame, one read with two iovecs, same total size. |
| {{4}, {"foobar"}, {{2, 4}}, {6}, {6}}, |
| // One frame, one read with two iovecs, larger total size in last iovec. |
| {{4}, {"foobar"}, {{2, 6}}, {6}, {6}}, |
| // One frame, one read with extra iovecs, body ends at iovec boundary. |
| {{4}, {"foobar"}, {{2, 4, 4, 3}}, {6}, {6}}, |
| // One frame, one read with extra iovecs, body ends not at iovec boundary. |
| {{4}, {"foobar"}, {{2, 7, 4, 3}}, {6}, {6}}, |
| // One frame, two reads with two iovecs each, smaller total size. |
| {{4}, {"foobarbaz"}, {{2, 1}, {3, 2}}, {3, 5}, {3, 5}}, |
| // One frame, two reads with two iovecs each, same total size. |
| {{4}, {"foobarbaz"}, {{2, 1}, {4, 2}}, {3, 6}, {3, 6}}, |
| // One frame, two reads with two iovecs each, larger total size. |
| {{4}, {"foobarbaz"}, {{2, 1}, {4, 10}}, {3, 6}, {3, 6}}, |
| // Two frames, one read with smaller iovec. |
| {{4, 3}, {"foobar", "baz"}, {{8}}, {8}, {11}}, |
| // Two frames, one read with same size iovec. |
| {{4, 3}, {"foobar", "baz"}, {{9}}, {9}, {12}}, |
| // Two frames, one read with larger iovec. |
| {{4, 3}, {"foobar", "baz"}, {{10}}, {9}, {12}}, |
| // Two frames, one read with two iovecs, smaller total size. |
| {{4, 3}, {"foobar", "baz"}, {{4, 3}}, {7}, {10}}, |
| // Two frames, one read with two iovecs, same total size. |
| {{4, 3}, {"foobar", "baz"}, {{4, 5}}, {9}, {12}}, |
| // Two frames, one read with two iovecs, larger total size in last iovec. |
| {{4, 3}, {"foobar", "baz"}, {{4, 6}}, {9}, {12}}, |
| // Two frames, one read with extra iovecs, body ends at iovec boundary. |
| {{4, 3}, {"foobar", "baz"}, {{4, 6, 4, 3}}, {9}, {12}}, |
| // Two frames, one read with extra iovecs, body ends not at iovec |
| // boundary. |
| {{4, 3}, {"foobar", "baz"}, {{4, 7, 4, 3}}, {9}, {12}}, |
| // Two frames, two reads with two iovecs each, reads end on frame |
| // boundary. |
| {{4, 3}, {"foobar", "baz"}, {{2, 4}, {2, 1}}, {6, 3}, {9, 3}}, |
| // Three frames, three reads, extra iovecs, no iovec ends on frame |
| // boundary. |
| {{4, 3, 6}, |
| {"foobar", "bazquux", "qux"}, |
| {{4, 3}, {2, 3}, {5, 3}}, |
| {7, 5, 4}, |
| {10, 5, 10}}, |
| }; |
| |
| for (size_t test_case_index = 0; |
| test_case_index < ABSL_ARRAYSIZE(kReadBodyTestData); ++test_case_index) { |
| const std::vector<QuicByteCount>& frame_header_lengths = |
| kReadBodyTestData[test_case_index].frame_header_lengths; |
| const std::vector<const char*>& frame_payloads = |
| kReadBodyTestData[test_case_index].frame_payloads; |
| const std::vector<std::vector<QuicByteCount>>& iov_lengths = |
| kReadBodyTestData[test_case_index].iov_lengths; |
| const std::vector<QuicByteCount>& expected_total_bytes_read = |
| kReadBodyTestData[test_case_index].expected_total_bytes_read; |
| const std::vector<QuicByteCount>& expected_return_values = |
| kReadBodyTestData[test_case_index].expected_return_values; |
| |
| QuicSpdyStreamBodyManager body_manager; |
| |
| std::string received_body; |
| |
| for (size_t frame_index = 0; frame_index < frame_header_lengths.size(); |
| ++frame_index) { |
| // Frame header of first frame can immediately be consumed, but not the |
| // other frames. Each test case uses a new QuicSpdyStreamBodyManager |
| // instance. |
| EXPECT_EQ(frame_index == 0 ? frame_header_lengths[frame_index] : 0u, |
| body_manager.OnNonBody(frame_header_lengths[frame_index])); |
| body_manager.OnBody(frame_payloads[frame_index]); |
| received_body.append(frame_payloads[frame_index]); |
| } |
| |
| std::string read_body; |
| |
| for (size_t call_index = 0; call_index < iov_lengths.size(); ++call_index) { |
| // Allocate single buffer for iovecs. |
| size_t total_iov_length = std::accumulate(iov_lengths[call_index].begin(), |
| iov_lengths[call_index].end(), |
| static_cast<size_t>(0)); |
| std::string buffer(total_iov_length, 'z'); |
| |
| // Construct iovecs pointing to contiguous areas in the buffer. |
| std::vector<iovec> iovecs; |
| size_t offset = 0; |
| for (size_t iov_length : iov_lengths[call_index]) { |
| QUICHE_CHECK(offset + iov_length <= buffer.size()); |
| iovecs.push_back({&buffer[offset], iov_length}); |
| offset += iov_length; |
| } |
| |
| // Make sure |total_bytes_read| differs from |expected_total_bytes_read|. |
| size_t total_bytes_read = expected_total_bytes_read[call_index] + 12; |
| EXPECT_EQ( |
| expected_return_values[call_index], |
| body_manager.ReadBody(&iovecs[0], iovecs.size(), &total_bytes_read)); |
| read_body.append(buffer.substr(0, total_bytes_read)); |
| } |
| |
| EXPECT_EQ(received_body.substr(0, read_body.size()), read_body); |
| EXPECT_EQ(read_body.size() < received_body.size(), |
| body_manager.HasBytesToRead()); |
| } |
| } |
| |
| } // anonymous namespace |
| |
| } // namespace test |
| |
| } // namespace quic |