zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup mocks for Video (en|de)coder factories

Browse Source 
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 <ilnik@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31179}
This commit is contained in:
Danil Chapovalov
2020-05-07 11:52:45 +02:00
committed by Commit Bot
parent 1e83d34fc1
commit b63331bb8f
5 changed files with 78 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
api/test/mock_video_decoder_factory.h
View File

@ -22,20 +22,17 @@ namespace webrtc {
class MockVideoDecoderFactory : public webrtc::VideoDecoderFactory {
public:
MOCK_CONST_METHOD0(GetSupportedFormats,
std::vector<webrtc::SdpVideoFormat>());
~MockVideoDecoderFactory() override { Die(); }
// We need to proxy to a return type that is copyable.
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) {
return std::unique_ptr<webrtc::VideoDecoder>(
CreateVideoDecoderProxy(format));
}
MOCK_METHOD1(CreateVideoDecoderProxy,
webrtc::VideoDecoder*(const webrtc::SdpVideoFormat&));
MOCK_METHOD0(Die, void());
~MockVideoDecoderFactory() { Die(); }
MOCK_METHOD(std::vector<webrtc::SdpVideoFormat>,
GetSupportedFormats,
(),
(const override));
MOCK_METHOD(std::unique_ptr<webrtc::VideoDecoder>,
CreateVideoDecoder,
(const webrtc::SdpVideoFormat&),
(override));
MOCK_METHOD(void, Die, (), ());
};
} // namespace webrtc

28
api/test/mock_video_encoder_factory.h
View File

@ -22,22 +22,22 @@ namespace webrtc {
class MockVideoEncoderFactory : public webrtc::VideoEncoderFactory {
public:
MOCK_CONST_METHOD0(GetSupportedFormats,
std::vector<webrtc::SdpVideoFormat>());
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<webrtc::VideoEncoder> CreateVideoEncoder(
const webrtc::SdpVideoFormat& format) {
return std::unique_ptr<webrtc::VideoEncoder>(
CreateVideoEncoderProxy(format));
}
MOCK_METHOD1(CreateVideoEncoderProxy,
webrtc::VideoEncoder*(const webrtc::SdpVideoFormat&));
MOCK_METHOD(std::vector<SdpVideoFormat>,
GetSupportedFormats,
(),
(const override));
MOCK_METHOD(CodecInfo,
QueryVideoEncoder,
(const SdpVideoFormat&),
(const override));
MOCK_METHOD(std::unique_ptr<VideoEncoder>,
CreateVideoEncoder,
(const SdpVideoFormat&),
(override));
MOCK_METHOD0(Die, void());
~MockVideoEncoderFactory() { Die(); }
MOCK_METHOD(void, Die, (), ());
};
} // namespace webrtc

78
media/engine/encoder_simulcast_proxy_unittest.cc
View File

@ -11,7 +11,9 @@
#include "media/engine/encoder_simulcast_proxy.h"
#include <memory>
#include <string>
#include <utility>
#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<MockVideoEncoder>* mock_encoder = new NiceMock<MockVideoEncoder>();
auto mock_encoder = std::make_unique<NiceMock<MockVideoEncoder>>();
NiceMock<MockVideoEncoderFactory> 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<MockVideoEncoder>* mock_encoder1 = new NiceMock<MockVideoEncoder>();
NiceMock<MockVideoEncoder>* mock_encoder2 = new NiceMock<MockVideoEncoder>();
NiceMock<MockVideoEncoder>* mock_encoder3 = new NiceMock<MockVideoEncoder>();
NiceMock<MockVideoEncoder>* mock_encoder4 = new NiceMock<MockVideoEncoder>();
NiceMock<MockVideoEncoderFactory> 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<NiceMock<MockVideoEncoder>>();
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<NiceMock<MockVideoEncoder>>();
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<MockVideoEncoder>* mock_encoder = new NiceMock<MockVideoEncoder>();
auto mock_encoder_owned = std::make_unique<NiceMock<MockVideoEncoder>>();
auto* mock_encoder = mock_encoder_owned.get();
NiceMock<MockVideoEncoderFactory> 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<MockVideoEncoder>* mock_encoder = new NiceMock<MockVideoEncoder>();
auto mock_encoder_owned = std::make_unique<NiceMock<MockVideoEncoder>>();
NiceMock<MockVideoEncoder>* mock_encoder = mock_encoder_owned.get();
NiceMock<MockVideoEncoderFactory> 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<MockVideoEncoder>* mock_encoder = new NiceMock<MockVideoEncoder>();
auto mock_encoder_owned = std::make_unique<NiceMock<MockVideoEncoder>>();
NiceMock<MockVideoEncoder>* mock_encoder = mock_encoder_owned.get();
NiceMock<MockVideoEncoderFactory> 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"));

21
media/engine/webrtc_video_engine_unittest.cc
View File

@ -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<FakeWebRtcVideoEncoder>(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<FakeWebRtcVideoDecoder>(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;

20
modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc
View File

@ -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();
}