From b63331bb8f7fc21ceb2d3dabfd977e535559ff23 Mon Sep 17 00:00:00 2001 From: Danil Chapovalov Date: Thu, 7 May 2020 11:52:45 +0200 Subject: [PATCH] Cleanup mocks for Video (en|de)coder factories In particular remove proxy mocks in favor of lambdas and Return(ByMove(...)) Bug: None Change-Id: If6b79601437e82a7116479d128d538e965622fab Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174701 Reviewed-by: Ilya Nikolaevskiy Reviewed-by: Sebastian Jansson Commit-Queue: Danil Chapovalov Cr-Commit-Position: refs/heads/master@{#31179} --- api/test/mock_video_decoder_factory.h | 23 +++--- api/test/mock_video_encoder_factory.h | 28 +++---- .../encoder_simulcast_proxy_unittest.cc | 78 +++++++++---------- media/engine/webrtc_video_engine_unittest.cc | 21 +++-- .../test/multiplex_adapter_unittest.cc | 20 ++--- 5 files changed, 78 insertions(+), 92 deletions(-) diff --git a/api/test/mock_video_decoder_factory.h b/api/test/mock_video_decoder_factory.h index 915e3911f0..1f832a156b 100644 --- a/api/test/mock_video_decoder_factory.h +++ b/api/test/mock_video_decoder_factory.h @@ -22,20 +22,17 @@ namespace webrtc { class MockVideoDecoderFactory : public webrtc::VideoDecoderFactory { public: - MOCK_CONST_METHOD0(GetSupportedFormats, - std::vector()); + ~MockVideoDecoderFactory() override { Die(); } - // We need to proxy to a return type that is copyable. - std::unique_ptr CreateVideoDecoder( - const webrtc::SdpVideoFormat& format) { - return std::unique_ptr( - CreateVideoDecoderProxy(format)); - } - MOCK_METHOD1(CreateVideoDecoderProxy, - webrtc::VideoDecoder*(const webrtc::SdpVideoFormat&)); - - MOCK_METHOD0(Die, void()); - ~MockVideoDecoderFactory() { Die(); } + MOCK_METHOD(std::vector, + GetSupportedFormats, + (), + (const override)); + MOCK_METHOD(std::unique_ptr, + CreateVideoDecoder, + (const webrtc::SdpVideoFormat&), + (override)); + MOCK_METHOD(void, Die, (), ()); }; } // namespace webrtc diff --git a/api/test/mock_video_encoder_factory.h b/api/test/mock_video_encoder_factory.h index a694b636e0..fa08dbd6bc 100644 --- a/api/test/mock_video_encoder_factory.h +++ b/api/test/mock_video_encoder_factory.h @@ -22,22 +22,22 @@ namespace webrtc { class MockVideoEncoderFactory : public webrtc::VideoEncoderFactory { public: - MOCK_CONST_METHOD0(GetSupportedFormats, - std::vector()); - MOCK_CONST_METHOD1(QueryVideoEncoder, - CodecInfo(const webrtc::SdpVideoFormat&)); + ~MockVideoEncoderFactory() override { Die(); } - // We need to proxy to a return type that is copyable. - std::unique_ptr CreateVideoEncoder( - const webrtc::SdpVideoFormat& format) { - return std::unique_ptr( - CreateVideoEncoderProxy(format)); - } - MOCK_METHOD1(CreateVideoEncoderProxy, - webrtc::VideoEncoder*(const webrtc::SdpVideoFormat&)); + MOCK_METHOD(std::vector, + GetSupportedFormats, + (), + (const override)); + MOCK_METHOD(CodecInfo, + QueryVideoEncoder, + (const SdpVideoFormat&), + (const override)); + MOCK_METHOD(std::unique_ptr, + CreateVideoEncoder, + (const SdpVideoFormat&), + (override)); - MOCK_METHOD0(Die, void()); - ~MockVideoEncoderFactory() { Die(); } + MOCK_METHOD(void, Die, (), ()); }; } // namespace webrtc diff --git a/media/engine/encoder_simulcast_proxy_unittest.cc b/media/engine/encoder_simulcast_proxy_unittest.cc index 591e7523de..ebbadb00a4 100644 --- a/media/engine/encoder_simulcast_proxy_unittest.cc +++ b/media/engine/encoder_simulcast_proxy_unittest.cc @@ -11,7 +11,9 @@ #include "media/engine/encoder_simulcast_proxy.h" +#include #include +#include #include "api/test/mock_video_encoder.h" #include "api/test/mock_video_encoder_factory.h" @@ -30,6 +32,7 @@ const VideoEncoder::Settings kSettings(kCapabilities, 4, 1200); } // namespace using ::testing::_; +using ::testing::ByMove; using ::testing::NiceMock; using ::testing::Return; @@ -65,7 +68,7 @@ TEST(EncoderSimulcastProxy, ChoosesCorrectImplementation) { 56}; codec_settings.numberOfSimulcastStreams = 3; - NiceMock* mock_encoder = new NiceMock(); + auto mock_encoder = std::make_unique>(); NiceMock simulcast_factory; EXPECT_CALL(*mock_encoder, InitEncode(_, _)) @@ -75,9 +78,9 @@ TEST(EncoderSimulcastProxy, ChoosesCorrectImplementation) { EXPECT_CALL(*mock_encoder, GetEncoderInfo()) .WillRepeatedly(Return(encoder_info)); - EXPECT_CALL(simulcast_factory, CreateVideoEncoderProxy(_)) + EXPECT_CALL(simulcast_factory, CreateVideoEncoder) .Times(1) - .WillOnce(Return(mock_encoder)); + .WillOnce(Return(ByMove(std::move(mock_encoder)))); EncoderSimulcastProxy simulcast_enabled_proxy(&simulcast_factory, SdpVideoFormat("VP8")); @@ -86,39 +89,27 @@ TEST(EncoderSimulcastProxy, ChoosesCorrectImplementation) { EXPECT_EQ(kImplementationName, simulcast_enabled_proxy.GetEncoderInfo().implementation_name); - NiceMock* mock_encoder1 = new NiceMock(); - NiceMock* mock_encoder2 = new NiceMock(); - NiceMock* mock_encoder3 = new NiceMock(); - NiceMock* mock_encoder4 = new NiceMock(); NiceMock nonsimulcast_factory; - EXPECT_CALL(*mock_encoder1, InitEncode(_, _)) - .WillOnce( - Return(WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED)); - EXPECT_CALL(*mock_encoder1, GetEncoderInfo()) - .WillRepeatedly(Return(encoder_info)); - - EXPECT_CALL(*mock_encoder2, InitEncode(_, _)) - .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); - EXPECT_CALL(*mock_encoder2, GetEncoderInfo()) - .WillRepeatedly(Return(encoder_info)); - - EXPECT_CALL(*mock_encoder3, InitEncode(_, _)) - .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); - EXPECT_CALL(*mock_encoder3, GetEncoderInfo()) - .WillRepeatedly(Return(encoder_info)); - - EXPECT_CALL(*mock_encoder4, InitEncode(_, _)) - .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); - EXPECT_CALL(*mock_encoder4, GetEncoderInfo()) - .WillRepeatedly(Return(encoder_info)); - - EXPECT_CALL(nonsimulcast_factory, CreateVideoEncoderProxy(_)) + EXPECT_CALL(nonsimulcast_factory, CreateVideoEncoder) .Times(4) - .WillOnce(Return(mock_encoder1)) - .WillOnce(Return(mock_encoder2)) - .WillOnce(Return(mock_encoder3)) - .WillOnce(Return(mock_encoder4)); + .WillOnce([&] { + auto mock_encoder = std::make_unique>(); + EXPECT_CALL(*mock_encoder, InitEncode(_, _)) + .WillOnce(Return( + WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED)); + ON_CALL(*mock_encoder, GetEncoderInfo) + .WillByDefault(Return(encoder_info)); + return mock_encoder; + }) + .WillRepeatedly([&] { + auto mock_encoder = std::make_unique>(); + EXPECT_CALL(*mock_encoder, InitEncode(_, _)) + .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); + ON_CALL(*mock_encoder, GetEncoderInfo) + .WillByDefault(Return(encoder_info)); + return mock_encoder; + }); EncoderSimulcastProxy simulcast_disabled_proxy(&nonsimulcast_factory, SdpVideoFormat("VP8")); @@ -133,15 +124,16 @@ TEST(EncoderSimulcastProxy, ChoosesCorrectImplementation) { } TEST(EncoderSimulcastProxy, ForwardsTrustedSetting) { - NiceMock* mock_encoder = new NiceMock(); + auto mock_encoder_owned = std::make_unique>(); + auto* mock_encoder = mock_encoder_owned.get(); NiceMock simulcast_factory; EXPECT_CALL(*mock_encoder, InitEncode(_, _)) .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); - EXPECT_CALL(simulcast_factory, CreateVideoEncoderProxy(_)) + EXPECT_CALL(simulcast_factory, CreateVideoEncoder) .Times(1) - .WillOnce(Return(mock_encoder)); + .WillOnce(Return(ByMove(std::move(mock_encoder_owned)))); EncoderSimulcastProxy simulcast_enabled_proxy(&simulcast_factory, SdpVideoFormat("VP8")); @@ -159,15 +151,16 @@ TEST(EncoderSimulcastProxy, ForwardsTrustedSetting) { } TEST(EncoderSimulcastProxy, ForwardsHardwareAccelerated) { - NiceMock* mock_encoder = new NiceMock(); + auto mock_encoder_owned = std::make_unique>(); + NiceMock* mock_encoder = mock_encoder_owned.get(); NiceMock simulcast_factory; EXPECT_CALL(*mock_encoder, InitEncode(_, _)) .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); - EXPECT_CALL(simulcast_factory, CreateVideoEncoderProxy(_)) + EXPECT_CALL(simulcast_factory, CreateVideoEncoder) .Times(1) - .WillOnce(Return(mock_encoder)); + .WillOnce(Return(ByMove(std::move(mock_encoder_owned)))); EncoderSimulcastProxy simulcast_enabled_proxy(&simulcast_factory, SdpVideoFormat("VP8")); @@ -189,15 +182,16 @@ TEST(EncoderSimulcastProxy, ForwardsHardwareAccelerated) { } TEST(EncoderSimulcastProxy, ForwardsInternalSource) { - NiceMock* mock_encoder = new NiceMock(); + auto mock_encoder_owned = std::make_unique>(); + NiceMock* mock_encoder = mock_encoder_owned.get(); NiceMock simulcast_factory; EXPECT_CALL(*mock_encoder, InitEncode(_, _)) .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); - EXPECT_CALL(simulcast_factory, CreateVideoEncoderProxy(_)) + EXPECT_CALL(simulcast_factory, CreateVideoEncoder) .Times(1) - .WillOnce(Return(mock_encoder)); + .WillOnce(Return(ByMove(std::move(mock_encoder_owned)))); EncoderSimulcastProxy simulcast_enabled_proxy(&simulcast_factory, SdpVideoFormat("VP8")); diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc index 4a33c5152b..a3ea95167d 100644 --- a/media/engine/webrtc_video_engine_unittest.cc +++ b/media/engine/webrtc_video_engine_unittest.cc @@ -1134,18 +1134,16 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) { const webrtc::SdpVideoFormat format("VP8"); EXPECT_CALL(*encoder_factory, QueryVideoEncoder(format)) .WillRepeatedly(Return(codec_info)); - FakeWebRtcVideoEncoder* const encoder = new FakeWebRtcVideoEncoder(nullptr); rtc::Event encoder_created; - EXPECT_CALL(*encoder_factory, CreateVideoEncoderProxy(format)) - .WillOnce( - ::testing::DoAll(::testing::InvokeWithoutArgs( - [&encoder_created]() { encoder_created.Set(); }), - Return(encoder))); + EXPECT_CALL(*encoder_factory, CreateVideoEncoder(format)).WillOnce([&] { + encoder_created.Set(); + return std::make_unique(nullptr); + }); // Mock decoder creation. |engine| take ownership of the decoder. - FakeWebRtcVideoDecoder* const decoder = new FakeWebRtcVideoDecoder(nullptr); - EXPECT_CALL(*decoder_factory, CreateVideoDecoderProxy(format)) - .WillOnce(Return(decoder)); + EXPECT_CALL(*decoder_factory, CreateVideoDecoder(format)).WillOnce([] { + return std::make_unique(nullptr); + }); // Create a call. webrtc::RtcEventLogNull event_log; @@ -1216,8 +1214,9 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullDecoder) { .WillRepeatedly(Return(supported_formats)); // Decoder creation fails. - EXPECT_CALL(*decoder_factory, CreateVideoDecoderProxy(_)) - .WillOnce(Return(nullptr)); + EXPECT_CALL(*decoder_factory, CreateVideoDecoder).WillOnce([] { + return nullptr; + }); // Create a call. webrtc::RtcEventLogNull event_log; diff --git a/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc b/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc index 8983fb022a..770d8b596c 100644 --- a/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc +++ b/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc @@ -180,21 +180,17 @@ class TestMultiplexAdapter : public VideoCodecUnitTest, private: void SetUp() override { - EXPECT_CALL(*decoder_factory_, Die()); + EXPECT_CALL(*decoder_factory_, Die); // The decoders/encoders will be owned by the caller of // CreateVideoDecoder()/CreateVideoEncoder(). - VideoDecoder* decoder1 = VP9Decoder::Create().release(); - VideoDecoder* decoder2 = VP9Decoder::Create().release(); - EXPECT_CALL(*decoder_factory_, CreateVideoDecoderProxy(_)) - .WillOnce(Return(decoder1)) - .WillOnce(Return(decoder2)); + EXPECT_CALL(*decoder_factory_, CreateVideoDecoder) + .Times(2) + .WillRepeatedly([] { return VP9Decoder::Create(); }); - EXPECT_CALL(*encoder_factory_, Die()); - VideoEncoder* encoder1 = VP9Encoder::Create().release(); - VideoEncoder* encoder2 = VP9Encoder::Create().release(); - EXPECT_CALL(*encoder_factory_, CreateVideoEncoderProxy(_)) - .WillOnce(Return(encoder1)) - .WillOnce(Return(encoder2)); + EXPECT_CALL(*encoder_factory_, Die); + EXPECT_CALL(*encoder_factory_, CreateVideoEncoder) + .Times(2) + .WillRepeatedly([] { return VP9Encoder::Create(); }); VideoCodecUnitTest::SetUp(); }