admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

In video/ replace mock macros with unified MOCK_METHOD macro

Browse Source 
Bug: webrtc:11564
Change-Id: Iec9dded7a3f045e048d0546c268ae206a7d3a7c7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175128
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31264}
This commit is contained in:
Danil Chapovalov 2020-05-14 19:17:51 +02:00 committed by Commit Bot
parent 37120ab59d
commit 91fdc607d8
10 changed files with 169 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
video/adaptation/overuse_frame_detector_unittest.cc
View File

@ -41,8 +41,8 @@ class MockCpuOveruseObserver : public OveruseFrameDetectorObserverInterface {
MockCpuOveruseObserver() {}
virtual ~MockCpuOveruseObserver() {}
MOCK_METHOD0(AdaptUp, void());
MOCK_METHOD0(AdaptDown, void());
MOCK_METHOD(void, AdaptUp, (), (override));
MOCK_METHOD(void, AdaptDown, (), (override));
};
class CpuOveruseObserverImpl : public OveruseFrameDetectorObserverInterface {

2
video/call_stats2_unittest.cc
View File

@ -33,7 +33,7 @@ class MockStatsObserver : public CallStatsObserver {
MockStatsObserver() {}
virtual ~MockStatsObserver() {}
MOCK_METHOD2(OnRttUpdate, void(int64_t, int64_t));
MOCK_METHOD(void, OnRttUpdate, (int64_t, int64_t), (override));
};
class CallStats2Test : public ::testing::Test {

2
video/call_stats_unittest.cc
View File

@ -32,7 +32,7 @@ class MockStatsObserver : public CallStatsObserver {
MockStatsObserver() {}
virtual ~MockStatsObserver() {}
MOCK_METHOD2(OnRttUpdate, void(int64_t, int64_t));
MOCK_METHOD(void, OnRttUpdate, (int64_t, int64_t), (override));
};
class CallStatsTest : public ::testing::Test {

46
video/rtp_video_stream_receiver_unittest.cc
View File

@ -73,37 +73,45 @@ RTPVideoHeader GetGenericVideoHeader(VideoFrameType frame_type) {
class MockTransport : public Transport {
public:
MOCK_METHOD3(SendRtp,
bool(const uint8_t* packet,
size_t length,
const PacketOptions& options));
MOCK_METHOD2(SendRtcp, bool(const uint8_t* packet, size_t length));
MOCK_METHOD(bool,
SendRtp,
(const uint8_t*, size_t length, const PacketOptions& options),
(override));
MOCK_METHOD(bool, SendRtcp, (const uint8_t*, size_t length), (override));
};
class MockNackSender : public NackSender {
public:
MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers));
MOCK_METHOD2(SendNack,
void(const std::vector<uint16_t>& sequence_numbers,
bool buffering_allowed));
MOCK_METHOD(void,
SendNack,
(const std::vector<uint16_t>& sequence_numbers,
bool buffering_allowed),
(override));
};
class MockKeyFrameRequestSender : public KeyFrameRequestSender {
public:
MOCK_METHOD0(RequestKeyFrame, void());
MOCK_METHOD(void, RequestKeyFrame, (), (override));
};
class MockOnCompleteFrameCallback
: public video_coding::OnCompleteFrameCallback {
public:
MOCK_METHOD1(DoOnCompleteFrame, void(video_coding::EncodedFrame* frame));
MOCK_METHOD1(DoOnCompleteFrameFailNullptr,
void(video_coding::EncodedFrame* frame));
MOCK_METHOD1(DoOnCompleteFrameFailLength,
void(video_coding::EncodedFrame* frame));
MOCK_METHOD1(DoOnCompleteFrameFailBitstream,
void(video_coding::EncodedFrame* frame));
void OnCompleteFrame(std::unique_ptr<video_coding::EncodedFrame> frame) {
MOCK_METHOD(void, DoOnCompleteFrame, (video_coding::EncodedFrame*), ());
MOCK_METHOD(void,
DoOnCompleteFrameFailNullptr,
(video_coding::EncodedFrame*),
());
MOCK_METHOD(void,
DoOnCompleteFrameFailLength,
(video_coding::EncodedFrame*),
());
MOCK_METHOD(void,
DoOnCompleteFrameFailBitstream,
(video_coding::EncodedFrame*),
());
void OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) override {
if (!frame) {
DoOnCompleteFrameFailNullptr(nullptr);
return;
@ -132,7 +140,7 @@ class MockOnCompleteFrameCallback
class MockRtpPacketSink : public RtpPacketSinkInterface {
public:
MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived&));
MOCK_METHOD(void, OnRtpPacket, (const RtpPacketReceived&), (override));
};
constexpr uint32_t kSsrc = 111;

44
video/test/mock_video_stream_encoder.h
View File

@ -17,22 +17,36 @@ namespace webrtc {
class MockVideoStreamEncoder : public VideoStreamEncoderInterface {
public:
MOCK_METHOD2(SetSource,
void(rtc::VideoSourceInterface<VideoFrame>*,
const DegradationPreference&));
MOCK_METHOD2(SetSink, void(EncoderSink*, bool));
MOCK_METHOD1(SetStartBitrate, void(int));
MOCK_METHOD0(SendKeyFrame, void());
MOCK_METHOD1(OnLossNotification, void(const VideoEncoder::LossNotification&));
MOCK_METHOD6(OnBitrateUpdated,
void(DataRate, DataRate, DataRate, uint8_t, int64_t, double));
MOCK_METHOD1(OnFrame, void(const VideoFrame&));
MOCK_METHOD1(SetBitrateAllocationObserver,
void(VideoBitrateAllocationObserver*));
MOCK_METHOD1(SetFecControllerOverride, void(FecControllerOverride*));
MOCK_METHOD0(Stop, void());
MOCK_METHOD(void,
SetSource,
(rtc::VideoSourceInterface<VideoFrame>*,
const DegradationPreference&),
(override));
MOCK_METHOD(void, SetSink, (EncoderSink*, bool), (override));
MOCK_METHOD(void, SetStartBitrate, (int), (override));
MOCK_METHOD(void, SendKeyFrame, (), (override));
MOCK_METHOD(void,
OnLossNotification,
(const VideoEncoder::LossNotification&),
(override));
MOCK_METHOD(void,
OnBitrateUpdated,
(DataRate, DataRate, DataRate, uint8_t, int64_t, double),
(override));
MOCK_METHOD(void, OnFrame, (const VideoFrame&), (override));
MOCK_METHOD(void,
SetBitrateAllocationObserver,
(VideoBitrateAllocationObserver*),
(override));
MOCK_METHOD(void,
SetFecControllerOverride,
(FecControllerOverride*),
(override));
MOCK_METHOD(void, Stop, (), (override));
MOCK_METHOD2(MockedConfigureEncoder, void(const VideoEncoderConfig&, size_t));
MOCK_METHOD(void,
MockedConfigureEncoder,
(const VideoEncoderConfig&, size_t));
// gtest generates implicit copy which is not allowed on VideoEncoderConfig,
// so we can't mock ConfigureEncoder directly.
void ConfigureEncoder(VideoEncoderConfig config,

34
video/video_receive_stream_unittest.cc
View File

@ -49,24 +49,30 @@ constexpr int kDefaultTimeOutMs = 50;
class MockTransport : public Transport {
public:
MOCK_METHOD3(SendRtp,
bool(const uint8_t* packet,
size_t length,
const PacketOptions& options));
MOCK_METHOD2(SendRtcp, bool(const uint8_t* packet, size_t length));
MOCK_METHOD(bool,
SendRtp,
(const uint8_t*, size_t length, const PacketOptions& options),
(override));
MOCK_METHOD(bool, SendRtcp, (const uint8_t*, size_t length), (override));
};
class MockVideoDecoder : public VideoDecoder {
public:
MOCK_METHOD2(InitDecode,
int32_t(const VideoCodec* config, int32_t number_of_cores));
MOCK_METHOD3(Decode,
int32_t(const EncodedImage& input,
bool missing_frames,
int64_t render_time_ms));
MOCK_METHOD1(RegisterDecodeCompleteCallback,
int32_t(DecodedImageCallback* callback));
MOCK_METHOD0(Release, int32_t(void));
MOCK_METHOD(int32_t,
InitDecode,
(const VideoCodec*, int32_t number_of_cores),
(override));
MOCK_METHOD(int32_t,
Decode,
(const EncodedImage& input,
bool missing_frames,
int64_t render_time_ms),
(override));
MOCK_METHOD(int32_t,
RegisterDecodeCompleteCallback,
(DecodedImageCallback*),
(override));
MOCK_METHOD(int32_t, Release, (), (override));
const char* ImplementationName() const { return "MockVideoDecoder"; }
};

64
video/video_send_stream_impl_unittest.cc
View File

@ -58,33 +58,45 @@ std::string GetAlrProbingExperimentString() {
}
class MockRtpVideoSender : public RtpVideoSenderInterface {
public:
MOCK_METHOD1(RegisterProcessThread, void(ProcessThread*));
MOCK_METHOD0(DeRegisterProcessThread, void());
MOCK_METHOD1(SetActive, void(bool));
MOCK_METHOD1(SetActiveModules, void(const std::vector<bool>));
MOCK_METHOD0(IsActive, bool());
MOCK_METHOD1(OnNetworkAvailability, void(bool));
MOCK_CONST_METHOD0(GetRtpStates, std::map<uint32_t, RtpState>());
MOCK_CONST_METHOD0(GetRtpPayloadStates,
std::map<uint32_t, RtpPayloadState>());
MOCK_METHOD2(DeliverRtcp, void(const uint8_t*, size_t));
MOCK_METHOD1(OnBitrateAllocationUpdated, void(const VideoBitrateAllocation&));
MOCK_METHOD3(OnEncodedImage,
EncodedImageCallback::Result(const EncodedImage&,
const CodecSpecificInfo*,
const RTPFragmentationHeader*));
MOCK_METHOD1(OnTransportOverheadChanged, void(size_t));
MOCK_METHOD1(OnOverheadChanged, void(size_t));
MOCK_METHOD2(OnBitrateUpdated, void(BitrateAllocationUpdate, int));
MOCK_CONST_METHOD0(GetPayloadBitrateBps, uint32_t());
MOCK_CONST_METHOD0(GetProtectionBitrateBps, uint32_t());
MOCK_METHOD3(SetEncodingData, void(size_t, size_t, size_t));
MOCK_CONST_METHOD2(GetSentRtpPacketInfos,
std::vector<RtpSequenceNumberMap::Info>(
uint32_t ssrc,
rtc::ArrayView<const uint16_t> sequence_numbers));
MOCK_METHOD(void, RegisterProcessThread, (ProcessThread*), (override));
MOCK_METHOD(void, DeRegisterProcessThread, (), (override));
MOCK_METHOD(void, SetActive, (bool), (override));
MOCK_METHOD(void, SetActiveModules, (const std::vector<bool>), (override));
MOCK_METHOD(bool, IsActive, (), (override));
MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
MOCK_METHOD((std::map<uint32_t, RtpState>),
GetRtpStates,
(),
(const, override));
MOCK_METHOD((std::map<uint32_t, RtpPayloadState>),
GetRtpPayloadStates,
(),
(const, override));
MOCK_METHOD(void, DeliverRtcp, (const uint8_t*, size_t), (override));
MOCK_METHOD(void,
OnBitrateAllocationUpdated,
(const VideoBitrateAllocation&),
(override));
MOCK_METHOD(EncodedImageCallback::Result,
OnEncodedImage,
(const EncodedImage&,
const CodecSpecificInfo*,
const RTPFragmentationHeader*),
(override));
MOCK_METHOD(void, OnTransportOverheadChanged, (size_t), (override));
MOCK_METHOD(void,
OnBitrateUpdated,
(BitrateAllocationUpdate, int),
(override));
MOCK_METHOD(uint32_t, GetPayloadBitrateBps, (), (const, override));
MOCK_METHOD(uint32_t, GetProtectionBitrateBps, (), (const, override));
MOCK_METHOD(void, SetEncodingData, (size_t, size_t, size_t), (override));
MOCK_METHOD(std::vector<RtpSequenceNumberMap::Info>,
GetSentRtpPacketInfos,
(uint32_t ssrc, rtc::ArrayView<const uint16_t> sequence_numbers),
(const, override));
MOCK_METHOD1(SetFecAllowed, void(bool fec_allowed));
MOCK_METHOD(void, SetFecAllowed, (bool fec_allowed), (override));
};
BitrateAllocationUpdate CreateAllocation(int bitrate_bps) {

17
video/video_source_sink_controller_unittest.cc
View File

@ -30,8 +30,8 @@ class MockVideoSinkWithVideoFrame : public rtc::VideoSinkInterface<VideoFrame> {
public:
~MockVideoSinkWithVideoFrame() override {}
MOCK_METHOD1(OnFrame, void(const VideoFrame& frame));
MOCK_METHOD0(OnDiscardedFrame, void());
MOCK_METHOD(void, OnFrame, (const VideoFrame& frame), (override));
MOCK_METHOD(void, OnDiscardedFrame, (), (override));
};
class MockVideoSourceWithVideoFrame
@ -39,10 +39,15 @@ class MockVideoSourceWithVideoFrame
public:
~MockVideoSourceWithVideoFrame() override {}
MOCK_METHOD2(AddOrUpdateSink,
void(rtc::VideoSinkInterface<VideoFrame>*,
const rtc::VideoSinkWants&));
MOCK_METHOD1(RemoveSink, void(rtc::VideoSinkInterface<VideoFrame>*));
MOCK_METHOD(void,
AddOrUpdateSink,
(rtc::VideoSinkInterface<VideoFrame>*,
const rtc::VideoSinkWants&),
(override));
MOCK_METHOD(void,
RemoveSink,
(rtc::VideoSinkInterface<VideoFrame>*),
(override));
};
} // namespace

36
video/video_stream_decoder_impl_unittest.cc
View File

@ -27,21 +27,25 @@ using ::testing::Return;
class MockVideoStreamDecoderCallbacks
: public VideoStreamDecoderInterface::Callbacks {
public:
MOCK_METHOD0(OnNonDecodableState, void());
MOCK_METHOD1(OnContinuousUntil,
void(const video_coding::VideoLayerFrameId& key));
MOCK_METHOD1(OnEncodedFrame, void(const video_coding::EncodedFrame& frame));
MOCK_METHOD3(OnDecodedFrame,
void(VideoFrame decodedImage,
absl::optional<int> decode_time_ms,
absl::optional<int> qp));
MOCK_METHOD(void, OnNonDecodableState, (), (override));
MOCK_METHOD(void,
OnContinuousUntil,
(const video_coding::VideoLayerFrameId& key),
(override));
MOCK_METHOD(void,
OnDecodedFrame,
(VideoFrame decodedImage,
absl::optional<int> decode_time_ms,
absl::optional<int> qp),
(override));
};
class StubVideoDecoder : public VideoDecoder {
public:
MOCK_METHOD2(InitDecode,
int32_t(const VideoCodec* codec_settings,
int32_t number_of_cores));
MOCK_METHOD(int32_t,
InitDecode,
(const VideoCodec*, int32_t number_of_cores),
(override));
int32_t Decode(const EncodedImage& input_image,
bool missing_frames,
@ -57,10 +61,12 @@ class StubVideoDecoder : public VideoDecoder {
return ret_code;
}
MOCK_METHOD3(DecodeCall,
int32_t(const EncodedImage& input_image,
bool missing_frames,
int64_t render_time_ms));
MOCK_METHOD(int32_t,
DecodeCall,
(const EncodedImage& input_image,
bool missing_frames,
int64_t render_time_ms),
());
int32_t Release() override { return 0; }

28
video/video_stream_encoder_unittest.cc
View File

@ -507,16 +507,24 @@ class MockableSendStatisticsProxy : public SendStatisticsProxy {
class MockBitrateObserver : public VideoBitrateAllocationObserver {
public:
MOCK_METHOD1(OnBitrateAllocationUpdated, void(const VideoBitrateAllocation&));
MOCK_METHOD(void,
OnBitrateAllocationUpdated,
(const VideoBitrateAllocation&),
(override));
};
class MockEncoderSelector
: public VideoEncoderFactory::EncoderSelectorInterface {
public:
MOCK_METHOD1(OnCurrentEncoder, void(const SdpVideoFormat& format));
MOCK_METHOD1(OnAvailableBitrate,
absl::optional<SdpVideoFormat>(const DataRate& rate));
MOCK_METHOD0(OnEncoderBroken, absl::optional<SdpVideoFormat>());
MOCK_METHOD(void,
OnCurrentEncoder,
(const SdpVideoFormat& format),
(override));
MOCK_METHOD(absl::optional<SdpVideoFormat>,
OnAvailableBitrate,
(const DataRate& rate),
(override));
MOCK_METHOD(absl::optional<SdpVideoFormat>, OnEncoderBroken, (), (override));
};
} // namespace
@ -5518,10 +5526,12 @@ TEST_F(VideoStreamEncoderTest, EncoderRatesPropagatedOnReconfigure) {
}
struct MockEncoderSwitchRequestCallback : public EncoderSwitchRequestCallback {
MOCK_METHOD0(RequestEncoderFallback, void());
MOCK_METHOD1(RequestEncoderSwitch, void(const Config& conf));
MOCK_METHOD1(RequestEncoderSwitch,
void(const webrtc::SdpVideoFormat& format));
MOCK_METHOD(void, RequestEncoderFallback, (), (override));
MOCK_METHOD(void, RequestEncoderSwitch, (const Config& conf), (override));
MOCK_METHOD(void,
RequestEncoderSwitch,
(const webrtc::SdpVideoFormat& format),
(override));
};
TEST_F(VideoStreamEncoderTest, BitrateEncoderSwitch) {