diff --git a/modules/rtp_rtcp/test/testAPI/test_api.cc b/modules/rtp_rtcp/test/testAPI/test_api.cc index b11a18b056..5fa1de07fb 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api.cc @@ -82,44 +82,34 @@ class RtpRtcpAPITest : public ::testing::Test { protected: RtpRtcpAPITest() : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) { - test_csrcs_.push_back(1234); - test_csrcs_.push_back(2345); - test_ssrc_ = 3456; - test_timestamp_ = 4567; - test_sequence_number_ = 2345; } ~RtpRtcpAPITest() override = default; - const uint32_t initial_ssrc = 8888; - void SetUp() override { + const uint32_t kInitialSsrc = 8888; RtpRtcp::Configuration configuration; configuration.audio = true; configuration.clock = &fake_clock_; configuration.outgoing_transport = &null_transport_; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; module_.reset(RtpRtcp::CreateRtpRtcp(configuration)); - module_->SetSSRC(initial_ssrc); - rtp_payload_registry_.reset(new RTPPayloadRegistry()); + module_->SetSSRC(kInitialSsrc); } - std::unique_ptr rtp_payload_registry_; std::unique_ptr module_; - uint32_t test_ssrc_; - uint32_t test_timestamp_; - uint16_t test_sequence_number_; - std::vector test_csrcs_; SimulatedClock fake_clock_; test::NullTransport null_transport_; RateLimiter retransmission_rate_limiter_; }; TEST_F(RtpRtcpAPITest, Basic) { - module_->SetSequenceNumber(test_sequence_number_); - EXPECT_EQ(test_sequence_number_, module_->SequenceNumber()); + const uint16_t kSequenceNumber = 2345; + module_->SetSequenceNumber(kSequenceNumber); + EXPECT_EQ(kSequenceNumber, module_->SequenceNumber()); - module_->SetStartTimestamp(test_timestamp_); - EXPECT_EQ(test_timestamp_, module_->StartTimestamp()); + const uint32_t kTimestamp = 4567; + module_->SetStartTimestamp(kTimestamp); + EXPECT_EQ(kTimestamp, module_->StartTimestamp()); EXPECT_FALSE(module_->Sending()); EXPECT_EQ(0, module_->SetSendingStatus(true)); @@ -132,8 +122,9 @@ TEST_F(RtpRtcpAPITest, PacketSize) { } TEST_F(RtpRtcpAPITest, SSRC) { - module_->SetSSRC(test_ssrc_); - EXPECT_EQ(test_ssrc_, module_->SSRC()); + const uint32_t kSsrc = 3456; + module_->SetSSRC(kSsrc); + EXPECT_EQ(kSsrc, module_->SSRC()); } TEST_F(RtpRtcpAPITest, RTCP) { diff --git a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc index 66166056bc..2618433dd5 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc @@ -28,6 +28,8 @@ const uint32_t kTestRate = 64000u; const uint8_t kTestPayload[] = {'t', 'e', 's', 't'}; const uint8_t kPcmuPayloadType = 96; const uint8_t kDtmfPayloadType = 97; +const uint32_t kSsrc = 3456; +const uint32_t kTimestamp = 4567; struct CngCodecSpec { int payload_type; @@ -86,43 +88,34 @@ class VerifyingAudioReceiver : public RtpData { class RtpRtcpAudioTest : public ::testing::Test { protected: RtpRtcpAudioTest() - : fake_clock(123456), retransmission_rate_limiter_(&fake_clock, 1000) { - test_CSRC[0] = 1234; - test_CSRC[2] = 2345; - test_ssrc = 3456; - test_timestamp = 4567; - test_sequence_number = 2345; - } + : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {} ~RtpRtcpAudioTest() override = default; void SetUp() override { - receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock)); - receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock)); - - rtp_payload_registry1_.reset(new RTPPayloadRegistry()); - rtp_payload_registry2_.reset(new RTPPayloadRegistry()); + receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock_)); + receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock_)); RtpRtcp::Configuration configuration; configuration.audio = true; - configuration.clock = &fake_clock; + configuration.clock = &fake_clock_; configuration.receive_statistics = receive_statistics1_.get(); configuration.outgoing_transport = &transport1; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; module1.reset(RtpRtcp::CreateRtpRtcp(configuration)); rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver( - &fake_clock, &data_receiver1, rtp_payload_registry1_.get())); + &fake_clock_, &data_receiver1, &rtp_payload_registry1_)); configuration.receive_statistics = receive_statistics2_.get(); configuration.outgoing_transport = &transport2; module2.reset(RtpRtcp::CreateRtpRtcp(configuration)); rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver( - &fake_clock, &data_receiver2, rtp_payload_registry2_.get())); + &fake_clock_, &data_receiver2, &rtp_payload_registry2_)); - transport1.SetSendModule(module2.get(), rtp_payload_registry2_.get(), + transport1.SetSendModule(module2.get(), &rtp_payload_registry2_, rtp_receiver2_.get(), receive_statistics2_.get()); - transport2.SetSendModule(module1.get(), rtp_payload_registry1_.get(), + transport2.SetSendModule(module1.get(), &rtp_payload_registry1_, rtp_receiver1_.get(), receive_statistics1_.get()); } @@ -139,25 +132,21 @@ class RtpRtcpAudioTest : public ::testing::Test { VerifyingAudioReceiver data_receiver2; std::unique_ptr receive_statistics1_; std::unique_ptr receive_statistics2_; - std::unique_ptr rtp_payload_registry1_; - std::unique_ptr rtp_payload_registry2_; + RTPPayloadRegistry rtp_payload_registry1_; + RTPPayloadRegistry rtp_payload_registry2_; std::unique_ptr rtp_receiver1_; std::unique_ptr rtp_receiver2_; std::unique_ptr module1; std::unique_ptr module2; LoopBackTransport transport1; LoopBackTransport transport2; - uint32_t test_ssrc; - uint32_t test_timestamp; - uint16_t test_sequence_number; - uint32_t test_CSRC[webrtc::kRtpCsrcSize]; - SimulatedClock fake_clock; + SimulatedClock fake_clock_; RateLimiter retransmission_rate_limiter_; }; TEST_F(RtpRtcpAudioTest, Basic) { - module1->SetSSRC(test_ssrc); - module1->SetStartTimestamp(test_timestamp); + module1->SetSSRC(kSsrc); + module1->SetStartTimestamp(kTimestamp); // Test detection at the end of a DTMF tone. // EXPECT_EQ(0, module2->SetTelephoneEventForwardToDecoder(true)); @@ -183,13 +172,13 @@ TEST_F(RtpRtcpAudioTest, Basic) { kPcmuPayloadType, 0, -1, kTestPayload, 4, nullptr, nullptr, nullptr)); - EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC()); + EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC()); uint32_t timestamp; int64_t receive_time_ms; EXPECT_TRUE( rtp_receiver2_->GetLatestTimestamps(×tamp, &receive_time_ms)); - EXPECT_EQ(test_timestamp, timestamp); - EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms); + EXPECT_EQ(kTimestamp, timestamp); + EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms); } TEST_F(RtpRtcpAudioTest, DTMF) { @@ -200,8 +189,8 @@ TEST_F(RtpRtcpAudioTest, DTMF) { memcpy(voice_codec.plname, "PCMU", 5); RegisterPayload(voice_codec); - module1->SetSSRC(test_ssrc); - module1->SetStartTimestamp(test_timestamp); + module1->SetSSRC(kSsrc); + module1->SetStartTimestamp(kTimestamp); EXPECT_EQ(0, module1->SetSendingStatus(true)); // Prepare for DTMF. @@ -228,7 +217,7 @@ TEST_F(RtpRtcpAudioTest, DTMF) { EXPECT_TRUE(module1->SendOutgoingData( webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1, kTestPayload, 4, nullptr, nullptr, nullptr)); - fake_clock.AdvanceTimeMilliseconds(20); + fake_clock_.AdvanceTimeMilliseconds(20); module1->Process(); } EXPECT_EQ(0, module1->SendTelephoneEventOutband(32, 9000, 10)); @@ -237,14 +226,14 @@ TEST_F(RtpRtcpAudioTest, DTMF) { EXPECT_TRUE(module1->SendOutgoingData( webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1, kTestPayload, 4, nullptr, nullptr, nullptr)); - fake_clock.AdvanceTimeMilliseconds(20); + fake_clock_.AdvanceTimeMilliseconds(20); module1->Process(); } } TEST_F(RtpRtcpAudioTest, ComfortNoise) { - module1->SetSSRC(test_ssrc); - module1->SetStartTimestamp(test_timestamp); + module1->SetSSRC(kSsrc); + module1->SetStartTimestamp(kTimestamp); EXPECT_EQ(0, module1->SetSendingStatus(true)); @@ -273,25 +262,25 @@ TEST_F(RtpRtcpAudioTest, ComfortNoise) { webrtc::kAudioFrameSpeech, kPcmuPayloadType, in_timestamp, -1, kTestPayload, 4, nullptr, nullptr, nullptr)); - EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC()); + EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC()); EXPECT_TRUE( rtp_receiver2_->GetLatestTimestamps(×tamp, &receive_time_ms)); - EXPECT_EQ(test_timestamp + in_timestamp, timestamp); - EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms); + EXPECT_EQ(kTimestamp + in_timestamp, timestamp); + EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms); in_timestamp += 10; - fake_clock.AdvanceTimeMilliseconds(20); + fake_clock_.AdvanceTimeMilliseconds(20); EXPECT_TRUE(module1->SendOutgoingData(webrtc::kAudioFrameCN, c.payload_type, in_timestamp, -1, kTestPayload, 1, nullptr, nullptr, nullptr)); - EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC()); + EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC()); EXPECT_TRUE( rtp_receiver2_->GetLatestTimestamps(×tamp, &receive_time_ms)); - EXPECT_EQ(test_timestamp + in_timestamp, timestamp); - EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms); + EXPECT_EQ(kTimestamp + in_timestamp, timestamp); + EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms); in_timestamp += 10; - fake_clock.AdvanceTimeMilliseconds(20); + fake_clock_.AdvanceTimeMilliseconds(20); } } diff --git a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc index 2edebae79f..7551e71c18 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc @@ -25,83 +25,66 @@ namespace webrtc { namespace { +const uint16_t kSequenceNumber = 2345; +const uint32_t kSsrc = 3456; +const uint32_t kTimestamp = 4567; class RtcpCallback : public RtcpIntraFrameObserver { public: - void SetModule(RtpRtcp* module) { _rtpRtcpModule = module; } - virtual void OnRTCPPacketTimeout(const int32_t id) {} - virtual void OnLipSyncUpdate(const int32_t id, - const int32_t audioVideoOffset) {} void OnReceivedIntraFrameRequest(uint32_t ssrc) override {} - - private: - RtpRtcp* _rtpRtcpModule; }; class RtpRtcpRtcpTest : public ::testing::Test { protected: RtpRtcpRtcpTest() - : fake_clock(123456), retransmission_rate_limiter_(&fake_clock, 1000) { - test_csrcs.push_back(1234); - test_csrcs.push_back(2345); - test_ssrc = 3456; - test_timestamp = 4567; - test_sequence_number = 2345; - } + : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {} ~RtpRtcpRtcpTest() override = default; void SetUp() override { receiver = new TestRtpReceiver(); transport1 = new LoopBackTransport(); transport2 = new LoopBackTransport(); - myRTCPFeedback1 = new RtcpCallback(); - myRTCPFeedback2 = new RtcpCallback(); - receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock)); - receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock)); + receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock_)); + receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock_)); RtpRtcp::Configuration configuration; configuration.audio = true; - configuration.clock = &fake_clock; + configuration.clock = &fake_clock_; configuration.receive_statistics = receive_statistics1_.get(); configuration.outgoing_transport = transport1; - configuration.intra_frame_callback = myRTCPFeedback1; + configuration.intra_frame_callback = &rtcp_callback1_; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_payload_registry1_.reset(new RTPPayloadRegistry()); - rtp_payload_registry2_.reset(new RTPPayloadRegistry()); - module1 = RtpRtcp::CreateRtpRtcp(configuration); rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver( - &fake_clock, receiver, rtp_payload_registry1_.get())); + &fake_clock_, receiver, &rtp_payload_registry1_)); configuration.receive_statistics = receive_statistics2_.get(); configuration.outgoing_transport = transport2; - configuration.intra_frame_callback = myRTCPFeedback2; + configuration.intra_frame_callback = &rtcp_callback2_; module2 = RtpRtcp::CreateRtpRtcp(configuration); rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver( - &fake_clock, receiver, rtp_payload_registry2_.get())); + &fake_clock_, receiver, &rtp_payload_registry2_)); - transport1->SetSendModule(module2, rtp_payload_registry2_.get(), + transport1->SetSendModule(module2, &rtp_payload_registry2_, rtp_receiver2_.get(), receive_statistics2_.get()); - transport2->SetSendModule(module1, rtp_payload_registry1_.get(), + transport2->SetSendModule(module1, &rtp_payload_registry1_, rtp_receiver1_.get(), receive_statistics1_.get()); - myRTCPFeedback1->SetModule(module1); - myRTCPFeedback2->SetModule(module2); module1->SetRTCPStatus(RtcpMode::kCompound); module2->SetRTCPStatus(RtcpMode::kCompound); - module2->SetSSRC(test_ssrc + 1); - module2->SetRemoteSSRC(test_ssrc); - module1->SetSSRC(test_ssrc); - module1->SetSequenceNumber(test_sequence_number); - module1->SetStartTimestamp(test_timestamp); + module2->SetSSRC(kSsrc + 1); + module2->SetRemoteSSRC(kSsrc); + module1->SetSSRC(kSsrc); + module1->SetSequenceNumber(kSequenceNumber); + module1->SetStartTimestamp(kTimestamp); - module1->SetCsrcs(test_csrcs); + module1->SetCsrcs(kCsrcs); EXPECT_EQ(0, module1->SetCNAME("john.doe@test.test")); EXPECT_EQ(0, module1->SetSendingStatus(true)); @@ -121,7 +104,7 @@ class RtpRtcpRtcpTest : public ::testing::Test { // We need to send one RTP packet to get the RTCP packet to be accepted by // the receiving module. - // send RTP packet with the data "testtest" + // Send RTP packet with the data "testtest". const uint8_t test[9] = "testtest"; EXPECT_EQ(true, module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96, 0, -1, @@ -131,17 +114,17 @@ class RtpRtcpRtcpTest : public ::testing::Test { void TearDown() override { delete module1; delete module2; - delete myRTCPFeedback1; - delete myRTCPFeedback2; delete transport1; delete transport2; delete receiver; } + RtcpCallback rtcp_callback1_; + RtcpCallback rtcp_callback2_; + RTPPayloadRegistry rtp_payload_registry1_; + RTPPayloadRegistry rtp_payload_registry2_; std::unique_ptr receive_statistics1_; std::unique_ptr receive_statistics2_; - std::unique_ptr rtp_payload_registry1_; - std::unique_ptr rtp_payload_registry2_; std::unique_ptr rtp_receiver1_; std::unique_ptr rtp_receiver2_; RtpRtcp* module1; @@ -149,30 +132,25 @@ class RtpRtcpRtcpTest : public ::testing::Test { TestRtpReceiver* receiver; LoopBackTransport* transport1; LoopBackTransport* transport2; - RtcpCallback* myRTCPFeedback1; - RtcpCallback* myRTCPFeedback2; - uint32_t test_ssrc; - uint32_t test_timestamp; - uint16_t test_sequence_number; - std::vector test_csrcs; - SimulatedClock fake_clock; + const std::vector kCsrcs = {1234, 2345}; + SimulatedClock fake_clock_; RateLimiter retransmission_rate_limiter_; }; TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) { // Set cname of mixed. - EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[0], "john@192.168.0.1")); - EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[1], "jane@192.168.0.2")); + EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[0], "john@192.168.0.1")); + EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[1], "jane@192.168.0.2")); - EXPECT_EQ(-1, module1->RemoveMixedCNAME(test_csrcs[0] + 1)); - EXPECT_EQ(0, module1->RemoveMixedCNAME(test_csrcs[1])); - EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[1], "jane@192.168.0.2")); + EXPECT_EQ(-1, module1->RemoveMixedCNAME(kCsrcs[0] + 1)); + EXPECT_EQ(0, module1->RemoveMixedCNAME(kCsrcs[1])); + EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[1], "jane@192.168.0.2")); - // send RTCP packet, triggered by timer - fake_clock.AdvanceTimeMilliseconds(7500); + // Send RTCP packet, triggered by timer. + fake_clock_.AdvanceTimeMilliseconds(7500); module1->Process(); - fake_clock.AdvanceTimeMilliseconds(100); + fake_clock_.AdvanceTimeMilliseconds(100); module2->Process(); char cName[RTCP_CNAME_SIZE]; @@ -182,15 +160,15 @@ TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) { EXPECT_EQ(0, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName)); EXPECT_EQ(0, strncmp(cName, "john.doe@test.test", RTCP_CNAME_SIZE)); - EXPECT_EQ(0, module2->RemoteCNAME(test_csrcs[0], cName)); + EXPECT_EQ(0, module2->RemoteCNAME(kCsrcs[0], cName)); EXPECT_EQ(0, strncmp(cName, "john@192.168.0.1", RTCP_CNAME_SIZE)); - EXPECT_EQ(0, module2->RemoteCNAME(test_csrcs[1], cName)); + EXPECT_EQ(0, module2->RemoteCNAME(kCsrcs[1], cName)); EXPECT_EQ(0, strncmp(cName, "jane@192.168.0.2", RTCP_CNAME_SIZE)); EXPECT_EQ(0, module1->SetSendingStatus(false)); - // Test that BYE clears the CNAME + // Test that BYE clears the CNAME. EXPECT_EQ(-1, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName)); } @@ -200,23 +178,22 @@ TEST_F(RtpRtcpRtcpTest, RemoteRTCPStatRemote) { EXPECT_EQ(0, module1->RemoteRTCPStat(&report_blocks)); EXPECT_EQ(0u, report_blocks.size()); - // send RTCP packet, triggered by timer - fake_clock.AdvanceTimeMilliseconds(7500); + // Send RTCP packet, triggered by timer. + fake_clock_.AdvanceTimeMilliseconds(7500); module1->Process(); - fake_clock.AdvanceTimeMilliseconds(100); + fake_clock_.AdvanceTimeMilliseconds(100); module2->Process(); EXPECT_EQ(0, module1->RemoteRTCPStat(&report_blocks)); ASSERT_EQ(1u, report_blocks.size()); - // |test_ssrc+1| is the SSRC of module2 that send the report. - EXPECT_EQ(test_ssrc + 1, report_blocks[0].sender_ssrc); - EXPECT_EQ(test_ssrc, report_blocks[0].source_ssrc); + // |kSsrc+1| is the SSRC of module2 that send the report. + EXPECT_EQ(kSsrc + 1, report_blocks[0].sender_ssrc); + EXPECT_EQ(kSsrc, report_blocks[0].source_ssrc); EXPECT_EQ(0, report_blocks[0].packets_lost); EXPECT_LT(0u, report_blocks[0].delay_since_last_sender_report); - EXPECT_EQ(test_sequence_number, - report_blocks[0].extended_highest_sequence_number); + EXPECT_EQ(kSequenceNumber, report_blocks[0].extended_highest_sequence_number); EXPECT_EQ(0u, report_blocks[0].fraction_lost); } diff --git a/modules/rtp_rtcp/test/testAPI/test_api_video.cc b/modules/rtp_rtcp/test/testAPI/test_api_video.cc index 2cfc94e990..4d8190bdad 100644 --- a/modules/rtp_rtcp/test/testAPI/test_api_video.cc +++ b/modules/rtp_rtcp/test/testAPI/test_api_video.cc @@ -12,7 +12,6 @@ #include #include -#include #include "api/video_codecs/video_codec.h" #include "modules/rtp_rtcp/include/rtp_payload_registry.h" @@ -25,7 +24,7 @@ #include "test/gtest.h" namespace { - +const uint32_t kSsrc = 3456; const unsigned char kPayloadType = 100; }; @@ -34,29 +33,25 @@ namespace webrtc { class RtpRtcpVideoTest : public ::testing::Test { protected: RtpRtcpVideoTest() - : test_ssrc_(3456), - test_timestamp_(4567), - test_sequence_number_(2345), - fake_clock(123456), - retransmission_rate_limiter_(&fake_clock, 1000) {} + : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {} ~RtpRtcpVideoTest() override = default; void SetUp() override { transport_ = new LoopBackTransport(); receiver_ = new TestRtpReceiver(); - receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock)); + receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock_)); RtpRtcp::Configuration configuration; configuration.audio = false; - configuration.clock = &fake_clock; + configuration.clock = &fake_clock_; configuration.outgoing_transport = transport_; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; video_module_ = RtpRtcp::CreateRtpRtcp(configuration); rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver( - &fake_clock, receiver_, &rtp_payload_registry_)); + &fake_clock_, receiver_, &rtp_payload_registry_)); video_module_->SetRTCPStatus(RtcpMode::kCompound); - video_module_->SetSSRC(test_ssrc_); + video_module_->SetSSRC(kSsrc); video_module_->SetStorePacketsStatus(true, 600); EXPECT_EQ(0, video_module_->SetSendingStatus(true)); @@ -78,14 +73,14 @@ class RtpRtcpVideoTest : public ::testing::Test { } } - size_t BuildRTPheader(uint8_t* dataBuffer, + size_t BuildRTPheader(uint8_t* buffer, uint32_t timestamp, uint32_t sequence_number) { - dataBuffer[0] = static_cast(0x80); // version 2 - dataBuffer[1] = static_cast(kPayloadType); - ByteWriter::WriteBigEndian(dataBuffer + 2, sequence_number); - ByteWriter::WriteBigEndian(dataBuffer + 4, timestamp); - ByteWriter::WriteBigEndian(dataBuffer + 8, 0x1234); // SSRC. + buffer[0] = static_cast(0x80); // version 2 + buffer[1] = static_cast(kPayloadType); + ByteWriter::WriteBigEndian(buffer + 2, sequence_number); + ByteWriter::WriteBigEndian(buffer + 4, timestamp); + ByteWriter::WriteBigEndian(buffer + 8, 0x1234); // SSRC. size_t rtpHeaderLength = 12; return rtpHeaderLength; } @@ -122,19 +117,15 @@ class RtpRtcpVideoTest : public ::testing::Test { delete receiver_; } - int test_id_; std::unique_ptr receive_statistics_; RTPPayloadRegistry rtp_payload_registry_; std::unique_ptr rtp_receiver_; RtpRtcp* video_module_; LoopBackTransport* transport_; TestRtpReceiver* receiver_; - uint32_t test_ssrc_; - uint32_t test_timestamp_; - uint16_t test_sequence_number_; uint8_t video_frame_[65000]; size_t payload_data_length_; - SimulatedClock fake_clock; + SimulatedClock fake_clock_; RateLimiter retransmission_rate_limiter_; }; @@ -174,7 +165,7 @@ TEST_F(RtpRtcpVideoTest, PaddingOnlyFrames) { EXPECT_EQ(payload_length, receiver_->rtp_header().header.paddingLength); } timestamp += 3000; - fake_clock.AdvanceTimeMilliseconds(33); + fake_clock_.AdvanceTimeMilliseconds(33); } }