[quic] Clean up single-arg `testing::Invoke()`s in `{moqt,qbone,tools}/`
Deprecated by cl/795969677. This CL should be a no-op.
PiperOrigin-RevId: 803196136
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index c328160..e57c1f4 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -49,7 +49,6 @@
using ::quic::test::MemSliceFromString;
using ::testing::_;
-using ::testing::Invoke;
using ::testing::Return;
using ::testing::StrictMock;
@@ -201,36 +200,36 @@
.WillOnce(Return(stream))
.WillOnce(Return(nullptr));
EXPECT_CALL(*stream, SetVisitor(_))
- .WillOnce(Invoke(
+ .WillOnce(
[&](std::unique_ptr<webtransport::StreamVisitor> new_visitor) {
visitor = std::move(new_visitor);
- }));
- EXPECT_CALL(*stream, visitor()).WillRepeatedly(Invoke([&]() {
+ });
+ EXPECT_CALL(*stream, visitor()).WillRepeatedly([&]() {
return visitor.get();
- }));
+ });
}
- EXPECT_CALL(*stream, PeekNextReadableRegion()).WillRepeatedly(Invoke([&]() {
+ EXPECT_CALL(*stream, PeekNextReadableRegion()).WillRepeatedly([&]() {
return quiche::ReadStream::PeekResult(
absl::string_view(buffer.data() + data_read,
buffer.size() - data_read),
fin && data_read == buffer.size(), fin);
- }));
- EXPECT_CALL(*stream, ReadableBytes()).WillRepeatedly(Invoke([&]() {
+ });
+ EXPECT_CALL(*stream, ReadableBytes()).WillRepeatedly([&]() {
return buffer.size() - data_read;
- }));
+ });
EXPECT_CALL(*stream, Read(testing::An<absl::Span<char>>()))
- .WillRepeatedly(Invoke([&](absl::Span<char> bytes_to_read) {
+ .WillRepeatedly([&](absl::Span<char> bytes_to_read) {
size_t read_size =
std::min(bytes_to_read.size(), buffer.size() - data_read);
memcpy(bytes_to_read.data(), buffer.data() + data_read, read_size);
data_read += read_size;
return quiche::ReadStream::ReadResult(
read_size, fin && data_read == buffer.size());
- }));
- EXPECT_CALL(*stream, SkipBytes(_)).WillRepeatedly(Invoke([&](size_t bytes) {
+ });
+ EXPECT_CALL(*stream, SkipBytes(_)).WillRepeatedly([&](size_t bytes) {
data_read += bytes;
return fin && data_read == buffer.size();
- }));
+ });
EXPECT_CALL(*track_visitor, OnObjectFragment).Times(1);
if (visitor == nullptr) {
session_.OnIncomingUnidirectionalStreamAvailable();
@@ -535,14 +534,14 @@
MoqtSubscribe request = DefaultSubscribe();
MockTrackPublisher* track = CreateTrackPublisher();
EXPECT_CALL(*track, AddObjectListener)
- .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+ .WillOnce([&](MoqtObjectListener* listener) {
EXPECT_CALL(
mock_stream_,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _));
EXPECT_CALL(*track, RemoveObjectListener);
listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
RequestErrorCode::kInternalError, "Test error"));
- }));
+ });
stream_input->OnSubscribeMessage(request);
EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId),
nullptr);
@@ -2323,10 +2322,9 @@
EXPECT_CALL(session, OpenOutgoingUnidirectionalStream())
.WillOnce(Return(&data_stream));
EXPECT_CALL(data_stream, SetVisitor)
- .WillOnce(
- Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
- stream_visitor = std::move(visitor);
- }));
+ .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+ stream_visitor = std::move(visitor);
+ });
EXPECT_CALL(data_stream, SetPriority).Times(1);
}
@@ -2343,7 +2341,7 @@
QUICHE_DCHECK(second_result != MoqtFetchTask::GetNextObjectResult::kSuccess);
EXPECT_CALL(data_stream, CanWrite).WillRepeatedly(Return(true));
EXPECT_CALL(*fetch_task, GetNextObject)
- .WillOnce(Invoke([=](PublishedObject& output) {
+ .WillOnce([=](PublishedObject& output) {
output.metadata.location = location;
output.metadata.subgroup = 0;
output.metadata.status = status;
@@ -2351,38 +2349,37 @@
output.payload = quiche::QuicheMemSlice::Copy(payload);
output.fin_after_this = true; // should be ignored.
return MoqtFetchTask::GetNextObjectResult::kSuccess;
- }))
- .WillOnce(
- Invoke([=](PublishedObject& /*output*/) { return second_result; }));
+ })
+ .WillOnce([=](PublishedObject& /*output*/) { return second_result; });
if (second_result == MoqtFetchTask::GetNextObjectResult::kEof) {
EXPECT_CALL(data_stream, Writev)
- .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
- const quiche::StreamWriteOptions& options) {
+ .WillOnce([](absl::Span<quiche::QuicheMemSlice> data,
+ const quiche::StreamWriteOptions& options) {
quic::QuicDataReader reader(data[0].AsStringView());
uint64_t type;
EXPECT_TRUE(reader.ReadVarInt62(&type));
EXPECT_EQ(type, MoqtDataStreamType::Fetch().value());
EXPECT_FALSE(options.send_fin()); // fin_after_this is ignored.
return absl::OkStatus();
- }))
- .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
- const quiche::StreamWriteOptions& options) {
+ })
+ .WillOnce([](absl::Span<quiche::QuicheMemSlice> data,
+ const quiche::StreamWriteOptions& options) {
EXPECT_TRUE(data.empty());
EXPECT_TRUE(options.send_fin());
return absl::OkStatus();
- }));
+ });
return;
}
EXPECT_CALL(data_stream, Writev)
- .WillOnce(Invoke([](absl::Span<quiche::QuicheMemSlice> data,
- const quiche::StreamWriteOptions& options) {
+ .WillOnce([](absl::Span<quiche::QuicheMemSlice> data,
+ const quiche::StreamWriteOptions& options) {
quic::QuicDataReader reader(data[0].AsStringView());
uint64_t type;
EXPECT_TRUE(reader.ReadVarInt62(&type));
EXPECT_EQ(type, MoqtDataStreamType::Fetch().value());
EXPECT_FALSE(options.send_fin()); // fin_after_this is ignored.
return absl::OkStatus();
- }));
+ });
if (second_result == MoqtFetchTask::GetNextObjectResult::kError) {
EXPECT_CALL(data_stream, ResetWithUserCode);
}
@@ -3158,14 +3155,13 @@
.WillRepeatedly(Return(kOutgoingUniStreamId));
std::unique_ptr<webtransport::StreamVisitor> stream_visitor;
EXPECT_CALL(data_mock, SetVisitor(_))
- .WillOnce(
- Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
- stream_visitor = std::move(visitor);
- }));
+ .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+ stream_visitor = std::move(visitor);
+ });
EXPECT_CALL(data_mock, CanWrite()).WillRepeatedly(Return(true));
- EXPECT_CALL(data_mock, visitor()).WillRepeatedly(Invoke([&]() {
+ EXPECT_CALL(data_mock, visitor()).WillRepeatedly([&]() {
return stream_visitor.get();
- }));
+ });
EXPECT_CALL(*track_publisher, GetCachedObject)
.WillOnce(
Return(PublishedObject{PublishedObjectMetadata{
@@ -3178,9 +3174,9 @@
},
quiche::QuicheMemSlice(), false}));
EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout))
- .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+ .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
stream_visitor.reset();
- }));
+ });
// Arrival time is very old; reset immediately.
ON_CALL(*track_publisher, largest_location)
.WillByDefault(Return(Location(0, 0)));
@@ -3227,14 +3223,13 @@
.WillRepeatedly(Return(kOutgoingUniStreamId));
std::unique_ptr<webtransport::StreamVisitor> stream_visitor;
EXPECT_CALL(data_mock, SetVisitor(_))
- .WillOnce(
- Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
- stream_visitor = std::move(visitor);
- }));
+ .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+ stream_visitor = std::move(visitor);
+ });
EXPECT_CALL(data_mock, CanWrite()).WillRepeatedly(Return(true));
- EXPECT_CALL(data_mock, visitor()).WillRepeatedly(Invoke([&]() {
+ EXPECT_CALL(data_mock, visitor()).WillRepeatedly([&]() {
return stream_visitor.get();
- }));
+ });
EXPECT_CALL(*track_publisher, GetCachedObject)
.WillOnce(Return(PublishedObject{
PublishedObjectMetadata{Location(0, 0), 0,
@@ -3251,9 +3246,9 @@
auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
MoqtSessionPeer::GetAlarm(stream_visitor.get()));
EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout))
- .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+ .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
stream_visitor.reset();
- }));
+ });
delivery_alarm->Fire();
}
@@ -3281,14 +3276,13 @@
.WillRepeatedly(Return(&data_mock));
std::unique_ptr<webtransport::StreamVisitor> stream_visitor;
EXPECT_CALL(data_mock, SetVisitor(_))
- .WillOnce(
- Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
- stream_visitor = std::move(visitor);
- }));
+ .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+ stream_visitor = std::move(visitor);
+ });
EXPECT_CALL(data_mock, CanWrite()).WillRepeatedly(Return(true));
- EXPECT_CALL(data_mock, visitor()).WillRepeatedly(Invoke([&]() {
+ EXPECT_CALL(data_mock, visitor()).WillRepeatedly([&]() {
return stream_visitor.get();
- }));
+ });
EXPECT_CALL(*track_publisher, GetCachedObject)
.WillOnce(Return(PublishedObject{
PublishedObjectMetadata{Location(0, 0), 0,
@@ -3307,9 +3301,9 @@
auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
MoqtSessionPeer::GetAlarm(stream_visitor.get()));
EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout))
- .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+ .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
stream_visitor.reset();
- }));
+ });
delivery_alarm->Fire();
}
@@ -3338,14 +3332,13 @@
.WillRepeatedly(Return(&data_mock1));
std::unique_ptr<webtransport::StreamVisitor> stream_visitor1;
EXPECT_CALL(data_mock1, SetVisitor(_))
- .WillOnce(
- Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
- stream_visitor1 = std::move(visitor);
- }));
+ .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+ stream_visitor1 = std::move(visitor);
+ });
EXPECT_CALL(data_mock1, CanWrite()).WillRepeatedly(Return(true));
- EXPECT_CALL(data_mock1, visitor()).WillRepeatedly(Invoke([&]() {
+ EXPECT_CALL(data_mock1, visitor()).WillRepeatedly([&]() {
return stream_visitor1.get();
- }));
+ });
EXPECT_CALL(*track_publisher, GetCachedObject)
.WillOnce(Return(PublishedObject{
PublishedObjectMetadata{Location(0, 0), 0,
@@ -3368,14 +3361,13 @@
.WillRepeatedly(Return(&data_mock2));
std::unique_ptr<webtransport::StreamVisitor> stream_visitor2;
EXPECT_CALL(data_mock2, SetVisitor(_))
- .WillOnce(
- Invoke([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
- stream_visitor2 = std::move(visitor);
- }));
+ .WillOnce([&](std::unique_ptr<webtransport::StreamVisitor> visitor) {
+ stream_visitor2 = std::move(visitor);
+ });
EXPECT_CALL(data_mock2, CanWrite()).WillRepeatedly(Return(true));
- EXPECT_CALL(data_mock2, visitor()).WillRepeatedly(Invoke([&]() {
+ EXPECT_CALL(data_mock2, visitor()).WillRepeatedly([&]() {
return stream_visitor2.get();
- }));
+ });
EXPECT_CALL(*track_publisher, GetCachedObject)
.WillOnce(Return(PublishedObject{
PublishedObjectMetadata{Location(1, 0), 0,
@@ -3393,9 +3385,9 @@
auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
MoqtSessionPeer::GetAlarm(stream_visitor1.get()));
EXPECT_CALL(data_mock1, ResetWithUserCode(kResetCodeDeliveryTimeout))
- .WillOnce(Invoke([&](webtransport::StreamErrorCode /*error*/) {
+ .WillOnce([&](webtransport::StreamErrorCode /*error*/) {
stream_visitor1.reset();
- }));
+ });
delivery_alarm->Fire();
}
@@ -3850,7 +3842,7 @@
MoqtTrackStatus track_status = DefaultSubscribe();
EXPECT_CALL(*track, AddObjectListener)
- .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+ .WillOnce([&](MoqtObjectListener* listener) {
EXPECT_CALL(*track, expiration)
.WillRepeatedly(
Return(quic::QuicTimeDelta::FromMilliseconds(10000)));
@@ -3868,7 +3860,7 @@
Writev(SerializedControlMessage(expected_ok), _));
EXPECT_CALL(*track, RemoveObjectListener);
listener->OnSubscribeAccepted();
- }));
+ });
stream_input->OnTrackStatusMessage(track_status);
}
@@ -3909,7 +3901,7 @@
MoqtTrackStatus track_status = DefaultSubscribe();
bool executed_AddObjectListener = false;
EXPECT_CALL(*track, AddObjectListener)
- .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+ .WillOnce([&](MoqtObjectListener* listener) {
EXPECT_CALL(
control_stream,
Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError),
@@ -3918,7 +3910,7 @@
listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
RequestErrorCode::kInternalError, "Test error"));
executed_AddObjectListener = true;
- }));
+ });
stream_input->OnTrackStatusMessage(track_status);
EXPECT_TRUE(executed_AddObjectListener);
}
diff --git a/quiche/quic/qbone/bonnet/icmp_reachable_test.cc b/quiche/quic/qbone/bonnet/icmp_reachable_test.cc
index 8e43bd0..555aa9f 100644
--- a/quiche/quic/qbone/bonnet/icmp_reachable_test.cc
+++ b/quiche/quic/qbone/bonnet/icmp_reachable_test.cc
@@ -22,7 +22,6 @@
using ::testing::_;
using ::testing::InSequence;
-using ::testing::Invoke;
using ::testing::Return;
using ::testing::StrictMock;
@@ -106,9 +105,9 @@
EXPECT_CALL(kernel_, setsockopt(read_fd_, SOL_ICMPV6, ICMP6_FILTER, _, _));
- EXPECT_CALL(kernel_, close(read_fd_)).WillOnce(Invoke([](int fd) {
+ EXPECT_CALL(kernel_, close(read_fd_)).WillOnce([](int fd) {
return close(fd);
- }));
+ });
}
protected:
@@ -131,13 +130,13 @@
ASSERT_TRUE(reachable.Init());
EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
- .WillOnce(Invoke([](int sockfd, const void* buf, size_t len, int flags,
- const struct sockaddr* dest_addr, socklen_t addrlen) {
+ .WillOnce([](int sockfd, const void* buf, size_t len, int flags,
+ const struct sockaddr* dest_addr, socklen_t addrlen) {
auto icmp_header = GetHeaderFromPacket(buf, len);
EXPECT_EQ(icmp_header.icmp6_type, ICMP6_ECHO_REQUEST);
EXPECT_EQ(icmp_header.icmp6_seq, 1);
return len;
- }));
+ });
event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
EXPECT_FALSE(stats_.HasWriteErrors());
@@ -152,9 +151,9 @@
EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
.Times(2)
- .WillRepeatedly(Invoke([](int sockfd, const void* buf, size_t len,
- int flags, const struct sockaddr* dest_addr,
- socklen_t addrlen) { return len; }));
+ .WillRepeatedly([](int sockfd, const void* buf, size_t len, int flags,
+ const struct sockaddr* dest_addr,
+ socklen_t addrlen) { return len; });
event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
EXPECT_EQ(stats_.unreachable_count(), 0);
@@ -175,25 +174,23 @@
icmp6_hdr last_request_hdr{};
EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
.Times(2)
- .WillRepeatedly(
- Invoke([&last_request_hdr](
- int sockfd, const void* buf, size_t len, int flags,
- const struct sockaddr* dest_addr, socklen_t addrlen) {
- last_request_hdr = GetHeaderFromPacket(buf, len);
- return len;
- }));
+ .WillRepeatedly([&last_request_hdr](
+ int sockfd, const void* buf, size_t len, int flags,
+ const struct sockaddr* dest_addr, socklen_t addrlen) {
+ last_request_hdr = GetHeaderFromPacket(buf, len);
+ return len;
+ });
sockaddr_in6 source_addr{};
std::string packed_source = source_.ToPackedString();
memcpy(&source_addr.sin6_addr, packed_source.data(), packed_source.size());
EXPECT_CALL(kernel_, recvfrom(read_fd_, _, _, _, _, _))
- .WillOnce(
- Invoke([&source_addr](int sockfd, void* buf, size_t len, int flags,
- struct sockaddr* src_addr, socklen_t* addrlen) {
- *reinterpret_cast<sockaddr_in6*>(src_addr) = source_addr;
- return read(sockfd, buf, len);
- }));
+ .WillOnce([&source_addr](int sockfd, void* buf, size_t len, int flags,
+ struct sockaddr* src_addr, socklen_t* addrlen) {
+ *reinterpret_cast<sockaddr_in6*>(src_addr) = source_addr;
+ return read(sockfd, buf, len);
+ });
event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
EXPECT_EQ(stats_.reachable_count(), 0);
@@ -219,11 +216,11 @@
ASSERT_TRUE(reachable.Init());
EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
- .WillOnce(Invoke([](int sockfd, const void* buf, size_t len, int flags,
- const struct sockaddr* dest_addr, socklen_t addrlen) {
+ .WillOnce([](int sockfd, const void* buf, size_t len, int flags,
+ const struct sockaddr* dest_addr, socklen_t addrlen) {
errno = EAGAIN;
return 0;
- }));
+ });
event_loop_->RunEventLoopOnce(QuicTime::Delta::FromSeconds(1));
EXPECT_EQ(stats_.WriteErrorCount(EAGAIN), 1);
@@ -237,16 +234,16 @@
ASSERT_TRUE(reachable.Init());
EXPECT_CALL(kernel_, sendto(kFakeWriteFd, _, _, _, _, _))
- .WillOnce(Invoke([](int sockfd, const void* buf, size_t len, int flags,
- const struct sockaddr* dest_addr,
- socklen_t addrlen) { return len; }));
+ .WillOnce([](int sockfd, const void* buf, size_t len, int flags,
+ const struct sockaddr* dest_addr,
+ socklen_t addrlen) { return len; });
EXPECT_CALL(kernel_, recvfrom(read_fd_, _, _, _, _, _))
- .WillOnce(Invoke([](int sockfd, void* buf, size_t len, int flags,
- struct sockaddr* src_addr, socklen_t* addrlen) {
+ .WillOnce([](int sockfd, void* buf, size_t len, int flags,
+ struct sockaddr* src_addr, socklen_t* addrlen) {
errno = EIO;
return -1;
- }));
+ });
icmp6_hdr response{};
diff --git a/quiche/quic/qbone/bonnet/tun_device_controller_test.cc b/quiche/quic/qbone/bonnet/tun_device_controller_test.cc
index 58a57d0..863e0c9 100644
--- a/quiche/quic/qbone/bonnet/tun_device_controller_test.cc
+++ b/quiche/quic/qbone/bonnet/tun_device_controller_test.cc
@@ -35,7 +35,6 @@
constexpr int kOldPrefixLen = 24;
using ::testing::_;
-using ::testing::Invoke;
using ::testing::Return;
using ::testing::StrictMock;
@@ -56,11 +55,11 @@
protected:
void ExpectLinkInfo(const std::string& interface_name, int ifindex) {
EXPECT_CALL(netlink_, GetLinkInfo(interface_name, _))
- .WillOnce(Invoke([ifindex](absl::string_view ifname,
- NetlinkInterface::LinkInfo* link_info) {
+ .WillOnce([ifindex](absl::string_view ifname,
+ NetlinkInterface::LinkInfo* link_info) {
link_info->index = ifindex;
return true;
- }));
+ });
}
MockNetlink netlink_;
@@ -90,15 +89,15 @@
ExpectLinkInfo(kIfname, kIfindex);
EXPECT_CALL(netlink_, GetAddresses(kIfindex, _, _, _))
- .WillOnce(Invoke([](int interface_index, uint8_t unwanted_flags,
- std::vector<NetlinkInterface::AddressInfo>* addresses,
- int* num_ipv6_nodad_dadfailed_addresses) {
+ .WillOnce([](int interface_index, uint8_t unwanted_flags,
+ std::vector<NetlinkInterface::AddressInfo>* addresses,
+ int* num_ipv6_nodad_dadfailed_addresses) {
NetlinkInterface::AddressInfo info{};
info.interface_address.FromString(kOldAddress);
info.prefix_length = kOldPrefixLen;
addresses->emplace_back(info);
return true;
- }));
+ });
QuicIpAddress old_address;
old_address.FromString(kOldAddress);
@@ -124,26 +123,25 @@
const int num_matching_routes = 3;
EXPECT_CALL(netlink_, GetRouteInfo(_))
- .WillOnce(
- Invoke([](std::vector<NetlinkInterface::RoutingRule>* routing_rules) {
- NetlinkInterface::RoutingRule non_matching_route{};
- non_matching_route.table = QboneConstants::kQboneRouteTableId;
- non_matching_route.out_interface = kIfindex + 1;
- routing_rules->push_back(non_matching_route);
+ .WillOnce([](std::vector<NetlinkInterface::RoutingRule>* routing_rules) {
+ NetlinkInterface::RoutingRule non_matching_route{};
+ non_matching_route.table = QboneConstants::kQboneRouteTableId;
+ non_matching_route.out_interface = kIfindex + 1;
+ routing_rules->push_back(non_matching_route);
- NetlinkInterface::RoutingRule matching_route{};
- matching_route.table = QboneConstants::kQboneRouteTableId;
- matching_route.out_interface = kIfindex;
- for (int i = 0; i < num_matching_routes; i++) {
- routing_rules->push_back(matching_route);
- }
+ NetlinkInterface::RoutingRule matching_route{};
+ matching_route.table = QboneConstants::kQboneRouteTableId;
+ matching_route.out_interface = kIfindex;
+ for (int i = 0; i < num_matching_routes; i++) {
+ routing_rules->push_back(matching_route);
+ }
- NetlinkInterface::RoutingRule non_matching_table{};
- non_matching_table.table = QboneConstants::kQboneRouteTableId + 1;
- non_matching_table.out_interface = kIfindex;
- routing_rules->push_back(non_matching_table);
- return true;
- }));
+ NetlinkInterface::RoutingRule non_matching_table{};
+ non_matching_table.table = QboneConstants::kQboneRouteTableId + 1;
+ non_matching_table.out_interface = kIfindex;
+ routing_rules->push_back(non_matching_table);
+ return true;
+ });
EXPECT_CALL(netlink_, ChangeRoute(NetlinkInterface::Verb::kRemove,
QboneConstants::kQboneRouteTableId, _, _, _,
diff --git a/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc b/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
index 988b00e..e84a0f1 100644
--- a/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
+++ b/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc
@@ -21,7 +21,6 @@
const int kFd = 15;
using ::testing::_;
-using ::testing::Invoke;
using ::testing::StrEq;
using ::testing::StrictMock;
@@ -53,10 +52,10 @@
TEST_F(TunDevicePacketExchangerTest, WritePacketReturnsFalseOnError) {
std::string packet = "fake packet";
EXPECT_CALL(mock_kernel_, write(kFd, _, packet.size()))
- .WillOnce(Invoke([](int fd, const void* buf, size_t count) {
+ .WillOnce([](int fd, const void* buf, size_t count) {
errno = ECOMM;
return -1;
- }));
+ });
EXPECT_CALL(mock_visitor_, OnWriteError(_));
EXPECT_CALL(mock_visitor_, OnWrite(StrEq(packet))).Times(1);
@@ -67,10 +66,10 @@
WritePacketReturnFalseAndBlockedOnBlockedTunnel) {
std::string packet = "fake packet";
EXPECT_CALL(mock_kernel_, write(kFd, _, packet.size()))
- .WillOnce(Invoke([](int fd, const void* buf, size_t count) {
+ .WillOnce([](int fd, const void* buf, size_t count) {
errno = EAGAIN;
return -1;
- }));
+ });
EXPECT_CALL(mock_stats_, OnWriteError(_)).Times(1);
EXPECT_CALL(mock_visitor_, OnWrite(StrEq(packet))).Times(1);
@@ -80,10 +79,10 @@
TEST_F(TunDevicePacketExchangerTest, WritePacketReturnsTrueOnSuccessfulWrite) {
std::string packet = "fake packet";
EXPECT_CALL(mock_kernel_, write(kFd, _, packet.size()))
- .WillOnce(Invoke([packet](int fd, const void* buf, size_t count) {
+ .WillOnce([packet](int fd, const void* buf, size_t count) {
EXPECT_THAT(reinterpret_cast<const char*>(buf), StrEq(packet));
return count;
- }));
+ });
EXPECT_CALL(mock_stats_, OnPacketWritten(_)).Times(1);
EXPECT_CALL(mock_visitor_, OnWrite(StrEq(packet))).Times(1);
@@ -92,20 +91,20 @@
TEST_F(TunDevicePacketExchangerTest, ReadPacketReturnsNullOnError) {
EXPECT_CALL(mock_kernel_, read(kFd, _, kMtu))
- .WillOnce(Invoke([](int fd, void* buf, size_t count) {
+ .WillOnce([](int fd, void* buf, size_t count) {
errno = ECOMM;
return -1;
- }));
+ });
EXPECT_CALL(mock_visitor_, OnReadError(_));
exchanger_.ReadAndDeliverPacket(&mock_client_);
}
TEST_F(TunDevicePacketExchangerTest, ReadPacketReturnsNullOnBlockedRead) {
EXPECT_CALL(mock_kernel_, read(kFd, _, kMtu))
- .WillOnce(Invoke([](int fd, void* buf, size_t count) {
+ .WillOnce([](int fd, void* buf, size_t count) {
errno = EAGAIN;
return -1;
- }));
+ });
EXPECT_CALL(mock_stats_, OnReadError(_)).Times(1);
EXPECT_FALSE(exchanger_.ReadAndDeliverPacket(&mock_client_));
}
@@ -114,10 +113,10 @@
ReadPacketReturnsThePacketOnSuccessfulRead) {
std::string packet = "fake_packet";
EXPECT_CALL(mock_kernel_, read(kFd, _, kMtu))
- .WillOnce(Invoke([packet](int fd, void* buf, size_t count) {
+ .WillOnce([packet](int fd, void* buf, size_t count) {
memcpy(buf, packet.data(), packet.size());
return packet.size();
- }));
+ });
EXPECT_CALL(mock_client_, ProcessPacketFromNetwork(StrEq(packet)));
EXPECT_CALL(mock_stats_, OnPacketRead(_)).Times(1);
EXPECT_TRUE(exchanger_.ReadAndDeliverPacket(&mock_client_));
diff --git a/quiche/quic/qbone/bonnet/tun_device_test.cc b/quiche/quic/qbone/bonnet/tun_device_test.cc
index cc82a2f..5bb50e1 100644
--- a/quiche/quic/qbone/bonnet/tun_device_test.cc
+++ b/quiche/quic/qbone/bonnet/tun_device_test.cc
@@ -16,7 +16,6 @@
using ::testing::_;
using ::testing::AnyNumber;
-using ::testing::Invoke;
using ::testing::Return;
using ::testing::StrEq;
using ::testing::Unused;
@@ -35,38 +34,38 @@
void SetUp() override {
EXPECT_CALL(mock_kernel_, socket(AF_INET6, _, _))
.Times(AnyNumber())
- .WillRepeatedly(Invoke([this](Unused, Unused, Unused) {
+ .WillRepeatedly([this](Unused, Unused, Unused) {
EXPECT_CALL(mock_kernel_, close(next_fd_)).WillOnce(Return(0));
return next_fd_++;
- }));
+ });
}
// Set the expectations for calling Init().
void SetInitExpectations(int mtu, bool persist) {
EXPECT_CALL(mock_kernel_, open(StrEq("/dev/net/tun"), _))
.Times(AnyNumber())
- .WillRepeatedly(Invoke([this](Unused, Unused) {
+ .WillRepeatedly([this](Unused, Unused) {
EXPECT_CALL(mock_kernel_, close(next_fd_)).WillOnce(Return(0));
return next_fd_++;
- }));
+ });
EXPECT_CALL(mock_kernel_, ioctl(_, TUNGETFEATURES, _))
.Times(AnyNumber())
- .WillRepeatedly(Invoke([](Unused, Unused, void* argp) {
+ .WillRepeatedly([](Unused, Unused, void* argp) {
auto* actual_flags = reinterpret_cast<int*>(argp);
*actual_flags = kSupportedFeatures;
return 0;
- }));
+ });
EXPECT_CALL(mock_kernel_, ioctl(_, TUNSETIFF, _))
.Times(AnyNumber())
- .WillRepeatedly(Invoke([](Unused, Unused, void* argp) {
+ .WillRepeatedly([](Unused, Unused, void* argp) {
auto* ifr = reinterpret_cast<struct ifreq*>(argp);
EXPECT_EQ(IFF_TUN | IFF_MULTI_QUEUE | IFF_NO_PI, ifr->ifr_flags);
EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
return 0;
- }));
+ });
EXPECT_CALL(mock_kernel_, ioctl(_, TUNSETPERSIST, _))
.Times(AnyNumber())
- .WillRepeatedly(Invoke([persist](Unused, Unused, void* argp) {
+ .WillRepeatedly([persist](Unused, Unused, void* argp) {
auto* ifr = reinterpret_cast<struct ifreq*>(argp);
if (persist) {
EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
@@ -74,21 +73,21 @@
EXPECT_EQ(nullptr, ifr);
}
return 0;
- }));
+ });
EXPECT_CALL(mock_kernel_, ioctl(_, SIOCSIFMTU, _))
.Times(AnyNumber())
- .WillRepeatedly(Invoke([mtu](Unused, Unused, void* argp) {
+ .WillRepeatedly([mtu](Unused, Unused, void* argp) {
auto* ifr = reinterpret_cast<struct ifreq*>(argp);
EXPECT_EQ(mtu, ifr->ifr_mtu);
EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
return 0;
- }));
+ });
}
// Expect that Up() will be called. Force the call to fail when fail == true.
void ExpectUp(bool fail) {
EXPECT_CALL(mock_kernel_, ioctl(_, SIOCSIFFLAGS, _))
- .WillOnce(Invoke([fail](Unused, Unused, void* argp) {
+ .WillOnce([fail](Unused, Unused, void* argp) {
auto* ifr = reinterpret_cast<struct ifreq*>(argp);
EXPECT_TRUE(ifr->ifr_flags & IFF_UP);
EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
@@ -97,14 +96,14 @@
} else {
return 0;
}
- }));
+ });
}
// Expect that Down() will be called *after* the interface is up. Force the
// call to fail when fail == true.
void ExpectDown(bool fail) {
EXPECT_CALL(mock_kernel_, ioctl(_, SIOCSIFFLAGS, _))
- .WillOnce(Invoke([fail](Unused, Unused, void* argp) {
+ .WillOnce([fail](Unused, Unused, void* argp) {
auto* ifr = reinterpret_cast<struct ifreq*>(argp);
EXPECT_FALSE(ifr->ifr_flags & IFF_UP);
EXPECT_THAT(ifr->ifr_name, StrEq(kDeviceName));
@@ -113,7 +112,7 @@
} else {
return 0;
}
- }));
+ });
}
MockKernel mock_kernel_;
@@ -154,11 +153,11 @@
TEST_F(TunDeviceTest, TooFewFeature) {
SetInitExpectations(/* mtu = */ 1500, /* persist = */ false);
EXPECT_CALL(mock_kernel_, ioctl(_, TUNGETFEATURES, _))
- .WillOnce(Invoke([](Unused, Unused, void* argp) {
+ .WillOnce([](Unused, Unused, void* argp) {
int* actual_features = reinterpret_cast<int*>(argp);
*actual_features = IFF_TUN | IFF_ONE_QUEUE;
return 0;
- }));
+ });
TunTapDevice tun_device(kDeviceName, 1500, false, true, false, &mock_kernel_);
EXPECT_FALSE(tun_device.Init());
EXPECT_EQ(tun_device.GetFileDescriptor(), -1);
diff --git a/quiche/quic/qbone/platform/netlink_test.cc b/quiche/quic/qbone/platform/netlink_test.cc
index e1f57c5..44f7e86 100644
--- a/quiche/quic/qbone/platform/netlink_test.cc
+++ b/quiche/quic/qbone/platform/netlink_test.cc
@@ -22,7 +22,6 @@
using ::testing::_;
using ::testing::Contains;
using ::testing::InSequence;
-using ::testing::Invoke;
using ::testing::Return;
using ::testing::Unused;
@@ -32,10 +31,10 @@
protected:
NetlinkTest() {
ON_CALL(mock_kernel_, socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE))
- .WillByDefault(Invoke([this](Unused, Unused, Unused) {
+ .WillByDefault([this](Unused, Unused, Unused) {
EXPECT_CALL(mock_kernel_, close(kSocketFd)).WillOnce(Return(0));
return kSocketFd;
- }));
+ });
}
void ExpectNetlinkPacket(
@@ -48,8 +47,8 @@
InSequence s;
EXPECT_CALL(mock_kernel_, sendmsg(kSocketFd, _, _))
- .WillOnce(Invoke([type, flags, send_callback](
- Unused, const struct msghdr* msg, int) {
+ .WillOnce([type, flags, send_callback](Unused, const struct msghdr* msg,
+ int) {
EXPECT_EQ(sizeof(struct sockaddr_nl), msg->msg_namelen);
auto* nl_addr =
reinterpret_cast<const struct sockaddr_nl*>(msg->msg_name);
@@ -80,13 +79,13 @@
QUICHE_CHECK_EQ(seq, -1);
seq = netlink_message->nlmsg_seq;
return buf.size();
- }));
+ });
EXPECT_CALL(mock_kernel_,
recvfrom(kSocketFd, _, 0, MSG_PEEK | MSG_TRUNC, _, _))
- .WillOnce(Invoke([this, recv_callback](Unused, Unused, Unused, Unused,
- struct sockaddr* src_addr,
- socklen_t* addrlen) {
+ .WillOnce([this, recv_callback](Unused, Unused, Unused, Unused,
+ struct sockaddr* src_addr,
+ socklen_t* addrlen) {
auto* nl_addr = reinterpret_cast<struct sockaddr_nl*>(src_addr);
nl_addr->nl_family = AF_NETLINK;
nl_addr->nl_pid = 0; // from kernel
@@ -95,12 +94,12 @@
int ret = recv_callback(reply_packet_, sizeof(reply_packet_), seq);
QUICHE_CHECK_LE(ret, sizeof(reply_packet_));
return ret;
- }));
+ });
EXPECT_CALL(mock_kernel_, recvfrom(kSocketFd, _, _, _, _, _))
- .WillOnce(Invoke([recv_callback](Unused, void* buf, size_t len, Unused,
- struct sockaddr* src_addr,
- socklen_t* addrlen) {
+ .WillOnce([recv_callback](Unused, void* buf, size_t len, Unused,
+ struct sockaddr* src_addr,
+ socklen_t* addrlen) {
auto* nl_addr = reinterpret_cast<struct sockaddr_nl*>(src_addr);
nl_addr->nl_family = AF_NETLINK;
nl_addr->nl_pid = 0; // from kernel
@@ -110,7 +109,7 @@
EXPECT_GE(len, ret);
seq = -1;
return ret;
- }));
+ });
}
char reply_packet_[4096];
diff --git a/quiche/quic/qbone/qbone_packet_processor_test.cc b/quiche/quic/qbone/qbone_packet_processor_test.cc
index ec424e2..b29031d 100644
--- a/quiche/quic/qbone/qbone_packet_processor_test.cc
+++ b/quiche/quic/qbone/qbone_packet_processor_test.cc
@@ -21,7 +21,6 @@
using OutputInterface = QbonePacketProcessor::OutputInterface;
using ::testing::_;
using ::testing::Eq;
-using ::testing::Invoke;
using ::testing::Return;
using ::testing::WithArgs;
@@ -509,8 +508,8 @@
TEST_F(QbonePacketProcessorTest, Icmp6EchoResponseHasRightPayload) {
auto filter = std::make_unique<MockPacketFilter>();
EXPECT_CALL(*filter, FilterPacket(_, _, _, _))
- .WillOnce(WithArgs<2, 3>(
- Invoke([](absl::string_view payload, icmp6_hdr* icmp_header) {
+ .WillOnce(
+ WithArgs<2, 3>([](absl::string_view payload, icmp6_hdr* icmp_header) {
icmp_header->icmp6_type = ICMP6_ECHO_REPLY;
icmp_header->icmp6_code = 0;
auto* request_header =
@@ -518,12 +517,12 @@
icmp_header->icmp6_id = request_header->icmp6_id;
icmp_header->icmp6_seq = request_header->icmp6_seq;
return ProcessingResult::ICMP;
- })));
+ }));
processor_->set_filter(std::move(filter));
EXPECT_CALL(stats_, OnPacketDroppedWithIcmp(Direction::FROM_OFF_NETWORK, _));
EXPECT_CALL(output_, SendPacketToClient(_))
- .WillOnce(Invoke([](absl::string_view packet) {
+ .WillOnce([](absl::string_view packet) {
// Explicit conversion because otherwise it is treated as a null
// terminated string.
absl::string_view expected = absl::string_view(
@@ -532,7 +531,7 @@
EXPECT_THAT(packet, Eq(expected));
QUIC_LOG(INFO) << "ICMP response:\n"
<< quiche::QuicheTextUtils::HexDump(packet);
- }));
+ });
SendPacketFromClient(kReferenceEchoRequest);
}
diff --git a/quiche/quic/qbone/qbone_session_test.cc b/quiche/quic/qbone/qbone_session_test.cc
index 9c943d7..6edeb00 100644
--- a/quiche/quic/qbone/qbone_session_test.cc
+++ b/quiche/quic/qbone/qbone_session_test.cc
@@ -40,7 +40,6 @@
using ::testing::Contains;
using ::testing::ElementsAre;
using ::testing::Eq;
-using ::testing::Invoke;
using ::testing::NiceMock;
using ::testing::Not;
@@ -362,11 +361,11 @@
MockPacketWriter* client_writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(client_peer_->connection()));
ON_CALL(*client_writer, WritePacket(_, _, _, _, _, _))
- .WillByDefault(Invoke([this](const char* buffer, size_t buf_len,
- const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address,
- PerPacketOptions* option,
- const QuicPacketWriterParams& params) {
+ .WillByDefault([this](const char* buffer, size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* option,
+ const QuicPacketWriterParams& params) {
char* copy = new char[1024 * 1024];
memcpy(copy, buffer, buf_len);
runner_.Schedule([this, copy, buf_len] {
@@ -377,15 +376,15 @@
delete[] copy;
});
return WriteResult(WRITE_STATUS_OK, buf_len);
- }));
+ });
MockPacketWriter* server_writer = static_cast<MockPacketWriter*>(
QuicConnectionPeer::GetWriter(server_peer_->connection()));
ON_CALL(*server_writer, WritePacket(_, _, _, _, _, _))
- .WillByDefault(Invoke([this](const char* buffer, size_t buf_len,
- const QuicIpAddress& self_address,
- const QuicSocketAddress& peer_address,
- PerPacketOptions* options,
- const QuicPacketWriterParams& params) {
+ .WillByDefault([this](const char* buffer, size_t buf_len,
+ const QuicIpAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ PerPacketOptions* options,
+ const QuicPacketWriterParams& params) {
char* copy = new char[1024 * 1024];
memcpy(copy, buffer, buf_len);
runner_.Schedule([this, copy, buf_len] {
@@ -396,7 +395,7 @@
delete[] copy;
});
return WriteResult(WRITE_STATUS_OK, buf_len);
- }));
+ });
}
void StartHandshake() {
diff --git a/quiche/quic/tools/quic_simple_server_session_test.cc b/quiche/quic/tools/quic_simple_server_session_test.cc
index d290f81..a9616a0 100644
--- a/quiche/quic/tools/quic_simple_server_session_test.cc
+++ b/quiche/quic/tools/quic_simple_server_session_test.cc
@@ -38,7 +38,6 @@
#include "quiche/quic/tools/quic_simple_server_stream.h"
using testing::_;
-using testing::Invoke;
using testing::StrictMock;
namespace quic {
@@ -117,8 +116,7 @@
StreamSendingState state) {
return QuicConsumedData(write_length, state != NO_FIN);
};
- ON_CALL(*this, SendStreamData(_, _, _, _))
- .WillByDefault(Invoke(consume_all_data));
+ ON_CALL(*this, SendStreamData(_, _, _, _)).WillByDefault(consume_all_data);
}
MOCK_METHOD(QuicConsumedData, SendStreamData,
@@ -209,7 +207,7 @@
if (VersionHasIetfQuicFrames(transport_version())) {
EXPECT_CALL(*session_, WriteControlFrame(_, _))
- .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
+ .WillRepeatedly(&ClearControlFrameWithTransmissionType);
}
session_->OnConfigNegotiated();
}
