quic/core/quic_udp_socket_test.cc - quiche - Git at Google


            
            // Copyright 2019 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_udp_socket.h"

            
            #include <sys/socket.h>


            #ifdef __APPLE__

            
            #include <TargetConditionals.h>

            
            #endif


            #include "net/third_party/quiche/src/quic/core/quic_constants.h"

            
            #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"


            namespace quic {

            
            namespace test {

            
            namespace {

            
            // Used by ReadMultiplePackets tests.

            
            struct ReadBuffers {

            
              char control_buffer[512];

            
              char packet_buffer[1536];

            
            };


            // Allows IPv6-specific testing.

            
            struct TestParameters {

            
              // If true, the test will only use IPv6.  If false, IPv4 will be used if

            
              // possible, with IPv6 used as a fallback.

            
              bool force_ipv6;

            
              // The value of ipv6_only to be used in QuicUdpSocketApi::Create calls.

            
              bool ipv6_only;

            
            };

            
            }  // namespace


            class QuicUdpSocketTest : public QuicTestWithParam<TestParameters> {

            
             protected:

            
              void SetUp() override {

            
                const TestParameters& parameters = GetParam();

            
                if (!parameters.force_ipv6) {

            
                  // Try creating AF_INET socket, if it fails because of unsupported address

            
                  // family then tests are being run under IPv6-only environment, initialize

            
                  // address family to use for running the test under as AF_INET6 otherwise

            
                  // initialize it as AF_INET.

            
                  address_family_ = AF_INET;

            
                  fd_client_ =

            
                      api_.Create(address_family_,

            
                                  /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,

            
                                  /*send_buffer_size =*/kDefaultSocketReceiveBuffer,

            
                                  /*ipv6_only =*/parameters.ipv6_only);

            
                }

            
                if (fd_client_ == kQuicInvalidSocketFd) {

            
                  // Either AF_INET is unsupported, or force_ipv6 is true.

            
                  address_family_ = AF_INET6;

            
                  fd_client_ =

            
                      api_.Create(address_family_,

            
                                  /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,

            
                                  /*send_buffer_size =*/kDefaultSocketReceiveBuffer,

            
                                  /*ipv6_only =*/parameters.ipv6_only);

            
                }

            
                ASSERT_NE(fd_client_, kQuicInvalidSocketFd);


                fd_server_ =

            
                    api_.Create(address_family_,

            
                                /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,

            
                                /*send_buffer_size =*/kDefaultSocketReceiveBuffer,

            
                                /*ipv6_only =*/parameters.ipv6_only);

            
                ASSERT_NE(fd_server_, kQuicInvalidSocketFd);


                ASSERT_TRUE(

            
                    api_.Bind(fd_server_, QuicSocketAddress(Loopback(), /*port=*/0)));


                ASSERT_EQ(0, server_address_.FromSocket(fd_server_));


                QUIC_LOG(INFO) << "Testing under IP"

            
                               << std::string((address_family_ == AF_INET) ? "v4" : "v6");

            
              }


              ~QuicUdpSocketTest() {

            
                api_.Destroy(fd_client_);

            
                api_.Destroy(fd_server_);

            
              }


              QuicIpAddress Loopback() const {

            
                return (address_family_ == AF_INET) ? QuicIpAddress::Loopback4()

            
                                                    : QuicIpAddress::Loopback6();

            
              }


              // Client sends the first |packet_size| bytes in |client_packet_buffer_| to

            
              // server.

            
              WriteResult SendPacketFromClient(size_t packet_size) {

            
                EXPECT_LE(packet_size, sizeof(client_packet_buffer_));

            
                QuicUdpPacketInfo packet_info;

            
                packet_info.SetPeerAddress(server_address_);

            
                return api_.WritePacket(fd_client_, client_packet_buffer_, packet_size,

            
                                        packet_info);

            
              }


              WriteResult SendPacketFromClientWithTtl(size_t packet_size, int ttl) {

            
                EXPECT_LE(packet_size, sizeof(client_packet_buffer_));

            
                QuicUdpPacketInfo packet_info;

            
                packet_info.SetPeerAddress(server_address_);

            
                packet_info.SetTtl(ttl);

            
                return api_.WritePacket(fd_client_, client_packet_buffer_, packet_size,

            
                                        packet_info);

            
              }


              // Server waits for an incoming packet and reads it into

            
              // |server_packet_buffer_|.

            
              QuicUdpSocketApi::ReadPacketResult ReadPacketFromServer(

            
                  BitMask64 packet_info_interested) {

            
                EXPECT_TRUE(

            
                    api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));

            
                memset(server_packet_buffer_, 0, sizeof(server_packet_buffer_));

            
                QuicUdpSocketApi::ReadPacketResult result;

            
                result.packet_buffer = {server_packet_buffer_,

            
                                        sizeof(server_packet_buffer_)};

            
                result.control_buffer = {server_control_buffer_,

            
                                         sizeof(server_control_buffer_)};

            
                api_.ReadPacket(fd_server_, packet_info_interested, &result);

            
                return result;

            
              }


              int ComparePacketBuffers(size_t packet_size) {

            
                return memcmp(client_packet_buffer_, server_packet_buffer_, packet_size);

            
              }


              bool VerifyBufferIsFilledWith(const char* buffer,

            
                                            size_t buffer_length,

            
                                            char c) {

            
                for (size_t i = 0; i < buffer_length; ++i) {

            
                  if (buffer[i] != c) {

            
                    return false;

            
                  }

            
                }

            
                return true;

            
              }


              QuicUdpSocketApi api_;

            
              QuicUdpSocketFd fd_client_ = kQuicInvalidSocketFd;

            
              QuicUdpSocketFd fd_server_ = kQuicInvalidSocketFd;

            
              QuicSocketAddress server_address_;

            
              int address_family_;

            
              char client_packet_buffer_[kEthernetMTU] = {0};

            
              char server_packet_buffer_[kDefaultMaxPacketSize] = {0};

            
              char server_control_buffer_[512] = {0};

            
            };


            INSTANTIATE_TEST_SUITE_P(

            
                PlatformIndependent,

            
                QuicUdpSocketTest,

            
                testing::Values(TestParameters{/*force_ipv6 =*/false, /*ipv6_only =*/false},

            
                                TestParameters{/*force_ipv6 =*/false, /*ipv6_only =*/true},

            
                                TestParameters{/*force_ipv6 =*/true, /*ipv6_only =*/true}));


            #ifndef TARGET_OS_IPHONE

            
            // IPv6 on iOS is known to fail without ipv6_only, so should not be tested.

            
            INSTANTIATE_TEST_SUITE_P(NonIos,

            
                                     QuicUdpSocketTest,

            
                                     testing::Values(TestParameters{/*force_ipv6 =*/true,

            
                                                                    /*ipv6_only =*/false}));

            
            #endif


            TEST_P(QuicUdpSocketTest, ReadPacketResultReset) {

            
              QuicUdpSocketApi::ReadPacketResult result;

            
              result.packet_info.SetDroppedPackets(100);

            
              result.packet_buffer.buffer_len = 100;

            
              result.ok = true;


              result.Reset(/*packet_buffer_length=*/200);


              EXPECT_FALSE(result.ok);

            
              EXPECT_FALSE(

            
                  result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS));

            
              EXPECT_EQ(200u, result.packet_buffer.buffer_len);

            
            }


            TEST_P(QuicUdpSocketTest, ReadPacketOnly) {

            
              const size_t kPacketSize = 512;

            
              memset(client_packet_buffer_, '-', kPacketSize);

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClient(kPacketSize));


              QuicUdpSocketApi::ReadPacketResult read_result =

            
                  ReadPacketFromServer(/*packet_info_interested=*/BitMask64());

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
            }


            TEST_P(QuicUdpSocketTest, ReadTruncated) {

            
              const size_t kPacketSize = kDefaultMaxPacketSize + 1;

            
              memset(client_packet_buffer_, '*', kPacketSize);

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClient(kPacketSize));


              QuicUdpSocketApi::ReadPacketResult read_result =

            
                  ReadPacketFromServer(/*packet_info_interested=*/BitMask64());

            
              ASSERT_FALSE(read_result.ok);

            
            }


            TEST_P(QuicUdpSocketTest, ReadDroppedPackets) {

            
              const size_t kPacketSize = kDefaultMaxPacketSize;

            
              memset(client_packet_buffer_, '-', kPacketSize);

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClient(kPacketSize));

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClient(kPacketSize));


              // Read the first packet without enabling DROPPED_PACKETS.

            
              QuicUdpSocketApi::ReadPacketResult read_result =

            
                  ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::DROPPED_PACKETS));

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
              ASSERT_FALSE(

            
                  read_result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS));


              // Enable DROPPED_PACKETS and read the second packet.

            
              if (!api_.EnableDroppedPacketCount(fd_server_)) {

            
                QUIC_LOG(INFO) << "DROPPED_PACKETS is not supported";

            
                return;

            
              }

            
              read_result =

            
                  ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::DROPPED_PACKETS));

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
              if (read_result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS)) {

            
                EXPECT_EQ(0u, read_result.packet_info.dropped_packets());

            
              }

            
            }


            TEST_P(QuicUdpSocketTest, ReadSelfIp) {

            
              const QuicUdpPacketInfoBit self_ip_bit =

            
                  (address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP

            
                                               : QuicUdpPacketInfoBit::V6_SELF_IP;


              const size_t kPacketSize = 512;

            
              memset(client_packet_buffer_, '&', kPacketSize);

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClient(kPacketSize));


              QuicUdpSocketApi::ReadPacketResult read_result =

            
                  ReadPacketFromServer(BitMask64(self_ip_bit));

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
              ASSERT_TRUE(read_result.packet_info.HasValue(self_ip_bit));

            
              EXPECT_EQ(Loopback(), (address_family_ == AF_INET)

            
                                        ? read_result.packet_info.self_v4_ip()

            
                                        : read_result.packet_info.self_v6_ip());

            
            }


            TEST_P(QuicUdpSocketTest, ReadReceiveTimestamp) {

            
              const size_t kPacketSize = kDefaultMaxPacketSize;

            
              memset(client_packet_buffer_, '-', kPacketSize);

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClient(kPacketSize));

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClient(kPacketSize));


              // Read the first packet without enabling RECV_TIMESTAMP.

            
              QuicUdpSocketApi::ReadPacketResult read_result =

            
                  ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::RECV_TIMESTAMP));

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
              ASSERT_FALSE(

            
                  read_result.packet_info.HasValue(QuicUdpPacketInfoBit::RECV_TIMESTAMP));


              // Enable RECV_TIMESTAMP and read the second packet.

            
              if (!api_.EnableReceiveTimestamp(fd_server_)) {

            
                QUIC_LOG(INFO) << "RECV_TIMESTAMP is not supported";

            
                return;

            
              }

            
              read_result =

            
                  ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::RECV_TIMESTAMP));

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
              ASSERT_TRUE(

            
                  read_result.packet_info.HasValue(QuicUdpPacketInfoBit::RECV_TIMESTAMP));

            
              QuicWallTime recv_timestamp = read_result.packet_info.receive_timestamp();

            
              // 1577836800 is the unix seconds for 2020-01-01

            
              EXPECT_TRUE(

            
                  QuicWallTime::FromUNIXSeconds(1577836800).IsBefore(recv_timestamp));

            
            }


            TEST_P(QuicUdpSocketTest, Ttl) {

            
              const size_t kPacketSize = 512;

            
              memset(client_packet_buffer_, '$', kPacketSize);

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClientWithTtl(kPacketSize, 13));

            
              ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                        SendPacketFromClientWithTtl(kPacketSize, 13));


              // Read the first packet without enabling ttl reporting.

            
              QuicUdpSocketApi::ReadPacketResult read_result =

            
                  ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::TTL));

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
              ASSERT_FALSE(read_result.packet_info.HasValue(QuicUdpPacketInfoBit::TTL));


              // Enable ttl reporting and read the second packet.

            
              if (!((address_family_ == AF_INET)

            
                        ? api_.EnableReceiveTtlForV4(fd_server_)

            
                        : api_.EnableReceiveTtlForV6(fd_server_))) {

            
                QUIC_LOG(INFO) << "TTL is not supported for address family "

            
                               << address_family_;

            
                return;

            
              }


              read_result = ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::TTL));

            
              ASSERT_TRUE(read_result.ok);

            
              ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);

            
              ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));

            
              ASSERT_TRUE(read_result.packet_info.HasValue(QuicUdpPacketInfoBit::TTL));

            
              EXPECT_EQ(13, read_result.packet_info.ttl());

            
            }


            TEST_P(QuicUdpSocketTest, ReadMultiplePackets) {

            
              const QuicUdpPacketInfoBit self_ip_bit =

            
                  (address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP

            
                                               : QuicUdpPacketInfoBit::V6_SELF_IP;

            
              const size_t kPacketSize = kDefaultMaxPacketSize;

            
              const size_t kNumPackets = 90;

            
              for (size_t i = 0; i < kNumPackets; ++i) {

            
                memset(client_packet_buffer_, ' ' + i, kPacketSize);

            
                ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                          SendPacketFromClient(kPacketSize));

            
              }


              const size_t kNumPacketsPerRead = 16;

            
              size_t total_packets_read = 0;

            
              while (total_packets_read < kNumPackets) {

            
                std::unique_ptr<ReadBuffers[]> read_buffers =

            
                    std::make_unique<ReadBuffers[]>(kNumPacketsPerRead);

            
                QuicUdpSocketApi::ReadPacketResults results(kNumPacketsPerRead);

            
                for (size_t i = 0; i < kNumPacketsPerRead; ++i) {

            
                  results[i].packet_buffer.buffer = read_buffers[i].packet_buffer;

            
                  results[i].packet_buffer.buffer_len =

            
                      sizeof(read_buffers[i].packet_buffer);


                  results[i].control_buffer.buffer = read_buffers[i].control_buffer;

            
                  results[i].control_buffer.buffer_len =

            
                      sizeof(read_buffers[i].control_buffer);

            
                }

            
                size_t packets_read =

            
                    api_.ReadMultiplePackets(fd_server_, BitMask64(self_ip_bit), &results);

            
                if (packets_read == 0) {

            
                  ASSERT_TRUE(

            
                      api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));

            
                  packets_read = api_.ReadMultiplePackets(fd_server_,

            
                                                          BitMask64(self_ip_bit), &results);

            
                  ASSERT_GT(packets_read, 0u);

            
                }


                for (size_t i = 0; i < packets_read; ++i) {

            
                  const auto& result = results[i];

            
                  ASSERT_TRUE(result.ok);

            
                  ASSERT_EQ(kPacketSize, result.packet_buffer.buffer_len);

            
                  ASSERT_TRUE(VerifyBufferIsFilledWith(result.packet_buffer.buffer,

            
                                                       result.packet_buffer.buffer_len,

            
                                                       ' ' + total_packets_read));

            
                  ASSERT_TRUE(result.packet_info.HasValue(self_ip_bit));

            
                  EXPECT_EQ(Loopback(), (address_family_ == AF_INET)

            
                                            ? result.packet_info.self_v4_ip()

            
                                            : result.packet_info.self_v6_ip());

            
                  total_packets_read++;

            
                }

            
              }

            
            }


            TEST_P(QuicUdpSocketTest, ReadMultiplePacketsSomeTruncated) {

            
              const QuicUdpPacketInfoBit self_ip_bit =

            
                  (address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP

            
                                               : QuicUdpPacketInfoBit::V6_SELF_IP;

            
              const size_t kPacketSize = kDefaultMaxPacketSize;

            
              const size_t kNumPackets = 90;

            
              for (size_t i = 0; i < kNumPackets; ++i) {

            
                memset(client_packet_buffer_, ' ' + i, kPacketSize);

            
                ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),

            
                          SendPacketFromClient(kPacketSize));

            
              }


              const size_t kNumPacketsPerRead = 16;

            
              size_t total_packets_read = 0;  // Including truncated packets.

            
              while (total_packets_read < kNumPackets) {

            
                std::unique_ptr<ReadBuffers[]> read_buffers =

            
                    std::make_unique<ReadBuffers[]>(kNumPacketsPerRead);

            
                QuicUdpSocketApi::ReadPacketResults results(kNumPacketsPerRead);

            
                // Use small packet buffer for all even-numbered packets and expect them to

            
                // be truncated.

            
                auto is_truncated = [total_packets_read](size_t i) {

            
                  return ((total_packets_read + i) % 2) == 1;

            
                };


                for (size_t i = 0; i < kNumPacketsPerRead; ++i) {

            
                  results[i].packet_buffer.buffer = read_buffers[i].packet_buffer;

            
                  results[i].packet_buffer.buffer_len =

            
                      is_truncated(i) ? kPacketSize - 1

            
                                      : sizeof(read_buffers[i].packet_buffer);


                  results[i].control_buffer.buffer = read_buffers[i].control_buffer;

            
                  results[i].control_buffer.buffer_len =

            
                      sizeof(read_buffers[i].control_buffer);

            
                }

            
                size_t packets_read =

            
                    api_.ReadMultiplePackets(fd_server_, BitMask64(self_ip_bit), &results);

            
                if (packets_read == 0) {

            
                  ASSERT_TRUE(

            
                      api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));

            
                  packets_read = api_.ReadMultiplePackets(fd_server_,

            
                                                          BitMask64(self_ip_bit), &results);

            
                  ASSERT_GT(packets_read, 0u);

            
                }


                for (size_t i = 0; i < packets_read; ++i) {

            
                  const auto& result = results[i];

            
                  if (is_truncated(i)) {

            
                    ASSERT_FALSE(result.ok);

            
                  } else {

            
                    ASSERT_TRUE(result.ok);

            
                    ASSERT_EQ(kPacketSize, result.packet_buffer.buffer_len);

            
                    ASSERT_TRUE(VerifyBufferIsFilledWith(result.packet_buffer.buffer,

            
                                                         result.packet_buffer.buffer_len,

            
                                                         ' ' + total_packets_read));

            
                    ASSERT_TRUE(result.packet_info.HasValue(self_ip_bit));

            
                    EXPECT_EQ(Loopback(), (address_family_ == AF_INET)

            
                                              ? result.packet_info.self_v4_ip()

            
                                              : result.packet_info.self_v6_ip());

            
                  }

            
                  total_packets_read++;

            
                }

            
              }

            
            }


            }  // namespace test

            
            }  // namespace quic
	// Copyright 2019 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_udp_socket.h"
	#include <sys/socket.h>

	#ifdef __APPLE__
	#include <TargetConditionals.h>
	#endif

	#include "net/third_party/quiche/src/quic/core/quic_constants.h"
	#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"

	namespace quic {
	namespace test {
	namespace {
	// Used by ReadMultiplePackets tests.
	struct ReadBuffers {
	char control_buffer[512];
	char packet_buffer[1536];
	};

	// Allows IPv6-specific testing.
	struct TestParameters {
	// If true, the test will only use IPv6. If false, IPv4 will be used if
	// possible, with IPv6 used as a fallback.
	bool force_ipv6;
	// The value of ipv6_only to be used in QuicUdpSocketApi::Create calls.
	bool ipv6_only;
	};
	} // namespace

	class QuicUdpSocketTest : public QuicTestWithParam<TestParameters> {
	protected:
	void SetUp() override {
	const TestParameters& parameters = GetParam();
	if (!parameters.force_ipv6) {
	// Try creating AF_INET socket, if it fails because of unsupported address
	// family then tests are being run under IPv6-only environment, initialize
	// address family to use for running the test under as AF_INET6 otherwise
	// initialize it as AF_INET.
	address_family_ = AF_INET;
	fd_client_ =
	api_.Create(address_family_,
	/receive_buffer_size =/kDefaultSocketReceiveBuffer,
	/send_buffer_size =/kDefaultSocketReceiveBuffer,
	/ipv6_only =/parameters.ipv6_only);
	}
	if (fd_client_ == kQuicInvalidSocketFd) {
	// Either AF_INET is unsupported, or force_ipv6 is true.
	address_family_ = AF_INET6;
	fd_client_ =
	api_.Create(address_family_,
	/receive_buffer_size =/kDefaultSocketReceiveBuffer,
	/send_buffer_size =/kDefaultSocketReceiveBuffer,
	/ipv6_only =/parameters.ipv6_only);
	}
	ASSERT_NE(fd_client_, kQuicInvalidSocketFd);

	fd_server_ =
	api_.Create(address_family_,
	/receive_buffer_size =/kDefaultSocketReceiveBuffer,
	/send_buffer_size =/kDefaultSocketReceiveBuffer,
	/ipv6_only =/parameters.ipv6_only);
	ASSERT_NE(fd_server_, kQuicInvalidSocketFd);

	ASSERT_TRUE(
	api_.Bind(fd_server_, QuicSocketAddress(Loopback(), /port=/0)));

	ASSERT_EQ(0, server_address_.FromSocket(fd_server_));

	QUIC_LOG(INFO) << "Testing under IP"
	<< std::string((address_family_ == AF_INET) ? "v4" : "v6");
	}

	~QuicUdpSocketTest() {
	api_.Destroy(fd_client_);
	api_.Destroy(fd_server_);
	}

	QuicIpAddress Loopback() const {
	return (address_family_ == AF_INET) ? QuicIpAddress::Loopback4()
	: QuicIpAddress::Loopback6();
	}

	// Client sends the first \|packet_size\| bytes in \|client_packet_buffer_\| to
	// server.
	WriteResult SendPacketFromClient(size_t packet_size) {
	EXPECT_LE(packet_size, sizeof(client_packet_buffer_));
	QuicUdpPacketInfo packet_info;
	packet_info.SetPeerAddress(server_address_);
	return api_.WritePacket(fd_client_, client_packet_buffer_, packet_size,
	packet_info);
	}

	WriteResult SendPacketFromClientWithTtl(size_t packet_size, int ttl) {
	EXPECT_LE(packet_size, sizeof(client_packet_buffer_));
	QuicUdpPacketInfo packet_info;
	packet_info.SetPeerAddress(server_address_);
	packet_info.SetTtl(ttl);
	return api_.WritePacket(fd_client_, client_packet_buffer_, packet_size,
	packet_info);
	}

	// Server waits for an incoming packet and reads it into
	// \|server_packet_buffer_\|.
	QuicUdpSocketApi::ReadPacketResult ReadPacketFromServer(
	BitMask64 packet_info_interested) {
	EXPECT_TRUE(
	api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));
	memset(server_packet_buffer_, 0, sizeof(server_packet_buffer_));
	QuicUdpSocketApi::ReadPacketResult result;
	result.packet_buffer = {server_packet_buffer_,
	sizeof(server_packet_buffer_)};
	result.control_buffer = {server_control_buffer_,
	sizeof(server_control_buffer_)};
	api_.ReadPacket(fd_server_, packet_info_interested, &result);
	return result;
	}

	int ComparePacketBuffers(size_t packet_size) {
	return memcmp(client_packet_buffer_, server_packet_buffer_, packet_size);
	}

	bool VerifyBufferIsFilledWith(const char* buffer,
	size_t buffer_length,
	char c) {
	for (size_t i = 0; i < buffer_length; ++i) {
	if (buffer[i] != c) {
	return false;
	}
	}
	return true;
	}

	QuicUdpSocketApi api_;
	QuicUdpSocketFd fd_client_ = kQuicInvalidSocketFd;
	QuicUdpSocketFd fd_server_ = kQuicInvalidSocketFd;
	QuicSocketAddress server_address_;
	int address_family_;
	char client_packet_buffer_[kEthernetMTU] = {0};
	char server_packet_buffer_[kDefaultMaxPacketSize] = {0};
	char server_control_buffer_[512] = {0};
	};

	INSTANTIATE_TEST_SUITE_P(
	PlatformIndependent,
	QuicUdpSocketTest,
	testing::Values(TestParameters{/force_ipv6 =/false, /ipv6_only =/false},
	TestParameters{/force_ipv6 =/false, /ipv6_only =/true},
	TestParameters{/force_ipv6 =/true, /ipv6_only =/true}));

	#ifndef TARGET_OS_IPHONE
	// IPv6 on iOS is known to fail without ipv6_only, so should not be tested.
	INSTANTIATE_TEST_SUITE_P(NonIos,
	QuicUdpSocketTest,
	testing::Values(TestParameters{/force_ipv6 =/true,
	/ipv6_only =/false}));
	#endif

	TEST_P(QuicUdpSocketTest, ReadPacketResultReset) {
	QuicUdpSocketApi::ReadPacketResult result;
	result.packet_info.SetDroppedPackets(100);
	result.packet_buffer.buffer_len = 100;
	result.ok = true;

	result.Reset(/packet_buffer_length=/200);

	EXPECT_FALSE(result.ok);
	EXPECT_FALSE(
	result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS));
	EXPECT_EQ(200u, result.packet_buffer.buffer_len);
	}

	TEST_P(QuicUdpSocketTest, ReadPacketOnly) {
	const size_t kPacketSize = 512;
	memset(client_packet_buffer_, '-', kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));

	QuicUdpSocketApi::ReadPacketResult read_result =
	ReadPacketFromServer(/packet_info_interested=/BitMask64());
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	}

	TEST_P(QuicUdpSocketTest, ReadTruncated) {
	const size_t kPacketSize = kDefaultMaxPacketSize + 1;
	memset(client_packet_buffer_, '*', kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));

	QuicUdpSocketApi::ReadPacketResult read_result =
	ReadPacketFromServer(/packet_info_interested=/BitMask64());
	ASSERT_FALSE(read_result.ok);
	}

	TEST_P(QuicUdpSocketTest, ReadDroppedPackets) {
	const size_t kPacketSize = kDefaultMaxPacketSize;
	memset(client_packet_buffer_, '-', kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));

	// Read the first packet without enabling DROPPED_PACKETS.
	QuicUdpSocketApi::ReadPacketResult read_result =
	ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::DROPPED_PACKETS));
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	ASSERT_FALSE(
	read_result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS));

	// Enable DROPPED_PACKETS and read the second packet.
	if (!api_.EnableDroppedPacketCount(fd_server_)) {
	QUIC_LOG(INFO) << "DROPPED_PACKETS is not supported";
	return;
	}
	read_result =
	ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::DROPPED_PACKETS));
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	if (read_result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS)) {
	EXPECT_EQ(0u, read_result.packet_info.dropped_packets());
	}
	}

	TEST_P(QuicUdpSocketTest, ReadSelfIp) {
	const QuicUdpPacketInfoBit self_ip_bit =
	(address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP
	: QuicUdpPacketInfoBit::V6_SELF_IP;

	const size_t kPacketSize = 512;
	memset(client_packet_buffer_, '&', kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));

	QuicUdpSocketApi::ReadPacketResult read_result =
	ReadPacketFromServer(BitMask64(self_ip_bit));
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	ASSERT_TRUE(read_result.packet_info.HasValue(self_ip_bit));
	EXPECT_EQ(Loopback(), (address_family_ == AF_INET)
	? read_result.packet_info.self_v4_ip()
	: read_result.packet_info.self_v6_ip());
	}

	TEST_P(QuicUdpSocketTest, ReadReceiveTimestamp) {
	const size_t kPacketSize = kDefaultMaxPacketSize;
	memset(client_packet_buffer_, '-', kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));

	// Read the first packet without enabling RECV_TIMESTAMP.
	QuicUdpSocketApi::ReadPacketResult read_result =
	ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::RECV_TIMESTAMP));
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	ASSERT_FALSE(
	read_result.packet_info.HasValue(QuicUdpPacketInfoBit::RECV_TIMESTAMP));

	// Enable RECV_TIMESTAMP and read the second packet.
	if (!api_.EnableReceiveTimestamp(fd_server_)) {
	QUIC_LOG(INFO) << "RECV_TIMESTAMP is not supported";
	return;
	}
	read_result =
	ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::RECV_TIMESTAMP));
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	ASSERT_TRUE(
	read_result.packet_info.HasValue(QuicUdpPacketInfoBit::RECV_TIMESTAMP));
	QuicWallTime recv_timestamp = read_result.packet_info.receive_timestamp();
	// 1577836800 is the unix seconds for 2020-01-01
	EXPECT_TRUE(
	QuicWallTime::FromUNIXSeconds(1577836800).IsBefore(recv_timestamp));
	}

	TEST_P(QuicUdpSocketTest, Ttl) {
	const size_t kPacketSize = 512;
	memset(client_packet_buffer_, '$', kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClientWithTtl(kPacketSize, 13));
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClientWithTtl(kPacketSize, 13));

	// Read the first packet without enabling ttl reporting.
	QuicUdpSocketApi::ReadPacketResult read_result =
	ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::TTL));
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	ASSERT_FALSE(read_result.packet_info.HasValue(QuicUdpPacketInfoBit::TTL));

	// Enable ttl reporting and read the second packet.
	if (!((address_family_ == AF_INET)
	? api_.EnableReceiveTtlForV4(fd_server_)
	: api_.EnableReceiveTtlForV6(fd_server_))) {
	QUIC_LOG(INFO) << "TTL is not supported for address family "
	<< address_family_;
	return;
	}

	read_result = ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::TTL));
	ASSERT_TRUE(read_result.ok);
	ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
	ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
	ASSERT_TRUE(read_result.packet_info.HasValue(QuicUdpPacketInfoBit::TTL));
	EXPECT_EQ(13, read_result.packet_info.ttl());
	}

	TEST_P(QuicUdpSocketTest, ReadMultiplePackets) {
	const QuicUdpPacketInfoBit self_ip_bit =
	(address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP
	: QuicUdpPacketInfoBit::V6_SELF_IP;
	const size_t kPacketSize = kDefaultMaxPacketSize;
	const size_t kNumPackets = 90;
	for (size_t i = 0; i < kNumPackets; ++i) {
	memset(client_packet_buffer_, ' ' + i, kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));
	}

	const size_t kNumPacketsPerRead = 16;
	size_t total_packets_read = 0;
	while (total_packets_read < kNumPackets) {
	std::unique_ptr<ReadBuffers[]> read_buffers =
	std::make_unique<ReadBuffers[]>(kNumPacketsPerRead);
	QuicUdpSocketApi::ReadPacketResults results(kNumPacketsPerRead);
	for (size_t i = 0; i < kNumPacketsPerRead; ++i) {
	results[i].packet_buffer.buffer = read_buffers[i].packet_buffer;
	results[i].packet_buffer.buffer_len =
	sizeof(read_buffers[i].packet_buffer);

	results[i].control_buffer.buffer = read_buffers[i].control_buffer;
	results[i].control_buffer.buffer_len =
	sizeof(read_buffers[i].control_buffer);
	}
	size_t packets_read =
	api_.ReadMultiplePackets(fd_server_, BitMask64(self_ip_bit), &results);
	if (packets_read == 0) {
	ASSERT_TRUE(
	api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));
	packets_read = api_.ReadMultiplePackets(fd_server_,
	BitMask64(self_ip_bit), &results);
	ASSERT_GT(packets_read, 0u);
	}

	for (size_t i = 0; i < packets_read; ++i) {
	const auto& result = results[i];
	ASSERT_TRUE(result.ok);
	ASSERT_EQ(kPacketSize, result.packet_buffer.buffer_len);
	ASSERT_TRUE(VerifyBufferIsFilledWith(result.packet_buffer.buffer,
	result.packet_buffer.buffer_len,
	' ' + total_packets_read));
	ASSERT_TRUE(result.packet_info.HasValue(self_ip_bit));
	EXPECT_EQ(Loopback(), (address_family_ == AF_INET)
	? result.packet_info.self_v4_ip()
	: result.packet_info.self_v6_ip());
	total_packets_read++;
	}
	}
	}

	TEST_P(QuicUdpSocketTest, ReadMultiplePacketsSomeTruncated) {
	const QuicUdpPacketInfoBit self_ip_bit =
	(address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP
	: QuicUdpPacketInfoBit::V6_SELF_IP;
	const size_t kPacketSize = kDefaultMaxPacketSize;
	const size_t kNumPackets = 90;
	for (size_t i = 0; i < kNumPackets; ++i) {
	memset(client_packet_buffer_, ' ' + i, kPacketSize);
	ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
	SendPacketFromClient(kPacketSize));
	}

	const size_t kNumPacketsPerRead = 16;
	size_t total_packets_read = 0; // Including truncated packets.
	while (total_packets_read < kNumPackets) {
	std::unique_ptr<ReadBuffers[]> read_buffers =
	std::make_unique<ReadBuffers[]>(kNumPacketsPerRead);
	QuicUdpSocketApi::ReadPacketResults results(kNumPacketsPerRead);
	// Use small packet buffer for all even-numbered packets and expect them to
	// be truncated.
	auto is_truncated = [total_packets_read](size_t i) {
	return ((total_packets_read + i) % 2) == 1;
	};

	for (size_t i = 0; i < kNumPacketsPerRead; ++i) {
	results[i].packet_buffer.buffer = read_buffers[i].packet_buffer;
	results[i].packet_buffer.buffer_len =
	is_truncated(i) ? kPacketSize - 1
	: sizeof(read_buffers[i].packet_buffer);

	results[i].control_buffer.buffer = read_buffers[i].control_buffer;
	results[i].control_buffer.buffer_len =
	sizeof(read_buffers[i].control_buffer);
	}
	size_t packets_read =
	api_.ReadMultiplePackets(fd_server_, BitMask64(self_ip_bit), &results);
	if (packets_read == 0) {
	ASSERT_TRUE(
	api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));
	packets_read = api_.ReadMultiplePackets(fd_server_,
	BitMask64(self_ip_bit), &results);
	ASSERT_GT(packets_read, 0u);
	}

	for (size_t i = 0; i < packets_read; ++i) {
	const auto& result = results[i];
	if (is_truncated(i)) {
	ASSERT_FALSE(result.ok);
	} else {
	ASSERT_TRUE(result.ok);
	ASSERT_EQ(kPacketSize, result.packet_buffer.buffer_len);
	ASSERT_TRUE(VerifyBufferIsFilledWith(result.packet_buffer.buffer,
	result.packet_buffer.buffer_len,
	' ' + total_packets_read));
	ASSERT_TRUE(result.packet_info.HasValue(self_ip_bit));
	EXPECT_EQ(Loopback(), (address_family_ == AF_INET)
	? result.packet_info.self_v4_ip()
	: result.packet_info.self_v6_ip());
	}
	total_packets_read++;
	}
	}
	}

	} // namespace test
	} // namespace quic