quiche/balsa/simple_buffer_test.cc - quiche - Git at Google

 // Copyright 2022 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/balsa/simple_buffer.h"

 #include <string>

 #include "absl/strings/string_view.h"
 #include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"

 namespace quiche {

 namespace test {

 namespace {

 constexpr int kMinimumSimpleBufferSize = 10;

 // Buffer full of 40 char strings.
 const char ibuf[] = {
     "123456789!@#$%^&*()abcdefghijklmnopqrstu"
     "123456789!@#$%^&*()abcdefghijklmnopqrstu"
     "123456789!@#$%^&*()abcdefghijklmnopqrstu"
     "123456789!@#$%^&*()abcdefghijklmnopqrstu"
     "123456789!@#$%^&*()abcdefghijklmnopqrstu"};

 }  // namespace

 class SimpleBufferTest : public QuicheTest {
  public:
   static char* storage(SimpleBuffer& buffer) { return buffer.storage_; }
   static int write_idx(SimpleBuffer& buffer) { return buffer.write_idx_; }
   static int read_idx(SimpleBuffer& buffer) { return buffer.read_idx_; }
   static int storage_size(SimpleBuffer& buffer) { return buffer.storage_size_; }
 };

 namespace {

 TEST_F(SimpleBufferTest, CreationWithSize) {
   SimpleBuffer buffer1(5);
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer1));

   SimpleBuffer buffer2(25);
   EXPECT_EQ(25, storage_size(buffer2));
 }

 // Make sure that a zero-sized initial buffer does not throw things off.
 TEST_F(SimpleBufferTest, CreationWithZeroSize) {
   SimpleBuffer buffer(0);
   EXPECT_EQ(0, storage_size(buffer));
   EXPECT_EQ(4, buffer.Write(ibuf, 4));
   EXPECT_EQ(4, write_idx(buffer));
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(4, buffer.ReadableBytes());
 }

 TEST_F(SimpleBufferTest, ReadZeroBytes) {
   SimpleBuffer buffer;

   EXPECT_EQ(0, buffer.Read(nullptr, 0));
 }

 TEST_F(SimpleBufferTest, WriteZeroFromNullptr) {
   SimpleBuffer buffer;

   EXPECT_EQ(0, buffer.Write(nullptr, 0));
 }

 TEST(SimpleBufferExpectBug, ReserveNegativeSize) {
   SimpleBuffer buffer;

   EXPECT_QUICHE_BUG(buffer.Reserve(-1), "size must not be negative");
 }

 TEST(SimpleBufferExpectBug, ReadNegativeSize) {
   SimpleBuffer buffer;

   EXPECT_QUICHE_BUG(buffer.Read(nullptr, -1), "size must not be negative");
 }

 TEST(SimpleBufferExpectBug, WriteNegativeSize) {
   SimpleBuffer buffer;

   EXPECT_QUICHE_BUG(buffer.Write(nullptr, -1), "size must not be negative");
 }

 TEST_F(SimpleBufferTest, Basics) {
   SimpleBuffer buffer;

   EXPECT_TRUE(buffer.Empty());
   EXPECT_EQ("", buffer.GetReadableRegion());
   EXPECT_EQ(0, storage_size(buffer));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));

   char* readable_ptr = nullptr;
   int readable_size = 0;
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
   char* writeable_ptr = nullptr;
   int writable_size = 0;
   buffer.GetWritablePtr(&writeable_ptr, &writable_size);

   EXPECT_EQ(storage(buffer), readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_EQ(storage(buffer), writeable_ptr);
   EXPECT_EQ(0, writable_size);
   EXPECT_EQ(0, buffer.ReadableBytes());

   const SimpleBuffer buffer2;
   EXPECT_EQ(0, buffer2.ReadableBytes());
 }

 TEST_F(SimpleBufferTest, BasicWR) {
   SimpleBuffer buffer;

   EXPECT_EQ(4, buffer.Write(ibuf, 4));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(4, write_idx(buffer));
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(4, buffer.ReadableBytes());
   EXPECT_EQ("1234", buffer.GetReadableRegion());
   int bytes_written = 4;
   EXPECT_TRUE(!buffer.Empty());

   char* readable_ptr = nullptr;
   int readable_size = 0;
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
   char* writeable_ptr = nullptr;
   int writable_size = 0;
   buffer.GetWritablePtr(&writeable_ptr, &writable_size);

   EXPECT_EQ(storage(buffer), readable_ptr);
   EXPECT_EQ(4, readable_size);
   EXPECT_EQ(storage(buffer) + 4, writeable_ptr);
   EXPECT_EQ(6, writable_size);

   char obuf[ABSL_ARRAYSIZE(ibuf)];
   int bytes_read = 0;
   EXPECT_EQ(4, buffer.Read(obuf + bytes_read, 40));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(0, buffer.ReadableBytes());
   EXPECT_EQ("", buffer.GetReadableRegion());
   bytes_read += 4;
   EXPECT_TRUE(buffer.Empty());
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
   buffer.GetWritablePtr(&writeable_ptr, &writable_size);
   EXPECT_EQ(storage(buffer), readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_EQ(storage(buffer), writeable_ptr);
   EXPECT_EQ(kMinimumSimpleBufferSize, writable_size);

   EXPECT_EQ(bytes_written, bytes_read);
   for (int i = 0; i < bytes_read; ++i) {
     EXPECT_EQ(obuf[i], ibuf[i]);
   }

   // More R/W tests.
   EXPECT_EQ(10, buffer.Write(ibuf + bytes_written, 10));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(10, write_idx(buffer));
   EXPECT_EQ(10, storage_size(buffer));
   EXPECT_EQ(10, buffer.ReadableBytes());
   bytes_written += 10;

   EXPECT_TRUE(!buffer.Empty());

   EXPECT_EQ(6, buffer.Read(obuf + bytes_read, 6));
   EXPECT_EQ(6, read_idx(buffer));
   EXPECT_EQ(10, write_idx(buffer));
   EXPECT_EQ(10, storage_size(buffer));
   EXPECT_EQ(4, buffer.ReadableBytes());
   bytes_read += 6;

   EXPECT_TRUE(!buffer.Empty());

   EXPECT_EQ(4, buffer.Read(obuf + bytes_read, 7));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
   EXPECT_EQ(10, storage_size(buffer));
   EXPECT_EQ(0, buffer.ReadableBytes());
   bytes_read += 4;

   EXPECT_TRUE(buffer.Empty());

   EXPECT_EQ(bytes_written, bytes_read);
   for (int i = 0; i < bytes_read; ++i) {
     EXPECT_EQ(obuf[i], ibuf[i]);
   }
 }

 TEST_F(SimpleBufferTest, Reserve) {
   SimpleBuffer buffer;
   EXPECT_EQ(0, storage_size(buffer));

   buffer.WriteString("foo");
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));

   // Reserve by expanding the buffer.
   buffer.Reserve(kMinimumSimpleBufferSize + 1);
   EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));

   buffer.Clear();
   buffer.AdvanceWritablePtr(kMinimumSimpleBufferSize);
   buffer.AdvanceReadablePtr(kMinimumSimpleBufferSize - 2);
   EXPECT_EQ(kMinimumSimpleBufferSize, write_idx(buffer));
   EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));

   // Reserve by moving data around.  `storage_size` does not change.
   buffer.Reserve(kMinimumSimpleBufferSize + 1);
   EXPECT_EQ(2, write_idx(buffer));
   EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));
 }

 TEST_F(SimpleBufferTest, Extend) {
   SimpleBuffer buffer;

   // Test a write which should not extend the buffer.
   EXPECT_EQ(7, buffer.Write(ibuf, 7));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(7, write_idx(buffer));
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(7, buffer.ReadableBytes());
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(7, write_idx(buffer));
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(7, buffer.ReadableBytes());
   int bytes_written = 7;

   // Test a write which should extend the buffer.
   EXPECT_EQ(4, buffer.Write(ibuf + bytes_written, 4));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(11, write_idx(buffer));
   EXPECT_EQ(20, storage_size(buffer));
   EXPECT_EQ(11, buffer.ReadableBytes());
   bytes_written += 4;

   char obuf[ABSL_ARRAYSIZE(ibuf)];
   EXPECT_EQ(11, buffer.Read(obuf, 11));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
   EXPECT_EQ(20, storage_size(buffer));
   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
   EXPECT_EQ(0, buffer.ReadableBytes());

   const int bytes_read = 11;
   EXPECT_EQ(bytes_written, bytes_read);
   for (int i = 0; i < bytes_read; ++i) {
     EXPECT_EQ(obuf[i], ibuf[i]);
   }
 }

 TEST_F(SimpleBufferTest, Clear) {
   SimpleBuffer buffer;

   buffer.Clear();

   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
   EXPECT_EQ(0, storage_size(buffer));
   EXPECT_EQ(0, buffer.ReadableBytes());

   buffer.WriteString("foo");
   buffer.Clear();

   EXPECT_EQ(0, read_idx(buffer));
   EXPECT_EQ(0, write_idx(buffer));
   EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
   EXPECT_EQ(0, buffer.ReadableBytes());
 }

 TEST_F(SimpleBufferTest, LongWrite) {
   SimpleBuffer buffer;

   std::string s1 = "HTTP/1.1 500 Service Unavailable";
   buffer.Write(s1.data(), s1.size());
   buffer.Write("\r\n", 2);
   std::string key = "Connection";
   std::string value = "close";
   buffer.Write(key.data(), key.size());
   buffer.Write(": ", 2);
   buffer.Write(value.data(), value.size());
   buffer.Write("\r\n", 2);
   buffer.Write("\r\n", 2);
   std::string message =
       "<html><head>\n"
       "<meta http-equiv=\"content-type\""
       " content=\"text/html;charset=us-ascii\">\n"
       "<style><!--\n"
       "body {font-family: arial,sans-serif}\n"
       "div.nav {margin-top: 1ex}\n"
       "div.nav A {font-size: 10pt; font-family: arial,sans-serif}\n"
       "span.nav {font-size: 10pt; font-family: arial,sans-serif;"
       " font-weight: bold}\n"
       "div.nav A,span.big {font-size: 12pt; color: #0000cc}\n"
       "div.nav A {font-size: 10pt; color: black}\n"
       "A.l:link {color: #6f6f6f}\n"
       "A.u:link {color: green}\n"
       "//--></style>\n"
       "</head>\n"
       "<body text=#000000 bgcolor=#ffffff>\n"
       "<table border=0 cellpadding=2 cellspacing=0 width=100%>"
       "<tr><td rowspan=3 width=1% nowrap>\n"
       "<b>"
       "<font face=times color=#0039b6 size=10>G</font>"
       "<font face=times color=#c41200 size=10>o</font>"
       "<font face=times color=#f3c518 size=10>o</font>"
       "<font face=times color=#0039b6 size=10>g</font>"
       "<font face=times color=#30a72f size=10>l</font>"
       "<font face=times color=#c41200 size=10>e</font>"
       "&nbsp;&nbsp;</b>\n"
       "<td>&nbsp;</td></tr>\n"
       "<tr><td bgcolor=#3366cc><font face=arial,sans-serif color=#ffffff>"
       " <b>Error</b></td></tr>\n"
       "<tr><td>&nbsp;</td></tr></table>\n"
       "<blockquote>\n"
       "<H1> Internal Server Error</H1>\n"
       " This server was unable to complete the request\n"
       "<p></blockquote>\n"
       "<table width=100% cellpadding=0 cellspacing=0>"
       "<tr><td bgcolor=#3366cc><img alt=\"\" width=1 height=4></td></tr>"
       "</table>"
       "</body></html>\n";
   buffer.Write(message.data(), message.size());
   const std::string correct_result =
       "HTTP/1.1 500 Service Unavailable\r\n"
       "Connection: close\r\n"
       "\r\n"
       "<html><head>\n"
       "<meta http-equiv=\"content-type\""
       " content=\"text/html;charset=us-ascii\">\n"
       "<style><!--\n"
       "body {font-family: arial,sans-serif}\n"
       "div.nav {margin-top: 1ex}\n"
       "div.nav A {font-size: 10pt; font-family: arial,sans-serif}\n"
       "span.nav {font-size: 10pt; font-family: arial,sans-serif;"
       " font-weight: bold}\n"
       "div.nav A,span.big {font-size: 12pt; color: #0000cc}\n"
       "div.nav A {font-size: 10pt; color: black}\n"
       "A.l:link {color: #6f6f6f}\n"
       "A.u:link {color: green}\n"
       "//--></style>\n"
       "</head>\n"
       "<body text=#000000 bgcolor=#ffffff>\n"
       "<table border=0 cellpadding=2 cellspacing=0 width=100%>"
       "<tr><td rowspan=3 width=1% nowrap>\n"
       "<b>"
       "<font face=times color=#0039b6 size=10>G</font>"
       "<font face=times color=#c41200 size=10>o</font>"
       "<font face=times color=#f3c518 size=10>o</font>"
       "<font face=times color=#0039b6 size=10>g</font>"
       "<font face=times color=#30a72f size=10>l</font>"
       "<font face=times color=#c41200 size=10>e</font>"
       "&nbsp;&nbsp;</b>\n"
       "<td>&nbsp;</td></tr>\n"
       "<tr><td bgcolor=#3366cc><font face=arial,sans-serif color=#ffffff>"
       " <b>Error</b></td></tr>\n"
       "<tr><td>&nbsp;</td></tr></table>\n"
       "<blockquote>\n"
       "<H1> Internal Server Error</H1>\n"
       " This server was unable to complete the request\n"
       "<p></blockquote>\n"
       "<table width=100% cellpadding=0 cellspacing=0>"
       "<tr><td bgcolor=#3366cc><img alt=\"\" width=1 height=4></td></tr>"
       "</table>"
       "</body></html>\n";
   EXPECT_EQ(correct_result, buffer.GetReadableRegion());
 }

 TEST_F(SimpleBufferTest, ReleaseAsSlice) {
   SimpleBuffer buffer;

   buffer.WriteString("abc");
   QuicheMemSlice slice = buffer.ReleaseAsSlice();
   EXPECT_EQ("abc", slice.AsStringView());

   char* readable_ptr = nullptr;
   int readable_size = 0;
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
   EXPECT_EQ(nullptr, readable_ptr);
   EXPECT_EQ(0, readable_size);

   buffer.WriteString("def");
   slice = buffer.ReleaseAsSlice();
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
   EXPECT_EQ(nullptr, readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_EQ("def", slice.AsStringView());
 }

 TEST_F(SimpleBufferTest, EmptyBufferReleaseAsSlice) {
   SimpleBuffer buffer;
   char* readable_ptr = nullptr;
   int readable_size = 0;

   QuicheMemSlice slice = buffer.ReleaseAsSlice();
   buffer.GetReadablePtr(&readable_ptr, &readable_size);
   EXPECT_EQ(nullptr, readable_ptr);
   EXPECT_EQ(0, readable_size);
   EXPECT_TRUE(slice.empty());
 }

 }  // namespace

 }  // namespace test

 }  // namespace quiche
	// Copyright 2022 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/balsa/simple_buffer.h"

	#include <string>

	#include "absl/strings/string_view.h"
	#include "quiche/common/platform/api/quiche_expect_bug.h"
	#include "quiche/common/platform/api/quiche_test.h"

	namespace quiche {

	namespace test {

	namespace {

	constexpr int kMinimumSimpleBufferSize = 10;

	// Buffer full of 40 char strings.
	const char ibuf[] = {
	"123456789!@#$%^&*()abcdefghijklmnopqrstu"
	"123456789!@#$%^&*()abcdefghijklmnopqrstu"
	"123456789!@#$%^&*()abcdefghijklmnopqrstu"
	"123456789!@#$%^&*()abcdefghijklmnopqrstu"
	"123456789!@#$%^&*()abcdefghijklmnopqrstu"};

	} // namespace

	class SimpleBufferTest : public QuicheTest {
	public:
	static char* storage(SimpleBuffer& buffer) { return buffer.storage_; }
	static int write_idx(SimpleBuffer& buffer) { return buffer.write_idx_; }
	static int read_idx(SimpleBuffer& buffer) { return buffer.read_idx_; }
	static int storage_size(SimpleBuffer& buffer) { return buffer.storage_size_; }
	};

	namespace {

	TEST_F(SimpleBufferTest, CreationWithSize) {
	SimpleBuffer buffer1(5);
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer1));

	SimpleBuffer buffer2(25);
	EXPECT_EQ(25, storage_size(buffer2));
	}

	// Make sure that a zero-sized initial buffer does not throw things off.
	TEST_F(SimpleBufferTest, CreationWithZeroSize) {
	SimpleBuffer buffer(0);
	EXPECT_EQ(0, storage_size(buffer));
	EXPECT_EQ(4, buffer.Write(ibuf, 4));
	EXPECT_EQ(4, write_idx(buffer));
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
	EXPECT_EQ(4, buffer.ReadableBytes());
	}

	TEST_F(SimpleBufferTest, ReadZeroBytes) {
	SimpleBuffer buffer;

	EXPECT_EQ(0, buffer.Read(nullptr, 0));
	}

	TEST_F(SimpleBufferTest, WriteZeroFromNullptr) {
	SimpleBuffer buffer;

	EXPECT_EQ(0, buffer.Write(nullptr, 0));
	}

	TEST(SimpleBufferExpectBug, ReserveNegativeSize) {
	SimpleBuffer buffer;

	EXPECT_QUICHE_BUG(buffer.Reserve(-1), "size must not be negative");
	}

	TEST(SimpleBufferExpectBug, ReadNegativeSize) {
	SimpleBuffer buffer;

	EXPECT_QUICHE_BUG(buffer.Read(nullptr, -1), "size must not be negative");
	}

	TEST(SimpleBufferExpectBug, WriteNegativeSize) {
	SimpleBuffer buffer;

	EXPECT_QUICHE_BUG(buffer.Write(nullptr, -1), "size must not be negative");
	}

	TEST_F(SimpleBufferTest, Basics) {
	SimpleBuffer buffer;

	EXPECT_TRUE(buffer.Empty());
	EXPECT_EQ("", buffer.GetReadableRegion());
	EXPECT_EQ(0, storage_size(buffer));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(0, write_idx(buffer));

	char* readable_ptr = nullptr;
	int readable_size = 0;
	buffer.GetReadablePtr(&readable_ptr, &readable_size);
	char* writeable_ptr = nullptr;
	int writable_size = 0;
	buffer.GetWritablePtr(&writeable_ptr, &writable_size);

	EXPECT_EQ(storage(buffer), readable_ptr);
	EXPECT_EQ(0, readable_size);
	EXPECT_EQ(storage(buffer), writeable_ptr);
	EXPECT_EQ(0, writable_size);
	EXPECT_EQ(0, buffer.ReadableBytes());

	const SimpleBuffer buffer2;
	EXPECT_EQ(0, buffer2.ReadableBytes());
	}

	TEST_F(SimpleBufferTest, BasicWR) {
	SimpleBuffer buffer;

	EXPECT_EQ(4, buffer.Write(ibuf, 4));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(4, write_idx(buffer));
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
	EXPECT_EQ(4, buffer.ReadableBytes());
	EXPECT_EQ("1234", buffer.GetReadableRegion());
	int bytes_written = 4;
	EXPECT_TRUE(!buffer.Empty());

	char* readable_ptr = nullptr;
	int readable_size = 0;
	buffer.GetReadablePtr(&readable_ptr, &readable_size);
	char* writeable_ptr = nullptr;
	int writable_size = 0;
	buffer.GetWritablePtr(&writeable_ptr, &writable_size);

	EXPECT_EQ(storage(buffer), readable_ptr);
	EXPECT_EQ(4, readable_size);
	EXPECT_EQ(storage(buffer) + 4, writeable_ptr);
	EXPECT_EQ(6, writable_size);

	char obuf[ABSL_ARRAYSIZE(ibuf)];
	int bytes_read = 0;
	EXPECT_EQ(4, buffer.Read(obuf + bytes_read, 40));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(0, write_idx(buffer));
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
	EXPECT_EQ(0, buffer.ReadableBytes());
	EXPECT_EQ("", buffer.GetReadableRegion());
	bytes_read += 4;
	EXPECT_TRUE(buffer.Empty());
	buffer.GetReadablePtr(&readable_ptr, &readable_size);
	buffer.GetWritablePtr(&writeable_ptr, &writable_size);
	EXPECT_EQ(storage(buffer), readable_ptr);
	EXPECT_EQ(0, readable_size);
	EXPECT_EQ(storage(buffer), writeable_ptr);
	EXPECT_EQ(kMinimumSimpleBufferSize, writable_size);

	EXPECT_EQ(bytes_written, bytes_read);
	for (int i = 0; i < bytes_read; ++i) {
	EXPECT_EQ(obuf[i], ibuf[i]);
	}

	// More R/W tests.
	EXPECT_EQ(10, buffer.Write(ibuf + bytes_written, 10));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(10, write_idx(buffer));
	EXPECT_EQ(10, storage_size(buffer));
	EXPECT_EQ(10, buffer.ReadableBytes());
	bytes_written += 10;

	EXPECT_TRUE(!buffer.Empty());

	EXPECT_EQ(6, buffer.Read(obuf + bytes_read, 6));
	EXPECT_EQ(6, read_idx(buffer));
	EXPECT_EQ(10, write_idx(buffer));
	EXPECT_EQ(10, storage_size(buffer));
	EXPECT_EQ(4, buffer.ReadableBytes());
	bytes_read += 6;

	EXPECT_TRUE(!buffer.Empty());

	EXPECT_EQ(4, buffer.Read(obuf + bytes_read, 7));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(0, write_idx(buffer));
	EXPECT_EQ(10, storage_size(buffer));
	EXPECT_EQ(0, buffer.ReadableBytes());
	bytes_read += 4;

	EXPECT_TRUE(buffer.Empty());

	EXPECT_EQ(bytes_written, bytes_read);
	for (int i = 0; i < bytes_read; ++i) {
	EXPECT_EQ(obuf[i], ibuf[i]);
	}
	}

	TEST_F(SimpleBufferTest, Reserve) {
	SimpleBuffer buffer;
	EXPECT_EQ(0, storage_size(buffer));

	buffer.WriteString("foo");
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));

	// Reserve by expanding the buffer.
	buffer.Reserve(kMinimumSimpleBufferSize + 1);
	EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));

	buffer.Clear();
	buffer.AdvanceWritablePtr(kMinimumSimpleBufferSize);
	buffer.AdvanceReadablePtr(kMinimumSimpleBufferSize - 2);
	EXPECT_EQ(kMinimumSimpleBufferSize, write_idx(buffer));
	EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));

	// Reserve by moving data around. `storage_size` does not change.
	buffer.Reserve(kMinimumSimpleBufferSize + 1);
	EXPECT_EQ(2, write_idx(buffer));
	EXPECT_EQ(2 * kMinimumSimpleBufferSize, storage_size(buffer));
	}

	TEST_F(SimpleBufferTest, Extend) {
	SimpleBuffer buffer;

	// Test a write which should not extend the buffer.
	EXPECT_EQ(7, buffer.Write(ibuf, 7));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(7, write_idx(buffer));
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
	EXPECT_EQ(7, buffer.ReadableBytes());
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(7, write_idx(buffer));
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
	EXPECT_EQ(7, buffer.ReadableBytes());
	int bytes_written = 7;

	// Test a write which should extend the buffer.
	EXPECT_EQ(4, buffer.Write(ibuf + bytes_written, 4));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(11, write_idx(buffer));
	EXPECT_EQ(20, storage_size(buffer));
	EXPECT_EQ(11, buffer.ReadableBytes());
	bytes_written += 4;

	char obuf[ABSL_ARRAYSIZE(ibuf)];
	EXPECT_EQ(11, buffer.Read(obuf, 11));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(0, write_idx(buffer));
	EXPECT_EQ(20, storage_size(buffer));
	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(0, write_idx(buffer));
	EXPECT_EQ(0, buffer.ReadableBytes());

	const int bytes_read = 11;
	EXPECT_EQ(bytes_written, bytes_read);
	for (int i = 0; i < bytes_read; ++i) {
	EXPECT_EQ(obuf[i], ibuf[i]);
	}
	}

	TEST_F(SimpleBufferTest, Clear) {
	SimpleBuffer buffer;

	buffer.Clear();

	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(0, write_idx(buffer));
	EXPECT_EQ(0, storage_size(buffer));
	EXPECT_EQ(0, buffer.ReadableBytes());

	buffer.WriteString("foo");
	buffer.Clear();

	EXPECT_EQ(0, read_idx(buffer));
	EXPECT_EQ(0, write_idx(buffer));
	EXPECT_EQ(kMinimumSimpleBufferSize, storage_size(buffer));
	EXPECT_EQ(0, buffer.ReadableBytes());
	}

	TEST_F(SimpleBufferTest, LongWrite) {
	SimpleBuffer buffer;

	std::string s1 = "HTTP/1.1 500 Service Unavailable";
	buffer.Write(s1.data(), s1.size());
	buffer.Write("\r\n", 2);
	std::string key = "Connection";
	std::string value = "close";
	buffer.Write(key.data(), key.size());
	buffer.Write(": ", 2);
	buffer.Write(value.data(), value.size());
	buffer.Write("\r\n", 2);
	buffer.Write("\r\n", 2);
	std::string message =
	"<html><head>\n"
	"<meta http-equiv=\"content-type\""
	" content=\"text/html;charset=us-ascii\">\n"
	"<style><!--\n"
	"body {font-family: arial,sans-serif}\n"
	"div.nav {margin-top: 1ex}\n"
	"div.nav A {font-size: 10pt; font-family: arial,sans-serif}\n"
	"span.nav {font-size: 10pt; font-family: arial,sans-serif;"
	" font-weight: bold}\n"
	"div.nav A,span.big {font-size: 12pt; color: #0000cc}\n"
	"div.nav A {font-size: 10pt; color: black}\n"
	"A.l:link {color: #6f6f6f}\n"
	"A.u:link {color: green}\n"
	"//--></style>\n"
	"</head>\n"
	"<body text=#000000 bgcolor=#ffffff>\n"
	"<table border=0 cellpadding=2 cellspacing=0 width=100%>"
	"<tr><td rowspan=3 width=1% nowrap>\n"
	"<b>"
	"<font face=times color=#0039b6 size=10>G</font>"
	"<font face=times color=#c41200 size=10>o</font>"
	"<font face=times color=#f3c518 size=10>o</font>"
	"<font face=times color=#0039b6 size=10>g</font>"
	"<font face=times color=#30a72f size=10>l</font>"
	"<font face=times color=#c41200 size=10>e</font>"
	"  </b>\n"
	"<td> </td></tr>\n"
	"<tr><td bgcolor=#3366cc><font face=arial,sans-serif color=#ffffff>"
	" <b>Error</b></td></tr>\n"
	"<tr><td> </td></tr></table>\n"
	"<blockquote>\n"
	"<H1> Internal Server Error</H1>\n"
	" This server was unable to complete the request\n"
	"<p></blockquote>\n"
	"<table width=100% cellpadding=0 cellspacing=0>"
	"<tr><td bgcolor=#3366cc><img alt=\"\" width=1 height=4></td></tr>"
	"</table>"
	"</body></html>\n";
	buffer.Write(message.data(), message.size());
	const std::string correct_result =
	"HTTP/1.1 500 Service Unavailable\r\n"
	"Connection: close\r\n"
	"\r\n"
	"<html><head>\n"
	"<meta http-equiv=\"content-type\""
	" content=\"text/html;charset=us-ascii\">\n"
	"<style><!--\n"
	"body {font-family: arial,sans-serif}\n"
	"div.nav {margin-top: 1ex}\n"
	"div.nav A {font-size: 10pt; font-family: arial,sans-serif}\n"
	"span.nav {font-size: 10pt; font-family: arial,sans-serif;"
	" font-weight: bold}\n"
	"div.nav A,span.big {font-size: 12pt; color: #0000cc}\n"
	"div.nav A {font-size: 10pt; color: black}\n"
	"A.l:link {color: #6f6f6f}\n"
	"A.u:link {color: green}\n"
	"//--></style>\n"
	"</head>\n"
	"<body text=#000000 bgcolor=#ffffff>\n"
	"<table border=0 cellpadding=2 cellspacing=0 width=100%>"
	"<tr><td rowspan=3 width=1% nowrap>\n"
	"<b>"
	"<font face=times color=#0039b6 size=10>G</font>"
	"<font face=times color=#c41200 size=10>o</font>"
	"<font face=times color=#f3c518 size=10>o</font>"
	"<font face=times color=#0039b6 size=10>g</font>"
	"<font face=times color=#30a72f size=10>l</font>"
	"<font face=times color=#c41200 size=10>e</font>"
	"  </b>\n"
	"<td> </td></tr>\n"
	"<tr><td bgcolor=#3366cc><font face=arial,sans-serif color=#ffffff>"
	" <b>Error</b></td></tr>\n"
	"<tr><td> </td></tr></table>\n"
	"<blockquote>\n"
	"<H1> Internal Server Error</H1>\n"
	" This server was unable to complete the request\n"
	"<p></blockquote>\n"
	"<table width=100% cellpadding=0 cellspacing=0>"
	"<tr><td bgcolor=#3366cc><img alt=\"\" width=1 height=4></td></tr>"
	"</table>"
	"</body></html>\n";
	EXPECT_EQ(correct_result, buffer.GetReadableRegion());
	}

	TEST_F(SimpleBufferTest, ReleaseAsSlice) {
	SimpleBuffer buffer;

	buffer.WriteString("abc");
	QuicheMemSlice slice = buffer.ReleaseAsSlice();
	EXPECT_EQ("abc", slice.AsStringView());

	char* readable_ptr = nullptr;
	int readable_size = 0;
	buffer.GetReadablePtr(&readable_ptr, &readable_size);
	EXPECT_EQ(nullptr, readable_ptr);
	EXPECT_EQ(0, readable_size);

	buffer.WriteString("def");
	slice = buffer.ReleaseAsSlice();
	buffer.GetReadablePtr(&readable_ptr, &readable_size);
	EXPECT_EQ(nullptr, readable_ptr);
	EXPECT_EQ(0, readable_size);
	EXPECT_EQ("def", slice.AsStringView());
	}

	TEST_F(SimpleBufferTest, EmptyBufferReleaseAsSlice) {
	SimpleBuffer buffer;
	char* readable_ptr = nullptr;
	int readable_size = 0;

	QuicheMemSlice slice = buffer.ReleaseAsSlice();
	buffer.GetReadablePtr(&readable_ptr, &readable_size);
	EXPECT_EQ(nullptr, readable_ptr);
	EXPECT_EQ(0, readable_size);
	EXPECT_TRUE(slice.empty());
	}

	} // namespace

	} // namespace test

	} // namespace quiche