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

Fix test issues and a win compile error introduced with r6605.

Browse Source 
Also changes the name of a variable which has been hijacked by windef.h (included by windows.h), which forces #define near and #define far upon us. This issue was introduced via the following inclusion chain:
bwe_test_framework_unittest.cc includes
  paced_sender.h
    tick_util.h
      windows.h
        windef.h

And causes EXPECT_NEAR(foo, bar, near); to expand to EXPECT_NEAR(foo, bar,); generating a very confusing compile error.

R=pbos@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/20849004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6606 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
stefan@webrtc.org
2014-07-04 17:00:06 +00:00
parent 875ad49dee
commit bee164a214
2 changed files with 30 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
webrtc/modules/pacing/paced_sender_unittest.cc
View File

@ -58,6 +58,7 @@ class PacedSenderTest : public ::testing::Test {
protected: protected:
PacedSenderTest() : clock_(123456) { PacedSenderTest() : clock_(123456) {
srand(0); srand(0);
TickTime::UseFakeClock(123456);
// Need to initialize PacedSender after we initialize clock. // Need to initialize PacedSender after we initialize clock.
send_bucket_.reset( send_bucket_.reset(
new PacedSender( new PacedSender(
@ -98,8 +99,10 @@ TEST_F(PacedSenderTest, QueuePacket) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
clock_.AdvanceTimeMilliseconds(4); clock_.AdvanceTimeMilliseconds(4);
TickTime::AdvanceFakeClock(4);
EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(1); clock_.AdvanceTimeMilliseconds(1);
TickTime::AdvanceFakeClock(1);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_CALL(callback_, TimeToSendPacket( EXPECT_CALL(callback_, TimeToSendPacket(
ssrc, sequence_number++, queued_packet_timestamp, false)) ssrc, sequence_number++, queued_packet_timestamp, false))
@ -134,6 +137,7 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
for (int k = 0; k < 10; ++k) { for (int k = 0; k < 10; ++k) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_CALL(callback_, EXPECT_CALL(callback_,
TimeToSendPacket(ssrc, _, _, false)) TimeToSendPacket(ssrc, _, _, false))
.Times(3) .Times(3)
@ -143,6 +147,7 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
} }
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
@ -180,6 +185,7 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
for (int k = 0; k < 10; ++k) { for (int k = 0; k < 10; ++k) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
for (int i = 0; i < 3; ++i) { for (int i = 0; i < 3; ++i) {
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, queued_sequence_number++, EXPECT_CALL(callback_, TimeToSendPacket(ssrc, queued_sequence_number++,
@ -193,6 +199,7 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
} }
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
@ -222,6 +229,7 @@ TEST_F(PacedSenderTest, Padding) {
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
@ -230,6 +238,7 @@ TEST_F(PacedSenderTest, Padding) {
WillOnce(Return(250)); WillOnce(Return(250));
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
} }
@ -241,11 +250,13 @@ TEST_F(PacedSenderTest, NoPaddingWhenDisabled) {
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
} }
@ -262,6 +273,7 @@ TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
capture_time_ms, 250, false); capture_time_ms, 250, false);
clock_.AdvanceTimeMilliseconds(kTimeStep); clock_.AdvanceTimeMilliseconds(kTimeStep);
TickTime::AdvanceFakeClock(kTimeStep);
EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
WillOnce(Return(250)); WillOnce(Return(250));
send_bucket_->Process(); send_bucket_->Process();
@ -287,6 +299,7 @@ TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
media_payload, false)); media_payload, false));
media_bytes += media_payload; media_bytes += media_payload;
clock_.AdvanceTimeMilliseconds(kTimeStep); clock_.AdvanceTimeMilliseconds(kTimeStep);
TickTime::AdvanceFakeClock(kTimeStep);
send_bucket_->Process(); send_bucket_->Process();
} }
EXPECT_NEAR(kTargetBitrate, 8 * (media_bytes + callback.padding_sent()) / EXPECT_NEAR(kTargetBitrate, 8 * (media_bytes + callback.padding_sent()) /
@ -328,6 +341,7 @@ TEST_F(PacedSenderTest, Priority) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
@ -338,6 +352,7 @@ TEST_F(PacedSenderTest, Priority) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
} }
@ -369,6 +384,7 @@ TEST_F(PacedSenderTest, Pause) {
ssrc, sequence_number++, capture_time_ms, 250, false)); ssrc, sequence_number++, capture_time_ms, 250, false));
clock_.AdvanceTimeMilliseconds(10000); clock_.AdvanceTimeMilliseconds(10000);
TickTime::AdvanceFakeClock(10000);
int64_t second_capture_time_ms = clock_.TimeInMilliseconds(); int64_t second_capture_time_ms = clock_.TimeInMilliseconds();
// Expect everything to be queued. // Expect everything to be queued.
@ -385,6 +401,7 @@ TEST_F(PacedSenderTest, Pause) {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
} }
@ -397,6 +414,7 @@ TEST_F(PacedSenderTest, Pause) {
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
@ -406,6 +424,7 @@ TEST_F(PacedSenderTest, Pause) {
.WillRepeatedly(Return(true)); .WillRepeatedly(Return(true));
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
clock_.AdvanceTimeMilliseconds(5); clock_.AdvanceTimeMilliseconds(5);
TickTime::AdvanceFakeClock(5);
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
EXPECT_EQ(0, send_bucket_->Process()); EXPECT_EQ(0, send_bucket_->Process());
EXPECT_EQ(0, send_bucket_->QueueInMs()); EXPECT_EQ(0, send_bucket_->QueueInMs());
@ -424,6 +443,7 @@ TEST_F(PacedSenderTest, ResendPacket) {
250, 250,
false)); false));
clock_.AdvanceTimeMilliseconds(1); clock_.AdvanceTimeMilliseconds(1);
TickTime::AdvanceFakeClock(1);
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
ssrc, ssrc,
sequence_number + 1, sequence_number + 1,
@ -431,6 +451,7 @@ TEST_F(PacedSenderTest, ResendPacket) {
250, 250,
false)); false));
clock_.AdvanceTimeMilliseconds(9999); clock_.AdvanceTimeMilliseconds(9999);
TickTime::AdvanceFakeClock(9999);
EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms, EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
send_bucket_->QueueInMs()); send_bucket_->QueueInMs());
// Fails to send first packet so only one call. // Fails to send first packet so only one call.
@ -439,6 +460,7 @@ TEST_F(PacedSenderTest, ResendPacket) {
.Times(1) .Times(1)
.WillOnce(Return(false)); .WillOnce(Return(false));
clock_.AdvanceTimeMilliseconds(10000); clock_.AdvanceTimeMilliseconds(10000);
TickTime::AdvanceFakeClock(10000);
send_bucket_->Process(); send_bucket_->Process();
// Queue remains unchanged. // Queue remains unchanged.
@ -455,6 +477,7 @@ TEST_F(PacedSenderTest, ResendPacket) {
.Times(1) .Times(1)
.WillOnce(Return(false)); .WillOnce(Return(false));
clock_.AdvanceTimeMilliseconds(10000); clock_.AdvanceTimeMilliseconds(10000);
TickTime::AdvanceFakeClock(10000);
send_bucket_->Process(); send_bucket_->Process();
// Queue is reduced by 1 packet. // Queue is reduced by 1 packet.
@ -467,6 +490,7 @@ TEST_F(PacedSenderTest, ResendPacket) {
.Times(1) .Times(1)
.WillOnce(Return(true)); .WillOnce(Return(true));
clock_.AdvanceTimeMilliseconds(10000); clock_.AdvanceTimeMilliseconds(10000);
TickTime::AdvanceFakeClock(10000);
send_bucket_->Process(); send_bucket_->Process();
EXPECT_EQ(0, send_bucket_->QueueInMs()); EXPECT_EQ(0, send_bucket_->QueueInMs());
} }
@ -487,6 +511,7 @@ TEST_F(PacedSenderTest, MaxQueueLength) {
} }
clock_.AdvanceTimeMilliseconds(2001); clock_.AdvanceTimeMilliseconds(2001);
TickTime::AdvanceFakeClock(2001);
SendAndExpectPacket(PacedSender::kNormalPriority, SendAndExpectPacket(PacedSender::kNormalPriority,
ssrc, ssrc,
sequence_number++, sequence_number++,
@ -497,6 +522,7 @@ TEST_F(PacedSenderTest, MaxQueueLength) {
send_bucket_->Process(); send_bucket_->Process();
EXPECT_EQ(0, send_bucket_->QueueInMs()); EXPECT_EQ(0, send_bucket_->QueueInMs());
clock_.AdvanceTimeMilliseconds(31); clock_.AdvanceTimeMilliseconds(31);
TickTime::AdvanceFakeClock(31);
send_bucket_->Process(); send_bucket_->Process();
} }
@ -514,6 +540,7 @@ TEST_F(PacedSenderTest, QueueTimeGrowsOverTime) {
false); false);
clock_.AdvanceTimeMilliseconds(500); clock_.AdvanceTimeMilliseconds(500);
TickTime::AdvanceFakeClock(500);
EXPECT_EQ(500, send_bucket_->QueueInMs()); EXPECT_EQ(500, send_bucket_->QueueInMs());
send_bucket_->Process(); send_bucket_->Process();
EXPECT_EQ(0, send_bucket_->QueueInMs()); EXPECT_EQ(0, send_bucket_->QueueInMs());

5
webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework_unittest.cc
View File

@ -500,7 +500,7 @@ TEST(BweTestFramework_JitterFilterTest, Jitter1031) {
TestJitterFilter(1031); TestJitterFilter(1031);
} }
static void TestReorderFilter(uint32_t reorder_percent, uint32_t near) { static void TestReorderFilter(uint32_t reorder_percent, uint32_t near_value) {
const uint32_t kPacketCount = 10000; const uint32_t kPacketCount = 10000;
// Generate packets with 10 ms interval. // Generate packets with 10 ms interval.
@ -533,7 +533,8 @@ static void TestReorderFilter(uint32_t reorder_percent, uint32_t near) {
// Because reordering is random, we allow a threshold when comparing. The // Because reordering is random, we allow a threshold when comparing. The
// maximum distance a packet can be moved is PacketCount - 1. // maximum distance a packet can be moved is PacketCount - 1.
EXPECT_NEAR(((kPacketCount - 1) * reorder_percent) / 100, distance, near); EXPECT_NEAR(
((kPacketCount - 1) * reorder_percent) / 100, distance, near_value);
} }
TEST(BweTestFramework_ReorderFilterTest, Reorder0) { TEST(BweTestFramework_ReorderFilterTest, Reorder0) {