Migrate ABSL_ARRAYSIZE()/arraysize() to std::size() or std::extent_v where possible
Tested:
TAP --sample ran all affected tests and none failed
http://test/OCL:956202316:BASE:956003919:1785375420815:8e4d0d8a
PiperOrigin-RevId: 956418130
diff --git a/quiche/quic/core/chlo_extractor_test.cc b/quiche/quic/core/chlo_extractor_test.cc
index c0e391d..8a56b3a 100644
--- a/quiche/quic/core/chlo_extractor_test.cc
+++ b/quiche/quic/core/chlo_extractor_test.cc
@@ -4,6 +4,7 @@
#include "quiche/quic/core/chlo_extractor.h"
+#include <iterator>
#include <memory>
#include <string>
#include <utility>
@@ -95,7 +96,7 @@
EXPECT_TRUE(packet != nullptr);
size_t encrypted_length =
framer.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number, *packet,
- buffer_, ABSL_ARRAYSIZE(buffer_));
+ buffer_, std::size(buffer_));
ASSERT_NE(0u, encrypted_length);
packet_ = std::make_unique<QuicEncryptedPacket>(buffer_, encrypted_length);
EXPECT_TRUE(packet_ != nullptr);
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 2639ded..73e0ca7 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -6,6 +6,7 @@
#include <algorithm>
#include <cstdint>
+#include <iterator>
#include <memory>
#include <optional>
#include <string>
@@ -10689,13 +10690,13 @@
size_t retry_packet_length;
if (version() == ParsedQuicVersion::RFCv2()) {
retry_packet = retry_packet_rfcv2;
- retry_packet_length = ABSL_ARRAYSIZE(retry_packet_rfcv2);
+ retry_packet_length = std::size(retry_packet_rfcv2);
} else if (version() == ParsedQuicVersion::RFCv1()) {
retry_packet = retry_packet_rfcv1;
- retry_packet_length = ABSL_ARRAYSIZE(retry_packet_rfcv1);
+ retry_packet_length = std::size(retry_packet_rfcv1);
} else if (version() == ParsedQuicVersion::Draft29()) {
retry_packet = retry_packet29;
- retry_packet_length = ABSL_ARRAYSIZE(retry_packet29);
+ retry_packet_length = std::size(retry_packet29);
} else {
// TODO(dschinazi) generate retry packets for all versions once we have
// server-side support for generating these programmatically.
@@ -10710,13 +10711,13 @@
QuicConnectionId original_connection_id(
reinterpret_cast<char*>(original_connection_id_bytes),
- ABSL_ARRAYSIZE(original_connection_id_bytes));
+ std::size(original_connection_id_bytes));
QuicConnectionId new_connection_id(
reinterpret_cast<char*>(new_connection_id_bytes),
- ABSL_ARRAYSIZE(new_connection_id_bytes));
+ std::size(new_connection_id_bytes));
std::string retry_token(reinterpret_cast<char*>(retry_token_bytes),
- ABSL_ARRAYSIZE(retry_token_bytes));
+ std::size(retry_token_bytes));
if (invalid_retry_tag) {
// Flip the last bit of the retry packet to prevent the integrity tag
diff --git a/quiche/quic/core/quic_crypto_client_stream_test.cc b/quiche/quic/core/quic_crypto_client_stream_test.cc
index 7b5ab9f..d8317bc 100644
--- a/quiche/quic/core/quic_crypto_client_stream_test.cc
+++ b/quiche/quic/core/quic_crypto_client_stream_test.cc
@@ -4,6 +4,7 @@
#include "quiche/quic/core/quic_crypto_client_stream.h"
+#include <iterator>
#include <memory>
#include <string>
#include <utility>
@@ -270,7 +271,7 @@
const std::string& cached_scfg = state->server_config();
quiche::test::CompareCharArraysWithHexError(
"scfg", cached_scfg.data(), cached_scfg.length(),
- reinterpret_cast<char*>(scfg), ABSL_ARRAYSIZE(scfg));
+ reinterpret_cast<char*>(scfg), std::size(scfg));
QuicStreamSequencer* sequencer = QuicStreamPeer::sequencer(stream());
EXPECT_FALSE(QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
diff --git a/quiche/quic/core/quic_data_writer_test.cc b/quiche/quic/core/quic_data_writer_test.cc
index 40262d0..836556c 100644
--- a/quiche/quic/core/quic_data_writer_test.cc
+++ b/quiche/quic/core/quic_data_writer_test.cc
@@ -6,6 +6,7 @@
#include <cstdint>
#include <cstring>
+#include <iterator>
#include <string>
#include <vector>
@@ -268,7 +269,7 @@
char big_endian[] = {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
};
- EXPECT_EQ(connection_id.length(), ABSL_ARRAYSIZE(big_endian));
+ EXPECT_EQ(connection_id.length(), std::size(big_endian));
ASSERT_LE(connection_id.length(), 255);
char buffer[255];
QuicDataWriter writer(connection_id.length(), buffer, GetParam().endianness);
@@ -280,7 +281,7 @@
QuicConnectionId read_connection_id;
QuicDataReader reader(buffer, connection_id.length(), GetParam().endianness);
EXPECT_TRUE(
- reader.ReadConnectionId(&read_connection_id, ABSL_ARRAYSIZE(big_endian)));
+ reader.ReadConnectionId(&read_connection_id, std::size(big_endian)));
EXPECT_EQ(connection_id, read_connection_id);
}
@@ -290,35 +291,33 @@
char length_prefixed_connection_id[] = {
0x08, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
};
- EXPECT_EQ(ABSL_ARRAYSIZE(length_prefixed_connection_id),
+ EXPECT_EQ(std::size(length_prefixed_connection_id),
kConnectionIdLengthSize + connection_id.length());
char buffer[kConnectionIdLengthSize + 255] = {};
- QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer);
+ QuicDataWriter writer(std::size(buffer), buffer);
EXPECT_TRUE(writer.WriteLengthPrefixedConnectionId(connection_id));
quiche::test::CompareCharArraysWithHexError(
"WriteLengthPrefixedConnectionId", buffer, writer.length(),
- length_prefixed_connection_id,
- ABSL_ARRAYSIZE(length_prefixed_connection_id));
+ length_prefixed_connection_id, std::size(length_prefixed_connection_id));
// Verify that writing length then connection ID produces the same output.
- memset(buffer, 0, ABSL_ARRAYSIZE(buffer));
- QuicDataWriter writer2(ABSL_ARRAYSIZE(buffer), buffer);
+ memset(buffer, 0, std::size(buffer));
+ QuicDataWriter writer2(std::size(buffer), buffer);
EXPECT_TRUE(writer2.WriteUInt8(connection_id.length()));
EXPECT_TRUE(writer2.WriteConnectionId(connection_id));
quiche::test::CompareCharArraysWithHexError(
"Write length then ConnectionId", buffer, writer2.length(),
- length_prefixed_connection_id,
- ABSL_ARRAYSIZE(length_prefixed_connection_id));
+ length_prefixed_connection_id, std::size(length_prefixed_connection_id));
QuicConnectionId read_connection_id;
- QuicDataReader reader(buffer, ABSL_ARRAYSIZE(buffer));
+ QuicDataReader reader(buffer, std::size(buffer));
EXPECT_TRUE(reader.ReadLengthPrefixedConnectionId(&read_connection_id));
EXPECT_EQ(connection_id, read_connection_id);
// Verify that reading length then connection ID produces the same output.
uint8_t read_connection_id_length2 = 33;
QuicConnectionId read_connection_id2;
- QuicDataReader reader2(buffer, ABSL_ARRAYSIZE(buffer));
+ QuicDataReader reader2(buffer, std::size(buffer));
ASSERT_TRUE(reader2.ReadUInt8(&read_connection_id_length2));
EXPECT_EQ(connection_id.length(), read_connection_id_length2);
EXPECT_TRUE(reader2.ReadConnectionId(&read_connection_id2,
@@ -329,7 +328,7 @@
TEST_P(QuicDataWriterTest, EmptyConnectionIds) {
QuicConnectionId empty_connection_id = EmptyQuicConnectionId();
char buffer[2];
- QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer, GetParam().endianness);
+ QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
EXPECT_TRUE(writer.WriteConnectionId(empty_connection_id));
EXPECT_TRUE(writer.WriteUInt8(1));
EXPECT_TRUE(writer.WriteConnectionId(empty_connection_id));
@@ -342,7 +341,7 @@
QuicConnectionId read_connection_id = TestConnectionId();
uint8_t read_byte;
- QuicDataReader reader(buffer, ABSL_ARRAYSIZE(buffer), GetParam().endianness);
+ QuicDataReader reader(buffer, std::size(buffer), GetParam().endianness);
EXPECT_TRUE(reader.ReadConnectionId(&read_connection_id, 0));
EXPECT_EQ(read_connection_id, empty_connection_id);
EXPECT_TRUE(reader.ReadUInt8(&read_byte));
@@ -660,10 +659,10 @@
TEST_P(QuicDataWriterTest, WriteBytes) {
char bytes[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
- char buf[ABSL_ARRAYSIZE(bytes)];
- QuicDataWriter writer(ABSL_ARRAYSIZE(buf), buf, GetParam().endianness);
- EXPECT_TRUE(writer.WriteBytes(bytes, ABSL_ARRAYSIZE(bytes)));
- for (unsigned int i = 0; i < ABSL_ARRAYSIZE(bytes); ++i) {
+ char buf[std::size(bytes)];
+ QuicDataWriter writer(std::size(buf), buf, GetParam().endianness);
+ EXPECT_TRUE(writer.WriteBytes(bytes, std::size(bytes)));
+ for (unsigned int i = 0; i < std::size(bytes); ++i) {
EXPECT_EQ(bytes[i], buf[i]);
}
}
@@ -786,13 +785,13 @@
TEST_P(QuicDataWriterTest, Seek) {
char buffer[3] = {};
- QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer, GetParam().endianness);
+ QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
EXPECT_TRUE(writer.WriteUInt8(42));
EXPECT_TRUE(writer.Seek(1));
EXPECT_TRUE(writer.WriteUInt8(3));
char expected[] = {42, 0, 3};
- for (size_t i = 0; i < ABSL_ARRAYSIZE(expected); ++i) {
+ for (size_t i = 0; i < std::size(expected); ++i) {
EXPECT_EQ(buffer[i], expected[i]);
}
}
@@ -802,23 +801,20 @@
// Check that one can seek to the end of the writer, but not past.
{
- QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
- GetParam().endianness);
+ QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
EXPECT_TRUE(writer.Seek(20));
EXPECT_FALSE(writer.Seek(1));
}
// Seeking several bytes past the end fails.
{
- QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
- GetParam().endianness);
+ QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
EXPECT_FALSE(writer.Seek(100));
}
// Seeking so far that arithmetic overflow could occur also fails.
{
- QuicDataWriter writer(ABSL_ARRAYSIZE(buffer), buffer,
- GetParam().endianness);
+ QuicDataWriter writer(std::size(buffer), buffer, GetParam().endianness);
EXPECT_TRUE(writer.Seek(10));
EXPECT_FALSE(writer.Seek(std::numeric_limits<size_t>::max()));
}
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index 859408f..9e83738 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -7,6 +7,7 @@
#include <algorithm>
#include <cstddef>
#include <cstdint>
+#include <iterator>
#include <list>
#include <map>
#include <memory>
@@ -1519,7 +1520,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 0xFF, 0x00, 0x00, 28, /*destination connection ID length*/ 0x08};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(*time_wait_list_manager_,
SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1535,7 +1536,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 0xFF, 0x00, 0x00, 27, /*destination connection ID length*/ 0x08};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(*time_wait_list_manager_,
SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1551,7 +1552,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 0xFF, 0x00, 0x00, 25, /*destination connection ID length*/ 0x08};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(*time_wait_list_manager_,
SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1567,7 +1568,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'T', '0', '5', '0', /*destination connection ID length*/ 0x08};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(*time_wait_list_manager_,
SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1583,7 +1584,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '9', /*destination connection ID length*/ 0x08};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(*time_wait_list_manager_,
SendVersionNegotiationPacket(_, _, /*ietf_quic=*/true,
@@ -1599,7 +1600,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '8', /*connection ID length byte*/ 0x50};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(
*time_wait_list_manager_,
@@ -1616,7 +1617,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '7', /*connection ID length byte*/ 0x50};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(
*time_wait_list_manager_,
@@ -1633,7 +1634,7 @@
uint8_t packet[kMinPacketSizeForVersionNegotiation] = {
0xC0, 'Q', '0', '4', '5', /*connection ID length byte*/ 0x50};
QuicReceivedPacket received_packet(reinterpret_cast<char*>(packet),
- ABSL_ARRAYSIZE(packet), QuicTime::Zero());
+ std::size(packet), QuicTime::Zero());
EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(
*time_wait_list_manager_,
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index cb94335..0ceec4e 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -6,6 +6,7 @@
#include <cstdint>
#include <cstring>
+#include <iterator>
#include <limits>
#include <memory>
#include <optional>
@@ -1151,7 +1152,7 @@
memset(packet + header_size, 0, kMaxIncomingPacketSize - header_size);
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
ASSERT_TRUE(visitor_.header_.get());
@@ -1274,11 +1275,11 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet49);
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -1309,7 +1310,7 @@
TEST_P(QuicFramerTest, AllZeroPacketParsingFails) {
unsigned char packet[1200] = {};
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
PacketHeaderFormat format = GOOGLE_QUIC_Q043_PACKET;
QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
bool version_flag = false;
@@ -1368,11 +1369,11 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet49);
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
uint8_t first_byte = 0x33;
@@ -1436,7 +1437,7 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
uint8_t first_byte = 0x33;
PacketHeaderFormat format = GOOGLE_QUIC_Q043_PACKET;
@@ -1689,7 +1690,7 @@
0x00,
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
EXPECT_EQ("", framer_.detailed_error());
@@ -1720,7 +1721,7 @@
0x00,
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
EXPECT_EQ("", framer_.detailed_error());
@@ -2116,10 +2117,10 @@
}
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (framer_.version().IsIetfQuic()) {
p = packet49;
- p_size = ABSL_ARRAYSIZE(packet49);
+ p_size = std::size(packet49);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2204,16 +2205,16 @@
switch (framer_.transport_version()) {
case QUIC_VERSION_46:
p = old_packet;
- p_size = ABSL_ARRAYSIZE(old_packet);
+ p_size = std::size(old_packet);
break;
case QUIC_VERSION_IETF_DRAFT_29:
case QUIC_VERSION_IETF_RFC_V1:
p = packetv2;
- p_size = ABSL_ARRAYSIZE(packetv2);
+ p_size = std::size(packetv2);
break;
case QUIC_VERSION_IETF_RFC_V2:
p = packetv1;
- p_size = ABSL_ARRAYSIZE(packetv1);
+ p_size = std::size(packetv1);
break;
default:
p = packetv2; // To silence warnings.
@@ -2307,10 +2308,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2530,10 +2531,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -2913,7 +2914,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -2940,7 +2941,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -4141,7 +4142,7 @@
// ACK Timestamp is not a feature of IETF QUIC.
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
"delta_from_largest_observed too high"));
@@ -4183,7 +4184,7 @@
// ACK Timestamp is not a feature of IETF QUIC.
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
"delta_from_largest_observed too high"));
@@ -4254,7 +4255,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
EXPECT_EQ("Invalid unacked delta.", framer_.detailed_error());
@@ -5098,9 +5099,8 @@
QuicEncryptedPacket encrypted(
AsChars(VersionIsIetfQuic(framer_.transport_version()) ? packet_ietf
: packet),
- VersionIsIetfQuic(framer_.transport_version())
- ? ABSL_ARRAYSIZE(packet_ietf)
- : ABSL_ARRAYSIZE(packet),
+ VersionIsIetfQuic(framer_.transport_version()) ? std::size(packet_ietf)
+ : std::size(packet),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -5135,7 +5135,7 @@
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5175,7 +5175,7 @@
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5212,7 +5212,7 @@
return;
}
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5253,7 +5253,7 @@
}
framer_.set_process_reset_stream_at(true);
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5299,7 +5299,7 @@
}
framer_.set_process_reset_stream_at(true);
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_EQ(framer_.error(), QUIC_INVALID_FRAME_DATA);
EXPECT_EQ(visitor_.reset_stream_at_frames_.size(), 0);
@@ -5417,7 +5417,7 @@
ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
}
// This packet cannot be decrypted because diversification nonce is missing.
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
ASSERT_THAT(framer_.error(), IsQuicNoError());
}
@@ -5452,7 +5452,7 @@
ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
}
// This packet cannot be decrypted because diversification nonce is missing.
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
}
@@ -5552,10 +5552,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
p = packet2;
- p_length = ABSL_ARRAYSIZE(packet2);
+ p_length = std::size(packet2);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -5629,14 +5629,14 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet_with_tag);
p = packet_with_tag;
- p_length = ABSL_ARRAYSIZE(packet_with_tag);
+ p_length = std::size(packet_with_tag);
} else if (framer_.version().IsIetfQuic()) {
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -5658,7 +5658,7 @@
"retry integrity tag", visitor_.retry_token_integrity_tag_->data(),
visitor_.retry_token_integrity_tag_->length(),
reinterpret_cast<const char*>(expected_integrity_tag),
- ABSL_ARRAYSIZE(expected_integrity_tag));
+ std::size(expected_integrity_tag));
ASSERT_TRUE(visitor_.retry_without_tag_.get());
quiche::test::CompareCharArraysWithHexError(
"retry without tag", visitor_.retry_without_tag_->data(),
@@ -5750,9 +5750,9 @@
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet));
+ quiche::test::CompareCharArraysWithHexError("constructed packet",
+ data->data(), data->length(),
+ AsChars(p), std::size(packet));
}
TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) {
@@ -5828,10 +5828,10 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -5893,9 +5893,9 @@
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet));
+ quiche::test::CompareCharArraysWithHexError("constructed packet",
+ data->data(), data->length(),
+ AsChars(p), std::size(packet));
}
TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
@@ -5952,9 +5952,9 @@
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet));
+ quiche::test::CompareCharArraysWithHexError("constructed packet",
+ data->data(), data->length(),
+ AsChars(p), std::size(packet));
}
TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
@@ -6011,9 +6011,9 @@
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet));
+ quiche::test::CompareCharArraysWithHexError("constructed packet",
+ data->data(), data->length(),
+ AsChars(p), std::size(packet));
}
TEST_P(QuicFramerTest, BuildStreamFramePacket) {
@@ -6080,10 +6080,10 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -6185,14 +6185,14 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
ReviseFirstByteByVersion(packet_ietf);
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
} else if (framer_.version().IsIetfQuic()) {
p = packet49;
- p_size = ABSL_ARRAYSIZE(packet49);
+ p_size = std::size(packet49);
}
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -6265,10 +6265,10 @@
// clang-format on
unsigned char* packet = packet48;
- size_t packet_size = ABSL_ARRAYSIZE(packet48);
+ size_t packet_size = std::size(packet48);
if (framer_.version().IsIetfQuic()) {
packet = packet_ietf;
- packet_size = ABSL_ARRAYSIZE(packet_ietf);
+ packet_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6382,7 +6382,7 @@
SupportedVersions(GetParam())));
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
@@ -6418,10 +6418,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (framer_.version().IsIetfQuic()) {
p = packet49;
- p_size = ABSL_ARRAYSIZE(packet49);
+ p_size = std::size(packet49);
}
QuicConnectionId connection_id = FramerTestConnectionId();
@@ -6466,7 +6466,7 @@
SupportedVersions(GetParam())));
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) {
@@ -6526,10 +6526,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -6647,7 +6647,7 @@
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFramePacketOutOfOrder) {
@@ -6748,7 +6748,7 @@
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildAckReceiveTimestampsAndEcnFrame) {
@@ -6841,7 +6841,7 @@
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFrameExceedsMaxTimestamps) {
@@ -6942,7 +6942,7 @@
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFrameWithExponentEncoding) {
@@ -7050,7 +7050,7 @@
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildAndProcessAckReceiveTimestampsWithMultipleRanges) {
@@ -7723,10 +7723,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7829,10 +7829,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8042,10 +8042,10 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8117,10 +8117,10 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -8188,10 +8188,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8269,10 +8269,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8398,10 +8398,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8459,7 +8459,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildTruncatedApplicationCloseFramePacket) {
@@ -8540,7 +8540,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildGoAwayPacket) {
@@ -8592,7 +8592,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildTruncatedGoAwayPacket) {
@@ -8672,7 +8672,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
@@ -8729,10 +8729,10 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
quiche::test::CompareCharArraysWithHexError(
@@ -8781,7 +8781,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildMaxDataPacket) {
@@ -8825,7 +8825,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildBlockedPacket) {
@@ -8884,10 +8884,10 @@
ASSERT_TRUE(data != nullptr);
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
quiche::test::CompareCharArraysWithHexError(
@@ -8938,9 +8938,9 @@
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet));
+ quiche::test::CompareCharArraysWithHexError("constructed packet",
+ data->data(), data->length(),
+ AsChars(p), std::size(packet));
}
TEST_P(QuicFramerTest, BuildHandshakeDonePacket) {
@@ -8974,7 +8974,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildAckFrequencyPacket) {
@@ -9022,7 +9022,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildImmediateAckPacket) {
@@ -9057,7 +9057,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildResetStreamAtPacket) {
@@ -9106,7 +9106,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildDatagramPacket) {
@@ -9171,9 +9171,9 @@
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet));
+ quiche::test::CompareCharArraysWithHexError("constructed packet",
+ data->data(), data->length(),
+ AsChars(p), std::size(packet));
}
// Test that the MTU discovery packet is serialized correctly as a PING packet.
@@ -9221,9 +9221,9 @@
p = packet_ietf;
}
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet));
+ quiche::test::CompareCharArraysWithHexError("constructed packet",
+ data->data(), data->length(),
+ AsChars(p), std::size(packet));
}
TEST_P(QuicFramerTest, BuildPublicResetPacket) {
@@ -9256,7 +9256,7 @@
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) {
@@ -9301,7 +9301,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, BuildPublicResetPacketWithEndpointId) {
@@ -9371,11 +9371,11 @@
if ('d' == data->data()[data->length() - 1]) {
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(),
- AsChars(packet_variant1), ABSL_ARRAYSIZE(packet_variant1));
+ AsChars(packet_variant1), std::size(packet_variant1));
} else {
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(),
- AsChars(packet_variant2), ABSL_ARRAYSIZE(packet_variant2));
+ AsChars(packet_variant2), std::size(packet_variant2));
}
}
@@ -9408,7 +9408,7 @@
"constructed packet",
data->data() + data->length() - kStatelessResetTokenLength,
kStatelessResetTokenLength,
- AsChars(packet) + ABSL_ARRAYSIZE(packet) - kStatelessResetTokenLength,
+ AsChars(packet) + std::size(packet) - kStatelessResetTokenLength,
kStatelessResetTokenLength);
// Packets with length <= minimal stateless reset does not trigger stateless
@@ -9464,7 +9464,7 @@
// Verify the entire packet.
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, EncryptPacket) {
@@ -9503,10 +9503,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (framer_.version().IsIetfQuic()) {
p = packet50;
- p_size = ABSL_ARRAYSIZE(packet50);
+ p_size = std::size(packet50);
}
std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -9590,11 +9590,11 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
// TODO(ianswett): see todo in previous test.
if (framer_.version().IsIetfQuic()) {
p = packet50;
- p_size = ABSL_ARRAYSIZE(packet50);
+ p_size = std::size(packet50);
}
std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -9880,10 +9880,10 @@
EXPECT_CALL(visitor, OnDecryptedPacket(_, _));
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -10064,7 +10064,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, IetfStreamBlockedFrame) {
@@ -10152,7 +10152,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BiDiMaxStreamsFrame) {
@@ -10352,8 +10352,8 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf), false);
+ QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+ false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
ASSERT_TRUE(visitor_.header_.get());
@@ -10389,8 +10389,8 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf), false);
+ QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+ false);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -10429,8 +10429,8 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf), false);
+ QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+ false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -10467,8 +10467,8 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf), false);
+ QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+ false);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -10505,8 +10505,8 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf), false);
+ QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+ false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
}
@@ -10710,8 +10710,8 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf), false);
+ QuicEncryptedPacket encrypted(AsChars(packet_ietf), std::size(packet_ietf),
+ false);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -10805,7 +10805,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildUniStreamsBlockedPacket) {
@@ -10847,7 +10847,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildBiDiMaxStreamsPacket) {
@@ -10889,7 +10889,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, BuildUniDiMaxStreamsPacket) {
@@ -10934,7 +10934,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, NewConnectionIdFrame) {
@@ -11245,7 +11245,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, NewTokenFrame) {
@@ -11340,7 +11340,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
+ std::size(packet));
}
TEST_P(QuicFramerTest, IetfStopSendingFrame) {
@@ -11433,7 +11433,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, IetfPathChallengeFrame) {
@@ -11516,7 +11516,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, IetfPathResponseFrame) {
@@ -11599,7 +11599,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, GetRetransmittableControlFrameSize) {
@@ -12405,7 +12405,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(packet_ietf),
- ABSL_ARRAYSIZE(packet_ietf));
+ std::size(packet_ietf));
}
TEST_P(QuicFramerTest, AckFrameWithInvalidLargestObserved) {
@@ -12453,10 +12453,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12509,10 +12509,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12584,10 +12584,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
if (VersionIsIetfQuic(framer_.transport_version())) {
p = packet_ietf;
- p_size = ABSL_ARRAYSIZE(packet_ietf);
+ p_size = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -12732,12 +12732,12 @@
EXPECT_EQ(packet_ietf[first_packet_ietf_size], 0xD3);
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet_ietf);
ReviseFirstByteByVersion(&packet_ietf[first_packet_ietf_size]);
p = packet_ietf;
- p_length = ABSL_ARRAYSIZE(packet_ietf);
+ p_length = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -12853,11 +12853,11 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet_ietf);
p = packet_ietf;
- p_length = ABSL_ARRAYSIZE(packet_ietf);
+ p_length = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13074,20 +13074,20 @@
switch (framer_.version().transport_version) {
case QUIC_VERSION_46:
p = packet;
- p_length = ABSL_ARRAYSIZE(packet);
+ p_length = std::size(packet);
break;
case QUIC_VERSION_IETF_DRAFT_29:
case QUIC_VERSION_IETF_RFC_V1:
p = packet_v1;
- p_length = ABSL_ARRAYSIZE(packet_v1);
+ p_length = std::size(packet_v1);
break;
case QUIC_VERSION_IETF_RFC_V2:
p = packet_v2;
- p_length = ABSL_ARRAYSIZE(packet_v2);
+ p_length = std::size(packet_v2);
break;
default:
p = packet_v2; // To silence warnings.
- p_length = ABSL_ARRAYSIZE(packet_v2);
+ p_length = std::size(packet_v2);
QUICHE_NOTREACHED();
break;
}
@@ -13249,12 +13249,12 @@
EXPECT_EQ(packet_ietf[first_packet_ietf_size], 0xD3);
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet_ietf);
ReviseFirstByteByVersion(&packet_ietf[first_packet_ietf_size]);
p = packet_ietf;
- p_length = ABSL_ARRAYSIZE(packet_ietf);
+ p_length = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13344,11 +13344,11 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet49);
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
// First attempt decryption without the handshake crypter.
EXPECT_FALSE(
@@ -13430,11 +13430,11 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet49);
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
EXPECT_FALSE(
@@ -13595,12 +13595,12 @@
EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet_ietf);
ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
p = packet_ietf;
- p_length = ABSL_ARRAYSIZE(packet_ietf);
+ p_length = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13768,12 +13768,12 @@
EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet_ietf);
ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
p = packet_ietf;
- p_length = ABSL_ARRAYSIZE(packet_ietf);
+ p_length = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13879,12 +13879,12 @@
EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet_ietf);
ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
p = packet_ietf;
- p_length = ABSL_ARRAYSIZE(packet_ietf);
+ p_length = std::size(packet_ietf);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -13943,7 +13943,7 @@
unsigned char packet[kMaxOutgoingPacketSize] = {};
size_t encrypted_length =
framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number, *data,
- AsChars(packet), ABSL_ARRAYSIZE(packet));
+ AsChars(packet), std::size(packet));
ASSERT_NE(0u, encrypted_length);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
@@ -13955,7 +13955,7 @@
std::move(server_crypters.decrypter));
// Make sure the first long header initial packet parses correctly.
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
// Make sure we discard the subsequent zeroes.
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -14010,10 +14010,10 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version() == ParsedQuicVersion::RFCv1()) {
p = packetv2;
- p_length = ABSL_ARRAYSIZE(packetv2);
+ p_length = std::size(packetv2);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
@@ -14049,7 +14049,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_PACKET_WRONG_VERSION));
@@ -14167,14 +14167,13 @@
std::make_unique<TestDecrypter>());
}
if (!VersionIsIetfQuic(framer_.transport_version())) {
- EXPECT_TRUE(framer_.ProcessPacket(
- QuicEncryptedPacket(AsChars(long_header_packet),
- ABSL_ARRAYSIZE(long_header_packet), false)));
+ EXPECT_TRUE(framer_.ProcessPacket(QuicEncryptedPacket(
+ AsChars(long_header_packet), std::size(long_header_packet), false)));
} else {
ReviseFirstByteByVersion(long_header_packet_ietf);
EXPECT_TRUE(framer_.ProcessPacket(
QuicEncryptedPacket(AsChars(long_header_packet_ietf),
- ABSL_ARRAYSIZE(long_header_packet_ietf), false)));
+ std::size(long_header_packet_ietf), false)));
}
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -14201,7 +14200,7 @@
// clang-format on
QuicEncryptedPacket short_header_encrypted(
- AsChars(short_header_packet), ABSL_ARRAYSIZE(short_header_packet), false);
+ AsChars(short_header_packet), std::size(short_header_packet), false);
if (framer_.version().IsIetfQuic()) {
framer_.InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
std::make_unique<TestDecrypter>());
@@ -14630,7 +14629,7 @@
ReviseFirstByteByVersion(packet);
ReviseFirstByteByVersion(&packet[first_packet_size]);
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
PacketHeaderFormat format;
@@ -14789,11 +14788,11 @@
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet49);
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
const bool parse_success =
framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false));
@@ -14851,11 +14850,11 @@
};
// clang-format on
unsigned char* p = packet;
- size_t p_length = ABSL_ARRAYSIZE(packet);
+ size_t p_length = std::size(packet);
if (framer_.version().IsIetfQuic()) {
ReviseFirstByteByVersion(packet49);
p = packet49;
- p_length = ABSL_ARRAYSIZE(packet49);
+ p_length = std::size(packet49);
}
const bool parse_success =
framer_.ProcessPacket(QuicEncryptedPacket(AsChars(p), p_length, false));
@@ -15065,8 +15064,8 @@
};
// clang-format on
- framer_.ProcessPacket(QuicEncryptedPacket(
- AsChars(packet_ietf), ABSL_ARRAYSIZE(packet_ietf), false));
+ framer_.ProcessPacket(
+ QuicEncryptedPacket(AsChars(packet_ietf), std::size(packet_ietf), false));
ASSERT_EQ(1u, visitor_.ack_frames_.size());
// Verify ack_delay_time is set correctly.
EXPECT_EQ(QuicTime::Delta::Infinite(),
@@ -15690,7 +15689,7 @@
// clang-format on
ReviseFirstByteByVersion(packet);
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -15719,7 +15718,7 @@
MockConnectionIdGenerator generator;
ON_CALL(generator, ConnectionIdLength(0x28)).WillByDefault(Return(9));
unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
+ size_t p_size = std::size(packet);
const size_t header_size = GetPacketHeaderSize(
framer_.transport_version(), kPacket8ByteConnectionId + 1,
@@ -15836,7 +15835,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), std::size(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
ASSERT_TRUE(visitor_.header_.get());
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index fca1f41..8338cf0 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -6,6 +6,7 @@
#include <cstddef>
#include <cstdint>
+#include <iterator>
#include <limits>
#include <memory>
#include <string>
@@ -778,9 +779,8 @@
std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
size_t length = creator_.BuildPaddedPathChallengePacket(
- header, buffer.get(), ABSL_ARRAYSIZE(packet), payload,
- ENCRYPTION_INITIAL);
- EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+ header, buffer.get(), std::size(packet), payload, ENCRYPTION_INITIAL);
+ EXPECT_EQ(length, std::size(packet));
// Payload has the random bytes that were generated. Copy them into packet,
// above, before checking that the generated packet is correct.
@@ -791,7 +791,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), std::size(packet));
}
TEST_P(QuicPacketCreatorTest, BuildConnectivityProbingPacket) {
@@ -834,10 +834,10 @@
// clang-format on
unsigned char* p = packet;
- size_t packet_size = ABSL_ARRAYSIZE(packet);
+ size_t packet_size = std::size(packet);
if (creator_.version().IsIetfQuic()) {
p = packet99;
- packet_size = ABSL_ARRAYSIZE(packet99);
+ packet_size = std::size(packet99);
}
std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
@@ -892,15 +892,15 @@
quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), std::size(packet), payloads,
/*is_padded=*/false, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+ EXPECT_EQ(length, std::size(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), std::size(packet));
}
TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket1ResponsePadded) {
@@ -939,15 +939,15 @@
quiche::QuicheCircularDeque<QuicPathFrameBuffer> payloads;
payloads.push_back(payload0);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), std::size(packet), payloads,
/*is_padded=*/true, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+ EXPECT_EQ(length, std::size(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), std::size(packet));
}
TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesUnpadded) {
@@ -991,15 +991,15 @@
payloads.push_back(payload1);
payloads.push_back(payload2);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), std::size(packet), payloads,
/*is_padded=*/false, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+ EXPECT_EQ(length, std::size(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), std::size(packet));
}
TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesPadded) {
@@ -1045,15 +1045,15 @@
payloads.push_back(payload1);
payloads.push_back(payload2);
size_t length = creator_.BuildPathResponsePacket(
- header, buffer.get(), ABSL_ARRAYSIZE(packet), payloads,
+ header, buffer.get(), std::size(packet), payloads,
/*is_padded=*/true, ENCRYPTION_INITIAL);
- EXPECT_EQ(length, ABSL_ARRAYSIZE(packet));
+ EXPECT_EQ(length, std::size(packet));
QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
header);
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data.data(), data.length(),
- reinterpret_cast<char*>(packet), ABSL_ARRAYSIZE(packet));
+ reinterpret_cast<char*>(packet), std::size(packet));
}
TEST_P(QuicPacketCreatorTest, SerializeConnectivityProbingPacket) {
diff --git a/quiche/quic/core/quic_sent_packet_manager_test.cc b/quiche/quic/core/quic_sent_packet_manager_test.cc
index a5792ed..ede33a9 100644
--- a/quiche/quic/core/quic_sent_packet_manager_test.cc
+++ b/quiche/quic/core/quic_sent_packet_manager_test.cc
@@ -7,6 +7,7 @@
#include <algorithm>
#include <cstddef>
#include <cstdint>
+#include <iterator>
#include <memory>
#include <optional>
#include <string>
@@ -367,10 +368,9 @@
SendDataPacket(1);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
uint64_t retransmittable[] = {1};
- VerifyRetransmittablePackets(retransmittable,
- ABSL_ARRAYSIZE(retransmittable));
+ VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
}
TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
@@ -379,7 +379,7 @@
EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
std::vector<uint64_t> retransmittable = {1, 2};
VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
}
@@ -399,7 +399,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
// Packet 1 is unacked, pending, but not retransmittable.
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
EXPECT_TRUE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
}
@@ -423,7 +423,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
// We do not know packet 2 is a spurious retransmission until it gets acked.
VerifyRetransmittablePackets(nullptr, 0);
EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
@@ -438,7 +438,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
}
@@ -460,7 +460,7 @@
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
// 2 remains unacked, but no packets have retransmittable data.
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
EXPECT_TRUE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
// Ack 2 causes 2 be considered as spurious retransmission.
@@ -527,7 +527,7 @@
ENCRYPTION_INITIAL, kEmptyCounts));
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
EXPECT_FALSE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
@@ -559,7 +559,7 @@
// Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
uint64_t unacked[] = {2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
EXPECT_FALSE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
@@ -597,7 +597,7 @@
// 2 and 3 remain unacked, but no packets have retransmittable data.
uint64_t unacked[] = {2, 3};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
EXPECT_TRUE(manager_.HasInFlightPackets());
VerifyRetransmittablePackets(nullptr, 0);
@@ -608,7 +608,7 @@
.WillOnce(Return(false))
.WillRepeatedly(Return(true));
uint64_t acked[] = {3, 4};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(4), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(5));
@@ -619,7 +619,7 @@
ENCRYPTION_INITIAL, kEmptyCounts));
uint64_t unacked2[] = {2};
- VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, std::size(unacked2));
EXPECT_TRUE(manager_.HasInFlightPackets());
SendDataPacket(5);
@@ -641,7 +641,7 @@
ENCRYPTION_INITIAL, kEmptyCounts));
uint64_t unacked3[] = {2};
- VerifyUnackedPackets(unacked3, ABSL_ARRAYSIZE(unacked3));
+ VerifyUnackedPackets(unacked3, std::size(unacked3));
EXPECT_FALSE(manager_.HasInFlightPackets());
// Spurious retransmission is detected when packet 3 gets acked. We cannot
// know packet 2 is a spurious until it gets acked.
@@ -690,7 +690,7 @@
// Ack 3, which causes SpuriousRetransmitDetected to be called.
{
uint64_t acked[] = {3};
- ExpectAcksAndLosses(false, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(false, acked, std::size(acked), nullptr, 0);
EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _, _));
EXPECT_CALL(*loss_algorithm,
SpuriousLossDetected(_, _, _, QuicPacketNumber(3),
@@ -737,7 +737,7 @@
// Now ack the ack and expect an RTT update.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2),
QuicTime::Delta::FromMilliseconds(5), clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -751,7 +751,7 @@
// Now ack the ack and expect only an RTT update.
uint64_t acked2[] = {3};
- ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
+ ExpectAcksAndLosses(true, acked2, std::size(acked2), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
@@ -911,8 +911,7 @@
// Crypto packets remain in flight, so any that aren't acked will be lost.
uint64_t acked[] = {3, 4, 5, 8, 9};
uint64_t lost[] = {1, 2, 6};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), lost,
- ABSL_ARRAYSIZE(lost));
+ ExpectAcksAndLosses(true, acked, std::size(acked), lost, std::size(lost));
EXPECT_CALL(notifier_, OnFrameLost(_)).Times(3);
EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
manager_.OnAckFrameStart(QuicPacketNumber(9), QuicTime::Delta::Infinite(),
@@ -946,7 +945,7 @@
// Now ack the second crypto packet, and ensure the first gets removed, but
// the third does not.
uint64_t acked[] = {2};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
EXPECT_CALL(notifier_, HasUnackedCryptoData()).WillRepeatedly(Return(false));
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
@@ -958,7 +957,7 @@
EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
uint64_t unacked[] = {1, 3};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
}
TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
@@ -1009,14 +1008,14 @@
manager_.NeuterUnencryptedPackets();
EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
uint64_t unacked[] = {1, 2, 3};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
EXPECT_FALSE(manager_.HasUnackedCryptoPackets());
EXPECT_FALSE(manager_.HasInFlightPackets());
// Ensure both packets get discarded when packet 2 is acked.
uint64_t acked[] = {3};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4));
@@ -1750,8 +1749,7 @@
// Ack [5, 7), [10, 12), [15, 17).
uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
- ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
- ABSL_ARRAYSIZE(lost1));
+ ExpectAcksAndLosses(true, acked1, std::size(acked1), lost1, std::size(lost1));
EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
clock_.Now());
@@ -1766,7 +1764,7 @@
// Ack [4, 8), [9, 13), [14, 21).
uint64_t acked2[] = {4, 7, 9, 12, 14, 17, 18, 19, 20};
- ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
+ ExpectAcksAndLosses(true, acked2, std::size(acked2), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(20), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(14), QuicPacketNumber(21));
@@ -1785,8 +1783,7 @@
// Ack [5, 7), [10, 12), [15, 17).
uint64_t acked1[] = {5, 6, 10, 11, 15, 16};
uint64_t lost1[] = {1, 2, 3, 4, 7, 8, 9, 12, 13};
- ExpectAcksAndLosses(true, acked1, ABSL_ARRAYSIZE(acked1), lost1,
- ABSL_ARRAYSIZE(lost1));
+ ExpectAcksAndLosses(true, acked1, std::size(acked1), lost1, std::size(lost1));
EXPECT_CALL(notifier_, OnFrameLost(_)).Times(AnyNumber());
manager_.OnAckFrameStart(QuicPacketNumber(16), QuicTime::Delta::Infinite(),
clock_.Now());
@@ -1799,7 +1796,7 @@
// Making sure reneged ACK does not harm. Ack [4, 8), [9, 13).
uint64_t acked2[] = {4, 7, 9, 12};
- ExpectAcksAndLosses(true, acked2, ABSL_ARRAYSIZE(acked2), nullptr, 0);
+ ExpectAcksAndLosses(true, acked2, std::size(acked2), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(12), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(9), QuicPacketNumber(13));
@@ -1920,7 +1917,7 @@
APPLICATION_DATA));
// Ack all packets.
uint64_t acked[] = {4, 6, 7, 8};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(8), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(4), QuicPacketNumber(9));
@@ -1990,7 +1987,7 @@
// Packet 1 gets acked in the wrong packet number space. Since packet 1 has
// been acked in the correct packet number space, tolerate it.
uint64_t acked[] = {2, 3};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(4));
@@ -2044,7 +2041,7 @@
// Received ACK for packets 1 and 2.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2397,7 +2394,7 @@
// Received ACK for packets 1 and 2.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2467,7 +2464,7 @@
// Received ACK for packets 1 and 2.
uint64_t acked[] = {1, 2};
- ExpectAcksAndLosses(true, acked, ABSL_ARRAYSIZE(acked), nullptr, 0);
+ ExpectAcksAndLosses(true, acked, std::size(acked), nullptr, 0);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
clock_.Now());
manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3));
@@ -2712,8 +2709,8 @@
EXPECT_NE(QuicTime::Zero(), manager_.GetRetransmissionTime());
uint64_t acked[] = {1};
- ExpectAcksAndLosses(/*rtt_updated=*/false, acked, ABSL_ARRAYSIZE(acked),
- nullptr, 0);
+ ExpectAcksAndLosses(/*rtt_updated=*/false, acked, std::size(acked), nullptr,
+ 0);
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(90));
manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
clock_.Now());
diff --git a/quiche/quic/core/quic_socket_address_coder_test.cc b/quiche/quic/core/quic_socket_address_coder_test.cc
index 32f3570..cdedf63 100644
--- a/quiche/quic/core/quic_socket_address_coder_test.cc
+++ b/quiche/quic/core/quic_socket_address_coder_test.cc
@@ -4,6 +4,7 @@
#include "quiche/quic/core/quic_socket_address_coder.h"
+#include <iterator>
#include <string>
#include "absl/base/macros.h"
@@ -113,7 +114,7 @@
{"::1", 65534},
};
- for (size_t i = 0; i < ABSL_ARRAYSIZE(test_case); i++) {
+ for (size_t i = 0; i < std::size(test_case); i++) {
QuicIpAddress ip;
ASSERT_TRUE(ip.FromString(test_case[i].ip_literal));
QuicSocketAddressCoder encoder(QuicSocketAddress(ip, test_case[i].port));
diff --git a/quiche/quic/core/quic_stream_sequencer_test.cc b/quiche/quic/core/quic_stream_sequencer_test.cc
index dc73a37..0b4d30e 100644
--- a/quiche/quic/core/quic_stream_sequencer_test.cc
+++ b/quiche/quic/core/quic_stream_sequencer_test.cc
@@ -6,6 +6,7 @@
#include <algorithm>
#include <cstdint>
+#include <iterator>
#include <memory>
#include <string>
#include <utility>
@@ -57,7 +58,7 @@
public:
void ConsumeData(size_t num_bytes) {
char buffer[1024];
- ASSERT_GT(ABSL_ARRAYSIZE(buffer), num_bytes);
+ ASSERT_GT(std::size(buffer), num_bytes);
struct iovec iov;
iov.iov_base = buffer;
iov.iov_len = num_bytes;
@@ -99,8 +100,7 @@
bool VerifyReadableRegions(const QuicStreamSequencer& sequencer,
const std::vector<std::string>& expected) {
iovec iovecs[5];
- size_t num_iovecs =
- sequencer.GetReadableRegions(iovecs, ABSL_ARRAYSIZE(iovecs));
+ size_t num_iovecs = sequencer.GetReadableRegions(iovecs, std::size(iovecs));
return VerifyReadableRegion(sequencer, expected) &&
VerifyIovecs(sequencer, iovecs, num_iovecs, expected);
}
@@ -390,7 +390,7 @@
using FrameList = std::vector<Frame>;
void CreateFrames() {
- int payload_size = ABSL_ARRAYSIZE(kPayload) - 1;
+ int payload_size = std::size(kPayload) - 1;
int remaining_payload = payload_size;
while (remaining_payload != 0) {
int size = std::min(OneToN(6), remaining_payload);
@@ -413,10 +413,10 @@
void ReadAvailableData() {
// Read all available data
- char output[ABSL_ARRAYSIZE(kPayload) + 1];
+ char output[std::size(kPayload) + 1];
iovec iov;
iov.iov_base = output;
- iov.iov_len = ABSL_ARRAYSIZE(output);
+ iov.iov_len = std::size(output);
int bytes_read = sequencer_->Readv(&iov, 1);
EXPECT_NE(0, bytes_read);
output_.append(output, bytes_read);
@@ -451,9 +451,9 @@
list_.erase(list_.begin() + index);
}
- ASSERT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, output_.size());
+ ASSERT_EQ(std::size(kPayload) - 1, output_.size());
EXPECT_EQ(kPayload, output_);
- EXPECT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
+ EXPECT_EQ(std::size(kPayload) - 1, total_bytes_consumed);
}
TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingBackup) {
@@ -472,7 +472,7 @@
total_bytes_consumed += bytes;
});
- while (output_.size() != ABSL_ARRAYSIZE(kPayload) - 1) {
+ while (output_.size() != std::size(kPayload) - 1) {
if (!list_.empty() && OneToN(2) == 1) { // Send data
int index = OneToN(list_.size()) - 1;
OnFrame(list_[index].first, list_[index].second.data());
@@ -488,7 +488,7 @@
ASSERT_EQ(0, iovs_peeked);
ASSERT_FALSE(sequencer_->GetReadableRegion(peek_iov));
}
- int total_bytes_to_peek = ABSL_ARRAYSIZE(buffer);
+ int total_bytes_to_peek = std::size(buffer);
for (int i = 0; i < iovs_peeked; ++i) {
int bytes_to_peek =
std::min<int>(peek_iov[i].iov_len, total_bytes_to_peek);
@@ -505,7 +505,7 @@
}
EXPECT_EQ(std::string(kPayload), output_);
EXPECT_EQ(std::string(kPayload), peeked_);
- EXPECT_EQ(ABSL_ARRAYSIZE(kPayload) - 1, total_bytes_consumed);
+ EXPECT_EQ(std::size(kPayload) - 1, total_bytes_consumed);
}
// Same as above, just using a different method for reading.
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index fc216c8..380d8b6 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -6,6 +6,7 @@
#include <cmath>
#include <cstddef>
+#include <iterator>
#include <memory>
#include <optional>
#include <string>
@@ -86,7 +87,7 @@
void ConsumeData(size_t num_bytes) {
char buffer[1024];
- ASSERT_GT(ABSL_ARRAYSIZE(buffer), num_bytes);
+ ASSERT_GT(std::size(buffer), num_bytes);
struct iovec iov;
iov.iov_base = buffer;
iov.iov_len = num_bytes;
diff --git a/quiche/quic/core/quic_unacked_packet_map_test.cc b/quiche/quic/core/quic_unacked_packet_map_test.cc
index a94e006..bbcf9b8 100644
--- a/quiche/quic/core/quic_unacked_packet_map_test.cc
+++ b/quiche/quic/core/quic_unacked_packet_map_test.cc
@@ -8,6 +8,7 @@
#include <cstddef>
#include <cstdint>
+#include <iterator>
#include <limits>
#include <vector>
@@ -195,7 +196,7 @@
ECN_NOT_ECT);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
VerifyInFlightPackets(nullptr, 0);
VerifyRetransmittablePackets(nullptr, 0);
@@ -212,18 +213,18 @@
ECN_NOT_ECT);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyRetransmittablePackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
+ VerifyRetransmittablePackets(unacked, std::size(unacked));
unacked_packets_.RemoveRetransmittability(QuicPacketNumber(1));
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(1));
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
@@ -239,15 +240,14 @@
ECN_NOT_ECT);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
uint64_t retransmittable[] = {1};
- VerifyRetransmittablePackets(retransmittable,
- ABSL_ARRAYSIZE(retransmittable));
+ VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
}
@@ -258,16 +258,14 @@
ECN_NOT_ECT);
uint64_t unacked[] = {1};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
uint64_t retransmittable[] = {1};
- VerifyRetransmittablePackets(retransmittable,
- ABSL_ARRAYSIZE(retransmittable));
+ VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyRetransmittablePackets(retransmittable,
- ABSL_ARRAYSIZE(retransmittable));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
+ VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
}
TEST_P(QuicUnackedPacketMapTest, StopRetransmissionAfterRetransmission) {
@@ -278,14 +276,14 @@
RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
std::vector<uint64_t> retransmittable = {1, 2};
VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
}
@@ -298,26 +296,26 @@
RetransmitAndSendPacket(1, 2, LOSS_RETRANSMISSION);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
std::vector<uint64_t> retransmittable = {1, 2};
VerifyRetransmittablePackets(&retransmittable[0], retransmittable.size());
EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false));
unacked_packets_.RemoveRetransmittability(QuicPacketNumber(1));
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
uint64_t unacked2[] = {1};
- VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
- VerifyInFlightPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, std::size(unacked2));
+ VerifyInFlightPackets(unacked2, std::size(unacked2));
VerifyRetransmittablePackets(nullptr, 0);
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
@@ -336,11 +334,10 @@
ECN_NOT_ECT);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
uint64_t retransmittable[] = {1, 2};
- VerifyRetransmittablePackets(retransmittable,
- ABSL_ARRAYSIZE(retransmittable));
+ VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
// Early retransmit 1 as 3 and send new data as 4.
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
@@ -353,9 +350,9 @@
ECN_NOT_ECT);
uint64_t unacked2[] = {1, 3, 4};
- VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, std::size(unacked2));
uint64_t pending2[] = {3, 4};
- VerifyInFlightPackets(pending2, ABSL_ARRAYSIZE(pending2));
+ VerifyInFlightPackets(pending2, std::size(pending2));
std::vector<uint64_t> retransmittable2 = {1, 3, 4};
VerifyRetransmittablePackets(&retransmittable2[0], retransmittable2.size());
@@ -373,7 +370,7 @@
VerifyUnackedPackets(&unacked3[0], unacked3.size());
VerifyRetransmittablePackets(&retransmittable3[0], retransmittable3.size());
uint64_t pending3[] = {3, 5, 6};
- VerifyInFlightPackets(pending3, ABSL_ARRAYSIZE(pending3));
+ VerifyInFlightPackets(pending3, std::size(pending3));
// Early retransmit 5 as 7 and ensure in flight packet 3 is not removed.
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(6));
@@ -386,13 +383,13 @@
VerifyUnackedPackets(&unacked4[0], unacked4.size());
VerifyRetransmittablePackets(&retransmittable4[0], retransmittable4.size());
uint64_t pending4[] = {3, 5, 7};
- VerifyInFlightPackets(pending4, ABSL_ARRAYSIZE(pending4));
+ VerifyInFlightPackets(pending4, std::size(pending4));
// Remove the older two transmissions from in flight.
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
unacked_packets_.RemoveFromInFlight(QuicPacketNumber(5));
uint64_t pending5[] = {7};
- VerifyInFlightPackets(pending5, ABSL_ARRAYSIZE(pending5));
+ VerifyInFlightPackets(pending5, std::size(pending5));
}
TEST_P(QuicUnackedPacketMapTest, RetransmitFourTimes) {
@@ -405,11 +402,10 @@
ECN_NOT_ECT);
uint64_t unacked[] = {1, 2};
- VerifyUnackedPackets(unacked, ABSL_ARRAYSIZE(unacked));
- VerifyInFlightPackets(unacked, ABSL_ARRAYSIZE(unacked));
+ VerifyUnackedPackets(unacked, std::size(unacked));
+ VerifyInFlightPackets(unacked, std::size(unacked));
uint64_t retransmittable[] = {1, 2};
- VerifyRetransmittablePackets(retransmittable,
- ABSL_ARRAYSIZE(retransmittable));
+ VerifyRetransmittablePackets(retransmittable, std::size(retransmittable));
// Early retransmit 1 as 3.
unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
@@ -419,9 +415,9 @@
RetransmitAndSendPacket(1, 3, LOSS_RETRANSMISSION);
uint64_t unacked2[] = {1, 3};
- VerifyUnackedPackets(unacked2, ABSL_ARRAYSIZE(unacked2));
+ VerifyUnackedPackets(unacked2, std::size(unacked2));
uint64_t pending2[] = {3};
- VerifyInFlightPackets(pending2, ABSL_ARRAYSIZE(pending2));
+ VerifyInFlightPackets(pending2, std::size(pending2));
std::vector<uint64_t> retransmittable2 = {1, 3};
VerifyRetransmittablePackets(&retransmittable2[0], retransmittable2.size());
@@ -432,9 +428,9 @@
ECN_NOT_ECT);
uint64_t unacked3[] = {1, 3, 4, 5};
- VerifyUnackedPackets(unacked3, ABSL_ARRAYSIZE(unacked3));
+ VerifyUnackedPackets(unacked3, std::size(unacked3));
uint64_t pending3[] = {3, 4, 5};
- VerifyInFlightPackets(pending3, ABSL_ARRAYSIZE(pending3));
+ VerifyInFlightPackets(pending3, std::size(pending3));
std::vector<uint64_t> retransmittable3 = {1, 3, 4, 5};
VerifyRetransmittablePackets(&retransmittable3[0], retransmittable3.size());
@@ -449,7 +445,7 @@
std::vector<uint64_t> unacked4 = {4, 6};
VerifyUnackedPackets(&unacked4[0], unacked4.size());
uint64_t pending4[] = {6};
- VerifyInFlightPackets(pending4, ABSL_ARRAYSIZE(pending4));
+ VerifyInFlightPackets(pending4, std::size(pending4));
std::vector<uint64_t> retransmittable4 = {4, 6};
VerifyRetransmittablePackets(&retransmittable4[0], retransmittable4.size());
}
diff --git a/quiche/quic/core/quic_utils_test.cc b/quiche/quic/core/quic_utils_test.cc
index 65e98b2..54a798c 100644
--- a/quiche/quic/core/quic_utils_test.cc
+++ b/quiche/quic/core/quic_utils_test.cc
@@ -4,6 +4,7 @@
#include "quiche/quic/core/quic_utils.h"
+#include <iterator>
#include <string>
#include <vector>
@@ -172,10 +173,10 @@
QuicConnectionId connection_id = QuicUtils::CreateRandomConnectionId(&random);
EXPECT_EQ(connection_id.length(), sizeof(uint64_t));
char connection_id_bytes[sizeof(uint64_t)];
- random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
+ random.RandBytes(connection_id_bytes, std::size(connection_id_bytes));
EXPECT_EQ(connection_id,
QuicConnectionId(static_cast<char*>(connection_id_bytes),
- ABSL_ARRAYSIZE(connection_id_bytes)));
+ std::size(connection_id_bytes)));
EXPECT_NE(connection_id, EmptyQuicConnectionId());
EXPECT_NE(connection_id, TestConnectionId());
EXPECT_NE(connection_id, TestConnectionId(1));
@@ -191,10 +192,10 @@
QuicUtils::CreateRandomConnectionId(connection_id_length, &random);
EXPECT_EQ(connection_id.length(), connection_id_length);
char connection_id_bytes[connection_id_length];
- random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
+ random.RandBytes(connection_id_bytes, std::size(connection_id_bytes));
EXPECT_EQ(connection_id,
QuicConnectionId(static_cast<char*>(connection_id_bytes),
- ABSL_ARRAYSIZE(connection_id_bytes)));
+ std::size(connection_id_bytes)));
EXPECT_NE(connection_id, EmptyQuicConnectionId());
EXPECT_NE(connection_id, TestConnectionId());
EXPECT_NE(connection_id, TestConnectionId(1));
diff --git a/quiche/quic/core/quic_versions_test.cc b/quiche/quic/core/quic_versions_test.cc
index 0d4af51..46f0f59 100644
--- a/quiche/quic/core/quic_versions_test.cc
+++ b/quiche/quic/core/quic_versions_test.cc
@@ -5,6 +5,7 @@
#include "quiche/quic/core/quic_versions.h"
#include <cstddef>
+#include <iterator>
#include <sstream>
#include <string>
@@ -256,7 +257,7 @@
QuicTransportVersion single_version[] = {QUIC_VERSION_46};
QuicTransportVersionVector versions_vector;
- for (size_t i = 0; i < ABSL_ARRAYSIZE(single_version); ++i) {
+ for (size_t i = 0; i < std::size(single_version); ++i) {
versions_vector.push_back(single_version[i]);
}
EXPECT_EQ("QUIC_VERSION_46",
@@ -265,7 +266,7 @@
QuicTransportVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED,
QUIC_VERSION_46};
versions_vector.clear();
- for (size_t i = 0; i < ABSL_ARRAYSIZE(multiple_versions); ++i) {
+ for (size_t i = 0; i < std::size(multiple_versions); ++i) {
versions_vector.push_back(multiple_versions[i]);
}
EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46",
diff --git a/quiche/quic/core/tls_client_handshaker_test.cc b/quiche/quic/core/tls_client_handshaker_test.cc
index 251183b..7c63be1 100644
--- a/quiche/quic/core/tls_client_handshaker_test.cc
+++ b/quiche/quic/core/tls_client_handshaker_test.cc
@@ -5,6 +5,7 @@
#include <algorithm>
#include <cstddef>
#include <cstdint>
+#include <iterator>
#include <memory>
#include <optional>
#include <string>
@@ -381,7 +382,7 @@
};
stream()->crypto_message_parser()->ProcessInput(
absl::string_view(bogus_handshake_message,
- ABSL_ARRAYSIZE(bogus_handshake_message)),
+ std::size(bogus_handshake_message)),
ENCRYPTION_INITIAL);
EXPECT_FALSE(stream()->one_rtt_keys_available());
diff --git a/quiche/quic/core/tls_server_handshaker_test.cc b/quiche/quic/core/tls_server_handshaker_test.cc
index cfd9a00..5abadfc 100644
--- a/quiche/quic/core/tls_server_handshaker_test.cc
+++ b/quiche/quic/core/tls_server_handshaker_test.cc
@@ -7,6 +7,7 @@
#include <algorithm>
#include <cstddef>
#include <cstdint>
+#include <iterator>
#include <memory>
#include <optional>
#include <string>
@@ -1044,7 +1045,7 @@
QuicConnection::ScopedPacketFlusher flusher(server_connection_);
server_stream()->crypto_message_parser()->ProcessInput(
absl::string_view(bogus_handshake_message,
- ABSL_ARRAYSIZE(bogus_handshake_message)),
+ std::size(bogus_handshake_message)),
ENCRYPTION_INITIAL);
EXPECT_FALSE(server_stream()->one_rtt_keys_available());
@@ -1646,7 +1647,7 @@
{true},
{false},
};
- for (size_t i = 0; i < ABSL_ARRAYSIZE(tests); i++) {
+ for (size_t i = 0; i < std::size(tests); i++) {
SCOPED_TRACE(absl::StrCat("Test #", i));
const auto& test = tests[i];
client_crypto_config_->set_alps_use_new_codepoint(
