blob: 3a5efb50e7f95f9876974ee272e075719273f7a4 [file] [log] [blame] [edit]
// Copyright (c) 2017 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 "net/third_party/quiche/src/quic/core/quic_stream_send_buffer.h"
#include <string>
#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
#include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test_mem_slice_vector.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
namespace quic {
namespace test {
namespace {
struct iovec MakeIovec(QuicStringPiece data) {
struct iovec iov = {const_cast<char*>(data.data()),
static_cast<size_t>(data.size())};
return iov;
}
class QuicStreamSendBufferTest : public QuicTest {
public:
QuicStreamSendBufferTest() : send_buffer_(&allocator_) {
EXPECT_EQ(0u, send_buffer_.size());
EXPECT_EQ(0u, send_buffer_.stream_bytes_written());
EXPECT_EQ(0u, send_buffer_.stream_bytes_outstanding());
std::string data1(1536, 'a');
std::string data2 = std::string(256, 'b') + std::string(256, 'c');
struct iovec iov[2];
iov[0] = MakeIovec(QuicStringPiece(data1));
iov[1] = MakeIovec(QuicStringPiece(data2));
QuicMemSlice slice1(&allocator_, 1024);
memset(const_cast<char*>(slice1.data()), 'c', 1024);
QuicMemSlice slice2(&allocator_, 768);
memset(const_cast<char*>(slice2.data()), 'd', 768);
// Index starts from not pointing to any slice.
EXPECT_EQ(nullptr,
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_));
// Save all data.
SetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size, 1024);
send_buffer_.SaveStreamData(iov, 2, 0, 2048);
send_buffer_.SaveMemSlice(std::move(slice1));
EXPECT_TRUE(slice1.empty());
send_buffer_.SaveMemSlice(std::move(slice2));
EXPECT_TRUE(slice2.empty());
EXPECT_EQ(4u, send_buffer_.size());
// At this point, the whole buffer looks like:
// | a * 1536 |b * 256| c * 1280 | d * 768 |
// | slice1 | slice2 | slice3 | slice4 |
}
void WriteAllData() {
// Write all data.
char buf[4000];
QuicDataWriter writer(4000, buf, HOST_BYTE_ORDER);
send_buffer_.WriteStreamData(0, 3840u, &writer);
send_buffer_.OnStreamDataConsumed(3840u);
EXPECT_EQ(3840u, send_buffer_.stream_bytes_written());
EXPECT_EQ(3840u, send_buffer_.stream_bytes_outstanding());
}
SimpleBufferAllocator allocator_;
QuicStreamSendBuffer send_buffer_;
};
TEST_F(QuicStreamSendBufferTest, CopyDataToBuffer) {
char buf[4000];
QuicDataWriter writer(4000, buf, HOST_BYTE_ORDER);
std::string copy1(1024, 'a');
std::string copy2 =
std::string(512, 'a') + std::string(256, 'b') + std::string(256, 'c');
std::string copy3(1024, 'c');
std::string copy4(768, 'd');
ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
EXPECT_EQ(copy1, QuicStringPiece(buf, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(1024, 1024, &writer));
EXPECT_EQ(copy2, QuicStringPiece(buf + 1024, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1024, &writer));
EXPECT_EQ(copy3, QuicStringPiece(buf + 2048, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(3072, 768, &writer));
EXPECT_EQ(copy4, QuicStringPiece(buf + 3072, 768));
// Test data piece across boundries.
QuicDataWriter writer2(4000, buf, HOST_BYTE_ORDER);
std::string copy5 =
std::string(536, 'a') + std::string(256, 'b') + std::string(232, 'c');
ASSERT_TRUE(send_buffer_.WriteStreamData(1000, 1024, &writer2));
EXPECT_EQ(copy5, QuicStringPiece(buf, 1024));
ASSERT_TRUE(send_buffer_.WriteStreamData(2500, 1024, &writer2));
std::string copy6 = std::string(572, 'c') + std::string(452, 'd');
EXPECT_EQ(copy6, QuicStringPiece(buf + 1024, 1024));
// Invalid data copy.
QuicDataWriter writer3(4000, buf, HOST_BYTE_ORDER);
EXPECT_FALSE(send_buffer_.WriteStreamData(3000, 1024, &writer3));
EXPECT_QUIC_BUG(send_buffer_.WriteStreamData(0, 4000, &writer3),
"Writer fails to write.");
send_buffer_.OnStreamDataConsumed(3840);
EXPECT_EQ(3840u, send_buffer_.stream_bytes_written());
EXPECT_EQ(3840u, send_buffer_.stream_bytes_outstanding());
}
TEST_F(QuicStreamSendBufferTest, RemoveStreamFrame) {
WriteAllData();
QuicByteCount newly_acked_length;
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(1024, 1024, &newly_acked_length));
EXPECT_EQ(1024u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2048, 1024, &newly_acked_length));
EXPECT_EQ(1024u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 1024, &newly_acked_length));
EXPECT_EQ(1024u, newly_acked_length);
// Send buffer is cleaned up in order.
EXPECT_EQ(1u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(3072, 768, &newly_acked_length));
EXPECT_EQ(768u, newly_acked_length);
EXPECT_EQ(0u, send_buffer_.size());
}
TEST_F(QuicStreamSendBufferTest, RemoveStreamFrameAcrossBoundries) {
WriteAllData();
QuicByteCount newly_acked_length;
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2024, 576, &newly_acked_length));
EXPECT_EQ(576u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 1000, &newly_acked_length));
EXPECT_EQ(1000u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(1000, 1024, &newly_acked_length));
EXPECT_EQ(1024u, newly_acked_length);
// Send buffer is cleaned up in order.
EXPECT_EQ(2u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2600, 1024, &newly_acked_length));
EXPECT_EQ(1024u, newly_acked_length);
EXPECT_EQ(1u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(3624, 216, &newly_acked_length));
EXPECT_EQ(216u, newly_acked_length);
EXPECT_EQ(0u, send_buffer_.size());
}
TEST_F(QuicStreamSendBufferTest, AckStreamDataMultipleTimes) {
WriteAllData();
QuicByteCount newly_acked_length;
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(100, 1500, &newly_acked_length));
EXPECT_EQ(1500u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2000, 500, &newly_acked_length));
EXPECT_EQ(500u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 2600, &newly_acked_length));
EXPECT_EQ(600u, newly_acked_length);
// Send buffer is cleaned up in order.
EXPECT_EQ(2u, send_buffer_.size());
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2200, 1640, &newly_acked_length));
EXPECT_EQ(1240u, newly_acked_length);
EXPECT_EQ(0u, send_buffer_.size());
EXPECT_FALSE(send_buffer_.OnStreamDataAcked(4000, 100, &newly_acked_length));
}
TEST_F(QuicStreamSendBufferTest, AckStreamDataOutOfOrder) {
WriteAllData();
QuicByteCount newly_acked_length;
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(500, 1000, &newly_acked_length));
EXPECT_EQ(1000u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
EXPECT_EQ(3840u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(1200, 1000, &newly_acked_length));
EXPECT_EQ(700u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
// Slice 2 gets fully acked.
EXPECT_EQ(2816u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(2000, 1840, &newly_acked_length));
EXPECT_EQ(1640u, newly_acked_length);
EXPECT_EQ(4u, send_buffer_.size());
// Slices 3 and 4 get fully acked.
EXPECT_EQ(1024u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 1000, &newly_acked_length));
EXPECT_EQ(500u, newly_acked_length);
EXPECT_EQ(0u, send_buffer_.size());
EXPECT_EQ(0u, QuicStreamSendBufferPeer::TotalLength(&send_buffer_));
}
TEST_F(QuicStreamSendBufferTest, PendingRetransmission) {
WriteAllData();
EXPECT_TRUE(send_buffer_.IsStreamDataOutstanding(0, 3840));
EXPECT_FALSE(send_buffer_.HasPendingRetransmission());
// Lost data [0, 1200).
send_buffer_.OnStreamDataLost(0, 1200);
// Lost data [1500, 2000).
send_buffer_.OnStreamDataLost(1500, 500);
EXPECT_TRUE(send_buffer_.HasPendingRetransmission());
EXPECT_EQ(StreamPendingRetransmission(0, 1200),
send_buffer_.NextPendingRetransmission());
// Retransmit data [0, 500).
send_buffer_.OnStreamDataRetransmitted(0, 500);
EXPECT_TRUE(send_buffer_.IsStreamDataOutstanding(0, 500));
EXPECT_EQ(StreamPendingRetransmission(500, 700),
send_buffer_.NextPendingRetransmission());
// Ack data [500, 1200).
QuicByteCount newly_acked_length = 0;
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(500, 700, &newly_acked_length));
EXPECT_FALSE(send_buffer_.IsStreamDataOutstanding(500, 700));
EXPECT_TRUE(send_buffer_.HasPendingRetransmission());
EXPECT_EQ(StreamPendingRetransmission(1500, 500),
send_buffer_.NextPendingRetransmission());
// Retransmit data [1500, 2000).
send_buffer_.OnStreamDataRetransmitted(1500, 500);
EXPECT_FALSE(send_buffer_.HasPendingRetransmission());
// Lost [200, 800).
send_buffer_.OnStreamDataLost(200, 600);
EXPECT_TRUE(send_buffer_.HasPendingRetransmission());
// Verify [200, 500) is considered as lost, as [500, 800) has been acked.
EXPECT_EQ(StreamPendingRetransmission(200, 300),
send_buffer_.NextPendingRetransmission());
// Verify 0 length data is not outstanding.
EXPECT_FALSE(send_buffer_.IsStreamDataOutstanding(100, 0));
// Verify partially acked data is outstanding.
EXPECT_TRUE(send_buffer_.IsStreamDataOutstanding(400, 800));
}
TEST_F(QuicStreamSendBufferTest, CurrentWriteIndex) {
char buf[4000];
QuicDataWriter writer(4000, buf, HOST_BYTE_ORDER);
// With data buffered, index points to the 1st slice of data.
EXPECT_EQ(0u,
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_)->offset);
ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
// Wrote all data on 1st slice, index points to next slice.
EXPECT_EQ(1024u,
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_)->offset);
ASSERT_TRUE(send_buffer_.WriteStreamData(1024, 512, &writer));
// Last write didn't finish a whole slice. Index remains.
EXPECT_EQ(1024u,
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_)->offset);
send_buffer_.OnStreamDataConsumed(1024);
// If data in 1st slice gets ACK'ed, it shouldn't change the indexed slice
QuicByteCount newly_acked_length;
EXPECT_TRUE(send_buffer_.OnStreamDataAcked(0, 1024, &newly_acked_length));
EXPECT_EQ(1024u,
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_)->offset);
ASSERT_TRUE(
send_buffer_.WriteStreamData(1024 + 512, 3840 - 1024 - 512, &writer));
// After writing all buffered data, index become invalid again.
EXPECT_EQ(nullptr,
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_));
QuicMemSlice slice(&allocator_, 60);
memset(const_cast<char*>(slice.data()), 'e', 60);
send_buffer_.SaveMemSlice(std::move(slice));
// With new data, index points to the new data.
EXPECT_EQ(3840u,
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer_)->offset);
}
TEST_F(QuicStreamSendBufferTest, SaveMemSliceSpan) {
SimpleBufferAllocator allocator;
QuicStreamSendBuffer send_buffer(&allocator);
char data[1024];
std::vector<std::pair<char*, size_t>> buffers;
for (size_t i = 0; i < 10; ++i) {
buffers.push_back(std::make_pair(data, 1024));
}
QuicTestMemSliceVector vector(buffers);
EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(vector.span()));
EXPECT_EQ(10u, send_buffer.size());
}
TEST_F(QuicStreamSendBufferTest, SaveEmptyMemSliceSpan) {
SimpleBufferAllocator allocator;
QuicStreamSendBuffer send_buffer(&allocator);
char data[1024];
std::vector<std::pair<char*, size_t>> buffers;
for (size_t i = 0; i < 10; ++i) {
buffers.push_back(std::make_pair(data, 1024));
}
buffers.push_back(std::make_pair(nullptr, 0));
QuicTestMemSliceVector vector(buffers);
EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(vector.span()));
// Verify the empty slice does not get saved.
EXPECT_EQ(10u, send_buffer.size());
}
} // namespace
} // namespace test
} // namespace quic