crypto/bio/bio_test.cc - boringssl - Git at Google

 /* Copyright (c) 2014, Google Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */

 #include <algorithm>
 #include <string>

 #include <gtest/gtest.h>

 #include <openssl/bio.h>
 #include <openssl/crypto.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>

 #include "../internal.h"
 #include "../test/test_util.h"

 #if !defined(OPENSSL_WINDOWS)
 #include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #else
 #include <io.h>
 OPENSSL_MSVC_PRAGMA(warning(push, 3))
 #include <winsock2.h>
 #include <ws2tcpip.h>
 OPENSSL_MSVC_PRAGMA(warning(pop))
 #endif


 #if !defined(OPENSSL_WINDOWS)
 static int closesocket(int sock) { return close(sock); }
 static std::string LastSocketError() { return strerror(errno); }
 #else
 static std::string LastSocketError() {
   char buf[DECIMAL_SIZE(int) + 1];
   BIO_snprintf(buf, sizeof(buf), "%d", WSAGetLastError());
   return buf;
 }
 #endif

 class ScopedSocket {
  public:
   explicit ScopedSocket(int sock) : sock_(sock) {}
   ~ScopedSocket() {
     closesocket(sock_);
   }

  private:
   const int sock_;
 };

 TEST(BIOTest, SocketConnect) {
   static const char kTestMessage[] = "test";
   int listening_sock = -1;
   socklen_t len = 0;
   sockaddr_storage ss;
   struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss;
   struct sockaddr_in *sin = (struct sockaddr_in *) &ss;
   OPENSSL_memset(&ss, 0, sizeof(ss));

   ss.ss_family = AF_INET6;
   listening_sock = socket(AF_INET6, SOCK_STREAM, 0);
   ASSERT_NE(-1, listening_sock) << LastSocketError();
   len = sizeof(*sin6);
   ASSERT_EQ(1, inet_pton(AF_INET6, "::1", &sin6->sin6_addr))
       << LastSocketError();
   if (bind(listening_sock, (struct sockaddr *)sin6, sizeof(*sin6)) == -1) {
     closesocket(listening_sock);

     ss.ss_family = AF_INET;
     listening_sock = socket(AF_INET, SOCK_STREAM, 0);
     ASSERT_NE(-1, listening_sock) << LastSocketError();
     len = sizeof(*sin);
     ASSERT_EQ(1, inet_pton(AF_INET, "127.0.0.1", &sin->sin_addr))
         << LastSocketError();
     ASSERT_EQ(0, bind(listening_sock, (struct sockaddr *)sin, sizeof(*sin)))
         << LastSocketError();
   }

   ScopedSocket listening_sock_closer(listening_sock);
   ASSERT_EQ(0, listen(listening_sock, 1)) << LastSocketError();
   ASSERT_EQ(0, getsockname(listening_sock, (struct sockaddr *)&ss, &len))
         << LastSocketError();

   char hostname[80];
   if (ss.ss_family == AF_INET6) {
     BIO_snprintf(hostname, sizeof(hostname), "[::1]:%d",
                  ntohs(sin6->sin6_port));
   } else if (ss.ss_family == AF_INET) {
     BIO_snprintf(hostname, sizeof(hostname), "127.0.0.1:%d",
                  ntohs(sin->sin_port));
   }

   // Connect to it with a connect BIO.
   bssl::UniquePtr<BIO> bio(BIO_new_connect(hostname));
   ASSERT_TRUE(bio);

   // Write a test message to the BIO.
   ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)),
             BIO_write(bio.get(), kTestMessage, sizeof(kTestMessage)));

   // Accept the socket.
   int sock = accept(listening_sock, (struct sockaddr *) &ss, &len);
   ASSERT_NE(-1, sock) << LastSocketError();
   ScopedSocket sock_closer(sock);

   // Check the same message is read back out.
   char buf[sizeof(kTestMessage)];
   ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)),
             recv(sock, buf, sizeof(buf), 0))
       << LastSocketError();
   EXPECT_EQ(Bytes(kTestMessage, sizeof(kTestMessage)), Bytes(buf, sizeof(buf)));
 }

 TEST(BIOTest, Printf) {
   // Test a short output, a very long one, and various sizes around
   // 256 (the size of the buffer) to ensure edge cases are correct.
   static const size_t kLengths[] = {5, 250, 251, 252, 253, 254, 1023};

   bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem()));
   ASSERT_TRUE(bio);

   for (size_t length : kLengths) {
     SCOPED_TRACE(length);

     std::string in(length, 'a');

     int ret = BIO_printf(bio.get(), "test %s", in.c_str());
     ASSERT_GE(ret, 0);
     EXPECT_EQ(5 + length, static_cast<size_t>(ret));

     const uint8_t *contents;
     size_t len;
     ASSERT_TRUE(BIO_mem_contents(bio.get(), &contents, &len));
     EXPECT_EQ("test " + in,
               std::string(reinterpret_cast<const char *>(contents), len));

     ASSERT_TRUE(BIO_reset(bio.get()));
   }
 }

 static const size_t kLargeASN1PayloadLen = 8000;

 struct ASN1TestParam {
   bool should_succeed;
   std::vector<uint8_t> input;
   // suffix_len is the number of zeros to append to |input|.
   size_t suffix_len;
   // expected_len, if |should_succeed| is true, is the expected length of the
   // ASN.1 element.
   size_t expected_len;
   size_t max_len;
 } kASN1TestParams[] = {
     {true, {0x30, 2, 1, 2, 0, 0}, 0, 4, 100},
     {false /* truncated */, {0x30, 3, 1, 2}, 0, 0, 100},
     {false /* should be short len */, {0x30, 0x81, 1, 1}, 0, 0, 100},
     {false /* zero padded */, {0x30, 0x82, 0, 1, 1}, 0, 0, 100},

     // Test a large payload.
     {true,
      {0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff},
      kLargeASN1PayloadLen,
      4 + kLargeASN1PayloadLen,
      kLargeASN1PayloadLen * 2},
     {false /* max_len too short */,
      {0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff},
      kLargeASN1PayloadLen,
      4 + kLargeASN1PayloadLen,
      3 + kLargeASN1PayloadLen},

     // Test an indefinite-length input.
     {true,
      {0x30, 0x80},
      kLargeASN1PayloadLen + 2,
      2 + kLargeASN1PayloadLen + 2,
      kLargeASN1PayloadLen * 2},
     {false /* max_len too short */,
      {0x30, 0x80},
      kLargeASN1PayloadLen + 2,
      2 + kLargeASN1PayloadLen + 2,
      2 + kLargeASN1PayloadLen + 1},
 };

 class BIOASN1Test : public testing::TestWithParam<ASN1TestParam> {};

 TEST_P(BIOASN1Test, ReadASN1) {
   const ASN1TestParam& param = GetParam();
   std::vector<uint8_t> input = param.input;
   input.resize(input.size() + param.suffix_len, 0);

   bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(input.data(), input.size()));
   ASSERT_TRUE(bio);

   uint8_t *out;
   size_t out_len;
   int ok = BIO_read_asn1(bio.get(), &out, &out_len, param.max_len);
   if (!ok) {
     out = nullptr;
   }
   bssl::UniquePtr<uint8_t> out_storage(out);

   ASSERT_EQ(param.should_succeed, (ok == 1));
   if (param.should_succeed) {
     EXPECT_EQ(Bytes(input.data(), param.expected_len), Bytes(out, out_len));
   }
 }

 INSTANTIATE_TEST_CASE_P(, BIOASN1Test, testing::ValuesIn(kASN1TestParams));

 // Run through the tests twice, swapping |bio1| and |bio2|, for symmetry.
 class BIOPairTest : public testing::TestWithParam<bool> {};

 TEST_P(BIOPairTest, TestPair) {
   BIO *bio1, *bio2;
   ASSERT_TRUE(BIO_new_bio_pair(&bio1, 10, &bio2, 10));
   bssl::UniquePtr<BIO> free_bio1(bio1), free_bio2(bio2);

   if (GetParam()) {
     std::swap(bio1, bio2);
   }

   // Check initial states.
   EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));
   EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1));

   // Data written in one end may be read out the other.
   uint8_t buf[20];
   EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
   EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
   ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
   EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

   // Attempting to write more than 10 bytes will write partially.
   EXPECT_EQ(10, BIO_write(bio1, "1234567890___", 13));
   EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
   EXPECT_EQ(-1, BIO_write(bio1, "z", 1));
   EXPECT_TRUE(BIO_should_write(bio1));
   ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("1234567890"), Bytes(buf, 10));
   EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

   // Unsuccessful reads update the read request.
   EXPECT_EQ(-1, BIO_read(bio2, buf, 5));
   EXPECT_TRUE(BIO_should_read(bio2));
   EXPECT_EQ(5u, BIO_ctrl_get_read_request(bio1));

   // The read request is clamped to the size of the buffer.
   EXPECT_EQ(-1, BIO_read(bio2, buf, 20));
   EXPECT_TRUE(BIO_should_read(bio2));
   EXPECT_EQ(10u, BIO_ctrl_get_read_request(bio1));

   // Data may be written and read in chunks.
   EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
   EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
   EXPECT_EQ(5, BIO_write(bio1, "67890___", 8));
   EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
   ASSERT_EQ(3, BIO_read(bio2, buf, 3));
   EXPECT_EQ(Bytes("123"), Bytes(buf, 3));
   EXPECT_EQ(3u, BIO_ctrl_get_write_guarantee(bio1));
   ASSERT_EQ(7, BIO_read(bio2, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("4567890"), Bytes(buf, 7));
   EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

   // Successful reads reset the read request.
   EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1));

   // Test writes and reads starting in the middle of the ring buffer and
   // wrapping to front.
   EXPECT_EQ(8, BIO_write(bio1, "abcdefgh", 8));
   EXPECT_EQ(2u, BIO_ctrl_get_write_guarantee(bio1));
   ASSERT_EQ(3, BIO_read(bio2, buf, 3));
   EXPECT_EQ(Bytes("abc"), Bytes(buf, 3));
   EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
   EXPECT_EQ(5, BIO_write(bio1, "ijklm___", 8));
   EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
   ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("defghijklm"), Bytes(buf, 10));
   EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

   // Data may flow from both ends in parallel.
   EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
   EXPECT_EQ(5, BIO_write(bio2, "67890", 5));
   ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
   ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("67890"), Bytes(buf, 5));

   // Closing the write end causes an EOF on the read half, after draining.
   EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
   EXPECT_TRUE(BIO_shutdown_wr(bio1));
   ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
   EXPECT_EQ(0, BIO_read(bio2, buf, sizeof(buf)));

   // A closed write end may not be written to.
   EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
   EXPECT_EQ(-1, BIO_write(bio1, "_____", 5));

   uint32_t err = ERR_get_error();
   EXPECT_EQ(ERR_LIB_BIO, ERR_GET_LIB(err));
   EXPECT_EQ(BIO_R_BROKEN_PIPE, ERR_GET_REASON(err));

   // The other end is still functional.
   EXPECT_EQ(5, BIO_write(bio2, "12345", 5));
   ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf)));
   EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
 }

 INSTANTIATE_TEST_CASE_P(, BIOPairTest, testing::Values(false, true));
	/* Copyright (c) 2014, Google Inc.
	*
	* Permission to use, copy, modify, and/or distribute this software for any
	* purpose with or without fee is hereby granted, provided that the above
	* copyright notice and this permission notice appear in all copies.
	*
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
	* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
	* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
	* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */

	#include <algorithm>
	#include <string>

	#include <gtest/gtest.h>

	#include <openssl/bio.h>
	#include <openssl/crypto.h>
	#include <openssl/err.h>
	#include <openssl/mem.h>

	#include "../internal.h"
	#include "../test/test_util.h"

	#if !defined(OPENSSL_WINDOWS)
	#include <arpa/inet.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <netinet/in.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <unistd.h>
	#else
	#include <io.h>
	OPENSSL_MSVC_PRAGMA(warning(push, 3))
	#include <winsock2.h>
	#include <ws2tcpip.h>
	OPENSSL_MSVC_PRAGMA(warning(pop))
	#endif


	#if !defined(OPENSSL_WINDOWS)
	static int closesocket(int sock) { return close(sock); }
	static std::string LastSocketError() { return strerror(errno); }
	#else
	static std::string LastSocketError() {
	char buf[DECIMAL_SIZE(int) + 1];
	BIO_snprintf(buf, sizeof(buf), "%d", WSAGetLastError());
	return buf;
	}
	#endif

	class ScopedSocket {
	public:
	explicit ScopedSocket(int sock) : sock_(sock) {}
	~ScopedSocket() {
	closesocket(sock_);
	}

	private:
	const int sock_;
	};

	TEST(BIOTest, SocketConnect) {
	static const char kTestMessage[] = "test";
	int listening_sock = -1;
	socklen_t len = 0;
	sockaddr_storage ss;
	struct sockaddr_in6 sin6 = (struct sockaddr_in6 ) &ss;
	struct sockaddr_in sin = (struct sockaddr_in ) &ss;
	OPENSSL_memset(&ss, 0, sizeof(ss));

	ss.ss_family = AF_INET6;
	listening_sock = socket(AF_INET6, SOCK_STREAM, 0);
	ASSERT_NE(-1, listening_sock) << LastSocketError();
	len = sizeof(*sin6);
	ASSERT_EQ(1, inet_pton(AF_INET6, "::1", &sin6->sin6_addr))
	<< LastSocketError();
	if (bind(listening_sock, (struct sockaddr )sin6, sizeof(sin6)) == -1) {
	closesocket(listening_sock);

	ss.ss_family = AF_INET;
	listening_sock = socket(AF_INET, SOCK_STREAM, 0);
	ASSERT_NE(-1, listening_sock) << LastSocketError();
	len = sizeof(*sin);
	ASSERT_EQ(1, inet_pton(AF_INET, "127.0.0.1", &sin->sin_addr))
	<< LastSocketError();
	ASSERT_EQ(0, bind(listening_sock, (struct sockaddr )sin, sizeof(sin)))
	<< LastSocketError();
	}

	ScopedSocket listening_sock_closer(listening_sock);
	ASSERT_EQ(0, listen(listening_sock, 1)) << LastSocketError();
	ASSERT_EQ(0, getsockname(listening_sock, (struct sockaddr *)&ss, &len))
	<< LastSocketError();

	char hostname[80];
	if (ss.ss_family == AF_INET6) {
	BIO_snprintf(hostname, sizeof(hostname), "[::1]:%d",
	ntohs(sin6->sin6_port));
	} else if (ss.ss_family == AF_INET) {
	BIO_snprintf(hostname, sizeof(hostname), "127.0.0.1:%d",
	ntohs(sin->sin_port));
	}

	// Connect to it with a connect BIO.
	bssl::UniquePtr<BIO> bio(BIO_new_connect(hostname));
	ASSERT_TRUE(bio);

	// Write a test message to the BIO.
	ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)),
	BIO_write(bio.get(), kTestMessage, sizeof(kTestMessage)));

	// Accept the socket.
	int sock = accept(listening_sock, (struct sockaddr *) &ss, &len);
	ASSERT_NE(-1, sock) << LastSocketError();
	ScopedSocket sock_closer(sock);

	// Check the same message is read back out.
	char buf[sizeof(kTestMessage)];
	ASSERT_EQ(static_cast<int>(sizeof(kTestMessage)),
	recv(sock, buf, sizeof(buf), 0))
	<< LastSocketError();
	EXPECT_EQ(Bytes(kTestMessage, sizeof(kTestMessage)), Bytes(buf, sizeof(buf)));
	}

	TEST(BIOTest, Printf) {
	// Test a short output, a very long one, and various sizes around
	// 256 (the size of the buffer) to ensure edge cases are correct.
	static const size_t kLengths[] = {5, 250, 251, 252, 253, 254, 1023};

	bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem()));
	ASSERT_TRUE(bio);

	for (size_t length : kLengths) {
	SCOPED_TRACE(length);

	std::string in(length, 'a');

	int ret = BIO_printf(bio.get(), "test %s", in.c_str());
	ASSERT_GE(ret, 0);
	EXPECT_EQ(5 + length, static_cast<size_t>(ret));

	const uint8_t *contents;
	size_t len;
	ASSERT_TRUE(BIO_mem_contents(bio.get(), &contents, &len));
	EXPECT_EQ("test " + in,
	std::string(reinterpret_cast<const char *>(contents), len));

	ASSERT_TRUE(BIO_reset(bio.get()));
	}
	}

	static const size_t kLargeASN1PayloadLen = 8000;

	struct ASN1TestParam {
	bool should_succeed;
	std::vector<uint8_t> input;
	// suffix_len is the number of zeros to append to \|input\|.
	size_t suffix_len;
	// expected_len, if \|should_succeed\| is true, is the expected length of the
	// ASN.1 element.
	size_t expected_len;
	size_t max_len;
	} kASN1TestParams[] = {
	{true, {0x30, 2, 1, 2, 0, 0}, 0, 4, 100},
	{false /* truncated */, {0x30, 3, 1, 2}, 0, 0, 100},
	{false /* should be short len */, {0x30, 0x81, 1, 1}, 0, 0, 100},
	{false /* zero padded */, {0x30, 0x82, 0, 1, 1}, 0, 0, 100},

	// Test a large payload.
	{true,
	{0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff},
	kLargeASN1PayloadLen,
	4 + kLargeASN1PayloadLen,
	kLargeASN1PayloadLen * 2},
	{false /* max_len too short */,
	{0x30, 0x82, kLargeASN1PayloadLen >> 8, kLargeASN1PayloadLen & 0xff},
	kLargeASN1PayloadLen,
	4 + kLargeASN1PayloadLen,
	3 + kLargeASN1PayloadLen},

	// Test an indefinite-length input.
	{true,
	{0x30, 0x80},
	kLargeASN1PayloadLen + 2,
	2 + kLargeASN1PayloadLen + 2,
	kLargeASN1PayloadLen * 2},
	{false /* max_len too short */,
	{0x30, 0x80},
	kLargeASN1PayloadLen + 2,
	2 + kLargeASN1PayloadLen + 2,
	2 + kLargeASN1PayloadLen + 1},
	};

	class BIOASN1Test : public testing::TestWithParam<ASN1TestParam> {};

	TEST_P(BIOASN1Test, ReadASN1) {
	const ASN1TestParam& param = GetParam();
	std::vector<uint8_t> input = param.input;
	input.resize(input.size() + param.suffix_len, 0);

	bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(input.data(), input.size()));
	ASSERT_TRUE(bio);

	uint8_t *out;
	size_t out_len;
	int ok = BIO_read_asn1(bio.get(), &out, &out_len, param.max_len);
	if (!ok) {
	out = nullptr;
	}
	bssl::UniquePtr<uint8_t> out_storage(out);

	ASSERT_EQ(param.should_succeed, (ok == 1));
	if (param.should_succeed) {
	EXPECT_EQ(Bytes(input.data(), param.expected_len), Bytes(out, out_len));
	}
	}

	INSTANTIATE_TEST_CASE_P(, BIOASN1Test, testing::ValuesIn(kASN1TestParams));

	// Run through the tests twice, swapping \|bio1\| and \|bio2\|, for symmetry.
	class BIOPairTest : public testing::TestWithParam<bool> {};

	TEST_P(BIOPairTest, TestPair) {
	BIO bio1, bio2;
	ASSERT_TRUE(BIO_new_bio_pair(&bio1, 10, &bio2, 10));
	bssl::UniquePtr<BIO> free_bio1(bio1), free_bio2(bio2);

	if (GetParam()) {
	std::swap(bio1, bio2);
	}

	// Check initial states.
	EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));
	EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1));

	// Data written in one end may be read out the other.
	uint8_t buf[20];
	EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
	EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
	ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
	EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

	// Attempting to write more than 10 bytes will write partially.
	EXPECT_EQ(10, BIO_write(bio1, "1234567890___", 13));
	EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
	EXPECT_EQ(-1, BIO_write(bio1, "z", 1));
	EXPECT_TRUE(BIO_should_write(bio1));
	ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("1234567890"), Bytes(buf, 10));
	EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

	// Unsuccessful reads update the read request.
	EXPECT_EQ(-1, BIO_read(bio2, buf, 5));
	EXPECT_TRUE(BIO_should_read(bio2));
	EXPECT_EQ(5u, BIO_ctrl_get_read_request(bio1));

	// The read request is clamped to the size of the buffer.
	EXPECT_EQ(-1, BIO_read(bio2, buf, 20));
	EXPECT_TRUE(BIO_should_read(bio2));
	EXPECT_EQ(10u, BIO_ctrl_get_read_request(bio1));

	// Data may be written and read in chunks.
	EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
	EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
	EXPECT_EQ(5, BIO_write(bio1, "67890___", 8));
	EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
	ASSERT_EQ(3, BIO_read(bio2, buf, 3));
	EXPECT_EQ(Bytes("123"), Bytes(buf, 3));
	EXPECT_EQ(3u, BIO_ctrl_get_write_guarantee(bio1));
	ASSERT_EQ(7, BIO_read(bio2, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("4567890"), Bytes(buf, 7));
	EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

	// Successful reads reset the read request.
	EXPECT_EQ(0u, BIO_ctrl_get_read_request(bio1));

	// Test writes and reads starting in the middle of the ring buffer and
	// wrapping to front.
	EXPECT_EQ(8, BIO_write(bio1, "abcdefgh", 8));
	EXPECT_EQ(2u, BIO_ctrl_get_write_guarantee(bio1));
	ASSERT_EQ(3, BIO_read(bio2, buf, 3));
	EXPECT_EQ(Bytes("abc"), Bytes(buf, 3));
	EXPECT_EQ(5u, BIO_ctrl_get_write_guarantee(bio1));
	EXPECT_EQ(5, BIO_write(bio1, "ijklm___", 8));
	EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
	ASSERT_EQ(10, BIO_read(bio2, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("defghijklm"), Bytes(buf, 10));
	EXPECT_EQ(10u, BIO_ctrl_get_write_guarantee(bio1));

	// Data may flow from both ends in parallel.
	EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
	EXPECT_EQ(5, BIO_write(bio2, "67890", 5));
	ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
	ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("67890"), Bytes(buf, 5));

	// Closing the write end causes an EOF on the read half, after draining.
	EXPECT_EQ(5, BIO_write(bio1, "12345", 5));
	EXPECT_TRUE(BIO_shutdown_wr(bio1));
	ASSERT_EQ(5, BIO_read(bio2, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
	EXPECT_EQ(0, BIO_read(bio2, buf, sizeof(buf)));

	// A closed write end may not be written to.
	EXPECT_EQ(0u, BIO_ctrl_get_write_guarantee(bio1));
	EXPECT_EQ(-1, BIO_write(bio1, "_____", 5));

	uint32_t err = ERR_get_error();
	EXPECT_EQ(ERR_LIB_BIO, ERR_GET_LIB(err));
	EXPECT_EQ(BIO_R_BROKEN_PIPE, ERR_GET_REASON(err));

	// The other end is still functional.
	EXPECT_EQ(5, BIO_write(bio2, "12345", 5));
	ASSERT_EQ(5, BIO_read(bio1, buf, sizeof(buf)));
	EXPECT_EQ(Bytes("12345"), Bytes(buf, 5));
	}

	INSTANTIATE_TEST_CASE_P(, BIOPairTest, testing::Values(false, true));