From dd7e284ce8bd86c9e13413b29777d1527f2cbe31 Mon Sep 17 00:00:00 2001 From: Danil Chapovalov Date: Fri, 9 Mar 2018 15:37:03 +0000 Subject: [PATCH] Reland "Enable and fix chromium clang warnings in rtp_rtcp test targets" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 01aa210fad68f1006528d32d388b307c22990734. Reason for revert: downstream project adjusted Original change's description: > Revert "Enable and fix chromium clang warnings in rtp_rtcp test targets" > > This reverts commit 9486b117daac09c9f7ac8450ccda835938cf3150. > > Reason for revert: Breaks downstream project > > Original change's description: > > Enable and fix chromium clang warnings in rtp_rtcp test targets > > > > Bug: webrtc:163 > > Change-Id: I4ed3e63296d8bf06536a83196d597c7a906ba11c > > Reviewed-on: https://webrtc-review.googlesource.com/60802 > > Reviewed-by: Björn Terelius > > Reviewed-by: Patrik Höglund > > Commit-Queue: Danil Chapovalov > > Cr-Commit-Position: refs/heads/master@{#22357} > > TBR=danilchap@webrtc.org,phoglund@webrtc.org,terelius@webrtc.org > > Change-Id: I2c3777ea9f26813bdb395e7fd68f6b49443586ea > No-Presubmit: true > No-Tree-Checks: true > No-Try: true > Bug: webrtc:163 > Reviewed-on: https://webrtc-review.googlesource.com/61060 > Reviewed-by: Oleh Prypin > Commit-Queue: Oleh Prypin > Cr-Commit-Position: refs/heads/master@{#22365} TBR=danilchap@webrtc.org,phoglund@webrtc.org,oprypin@webrtc.org,terelius@webrtc.org Change-Id: I0b4cb6d05b37caeb52cca9abf95417ad3ad6f76b No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: webrtc:163 Reviewed-on: https://webrtc-review.googlesource.com/61080 Reviewed-by: Danil Chapovalov Commit-Queue: Danil Chapovalov Cr-Commit-Position: refs/heads/master@{#22368} --- logging/BUILD.gn | 1 + .../rtc_event_log/mock/mock_rtc_event_log.cc | 19 +++++++++++++++++ .../rtc_event_log/mock/mock_rtc_event_log.h | 3 +++ modules/rtp_rtcp/BUILD.gn | 18 ++++++---------- .../mocks/mock_recovered_packet_receiver.cc | 18 ++++++++++++++++ .../mocks/mock_recovered_packet_receiver.h | 2 ++ .../mocks/mock_rtcp_bandwidth_observer.cc | 18 ++++++++++++++++ .../mocks/mock_rtcp_bandwidth_observer.h | 3 +++ modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc | 18 ++++++++++++++++ modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h | 3 +++ modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc | 21 +++++++++++++++++++ modules/rtp_rtcp/mocks/mock_rtp_rtcp.h | 6 ++++++ modules/rtp_rtcp/source/byte_io_unittest.cc | 4 ++-- modules/rtp_rtcp/source/fec_test_helper.cc | 11 ++++++++++ modules/rtp_rtcp/source/fec_test_helper.h | 7 ++----- .../source/flexfec_receiver_unittest.cc | 8 +++---- modules/rtp_rtcp/source/nack_rtx_unittest.cc | 2 +- .../source/receive_statistics_unittest.cc | 8 +++---- .../remote_ntp_time_estimator_unittest.cc | 2 +- .../rtp_rtcp/source/rtcp_sender_unittest.cc | 2 +- .../source/rtp_format_vp8_unittest.cc | 2 +- .../source/rtp_format_vp9_unittest.cc | 8 ++----- .../rtp_rtcp/source/rtp_receiver_unittest.cc | 2 +- .../rtp_rtcp/source/rtp_rtcp_impl_unittest.cc | 2 +- .../rtp_rtcp/source/rtp_sender_unittest.cc | 6 +++--- modules/rtp_rtcp/test/testAPI/test_api.cc | 2 +- .../rtp_rtcp/test/testAPI/test_api_audio.cc | 2 +- .../rtp_rtcp/test/testAPI/test_api_rtcp.cc | 10 ++++----- .../rtp_rtcp/test/testAPI/test_api_video.cc | 6 +++--- test/BUILD.gn | 1 + test/mock_transport.cc | 18 ++++++++++++++++ test/mock_transport.h | 3 +++ 32 files changed, 184 insertions(+), 52 deletions(-) create mode 100644 logging/rtc_event_log/mock/mock_rtc_event_log.cc create mode 100644 modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc create mode 100644 modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc create mode 100644 modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc create mode 100644 modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc create mode 100644 test/mock_transport.cc diff --git a/logging/BUILD.gn b/logging/BUILD.gn index 16b186c1d8..d5d7e55ed7 100644 --- a/logging/BUILD.gn +++ b/logging/BUILD.gn @@ -421,6 +421,7 @@ if (rtc_include_tests) { rtc_source_set("mocks") { testonly = true sources = [ + "rtc_event_log/mock/mock_rtc_event_log.cc", "rtc_event_log/mock/mock_rtc_event_log.h", ] deps = [ diff --git a/logging/rtc_event_log/mock/mock_rtc_event_log.cc b/logging/rtc_event_log/mock/mock_rtc_event_log.cc new file mode 100644 index 0000000000..10c2b9677c --- /dev/null +++ b/logging/rtc_event_log/mock/mock_rtc_event_log.cc @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "logging/rtc_event_log/mock/mock_rtc_event_log.h" + +namespace webrtc { + +MockRtcEventLog::MockRtcEventLog() = default; +MockRtcEventLog::~MockRtcEventLog() = default; + +} // namespace webrtc + diff --git a/logging/rtc_event_log/mock/mock_rtc_event_log.h b/logging/rtc_event_log/mock/mock_rtc_event_log.h index 6f69169eff..44207ff2ba 100644 --- a/logging/rtc_event_log/mock/mock_rtc_event_log.h +++ b/logging/rtc_event_log/mock/mock_rtc_event_log.h @@ -20,6 +20,9 @@ namespace webrtc { class MockRtcEventLog : public RtcEventLog { public: + MockRtcEventLog(); + ~MockRtcEventLog(); + virtual bool StartLogging(std::unique_ptr output, int64_t output_period_ms) { return StartLoggingProxy(output.get(), output_period_ms); diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn index 13b10c07ff..8e1c2326f2 100644 --- a/modules/rtp_rtcp/BUILD.gn +++ b/modules/rtp_rtcp/BUILD.gn @@ -264,15 +264,17 @@ rtc_source_set("fec_test_helper") { # TODO(jschuh): bugs.webrtc.org/1348: fix this warning. configs += [ "//build/config/compiler:no_size_t_to_int_warning" ] - if (!build_with_chromium && is_clang) { - # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163). - suppressed_configs += [ "//build/config/clang:find_bad_constructs" ] - } } rtc_source_set("mock_rtp_rtcp") { testonly = true sources = [ + "mocks/mock_recovered_packet_receiver.cc", + "mocks/mock_rtcp_bandwidth_observer.cc", + "mocks/mock_rtcp_rtt_stats.cc", + "mocks/mock_rtp_rtcp.cc", + ] + public = [ "mocks/mock_recovered_packet_receiver.h", "mocks/mock_rtcp_bandwidth_observer.h", "mocks/mock_rtcp_rtt_stats.h", @@ -317,10 +319,6 @@ if (rtc_include_tests) { "../../rtc_base:rtc_base_approved", "../../test:test_support", ] - if (!build_with_chromium && is_clang) { - # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163). - suppressed_configs += [ "//build/config/clang:find_bad_constructs" ] - } } rtc_source_set("rtp_rtcp_unittests") { @@ -422,9 +420,5 @@ if (rtc_include_tests) { # TODO(jschuh): bugs.webrtc.org/1348: fix this warning. configs += [ "//build/config/compiler:no_size_t_to_int_warning" ] - if (!build_with_chromium && is_clang) { - # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163). - suppressed_configs += [ "//build/config/clang:find_bad_constructs" ] - } } } diff --git a/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc b/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc new file mode 100644 index 0000000000..e0183f89c0 --- /dev/null +++ b/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h" + +namespace webrtc { + +MockRecoveredPacketReceiver::MockRecoveredPacketReceiver() = default; +MockRecoveredPacketReceiver::~MockRecoveredPacketReceiver() = default; + +} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h b/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h index 501c5c3298..51a2bf12ac 100644 --- a/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h +++ b/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h @@ -19,6 +19,8 @@ namespace webrtc { class MockRecoveredPacketReceiver : public RecoveredPacketReceiver { public: + MockRecoveredPacketReceiver(); + ~MockRecoveredPacketReceiver(); MOCK_METHOD2(OnRecoveredPacket, void(const uint8_t* packet, size_t length)); }; diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc b/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc new file mode 100644 index 0000000000..abaf129d8b --- /dev/null +++ b/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h" + +namespace webrtc { + +MockRtcpBandwidthObserver::MockRtcpBandwidthObserver() = default; +MockRtcpBandwidthObserver::~MockRtcpBandwidthObserver() = default; + +} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h b/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h index 76b40e6299..b9a8f79a1d 100644 --- a/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h +++ b/modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h @@ -18,6 +18,9 @@ namespace webrtc { class MockRtcpBandwidthObserver : public RtcpBandwidthObserver { public: + MockRtcpBandwidthObserver(); + ~MockRtcpBandwidthObserver(); + MOCK_METHOD1(OnReceivedEstimatedBitrate, void(uint32_t)); MOCK_METHOD3(OnReceivedRtcpReceiverReport, void(const ReportBlockList&, int64_t, int64_t)); diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc b/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc new file mode 100644 index 0000000000..1aca566bb6 --- /dev/null +++ b/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h" + +namespace webrtc { + +MockRtcpRttStats::MockRtcpRttStats() = default; +MockRtcpRttStats::~MockRtcpRttStats() = default; + +} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h b/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h index 8f2bb6e1e1..6ccef612c2 100644 --- a/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h +++ b/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h @@ -18,6 +18,9 @@ namespace webrtc { class MockRtcpRttStats : public RtcpRttStats { public: + MockRtcpRttStats(); + ~MockRtcpRttStats(); + MOCK_METHOD1(OnRttUpdate, void(int64_t rtt)); MOCK_CONST_METHOD0(LastProcessedRtt, int64_t()); }; diff --git a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc new file mode 100644 index 0000000000..d24c1b094c --- /dev/null +++ b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" + +namespace webrtc { + +MockRtpData::MockRtpData() = default; +MockRtpData::~MockRtpData() = default; + +MockRtpRtcp::MockRtpRtcp() = default; +MockRtpRtcp::~MockRtpRtcp() = default; + +} // namespace webrtc diff --git a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h index 05eea81cd5..4dc3642ccd 100644 --- a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h +++ b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h @@ -27,6 +27,9 @@ namespace webrtc { class MockRtpData : public RtpData { public: + MockRtpData(); + ~MockRtpData(); + MOCK_METHOD3(OnReceivedPayloadData, int32_t(const uint8_t* payload_data, size_t payload_size, @@ -35,6 +38,9 @@ class MockRtpData : public RtpData { class MockRtpRtcp : public RtpRtcp { public: + MockRtpRtcp(); + ~MockRtpRtcp(); + MOCK_METHOD1(RegisterDefaultModule, int32_t(RtpRtcp* module)); MOCK_METHOD0(DeRegisterDefaultModule, int32_t()); MOCK_METHOD0(DefaultModuleRegistered, bool()); diff --git a/modules/rtp_rtcp/source/byte_io_unittest.cc b/modules/rtp_rtcp/source/byte_io_unittest.cc index 3931a04fe3..3ddb7617bf 100644 --- a/modules/rtp_rtcp/source/byte_io_unittest.cc +++ b/modules/rtp_rtcp/source/byte_io_unittest.cc @@ -18,8 +18,8 @@ namespace { class ByteIoTest : public ::testing::Test { protected: - ByteIoTest() {} - virtual ~ByteIoTest() {} + ByteIoTest() = default; + ~ByteIoTest() override = default; enum { kAlignments = sizeof(uint64_t) - 1 }; diff --git a/modules/rtp_rtcp/source/fec_test_helper.cc b/modules/rtp_rtcp/source/fec_test_helper.cc index d73af5a31c..c45872b28b 100644 --- a/modules/rtp_rtcp/source/fec_test_helper.cc +++ b/modules/rtp_rtcp/source/fec_test_helper.cc @@ -30,6 +30,17 @@ constexpr uint8_t kVp8PayloadType = 120; constexpr int kPacketTimestampIncrement = 3000; } // namespace +MediaPacketGenerator::MediaPacketGenerator(uint32_t min_packet_size, + uint32_t max_packet_size, + uint32_t ssrc, + Random* random) + : min_packet_size_(min_packet_size), + max_packet_size_(max_packet_size), + ssrc_(ssrc), + random_(random) {} + +MediaPacketGenerator::~MediaPacketGenerator() = default; + ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets( int num_media_packets, uint16_t start_seq_num) { diff --git a/modules/rtp_rtcp/source/fec_test_helper.h b/modules/rtp_rtcp/source/fec_test_helper.h index 712b20143b..79dfb5eec1 100644 --- a/modules/rtp_rtcp/source/fec_test_helper.h +++ b/modules/rtp_rtcp/source/fec_test_helper.h @@ -36,11 +36,8 @@ class MediaPacketGenerator { MediaPacketGenerator(uint32_t min_packet_size, uint32_t max_packet_size, uint32_t ssrc, - Random* random) - : min_packet_size_(min_packet_size), - max_packet_size_(max_packet_size), - ssrc_(ssrc), - random_(random) {} + Random* random); + ~MediaPacketGenerator(); // Construct the media packets, up to |num_media_packets| packets. ForwardErrorCorrection::PacketList ConstructMediaPackets( diff --git a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc index af9a9983b9..5cdcdf59d6 100644 --- a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc @@ -211,7 +211,7 @@ TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) { } // Receive FEC packet. - auto fec_packet = fec_packets.front(); + auto* fec_packet = fec_packets.front(); std::unique_ptr packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(*fec_packet); std::unique_ptr received_packet = @@ -354,7 +354,7 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) { // Receive all FEC packets. media_it = media_packets.begin(); - for (const auto& fec_packet : fec_packets) { + for (const auto* fec_packet : fec_packets) { std::unique_ptr fec_packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(*fec_packet); ++media_it; @@ -453,7 +453,7 @@ TEST_F(FlexfecReceiverTest, SurvivesOldRecoveredPacketBeingReinserted) { void SetReceiver(FlexfecReceiver* receiver) { receiver_ = receiver; } // Implements RecoveredPacketReceiver. - void OnRecoveredPacket(const uint8_t* packet, size_t length) { + void OnRecoveredPacket(const uint8_t* packet, size_t length) override { RtpPacketReceived parsed_packet; EXPECT_TRUE(parsed_packet.Parse(packet, length)); parsed_packet.set_recovered(true); @@ -567,7 +567,7 @@ TEST_F(FlexfecReceiverTest, RecoveryCallbackDoesNotLoopInfinitely) { bool DeepRecursion() const { return deep_recursion_; } // Implements RecoveredPacketReceiver. - void OnRecoveredPacket(const uint8_t* packet, size_t length) { + void OnRecoveredPacket(const uint8_t* packet, size_t length) override { RtpPacketReceived parsed_packet; EXPECT_TRUE(parsed_packet.Parse(packet, length)); diff --git a/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/modules/rtp_rtcp/source/nack_rtx_unittest.cc index f3b0becd90..77750247c7 100644 --- a/modules/rtp_rtcp/source/nack_rtx_unittest.cc +++ b/modules/rtp_rtcp/source/nack_rtx_unittest.cc @@ -126,7 +126,7 @@ class RtpRtcpRtxNackTest : public ::testing::Test { payload_data_length(sizeof(payload_data)), fake_clock(123456), retransmission_rate_limiter_(&fake_clock, kMaxRttMs) {} - ~RtpRtcpRtxNackTest() {} + ~RtpRtcpRtxNackTest() override {} void SetUp() override { RtpRtcp::Configuration configuration; diff --git a/modules/rtp_rtcp/source/receive_statistics_unittest.cc b/modules/rtp_rtcp/source/receive_statistics_unittest.cc index 001ae2e119..c586b3dc4d 100644 --- a/modules/rtp_rtcp/source/receive_statistics_unittest.cc +++ b/modules/rtp_rtcp/source/receive_statistics_unittest.cc @@ -195,7 +195,7 @@ TEST_F(ReceiveStatisticsTest, RtcpCallbacks) { public: TestCallback() : RtcpStatisticsCallback(), num_calls_(0), ssrc_(0), stats_() {} - virtual ~TestCallback() {} + ~TestCallback() override {} void StatisticsUpdated(const RtcpStatistics& statistics, uint32_t ssrc) override { @@ -283,10 +283,10 @@ class RtpTestCallback : public StreamDataCountersCallback { public: RtpTestCallback() : StreamDataCountersCallback(), num_calls_(0), ssrc_(0), stats_() {} - virtual ~RtpTestCallback() {} + ~RtpTestCallback() override = default; - virtual void DataCountersUpdated(const StreamDataCounters& counters, - uint32_t ssrc) { + void DataCountersUpdated(const StreamDataCounters& counters, + uint32_t ssrc) override { ssrc_ = ssrc; stats_ = counters; ++num_calls_; diff --git a/modules/rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc b/modules/rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc index 24eb46f767..e752369f73 100644 --- a/modules/rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc +++ b/modules/rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc @@ -32,7 +32,7 @@ class RemoteNtpTimeEstimatorTest : public ::testing::Test { : local_clock_(kLocalClockInitialTimeMs * 1000), remote_clock_(kRemoteClockInitialTimeMs * 1000), estimator_(new RemoteNtpTimeEstimator(&local_clock_)) {} - ~RemoteNtpTimeEstimatorTest() {} + ~RemoteNtpTimeEstimatorTest() override = default; void AdvanceTimeMilliseconds(int64_t ms) { local_clock_.AdvanceTimeMilliseconds(ms); diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc index 1aaef1d5c6..77423746f1 100644 --- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc @@ -185,7 +185,7 @@ TEST(NACKStringBuilderTest, TestCase13) { class RtcpPacketTypeCounterObserverImpl : public RtcpPacketTypeCounterObserver { public: RtcpPacketTypeCounterObserverImpl() : ssrc_(0) {} - virtual ~RtcpPacketTypeCounterObserverImpl() {} + ~RtcpPacketTypeCounterObserverImpl() override = default; void RtcpPacketTypesCounterUpdated( uint32_t ssrc, const RtcpPacketTypeCounter& packet_counter) override { diff --git a/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc b/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc index 0095560e5d..038693eb69 100644 --- a/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc @@ -82,7 +82,7 @@ void VerifyExtensions(RTPTypeHeader* type, class RtpPacketizerVp8Test : public ::testing::Test { protected: RtpPacketizerVp8Test() : helper_(NULL) {} - virtual void TearDown() { delete helper_; } + void TearDown() override { delete helper_; } bool Init(const size_t* partition_sizes, size_t num_partitions) { hdr_info_.pictureId = kNoPictureId; hdr_info_.nonReference = false; diff --git a/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc b/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc index c522c4dc8a..c8987df6fd 100644 --- a/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc @@ -127,9 +127,7 @@ class RtpPacketizerVp9Test : public ::testing::Test { static constexpr size_t kMaxPacketSize = 1200; RtpPacketizerVp9Test() : packet_(kNoExtensions, kMaxPacketSize) {} - virtual void SetUp() { - expected_.InitRTPVideoHeaderVP9(); - } + void SetUp() override { expected_.InitRTPVideoHeaderVP9(); } RtpPacketToSend packet_; std::unique_ptr payload_; @@ -584,9 +582,7 @@ class RtpDepacketizerVp9Test : public ::testing::Test { RtpDepacketizerVp9Test() : depacketizer_(new RtpDepacketizerVp9()) {} - virtual void SetUp() { - expected_.InitRTPVideoHeaderVP9(); - } + void SetUp() override { expected_.InitRTPVideoHeaderVP9(); } RTPVideoHeaderVP9 expected_; std::unique_ptr depacketizer_; diff --git a/modules/rtp_rtcp/source/rtp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtp_receiver_unittest.cc index 3d23b50c50..6e3b0e56f1 100644 --- a/modules/rtp_rtcp/source/rtp_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_receiver_unittest.cc @@ -236,7 +236,7 @@ TEST_F(RtpReceiverTest, GetSourcesRemoveOutdatedSource) { header.arrOfCSRCs[0] = kCsrc1; EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket( header, kTestPayload, sizeof(kTestPayload), payload_specific)); - auto rtp_receiver_impl = static_cast(rtp_receiver_.get()); + auto* rtp_receiver_impl = static_cast(rtp_receiver_.get()); auto ssrc_sources = rtp_receiver_impl->ssrc_sources_for_testing(); ASSERT_EQ(1u, ssrc_sources.size()); EXPECT_EQ(kSsrc1, ssrc_sources.begin()->source_id()); diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc index 403dacaab6..2d75a3cd42 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc @@ -42,7 +42,7 @@ const int64_t kMaxRttMs = 1000; class RtcpRttStatsTestImpl : public RtcpRttStats { public: RtcpRttStatsTestImpl() : rtt_ms_(0) {} - virtual ~RtcpRttStatsTestImpl() {} + ~RtcpRttStatsTestImpl() override = default; void OnRttUpdate(int64_t rtt_ms) override { rtt_ms_ = rtt_ms; } int64_t LastProcessedRtt() const override { return rtt_ms_; } diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc index ca7a6f2b6f..d64aaa8f25 100644 --- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -1196,7 +1196,7 @@ TEST_P(RtpSenderTest, FrameCountCallbacks) { class TestCallback : public FrameCountObserver { public: TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {} - virtual ~TestCallback() {} + ~TestCallback() override = default; void FrameCountUpdated(const FrameCounts& frame_counts, uint32_t ssrc) override { @@ -1256,7 +1256,7 @@ TEST_P(RtpSenderTest, BitrateCallbacks) { ssrc_(0), total_bitrate_(0), retransmit_bitrate_(0) {} - virtual ~TestCallback() {} + ~TestCallback() override = default; void Notify(uint32_t total_bitrate, uint32_t retransmit_bitrate, @@ -1344,7 +1344,7 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { class TestCallback : public StreamDataCountersCallback { public: TestCallback() : StreamDataCountersCallback(), ssrc_(0), counters_() {} - virtual ~TestCallback() {} + ~TestCallback() override = default; void DataCountersUpdated(const StreamDataCounters& counters, uint32_t ssrc) override { diff --git a/modules/rtp_rtcp/test/testAPI/test_api.cc b/modules/rtp_rtcp/test/testAPI/test_api.cc index e2afa42856..fd5067be99 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api.cc @@ -87,7 +87,7 @@ class RtpRtcpAPITest : public ::testing::Test { test_timestamp_ = 4567; test_sequence_number_ = 2345; } - ~RtpRtcpAPITest() {} + ~RtpRtcpAPITest() override = default; const uint32_t initial_ssrc = 8888; diff --git a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc index a668425dcf..e316d909c3 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc @@ -91,7 +91,7 @@ class RtpRtcpAudioTest : public ::testing::Test { test_timestamp = 4567; test_sequence_number = 2345; } - ~RtpRtcpAudioTest() {} + ~RtpRtcpAudioTest() override = default; void SetUp() override { receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock)); diff --git a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc index 4b5b50b8b6..d42a713f1a 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc @@ -35,7 +35,7 @@ class RtcpCallback : public RtcpIntraFrameObserver { } virtual void OnLipSyncUpdate(const int32_t id, const int32_t audioVideoOffset) {} - virtual void OnReceivedIntraFrameRequest(uint32_t ssrc) {} + void OnReceivedIntraFrameRequest(uint32_t ssrc) override {} private: RtpRtcp* _rtpRtcpModule; @@ -44,7 +44,7 @@ class RtcpCallback : public RtcpIntraFrameObserver { class TestRtpFeedback : public NullRtpFeedback { public: explicit TestRtpFeedback(RtpRtcp* rtp_rtcp) : rtp_rtcp_(rtp_rtcp) {} - virtual ~TestRtpFeedback() {} + ~TestRtpFeedback() override = default; void OnIncomingSSRCChanged(uint32_t ssrc) override { rtp_rtcp_->SetRemoteSSRC(ssrc); @@ -64,9 +64,9 @@ class RtpRtcpRtcpTest : public ::testing::Test { test_timestamp = 4567; test_sequence_number = 2345; } - ~RtpRtcpRtcpTest() {} + ~RtpRtcpRtcpTest() override = default; - virtual void SetUp() { + void SetUp() override { receiver = new TestRtpReceiver(); transport1 = new LoopBackTransport(); transport2 = new LoopBackTransport(); @@ -149,7 +149,7 @@ class RtpRtcpRtcpTest : public ::testing::Test { test, 8, nullptr, nullptr, nullptr)); } - virtual void TearDown() { + void TearDown() override { delete module1; delete module2; delete myRTCPFeedback1; diff --git a/modules/rtp_rtcp/test/testAPI/test_api_video.cc b/modules/rtp_rtcp/test/testAPI/test_api_video.cc index a77a92a9b7..0ef29a8a0a 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api_video.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api_video.cc @@ -40,9 +40,9 @@ class RtpRtcpVideoTest : public ::testing::Test { test_sequence_number_(2345), fake_clock(123456), retransmission_rate_limiter_(&fake_clock, 1000) {} - ~RtpRtcpVideoTest() {} + ~RtpRtcpVideoTest() override = default; - virtual void SetUp() { + void SetUp() override { transport_ = new LoopBackTransport(); receiver_ = new TestRtpReceiver(); receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock)); @@ -118,7 +118,7 @@ class RtpRtcpVideoTest : public ::testing::Test { return padding_bytes_in_packet + header_length; } - virtual void TearDown() { + void TearDown() override { delete video_module_; delete transport_; delete receiver_; diff --git a/test/BUILD.gn b/test/BUILD.gn index 409be1a1a5..b4b1277221 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -567,6 +567,7 @@ rtc_source_set("test_common") { "fake_videorenderer.h", "layer_filtering_transport.cc", "layer_filtering_transport.h", + "mock_transport.cc", "mock_transport.h", "null_transport.cc", "null_transport.h", diff --git a/test/mock_transport.cc b/test/mock_transport.cc new file mode 100644 index 0000000000..3878b3bdbe --- /dev/null +++ b/test/mock_transport.cc @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "test/mock_transport.h" + +namespace webrtc { + +MockTransport::MockTransport() = default; +MockTransport::~MockTransport() = default; + +} // namespace webrtc diff --git a/test/mock_transport.h b/test/mock_transport.h index 9837593f33..7eaf3c94c3 100644 --- a/test/mock_transport.h +++ b/test/mock_transport.h @@ -18,6 +18,9 @@ namespace webrtc { class MockTransport : public Transport { public: + MockTransport(); + ~MockTransport(); + MOCK_METHOD3(SendRtp, bool(const uint8_t* data, size_t len,