signalapp/webrtc
signalapp/webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove ::testing::Invoke usage for lambdas

Browse Source 
Created using gemini-cli.

Bug: webrtc:452541285
Change-Id: I7890f07604859f2ad62f093d9118622a79f49d67
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/417780
Reviewed-by: Henrik Lundin <henrik.lundin@webrtc.org>
Commit-Queue: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#45975}
This commit is contained in:
Ilya Nikolaevskiy 2025-10-17 10:13:55 +00:00 committed by WebRTC LUCI CQ
parent 04b20134ed
commit 47ad4b6918
22 changed files with 189 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
audio/audio_receive_stream_unittest.cc
View File

@ -125,8 +125,6 @@ struct ConfigHelper {
ConfigHelper(scoped_refptr<MockAudioMixer> audio_mixer,
bool use_null_audio_processing)
: audio_mixer_(audio_mixer) {
using ::testing::Invoke;
AudioState::Config config;
config.audio_mixer = audio_mixer_;
config.audio_processing =
@ -146,9 +144,9 @@ struct ConfigHelper {
EXPECT_CALL(*channel_receive_, ResetReceiverCongestionControlObjects())
.Times(1);
EXPECT_CALL(*channel_receive_, SetReceiveCodecs(_))
.WillRepeatedly(Invoke([](const std::map<int, SdpAudioFormat>& codecs) {
.WillRepeatedly([](const std::map<int, SdpAudioFormat>& codecs) {
EXPECT_THAT(codecs, ::testing::IsEmpty());
}));
});
stream_config_.rtp.local_ssrc = kLocalSsrc;
stream_config_.rtp.remote_ssrc = kRemoteSsrc;

17
audio/audio_send_stream_unittest.cc
View File

@ -69,7 +69,6 @@ using ::testing::ElementsAreArray;
using ::testing::Eq;
using ::testing::Field;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::Ne;
using ::testing::NiceMock;
using ::testing::Return;
@ -228,9 +227,9 @@ class ConfigHelper {
void SetupDefaultChannelSend(bool audio_bwe_enabled) {
EXPECT_TRUE(channel_send_ == nullptr);
channel_send_ = new ::testing::StrictMock<MockChannelSend>();
EXPECT_CALL(*channel_send_, GetRtpRtcp()).WillRepeatedly(Invoke([this]() {
EXPECT_CALL(*channel_send_, GetRtpRtcp()).WillRepeatedly([this]() {
return &this->rtp_rtcp_;
}));
});
EXPECT_CALL(rtp_rtcp_, SSRC).WillRepeatedly(Return(kSsrc));
EXPECT_CALL(*channel_send_, SetRTCP_CNAME(StrEq(kCName))).Times(1);
EXPECT_CALL(*channel_send_, SetFrameEncryptor(_)).Times(1);
@ -966,10 +965,10 @@ TEST(AudioSendStreamTest, DefaultsHonorsPriorityBitrate) {
helper.field_trials().Set("WebRTC-Audio-Allocation", "prio_rate:20");
auto send_stream = helper.CreateAudioSendStream();
EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _))
.WillOnce(Invoke(
.WillOnce(
[&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
EXPECT_EQ(config.priority_bitrate_bps, 20000);
}));
});
EXPECT_CALL(*helper.channel_send(), StartSend());
send_stream->Start();
EXPECT_CALL(*helper.channel_send(), StopSend());
@ -996,10 +995,10 @@ TEST(AudioSendStreamTest, OverridesPriorityBitrate) {
helper.field_trials().Set("WebRTC-Audio-PriorityBitrate", "Disabled");
auto send_stream = helper.CreateAudioSendStream();
EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _))
.WillOnce(Invoke(
.WillOnce(
[&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
EXPECT_EQ(config.priority_bitrate_bps, 0);
}));
});
EXPECT_CALL(*helper.channel_send(), StartSend());
send_stream->Start();
EXPECT_CALL(*helper.channel_send(), StopSend());
@ -1019,11 +1018,11 @@ TEST(AudioSendStreamTest, UseEncoderBitrateRange) {
}));
auto send_stream = helper.CreateAudioSendStream();
EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _))
.WillOnce(Invoke(
.WillOnce(
[&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
EXPECT_EQ(config.min_bitrate_bps, bitrate_range.first.bps());
EXPECT_EQ(config.max_bitrate_bps, bitrate_range.second.bps());
}));
});
EXPECT_CALL(*helper.channel_send(), StartSend());
send_stream->Start();
EXPECT_CALL(*helper.channel_send(), StopSend());

29
audio/audio_state_unittest.cc
View File

@ -239,11 +239,11 @@ TEST_P(AudioStateTest, RecordedAudioArrivesAtSingleStream) {
::testing::Field(&AudioFrame::num_channels_, ::testing::Eq(2u)))))
.WillOnce(
// Verify that channels are not swapped by default.
::testing::Invoke([](AudioFrame* audio_frame) {
[](AudioFrame* audio_frame) {
auto levels = ComputeChannelLevels(audio_frame);
EXPECT_LT(0u, levels[0]);
EXPECT_EQ(0u, levels[1]);
}));
});
MockAudioProcessing* ap =
GetParam().use_null_audio_processing
? nullptr
@ -289,10 +289,10 @@ TEST_P(AudioStateTest, RecordedAudioArrivesAtMultipleStreams) {
::testing::Field(&AudioFrame::num_channels_, ::testing::Eq(1u)))))
.WillOnce(
// Verify that there is output signal.
::testing::Invoke([](AudioFrame* audio_frame) {
[](AudioFrame* audio_frame) {
auto levels = ComputeChannelLevels(audio_frame);
EXPECT_LT(0u, levels[0]);
}));
});
EXPECT_CALL(
stream_2,
SendAudioDataForMock(::testing::AllOf(
@ -300,10 +300,10 @@ TEST_P(AudioStateTest, RecordedAudioArrivesAtMultipleStreams) {
::testing::Field(&AudioFrame::num_channels_, ::testing::Eq(1u)))))
.WillOnce(
// Verify that there is output signal.
::testing::Invoke([](AudioFrame* audio_frame) {
[](AudioFrame* audio_frame) {
auto levels = ComputeChannelLevels(audio_frame);
EXPECT_LT(0u, levels[0]);
}));
});
MockAudioProcessing* ap =
static_cast<MockAudioProcessing*>(audio_state->audio_processing());
if (ap) {
@ -346,11 +346,11 @@ TEST_P(AudioStateTest, EnableChannelSwap) {
EXPECT_CALL(stream, SendAudioDataForMock(_))
.WillOnce(
// Verify that channels are swapped.
::testing::Invoke([](AudioFrame* audio_frame) {
[](AudioFrame* audio_frame) {
auto levels = ComputeChannelLevels(audio_frame);
EXPECT_EQ(0u, levels[0]);
EXPECT_LT(0u, levels[1]);
}));
});
auto audio_data = Create10msTestData(kSampleRate, kNumChannels);
uint32_t new_mic_level = 667;
@ -371,13 +371,12 @@ TEST_P(AudioStateTest,
helper.mixer()->AddSource(&fake_source);
EXPECT_CALL(fake_source, GetAudioFrameWithInfo(_, _))
.WillOnce(
::testing::Invoke([](int sample_rate_hz, AudioFrame* audio_frame) {
audio_frame->sample_rate_hz_ = sample_rate_hz;
audio_frame->samples_per_channel_ = sample_rate_hz / 100;
audio_frame->num_channels_ = kNumberOfChannels;
return AudioMixer::Source::AudioFrameInfo::kNormal;
}));
.WillOnce([](int sample_rate_hz, AudioFrame* audio_frame) {
audio_frame->sample_rate_hz_ = sample_rate_hz;
audio_frame->samples_per_channel_ = sample_rate_hz / 100;
audio_frame->num_channels_ = kNumberOfChannels;
return AudioMixer::Source::AudioFrameInfo::kNormal;
});
int16_t audio_buffer[kSampleRate / 100 * kNumberOfChannels];
size_t n_samples_out;

17
audio/channel_send_unittest.cc
View File

@ -56,7 +56,6 @@ namespace voe {
namespace {
using ::testing::Eq;
using ::testing::Invoke;
using ::testing::IsTrue;
using ::testing::NiceMock;
using ::testing::Return;
@ -164,7 +163,7 @@ TEST_F(ChannelSendTest, IncreaseRtpTimestampByPauseDuration) {
timestamp = packet.Timestamp();
return true;
};
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(Invoke(send_rtp));
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(send_rtp);
ProcessNextFrame();
ProcessNextFrame();
EXPECT_EQ(sent_packets, 1);
@ -200,7 +199,7 @@ TEST_F(ChannelSendTest, FrameTransformerGetsCorrectTimestamp) {
}
return true;
};
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(Invoke(send_rtp));
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(send_rtp);
channel_->StartSend();
int64_t transformable_frame_timestamp = -1;
@ -249,7 +248,7 @@ TEST_F(ChannelSendTest, AudioLevelsAttachedToCorrectTransformedFrame) {
sent_audio_levels.push_back(header.extension.audio_level()->level());
return true;
};
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(Invoke(send_rtp));
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(send_rtp);
channel_->StartSend();
std::vector<std::unique_ptr<TransformableFrameInterface>> frames;
@ -313,7 +312,7 @@ TEST_F(ChannelSendTest, AudioLevelsAttachedToInsertedTransformedFrame) {
sent_audio_level = header.extension.audio_level()->level();
return true;
};
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(Invoke(send_rtp));
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(send_rtp);
channel_->StartSend();
@ -424,7 +423,7 @@ TEST_F(ChannelSendTest, ConfiguredCsrcsAreIncludedInRtpPackets) {
return true;
};
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(Invoke(send_rtp));
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(send_rtp);
ProcessNextFrame();
ProcessNextFrame();
@ -486,7 +485,7 @@ TEST_F(ChannelSendTest, FrameTransformerTakesPrecedenceOverSetCsrcs) {
std::vector<uint32_t> csrcs_output_by_frame_transformer = {1, 2, 3};
EXPECT_CALL(*mock_frame_transformer, Transform)
.WillRepeatedly(
Invoke([&](std::unique_ptr<TransformableFrameInterface> frame) {
[&](std::unique_ptr<TransformableFrameInterface> frame) {
auto audio_frame =
static_cast<TransformableAudioFrameInterface*>(frame.get());
csrcs_provided_to_frame_transformer.assign(
@ -494,7 +493,7 @@ TEST_F(ChannelSendTest, FrameTransformerTakesPrecedenceOverSetCsrcs) {
audio_frame->GetContributingSources().end());
callback->OnTransformedFrame(CreateMockFrameWithCsrcs(
audio_frame, csrcs_output_by_frame_transformer));
}));
});
std::vector<uint32_t> set_csrcs = {4, 5, 6};
channel_->SetCsrcs(set_csrcs);
@ -509,7 +508,7 @@ TEST_F(ChannelSendTest, FrameTransformerTakesPrecedenceOverSetCsrcs) {
return true;
};
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(Invoke(send_rtp));
EXPECT_CALL(transport_, SendRtp).WillRepeatedly(send_rtp);
ProcessNextFrame();
ProcessNextFrame();

5
logging/rtc_event_log/rtc_event_log_impl_unittest.cc
View File

@ -35,7 +35,6 @@ namespace {
using ::testing::_;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::Mock;
using ::testing::Property;
using ::testing::Ref;
@ -309,13 +308,13 @@ TEST_F(RtcEventLogImplTest, StopOutputOnWriteFailure) {
size_t number_of_encoded_events = 0;
EXPECT_CALL(*encoder_ptr_, OnEncode(_))
.WillRepeatedly(Invoke([this, &number_of_encoded_events]() {
.WillRepeatedly([this, &number_of_encoded_events]() {
++number_of_encoded_events;
if (number_of_encoded_events == kFailsWriteOnEventsCount) {
output_ptr_->FailsNextWrite();
}
return std::string();
}));
});
event_log_.StartLogging(std::move(output_), kOutputPeriod.ms());

5
modules/audio_coding/neteq/neteq_impl_unittest.cc
View File

@ -64,7 +64,6 @@ using ::testing::AtLeast;
using ::testing::DoAll;
using ::testing::ElementsAre;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::IsEmpty;
using ::testing::IsNull;
using ::testing::Pointee;
@ -1665,10 +1664,10 @@ TEST_F(NetEqImplTest, NoCrashWithMaxChannels) {
EXPECT_CALL(*mock_decoder_database_, GetActiveDecoder())
.WillRepeatedly(Return(decoder));
EXPECT_CALL(*mock_decoder_database_, SetActiveDecoder(_, _))
.WillOnce(Invoke([](uint8_t /* rtp_payload_type */, bool* new_decoder) {
.WillOnce([](uint8_t /* rtp_payload_type */, bool* new_decoder) {
*new_decoder = true;
return 0;
}));
});
// Insert first packet.
neteq_->InsertPacket(rtp_header, payload);

31
modules/desktop_capture/desktop_capturer_differ_wrapper_unittest.cc
View File

@ -125,19 +125,18 @@ void ExecuteDifferWrapperCase(BlackWhiteDesktopFramePainter* frame_painter,
EXPECT_CALL(*callback, OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS,
::testing::_))
.Times(1)
.WillOnce(
::testing::Invoke([&updated_region, check_result, exactly_match](
DesktopCapturer::Result result,
std::unique_ptr<DesktopFrame>* frame) {
ASSERT_EQ(result, DesktopCapturer::Result::SUCCESS);
if (check_result) {
if (exactly_match) {
AssertUpdatedRegionIs(**frame, updated_region);
} else {
AssertUpdatedRegionCovers(**frame, updated_region);
}
}
}));
.WillOnce([&updated_region, check_result, exactly_match](
DesktopCapturer::Result result,
std::unique_ptr<DesktopFrame>* frame) {
ASSERT_EQ(result, DesktopCapturer::Result::SUCCESS);
if (check_result) {
if (exactly_match) {
AssertUpdatedRegionIs(**frame, updated_region);
} else {
AssertUpdatedRegionCovers(**frame, updated_region);
}
}
});
for (const auto& rect : updated_region) {
frame_painter->updated_region()->AddRect(rect);
}
@ -178,12 +177,12 @@ void ExecuteDifferWrapperTest(Clock* clock,
EXPECT_CALL(callback, OnCaptureResultPtr(DesktopCapturer::Result::SUCCESS,
::testing::_))
.Times(1)
.WillOnce(::testing::Invoke([](DesktopCapturer::Result result,
std::unique_ptr<DesktopFrame>* frame) {
.WillOnce([](DesktopCapturer::Result result,
std::unique_ptr<DesktopFrame>* frame) {
ASSERT_EQ(result, DesktopCapturer::Result::SUCCESS);
AssertUpdatedRegionIs(**frame,
{DesktopRect::MakeSize((*frame)->size())});
}));
});
capturer.CaptureFrame();
ExecuteDifferWrapperCase(&frame_painter, &capturer, &callback,

24
modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc
View File

@ -28,7 +28,6 @@
#include "test/rtcp_packet_parser.h"
using ::testing::_;
using ::testing::Invoke;
using ::testing::MockFunction;
using webrtc::rtcp::Bye;
using webrtc::rtcp::CompoundPacket;
@ -110,14 +109,13 @@ TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) {
const size_t kBufferSize = kRrLength + kReportBlockLength + kFirLength;
MockFunction<void(ArrayView<const uint8_t>)> callback;
EXPECT_CALL(callback, Call(_))
.WillOnce(Invoke([&](ArrayView<const uint8_t> packet) {
RtcpPacketParser parser;
parser.Parse(packet);
EXPECT_EQ(1, parser.receiver_report()->num_packets());
EXPECT_EQ(1u, parser.receiver_report()->report_blocks().size());
EXPECT_EQ(1, parser.fir()->num_packets());
}));
EXPECT_CALL(callback, Call(_)).WillOnce([&](ArrayView<const uint8_t> packet) {
RtcpPacketParser parser;
parser.Parse(packet);
EXPECT_EQ(1, parser.receiver_report()->num_packets());
EXPECT_EQ(1u, parser.receiver_report()->report_blocks().size());
EXPECT_EQ(1, parser.fir()->num_packets());
});
EXPECT_TRUE(compound.Build(kBufferSize, callback.AsStdFunction()));
}
@ -139,20 +137,20 @@ TEST(RtcpCompoundPacketTest, BuildWithTooSmallBuffer_FragmentedSend) {
const size_t kBufferSize = kRrLength + kReportBlockLength;
MockFunction<void(ArrayView<const uint8_t>)> callback;
EXPECT_CALL(callback, Call(_))
.WillOnce(Invoke([&](ArrayView<const uint8_t> packet) {
.WillOnce([&](ArrayView<const uint8_t> packet) {
RtcpPacketParser parser;
parser.Parse(packet);
EXPECT_EQ(1, parser.receiver_report()->num_packets());
EXPECT_EQ(1U, parser.receiver_report()->report_blocks().size());
EXPECT_EQ(0, parser.fir()->num_packets());
}))
.WillOnce(Invoke([&](ArrayView<const uint8_t> packet) {
})
.WillOnce([&](ArrayView<const uint8_t> packet) {
RtcpPacketParser parser;
parser.Parse(packet);
EXPECT_EQ(0, parser.receiver_report()->num_packets());
EXPECT_EQ(0U, parser.receiver_report()->report_blocks().size());
EXPECT_EQ(1, parser.fir()->num_packets());
}));
});
EXPECT_TRUE(compound.Build(kBufferSize, callback.AsStdFunction()));
}

9
modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc
View File

@ -27,7 +27,6 @@ using rtcp::Nack;
using ::testing::_;
using ::testing::ElementsAre;
using ::testing::ElementsAreArray;
using ::testing::Invoke;
using ::testing::make_tuple;
using ::testing::MockFunction;
using ::testing::UnorderedElementsAreArray;
@ -136,20 +135,20 @@ TEST(RtcpPacketNackTest, CreateFragmented) {
MockFunction<void(ArrayView<const uint8_t>)> callback;
EXPECT_CALL(callback, Call(_))
.WillOnce(Invoke([&](ArrayView<const uint8_t> packet) {
.WillOnce([&](ArrayView<const uint8_t> packet) {
Nack nack;
EXPECT_TRUE(test::ParseSinglePacket(packet, &nack));
EXPECT_EQ(kSenderSsrc, nack.sender_ssrc());
EXPECT_EQ(kRemoteSsrc, nack.media_ssrc());
EXPECT_THAT(nack.packet_ids(), ElementsAre(1, 100, 200));
}))
.WillOnce(Invoke([&](ArrayView<const uint8_t> packet) {
})
.WillOnce([&](ArrayView<const uint8_t> packet) {
Nack nack;
EXPECT_TRUE(test::ParseSinglePacket(packet, &nack));
EXPECT_EQ(kSenderSsrc, nack.sender_ssrc());
EXPECT_EQ(kRemoteSsrc, nack.media_ssrc());
EXPECT_THAT(nack.packet_ids(), ElementsAre(300, 400));
}));
});
EXPECT_TRUE(nack.Build(kBufferSize, callback.AsStdFunction()));
}

5
modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -54,7 +54,6 @@ namespace {
using ::testing::_;
using ::testing::ElementsAre;
using ::testing::Eq;
using ::testing::Invoke;
using ::testing::Property;
using ::testing::SizeIs;
@ -668,7 +667,7 @@ TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
TEST_F(RtcpSenderTest, ByeMustBeLast) {
MockTransport mock_transport;
EXPECT_CALL(mock_transport, SendRtcp(_, _))
.WillOnce(Invoke([](ArrayView<const uint8_t> data, ::testing::Unused) {
.WillOnce([](ArrayView<const uint8_t> data, ::testing::Unused) {
const uint8_t* next_packet = data.data();
const uint8_t* const packet_end = data.data() + data.size();
rtcp::CommonHeader packet;
@ -685,7 +684,7 @@ TEST_F(RtcpSenderTest, ByeMustBeLast) {
}
return true;
}));
});
// Re-configure rtcp_sender with mock_transport_
RTCPSender::Configuration config = GetDefaultConfig();

9
modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -64,7 +64,6 @@ using ::testing::AllOf;
using ::testing::ElementsAre;
using ::testing::ElementsAreArray;
using ::testing::Field;
using ::testing::Invoke;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::Values;
@ -629,15 +628,15 @@ TEST_F(TestVp8Impl, KeepsTimestampOnReencode) {
codec_settings_.legacy_conference_mode = true;
EXPECT_CALL(*vpx, img_wrap(_, _, _, _, _, _))
.WillOnce(Invoke([](vpx_image_t* img, vpx_img_fmt_t fmt, unsigned int d_w,
unsigned int d_h, unsigned int /* stride_align */,
unsigned char* img_data) {
.WillOnce([](vpx_image_t* img, vpx_img_fmt_t fmt, unsigned int d_w,
unsigned int d_h, unsigned int /* stride_align */,
unsigned char* img_data) {
img->fmt = fmt;
img->d_w = d_w;
img->d_h = d_h;
img->img_data = img_data;
return img;
}));
});
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
encoder.InitEncode(&codec_settings_,
VideoEncoder::Settings(kCapabilities, 1, 1000)));

30
pc/peer_connection_end_to_end_unittest.cc
View File

@ -38,9 +38,9 @@
#include "api/rtc_error.h"
#include "api/rtp_parameters.h"
#include "api/scoped_refptr.h"
#include "api/sctp_transport_interface.h"
#include "api/test/rtc_error_matchers.h"
#include "api/units/time_delta.h"
#include "media/sctp/sctp_transport_internal.h"
#include "rtc_base/checks.h"
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/physical_socket_server.h"
@ -63,7 +63,6 @@
using ::testing::_;
using ::testing::AtLeast;
using ::testing::Invoke;
using ::testing::StrictMock;
using ::testing::Values;
@ -272,28 +271,28 @@ std::unique_ptr<AudioDecoder> CreateForwardingMockDecoder(
std::make_unique<ForwardingMockDecoder>(std::move(real_decoder));
EXPECT_CALL(*mock_decoder, Channels())
.Times(AtLeast(1))
.WillRepeatedly(Invoke([dec] { return dec->Channels(); }));
.WillRepeatedly([dec] { return dec->Channels(); });
EXPECT_CALL(*mock_decoder, DecodeInternal(_, _, _, _, _))
.Times(AtLeast(1))
.WillRepeatedly(Invoke(
.WillRepeatedly(
[dec](const uint8_t* encoded, size_t encoded_len, int sample_rate_hz,
int16_t* decoded, AudioDecoder::SpeechType* speech_type) {
return dec->Decode(encoded, encoded_len, sample_rate_hz,
std::numeric_limits<size_t>::max(), decoded,
speech_type);
}));
});
EXPECT_CALL(*mock_decoder, Die());
EXPECT_CALL(*mock_decoder, HasDecodePlc()).WillRepeatedly(Invoke([dec] {
EXPECT_CALL(*mock_decoder, HasDecodePlc()).WillRepeatedly([dec] {
return dec->HasDecodePlc();
}));
});
EXPECT_CALL(*mock_decoder, PacketDuration(_, _))
.Times(AtLeast(1))
.WillRepeatedly(Invoke([dec](const uint8_t* encoded, size_t encoded_len) {
.WillRepeatedly([dec](const uint8_t* encoded, size_t encoded_len) {
return dec->PacketDuration(encoded, encoded_len);
}));
});
EXPECT_CALL(*mock_decoder, SampleRateHz())
.Times(AtLeast(1))
.WillRepeatedly(Invoke([dec] { return dec->SampleRateHz(); }));
.WillRepeatedly([dec] { return dec->SampleRateHz(); });
return std::move(mock_decoder);
}
@ -304,15 +303,14 @@ scoped_refptr<AudioDecoderFactory> CreateForwardingMockDecoderFactory(
make_ref_counted<StrictMock<MockAudioDecoderFactory>>();
EXPECT_CALL(*mock_decoder_factory, GetSupportedDecoders())
.Times(AtLeast(1))
.WillRepeatedly(Invoke([real_decoder_factory] {
.WillRepeatedly([real_decoder_factory] {
return real_decoder_factory->GetSupportedDecoders();
}));
});
EXPECT_CALL(*mock_decoder_factory, IsSupportedDecoder(_))
.Times(AtLeast(1))
.WillRepeatedly(
Invoke([real_decoder_factory](const SdpAudioFormat& format) {
return real_decoder_factory->IsSupportedDecoder(format);
}));
.WillRepeatedly([real_decoder_factory](const SdpAudioFormat& format) {
return real_decoder_factory->IsSupportedDecoder(format);
});
EXPECT_CALL(*mock_decoder_factory, Create)
.Times(AtLeast(2))
.WillRepeatedly(

19
pc/rtc_stats_collector_unittest.cc
View File

@ -97,7 +97,6 @@
#include "test/wait_until.h"
using ::testing::_;
using ::testing::Invoke;
using ::testing::Return;
namespace webrtc {
@ -341,15 +340,15 @@ scoped_refptr<MockRtpSenderInternal> CreateMockSender(
EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
EXPECT_CALL(*sender, media_type()).WillRepeatedly(Return(media_type));
EXPECT_CALL(*sender, GetParameters())
.WillRepeatedly(
Invoke([s = sender.get()]() { return s->GetParametersInternal(); }));
EXPECT_CALL(*sender, GetParametersInternal()).WillRepeatedly(Invoke([ssrc]() {
EXPECT_CALL(*sender, GetParameters()).WillRepeatedly([s = sender.get()]() {
return s->GetParametersInternal();
});
EXPECT_CALL(*sender, GetParametersInternal()).WillRepeatedly([ssrc]() {
RtpParameters params;
params.encodings.push_back(RtpEncodingParameters());
params.encodings[0].ssrc = ssrc;
return params;
}));
});
EXPECT_CALL(*sender, AttachmentId()).WillRepeatedly(Return(attachment_id));
EXPECT_CALL(*sender, stream_ids()).WillRepeatedly(Return(local_stream_ids));
EXPECT_CALL(*sender, SetTransceiverAsStopped());
@ -362,9 +361,7 @@ scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
int attachment_id) {
auto receiver = make_ref_counted<MockRtpReceiverInternal>();
EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
EXPECT_CALL(*receiver, ssrc()).WillRepeatedly(Invoke([ssrc]() {
return ssrc;
}));
EXPECT_CALL(*receiver, ssrc()).WillRepeatedly([ssrc]() { return ssrc; });
EXPECT_CALL(*receiver, streams())
.WillRepeatedly(
Return(std::vector<scoped_refptr<MediaStreamInterface>>({})));
@ -374,12 +371,12 @@ scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
Return(track->kind() == MediaStreamTrackInterface::kAudioKind
? MediaType::AUDIO
: MediaType::VIDEO));
EXPECT_CALL(*receiver, GetParameters()).WillRepeatedly(Invoke([ssrc]() {
EXPECT_CALL(*receiver, GetParameters()).WillRepeatedly([ssrc]() {
RtpParameters params;
params.encodings.push_back(RtpEncodingParameters());
params.encodings[0].ssrc = ssrc;
return params;
}));
});
EXPECT_CALL(*receiver, AttachmentId()).WillRepeatedly(Return(attachment_id));
EXPECT_CALL(*receiver, Stop()).WillRepeatedly(Return());
return receiver;

8
rtc_base/crypto_random_unittest.cc
View File

@ -25,7 +25,6 @@ namespace {
using ::testing::_;
using ::testing::DoAll;
using ::testing::Invoke;
using ::testing::IsEmpty;
using ::testing::Not;
using ::testing::Return;
@ -139,10 +138,9 @@ TEST(RandomTest, TestSetRandomGenerator) {
uint32_t id = 4658;
EXPECT_CALL(*generator, Generate(_, sizeof(uint32_t)))
.WillOnce(DoAll(WithArg<0>(Invoke([&id](void* p) {
std::memcpy(p, &id, sizeof(uint32_t));
})),
Return(true)));
.WillOnce(DoAll(
WithArg<0>([&id](void* p) { std::memcpy(p, &id, sizeof(uint32_t)); }),
Return(true)));
EXPECT_EQ(CreateRandomId(), id);
EXPECT_CALL(*generator, Generate)

13
rtc_base/task_utils/repeating_task_unittest.cc
View File

@ -32,7 +32,6 @@
namespace webrtc {
namespace {
using ::testing::AtLeast;
using ::testing::Invoke;
using ::testing::MockFunction;
using ::testing::NiceMock;
using ::testing::Return;
@ -213,7 +212,7 @@ TEST(RepeatingTaskTest, CancelDelayedTaskBeforeItRuns) {
Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).Times(0);
EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
EXPECT_CALL(mock, Delete).WillOnce([&done] { done.Set(); });
TaskQueueForTest task_queue("queue");
auto handle = RepeatingTaskHandle::DelayedStart(
task_queue.Get(), TimeDelta::Millis(100), MoveOnlyClosure(&mock));
@ -226,7 +225,7 @@ TEST(RepeatingTaskTest, CancelTaskAfterItRuns) {
Event done;
MockClosure mock;
EXPECT_CALL(mock, Call).WillOnce(Return(TimeDelta::Millis(100)));
EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
EXPECT_CALL(mock, Delete).WillOnce([&done] { done.Set(); });
TaskQueueForTest task_queue("queue");
auto handle =
RepeatingTaskHandle::Start(task_queue.Get(), MoveOnlyClosure(&mock));
@ -269,10 +268,10 @@ TEST(RepeatingTaskTest, ZeroReturnValueRepostsTheTask) {
Event done;
EXPECT_CALL(closure, Call())
.WillOnce(Return(TimeDelta::Zero()))
.WillOnce(Invoke([&] {
.WillOnce([&] {
done.Set();
return TimeDelta::PlusInfinity();
}));
});
TaskQueueForTest task_queue("queue");
RepeatingTaskHandle::Start(task_queue.Get(), MoveOnlyClosure(&closure));
EXPECT_TRUE(done.Wait(kTimeout));
@ -284,10 +283,10 @@ TEST(RepeatingTaskTest, StartPeriodicTask) {
EXPECT_CALL(closure, Call())
.WillOnce(Return(TimeDelta::Millis(20)))
.WillOnce(Return(TimeDelta::Millis(20)))
.WillOnce(Invoke([&] {
.WillOnce([&] {
done.Set();
return TimeDelta::PlusInfinity();
}));
});
TaskQueueForTest task_queue("queue");
RepeatingTaskHandle::Start(task_queue.Get(), closure.AsStdFunction());
EXPECT_TRUE(done.Wait(kTimeout));

5
test/time_controller/simulated_time_controller_unittest.cc
View File

@ -29,7 +29,6 @@
namespace webrtc {
namespace {
using ::testing::AtLeast;
using ::testing::Invoke;
using ::testing::MockFunction;
using ::testing::NiceMock;
using ::testing::Return;
@ -156,10 +155,10 @@ TEST(SimulatedTimeControllerTest, SkipsDelayedTaskForward) {
constexpr auto duration_during_which_nothing_runs = TimeDelta::Seconds(2);
constexpr auto shorter_duration = TimeDelta::Seconds(1);
MockFunction<void()> fun;
EXPECT_CALL(fun, Call).WillOnce(Invoke([&] {
EXPECT_CALL(fun, Call).WillOnce([&] {
ASSERT_EQ(sim.GetClock()->CurrentTime(),
kStartTime + duration_during_which_nothing_runs);
}));
});
main_thread->PostDelayedTask(fun.AsStdFunction(), shorter_duration);
sim.SkipForwardBy(duration_during_which_nothing_runs);
// Run tasks that were pending during the skip.

6
video/decode_synchronizer_unittest.cc
View File

@ -10,7 +10,6 @@
#include "video/decode_synchronizer.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
@ -29,7 +28,6 @@
using ::testing::_;
using ::testing::Eq;
using ::testing::Invoke;
using ::testing::Mock;
using ::testing::MockFunction;
using ::testing::Return;
@ -242,9 +240,9 @@ TEST(DecodeSynchronizerStandaloneTest,
time_controller.GetMainThread());
absl::AnyInvocable<void() &&> callback;
EXPECT_CALL(metronome, RequestCallOnNextTick)
.WillOnce(Invoke([&callback](absl::AnyInvocable<void()&&> cb) {
.WillOnce([&callback](absl::AnyInvocable<void() &&> cb) {
callback = std::move(cb);
}));
});
auto scheduler = decode_synchronizer_.CreateSynchronizedFrameScheduler();
auto scheduler2 = decode_synchronizer_.CreateSynchronizedFrameScheduler();
scheduler->Stop();

46
video/frame_cadence_adapter_unittest.cc
View File

@ -50,7 +50,6 @@ namespace {
using ::testing::_;
using ::testing::ElementsAre;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::InvokeWithoutArgs;
using ::testing::Mock;
using ::testing::NiceMock;
@ -225,14 +224,13 @@ TEST(FrameCadenceAdapterTest, ForwardsFramesDelayed) {
EXPECT_CALL(callback, OnFrame).Times(0);
adapter->OnFrame(frame);
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp post_time, bool,
const VideoFrame& frame) {
.WillOnce([&](Timestamp post_time, bool, const VideoFrame& frame) {
EXPECT_EQ(post_time, time_controller.GetClock()->CurrentTime());
EXPECT_EQ(frame.timestamp_us(),
original_timestamp_us + index * kNumMicrosecsPerSec);
EXPECT_EQ(frame.ntp_time_ms(),
original_ntp_time.ToMs() + index * kNumMillisecsPerSec);
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
frame = CreateFrameWithTimestamps(&time_controller);
}
@ -308,33 +306,33 @@ TEST(FrameCadenceAdapterTest, RepeatsFramesDelayed) {
adapter->OnFrame(frame);
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp post_time, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp post_time, bool, const VideoFrame& frame) {
EXPECT_EQ(post_time, time_controller.GetClock()->CurrentTime());
EXPECT_EQ(frame.timestamp_us(), original_timestamp_us);
EXPECT_EQ(frame.ntp_time_ms(), original_ntp_time.ToMs());
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
Mock::VerifyAndClearExpectations(&callback);
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp post_time, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp post_time, bool, const VideoFrame& frame) {
EXPECT_EQ(post_time, time_controller.GetClock()->CurrentTime());
EXPECT_EQ(frame.timestamp_us(),
original_timestamp_us + kNumMicrosecsPerSec);
EXPECT_EQ(frame.ntp_time_ms(),
original_ntp_time.ToMs() + kNumMillisecsPerSec);
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
Mock::VerifyAndClearExpectations(&callback);
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp post_time, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp post_time, bool, const VideoFrame& frame) {
EXPECT_EQ(post_time, time_controller.GetClock()->CurrentTime());
EXPECT_EQ(frame.timestamp_us(),
original_timestamp_us + 2 * kNumMicrosecsPerSec);
EXPECT_EQ(frame.ntp_time_ms(),
original_ntp_time.ToMs() + 2 * kNumMillisecsPerSec);
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
}
@ -353,17 +351,17 @@ TEST(FrameCadenceAdapterTest, SetsIsRepeatFrameFlag) {
auto frame = CreateFrameWithTimestamps(&time_controller);
adapter->OnFrame(frame);
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp, bool, const VideoFrame& frame) {
EXPECT_FALSE(frame.is_repeat_frame());
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
Mock::VerifyAndClearExpectations(&callback);
// Expect the repeated frame to have is_repeat_frame set to true.
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp, bool, const VideoFrame& frame) {
EXPECT_TRUE(frame.is_repeat_frame());
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
Mock::VerifyAndClearExpectations(&callback);
@ -371,9 +369,9 @@ TEST(FrameCadenceAdapterTest, SetsIsRepeatFrameFlag) {
auto new_frame = CreateFrameWithTimestamps(&time_controller);
adapter->OnFrame(new_frame);
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp, bool, const VideoFrame& frame) {
EXPECT_FALSE(frame.is_repeat_frame());
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
}
@ -398,19 +396,19 @@ TEST(FrameCadenceAdapterTest,
// Send one frame, expect a repeat.
adapter->OnFrame(CreateFrame());
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp post_time, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp post_time, bool, const VideoFrame& frame) {
EXPECT_EQ(post_time, time_controller.GetClock()->CurrentTime());
EXPECT_EQ(frame.timestamp_us(), 0);
EXPECT_EQ(frame.ntp_time_ms(), 0);
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
Mock::VerifyAndClearExpectations(&callback);
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp post_time, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp post_time, bool, const VideoFrame& frame) {
EXPECT_EQ(post_time, time_controller.GetClock()->CurrentTime());
EXPECT_EQ(frame.timestamp_us(), 0);
EXPECT_EQ(frame.ntp_time_ms(), 0);
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
}
@ -439,11 +437,11 @@ TEST(FrameCadenceAdapterTest, StopsRepeatingFramesDelayed) {
// Send the new frame at 2.5s, which should appear after 3.5s.
adapter->OnFrame(CreateFrameWithTimestamps(&time_controller));
EXPECT_CALL(callback, OnFrame)
.WillOnce(Invoke([&](Timestamp, bool, const VideoFrame& frame) {
.WillOnce([&](Timestamp, bool, const VideoFrame& frame) {
EXPECT_EQ(frame.timestamp_us(), 5 * kNumMicrosecsPerSec / 2);
EXPECT_EQ(frame.ntp_time_ms(),
original_ntp_time.ToMs() + 5u * kNumMillisecsPerSec / 2);
}));
});
time_controller.AdvanceTime(TimeDelta::Seconds(1));
}
@ -1102,7 +1100,7 @@ TEST(FrameCadenceAdapterRealTimeTest, TimestampsDoNotDrift) {
constexpr int kSleepMs = kNumMillisecsPerSec / 2;
EXPECT_CALL(callback, OnFrame)
.WillRepeatedly(
Invoke([&](Timestamp, bool, const VideoFrame& incoming_frame) {
[&](Timestamp, bool, const VideoFrame& incoming_frame) {
++frame_counter;
// Avoid the first OnFrame and sleep on the second.
if (frame_counter == 2) {
@ -1114,7 +1112,7 @@ TEST(FrameCadenceAdapterRealTimeTest, TimestampsDoNotDrift) {
original_timestamp_us + kSleepMs);
event.Set();
}
}));
});
adapter->OnFrame(frame);
});
event.Wait(Event::kForever);

35
video/rtp_video_stream_receiver2_unittest.cc
View File

@ -77,7 +77,6 @@ using ::testing::_;
using ::testing::DoubleNear;
using ::testing::ElementsAre;
using ::testing::Eq;
using ::testing::Invoke;
using ::testing::SizeIs;
using ::testing::Values;
@ -204,9 +203,9 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test,
/*raw_payload=*/false);
ON_CALL(mock_transport_, SendRtcp)
.WillByDefault(
Invoke([this](ArrayView<const uint8_t> packet, ::testing::Unused) {
[this](ArrayView<const uint8_t> packet, ::testing::Unused) {
return rtcp_packet_parser_.Parse(packet);
}));
});
}
RTPVideoHeader GetDefaultH264VideoHeader() {
@ -372,10 +371,10 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
EXPECT_TRUE(key_frame_packet2.GetExtension<ColorSpaceExtension>());
rtp_video_stream_receiver_->OnRtpPacket(key_frame_packet1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
.WillOnce([kColorSpace](EncodedFrame* frame) {
ASSERT_TRUE(frame->EncodedImage().ColorSpace());
EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
}));
});
rtp_video_stream_receiver_->OnRtpPacket(key_frame_packet2);
// Resend the first key frame packet to simulate padding for example.
rtp_video_stream_receiver_->OnRtpPacket(key_frame_packet1);
@ -388,10 +387,10 @@ TEST_F(RtpVideoStreamReceiver2Test, CacheColorSpaceFromLastPacketOfKeyframe) {
// included in the RTP packet.
EXPECT_FALSE(delta_frame_packet.GetExtension<ColorSpaceExtension>());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([kColorSpace](EncodedFrame* frame) {
.WillOnce([kColorSpace](EncodedFrame* frame) {
ASSERT_TRUE(frame->EncodedImage().ColorSpace());
EXPECT_EQ(*frame->EncodedImage().ColorSpace(), kColorSpace);
}));
});
rtp_video_stream_receiver_->OnRtpPacket(delta_frame_packet);
}
@ -677,10 +676,10 @@ TEST_F(RtpVideoStreamReceiver2Test, PacketInfoIsPropagatedIntoVideoFrames) {
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
.WillOnce([kAbsoluteCaptureTimestamp](EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame),
ElementsAre(kAbsoluteCaptureTimestamp));
}));
});
rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
video_header, 0);
}
@ -724,9 +723,9 @@ TEST_F(RtpVideoStreamReceiver2Test,
// Expect rtp video stream receiver to extrapolate it for the resulting video
// frame using absolute capture time from the previous packet.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([](EncodedFrame* frame) {
.WillOnce([](EncodedFrame* frame) {
EXPECT_THAT(GetAbsoluteCaptureTimestamps(frame), SizeIs(1));
}));
});
rtp_video_stream_receiver_->OnReceivedPayloadData(data, rtp_packet,
video_header, 0);
}
@ -1190,13 +1189,13 @@ TEST_F(RtpVideoStreamReceiver2Test, ParseGenericDescriptorOnePacket) {
rtp_packet.SetSequenceNumber(1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
.WillOnce([kSpatialIndex](EncodedFrame* frame) {
EXPECT_EQ(frame->num_references, 2U);
EXPECT_EQ(frame->references[0], frame->Id() - 90);
EXPECT_EQ(frame->references[1], frame->Id() - 80);
EXPECT_EQ(frame->SpatialIndex(), kSpatialIndex);
EXPECT_THAT(frame->PacketInfos(), SizeIs(1));
}));
});
rtp_video_stream_receiver_->OnRtpPacket(rtp_packet);
}
@ -1248,13 +1247,13 @@ TEST_F(RtpVideoStreamReceiver2Test, ParseGenericDescriptorTwoPackets) {
data.size() - 1);
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame)
.WillOnce(Invoke([kSpatialIndex](EncodedFrame* frame) {
.WillOnce([kSpatialIndex](EncodedFrame* frame) {
EXPECT_EQ(frame->num_references, 0U);
EXPECT_EQ(frame->SpatialIndex(), kSpatialIndex);
EXPECT_EQ(frame->EncodedImage()._encodedWidth, 480u);
EXPECT_EQ(frame->EncodedImage()._encodedHeight, 360u);
EXPECT_THAT(frame->PacketInfos(), SizeIs(2));
}));
});
rtp_video_stream_receiver_->OnRtpPacket(second_packet);
}
@ -1750,10 +1749,10 @@ TEST_P(RtpVideoStreamReceiver2TestPlayoutDelay, PlayoutDelay) {
// Expect the playout delay of encoded frame to be the same as the transmitted
// playout delay unless it was overridden by a field trial.
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_))
.WillOnce(Invoke([expected_playout_delay =
GetParam().expected_delay](EncodedFrame* frame) {
.WillOnce([expected_playout_delay =
GetParam().expected_delay](EncodedFrame* frame) {
EXPECT_EQ(frame->EncodedImage().PlayoutDelay(), expected_playout_delay);
}));
});
rtp_video_stream_receiver_->OnReceivedPayloadData(
received_packet.PayloadBuffer(), received_packet, video_header, 0);
}

15
video/video_receive_stream2_unittest.cc
View File

@ -213,9 +213,9 @@ class VideoReceiveStream2Test : public ::testing::TestWithParam<bool> {
.WillByDefault(Invoke(&fake_decoder_, &test::FakeDecoder::Release));
ON_CALL(mock_transport_, SendRtcp)
.WillByDefault(
Invoke([this](ArrayView<const uint8_t> packet, ::testing::Unused) {
[this](ArrayView<const uint8_t> packet, ::testing::Unused) {
return rtcp_packet_parser_.Parse(packet);
}));
});
}
~VideoReceiveStream2Test() override {
@ -1012,11 +1012,12 @@ TEST_P(VideoReceiveStream2Test, FramesFastForwardOnSystemHalt) {
.Build();
InSequence seq;
EXPECT_CALL(mock_decoder_, Decode(test::RtpTimestamp(kFirstRtpTimestamp), _))
.WillOnce(testing::DoAll(Invoke([&] {
// System halt will be simulated in the decode.
time_controller_.AdvanceTime(k30FpsDelay * 2);
}),
DefaultDecodeAction()));
.WillOnce(testing::DoAll(
[&] {
// System halt will be simulated in the decode.
time_controller_.AdvanceTime(k30FpsDelay * 2);
},
DefaultDecodeAction()));
EXPECT_CALL(mock_decoder_,
Decode(test::RtpTimestamp(RtpTimestampForFrame(2)), _));
video_receive_stream_->OnCompleteFrame(std::move(key_frame));

26
video/video_send_stream_impl_unittest.cc
View File

@ -76,7 +76,6 @@ using ::testing::AnyNumber;
using ::testing::ElementsAreArray;
using ::testing::Eq;
using ::testing::Field;
using ::testing::Invoke;
using ::testing::Mock;
using ::testing::NiceMock;
using ::testing::Return;
@ -164,9 +163,9 @@ class VideoSendStreamImplTest : public ::testing::Test {
.WillRepeatedly(Return(&packet_router_));
EXPECT_CALL(transport_controller_, CreateRtpVideoSender)
.WillRepeatedly(Return(&rtp_video_sender_));
ON_CALL(rtp_video_sender_, IsActive()).WillByDefault(Invoke([&]() {
ON_CALL(rtp_video_sender_, IsActive()).WillByDefault([&]() {
return rtp_sending_;
}));
});
ON_CALL(rtp_video_sender_, SetSending)
.WillByDefault(SaveArg<0>(&rtp_sending_));
}
@ -426,7 +425,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) {
int min_transmit_bitrate_bps = 30000;
EXPECT_CALL(bitrate_allocator_, AddObserver(vss_impl.get(), _))
.WillRepeatedly(Invoke(
.WillRepeatedly(
[&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
EXPECT_EQ(config.min_bitrate_bps,
static_cast<uint32_t>(min_transmit_bitrate_bps));
@ -439,7 +438,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) {
vga_stream.min_bitrate_bps));
}
EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
}));
});
encoder_queue_->PostTask([&] {
static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
@ -493,7 +492,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
int min_transmit_bitrate_bps = 400000;
EXPECT_CALL(bitrate_allocator_, AddObserver(vss_impl.get(), _))
.WillRepeatedly(Invoke(
.WillRepeatedly(
[&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
EXPECT_EQ(config.min_bitrate_bps,
static_cast<uint32_t>(low_stream.min_bitrate_bps));
@ -505,7 +504,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
static_cast<uint32_t>(min_transmit_bitrate_bps));
}
EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
}));
});
encoder_queue_->PostTask([&] {
static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
->OnEncoderConfigurationChanged(
@ -549,8 +548,8 @@ TEST_F(VideoSendStreamImplTest,
high_stream.bitrate_priority = 1;
EXPECT_CALL(bitrate_allocator_, AddObserver(vss_impl.get(), _))
.WillRepeatedly(Invoke([&](BitrateAllocatorObserver*,
MediaStreamAllocationConfig config) {
.WillRepeatedly([&](BitrateAllocatorObserver*,
MediaStreamAllocationConfig config) {
EXPECT_EQ(config.min_bitrate_bps,
static_cast<uint32_t>(low_stream.min_bitrate_bps));
EXPECT_EQ(config.max_bitrate_bps,
@ -561,7 +560,7 @@ TEST_F(VideoSendStreamImplTest,
static_cast<uint32_t>(low_stream.target_bitrate_bps +
1.25 * high_stream.min_bitrate_bps));
}
}));
});
encoder_queue_->PostTask([&] {
static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
@ -1029,14 +1028,13 @@ TEST_F(VideoSendStreamImplTest, DisablesPaddingOnPausedEncoder) {
// Capture padding bitrate for testing.
EXPECT_CALL(bitrate_allocator_, AddObserver(vss_impl.get(), _))
.WillRepeatedly(Invoke(
.WillRepeatedly(
[&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
padding_bitrate = config.pad_up_bitrate_bps;
}));
});
// If observer is removed, no padding will be sent.
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get()))
.WillRepeatedly(
Invoke([&](BitrateAllocatorObserver*) { padding_bitrate = 0; }));
.WillRepeatedly([&](BitrateAllocatorObserver*) { padding_bitrate = 0; });
EXPECT_CALL(rtp_video_sender_, OnEncodedImage)
.WillRepeatedly(Return(

47
video/video_stream_encoder_unittest.cc
View File

@ -130,7 +130,6 @@ using ::testing::Eq;
using ::testing::Field;
using ::testing::Ge;
using ::testing::Gt;
using ::testing::Invoke;
using ::testing::IsTrue;
using ::testing::Le;
using ::testing::Lt;
@ -10031,10 +10030,10 @@ TEST(VideoStreamEncoderFrameCadenceTest, ActivatesFrameCadenceOnContentType) {
FrameCadenceAdapterInterface::Callback* video_stream_encoder_callback =
nullptr;
EXPECT_CALL(*adapter_ptr, Initialize)
.WillOnce(Invoke([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
.WillOnce([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
video_stream_encoder_callback = callback;
}));
});
TaskQueueBase* encoder_queue = nullptr;
auto video_stream_encoder =
factory.Create(std::move(adapter), &encoder_queue);
@ -10095,10 +10094,10 @@ TEST(VideoStreamEncoderFrameCadenceTest, UsesFrameCadenceAdapterForFrameRate) {
FrameCadenceAdapterInterface::Callback* video_stream_encoder_callback =
nullptr;
EXPECT_CALL(*adapter_ptr, Initialize)
.WillOnce(Invoke([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
.WillOnce([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
video_stream_encoder_callback = callback;
}));
});
TaskQueueBase* encoder_queue = nullptr;
auto video_stream_encoder =
factory.Create(std::move(adapter), &encoder_queue);
@ -10126,10 +10125,10 @@ TEST(VideoStreamEncoderFrameCadenceTest,
FrameCadenceAdapterInterface::Callback* video_stream_encoder_callback =
nullptr;
EXPECT_CALL(*adapter_ptr, Initialize)
.WillOnce(Invoke([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
.WillOnce([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
video_stream_encoder_callback = callback;
}));
});
TaskQueueBase* encoder_queue = nullptr;
auto video_stream_encoder =
factory.Create(std::move(adapter), &encoder_queue);
@ -10182,10 +10181,10 @@ TEST(VideoStreamEncoderFrameCadenceTest, UpdatesQualityConvergence) {
FrameCadenceAdapterInterface::Callback* video_stream_encoder_callback =
nullptr;
EXPECT_CALL(*adapter_ptr, Initialize)
.WillOnce(Invoke([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
.WillOnce([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
video_stream_encoder_callback = callback;
}));
});
TaskQueueBase* encoder_queue = nullptr;
auto video_stream_encoder =
factory.Create(std::move(adapter), &encoder_queue);
@ -10207,13 +10206,13 @@ TEST(VideoStreamEncoderFrameCadenceTest, UpdatesQualityConvergence) {
// Pass a frame which has unconverged results.
PassAFrame(encoder_queue, video_stream_encoder_callback, /*ntp_time_ms=*/1);
EXPECT_CALL(factory.GetMockFakeEncoder(), EncodeHook)
.WillRepeatedly(Invoke([](EncodedImage& encoded_image,
scoped_refptr<EncodedImageBuffer> buffer) {
.WillRepeatedly([](EncodedImage& encoded_image,
scoped_refptr<EncodedImageBuffer> buffer) {
encoded_image.qp_ = kVp8SteadyStateQpThreshold + 1;
CodecSpecificInfo codec_specific;
codec_specific.codecType = kVideoCodecVP8;
return codec_specific;
}));
});
EXPECT_CALL(*adapter_ptr, UpdateLayerQualityConvergence(0, false));
EXPECT_CALL(*adapter_ptr, UpdateLayerQualityConvergence(1, false));
factory.DepleteTaskQueues();
@ -10223,8 +10222,8 @@ TEST(VideoStreamEncoderFrameCadenceTest, UpdatesQualityConvergence) {
// Pass a frame which converges in layer 0 and not in layer 1.
PassAFrame(encoder_queue, video_stream_encoder_callback, /*ntp_time_ms=*/2);
EXPECT_CALL(factory.GetMockFakeEncoder(), EncodeHook)
.WillRepeatedly(Invoke([](EncodedImage& encoded_image,
scoped_refptr<EncodedImageBuffer> buffer) {
.WillRepeatedly([](EncodedImage& encoded_image,
scoped_refptr<EncodedImageBuffer> buffer) {
// This sets simulcast index 0 content to be at target quality, while
// index 1 content is not.
encoded_image.qp_ = kVp8SteadyStateQpThreshold +
@ -10232,7 +10231,7 @@ TEST(VideoStreamEncoderFrameCadenceTest, UpdatesQualityConvergence) {
CodecSpecificInfo codec_specific;
codec_specific.codecType = kVideoCodecVP8;
return codec_specific;
}));
});
EXPECT_CALL(*adapter_ptr, UpdateLayerQualityConvergence(0, true));
EXPECT_CALL(*adapter_ptr, UpdateLayerQualityConvergence(1, false));
factory.DepleteTaskQueues();
@ -10249,10 +10248,10 @@ TEST(VideoStreamEncoderFrameCadenceTest,
FrameCadenceAdapterInterface::Callback* video_stream_encoder_callback =
nullptr;
EXPECT_CALL(*adapter_ptr, Initialize)
.WillOnce(Invoke([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
.WillOnce([&video_stream_encoder_callback](
FrameCadenceAdapterInterface::Callback* callback) {
video_stream_encoder_callback = callback;
}));
});
TaskQueueBase* encoder_queue = nullptr;
auto video_stream_encoder =
factory.Create(std::move(adapter), &encoder_queue);
@ -10267,9 +10266,9 @@ TEST(VideoStreamEncoderFrameCadenceTest,
factory.DepleteTaskQueues();
EXPECT_CALL(*adapter_ptr, ProcessKeyFrameRequest)
.WillOnce(Invoke([video_stream_encoder_callback] {
.WillOnce([video_stream_encoder_callback] {
video_stream_encoder_callback->RequestRefreshFrame();
}));
});
EXPECT_CALL(mock_source, RequestRefreshFrame);
video_stream_encoder->SendKeyFrame();
factory.DepleteTaskQueues();