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

Making BasicPortAllocator tests slightly less fragile.

Browse Source 
Many of the tests follow a pattern of "wait for N candidates to be
gathered, then (without waiting) assert that gathering is complete". But
this only works if the "gathering complete" signal happens in the same
task as the last candidate being gathered, which isn't an API guarantee.
So the tests will be less fragile if they do the reverse: "wait for
gathering to be complete, then (without waiting) assert that N candidates
were gathered".

Also fixing some somewhat unrelated issues elsewhere. Like a test that
was supposed to be waiting for some period of time and ensuring no
additional candidates were gathered, but wasn't actually waiting at all.

BUG=None

Review-Url: https://codereview.webrtc.org/3018493002
Cr-Commit-Position: refs/heads/master@{#19872}
This commit is contained in:
deadbeef 2017-09-15 17:40:01 -07:00 committed by Commit Bot
parent 930021d465
commit 7f1563facf
1 changed files with 78 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
p2p/client/basicportallocator_unittest.cc
View File

@ -871,8 +871,9 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsWithMinimumStepDelay) {
AddInterface(kClientAddr); AddInterface(kClientAddr);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_EQ(4U, ports_.size()); EXPECT_EQ(4U, ports_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp", kClientAddr);
@ -882,7 +883,6 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsWithMinimumStepDelay) {
EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp", EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
kRelaySslTcpIntAddr); kRelaySslTcpIntAddr);
EXPECT_TRUE(candidate_allocation_done_);
} }
// Test that when the same network interface is brought down and up, the // Test that when the same network interface is brought down and up, the
@ -893,27 +893,33 @@ TEST_F(BasicPortAllocatorTest, TestSameNetworkDownAndUpWhenSessionNotStopped) {
AddInterface(kClientAddr, if_name); AddInterface(kClientAddr, if_name);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_EQ(4U, ports_.size()); EXPECT_EQ(4U, ports_.size());
EXPECT_TRUE(candidate_allocation_done_);
candidate_allocation_done_ = false; candidate_allocation_done_ = false;
candidates_.clear(); candidates_.clear();
ports_.clear(); ports_.clear();
// Disable socket creation to simulate the network interface being down. When
// no network interfaces are available, BasicPortAllocator will fall back to
// binding to the "ANY" address, so we need to make sure that fails too.
fss_->set_tcp_sockets_enabled(false);
fss_->set_udp_sockets_enabled(false);
RemoveInterface(kClientAddr); RemoveInterface(kClientAddr);
ASSERT_EQ_SIMULATED_WAIT(0U, candidates_.size(), kDefaultAllocationTimeout, SIMULATED_WAIT(false, 1000, fake_clock);
fake_clock); EXPECT_EQ(0U, candidates_.size());
EXPECT_EQ(0U, ports_.size()); ports_.clear();
EXPECT_FALSE(candidate_allocation_done_);
// When the same interfaces are added again, new candidates/ports should be // When the same interfaces are added again, new candidates/ports should be
// generated. // generated.
fss_->set_tcp_sockets_enabled(true);
fss_->set_udp_sockets_enabled(true);
AddInterface(kClientAddr, if_name); AddInterface(kClientAddr, if_name);
ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_EQ(4U, ports_.size()); EXPECT_EQ(4U, ports_.size());
EXPECT_TRUE(candidate_allocation_done_);
} }
// Test that when the same network interface is brought down and up, the // Test that when the same network interface is brought down and up, the
@ -924,26 +930,27 @@ TEST_F(BasicPortAllocatorTest, TestSameNetworkDownAndUpWhenSessionStopped) {
AddInterface(kClientAddr, if_name); AddInterface(kClientAddr, if_name);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_EQ(4U, ports_.size()); EXPECT_EQ(4U, ports_.size());
EXPECT_TRUE(candidate_allocation_done_);
session_->StopGettingPorts(); session_->StopGettingPorts();
candidates_.clear(); candidates_.clear();
ports_.clear(); ports_.clear();
RemoveInterface(kClientAddr); RemoveInterface(kClientAddr);
ASSERT_EQ_SIMULATED_WAIT(0U, candidates_.size(), kDefaultAllocationTimeout, // Wait one (simulated) second and then verify no new candidates have
fake_clock); // appeared.
SIMULATED_WAIT(false, 1000, fake_clock);
EXPECT_EQ(0U, candidates_.size());
EXPECT_EQ(0U, ports_.size()); EXPECT_EQ(0U, ports_.size());
// When the same interfaces are added again, new candidates/ports should not // When the same interfaces are added again, new candidates/ports should not
// be generated because the session has stopped. // be generated because the session has stopped.
AddInterface(kClientAddr, if_name); AddInterface(kClientAddr, if_name);
ASSERT_EQ_SIMULATED_WAIT(0U, candidates_.size(), kDefaultAllocationTimeout, SIMULATED_WAIT(false, 1000, fake_clock);
fake_clock); EXPECT_EQ(0U, candidates_.size());
EXPECT_EQ(0U, ports_.size()); EXPECT_EQ(0U, ports_.size());
EXPECT_TRUE(candidate_allocation_done_);
} }
// Verify candidates with default step delay of 1sec. // Verify candidates with default step delay of 1sec.
@ -975,9 +982,9 @@ TEST_F(BasicPortAllocatorTest, TestSetupVideoRtpPortsWithNormalSendBuffers) {
AddInterface(kClientAddr); AddInterface(kClientAddr);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP, CN_VIDEO)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP, CN_VIDEO));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_TRUE(candidate_allocation_done_); EXPECT_EQ(7U, candidates_.size());
// If we Stop gathering now, we shouldn't get a second "done" callback. // If we Stop gathering now, we shouldn't get a second "done" callback.
session_->StopGettingPorts(); session_->StopGettingPorts();
@ -985,15 +992,18 @@ TEST_F(BasicPortAllocatorTest, TestSetupVideoRtpPortsWithNormalSendBuffers) {
CheckSendBufferSizesOfAllPorts(-1); CheckSendBufferSizesOfAllPorts(-1);
} }
// Tests that we can get callback after StopGetAllPorts. // Tests that we can get callback after StopGetAllPorts when called in the
// middle of gathering.
TEST_F(BasicPortAllocatorTest, TestStopGetAllPorts) { TEST_F(BasicPortAllocatorTest, TestStopGetAllPorts) {
AddInterface(kClientAddr); AddInterface(kClientAddr);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout); ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout,
fake_clock);
EXPECT_EQ(2U, ports_.size()); EXPECT_EQ(2U, ports_.size());
session_->StopGettingPorts(); session_->StopGettingPorts();
EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout); EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock);
} }
// Test that we restrict client ports appropriately when a port range is set. // Test that we restrict client ports appropriately when a port range is set.
@ -1009,8 +1019,9 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsPortRange) {
EXPECT_TRUE(SetPortRange(kMinPort, kMaxPort)); EXPECT_TRUE(SetPortRange(kMinPort, kMaxPort));
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_EQ(4U, ports_.size()); EXPECT_EQ(4U, ports_.size());
int num_nonrelay_candidates = 0; int num_nonrelay_candidates = 0;
@ -1025,7 +1036,6 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsPortRange) {
// Check the port number used to connect to the relay server. // Check the port number used to connect to the relay server.
EXPECT_PRED3(CheckPort, relay_server_.GetConnection(0).source(), kMinPort, EXPECT_PRED3(CheckPort, relay_server_.GetConnection(0).source(), kMinPort,
kMaxPort); kMaxPort);
EXPECT_TRUE(candidate_allocation_done_);
} }
// Test that if we have no network adapters, we bind to the ANY address and // Test that if we have no network adapters, we bind to the ANY address and
@ -1218,8 +1228,9 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsNoUdpSockets) {
fss_->set_udp_sockets_enabled(false); fss_->set_udp_sockets_enabled(false);
EXPECT_TRUE(CreateSession(1)); EXPECT_TRUE(CreateSession(1));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(5U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(5U, candidates_.size());
EXPECT_EQ(2U, ports_.size()); EXPECT_EQ(2U, ports_.size());
EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr); EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr); EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
@ -1227,7 +1238,6 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsNoUdpSockets) {
EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp", EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
kRelaySslTcpIntAddr); kRelaySslTcpIntAddr);
EXPECT_TRUE(candidate_allocation_done_);
} }
#endif // if !defined(ADDRESS_SANITIZER) #endif // if !defined(ADDRESS_SANITIZER)
@ -1241,8 +1251,9 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsNoUdpSocketsNoTcpListen) {
fss_->set_tcp_listen_enabled(false); fss_->set_tcp_listen_enabled(false);
EXPECT_TRUE(CreateSession(1)); EXPECT_TRUE(CreateSession(1));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(5U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(5U, candidates_.size());
EXPECT_EQ(2U, ports_.size()); EXPECT_EQ(2U, ports_.size());
EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr); EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr); EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
@ -1250,7 +1261,6 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsNoUdpSocketsNoTcpListen) {
EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp", EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
kRelaySslTcpIntAddr); kRelaySslTcpIntAddr);
EXPECT_TRUE(candidate_allocation_done_);
} }
// Test that we don't crash or malfunction if we can't create any sockets. // Test that we don't crash or malfunction if we can't create any sockets.
@ -1261,7 +1271,7 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsNoSockets) {
fss_->set_udp_sockets_enabled(false); fss_->set_udp_sockets_enabled(false);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
WAIT(candidates_.size() > 0, 2000); SIMULATED_WAIT(candidates_.size() > 0, 2000, fake_clock);
// TODO(deadbeef): Check candidate_allocation_done signal. // TODO(deadbeef): Check candidate_allocation_done signal.
// In case of Relay, ports creation will succeed but sockets will fail. // In case of Relay, ports creation will succeed but sockets will fail.
// There is no error reporting from RelayEntry to handle this failure. // There is no error reporting from RelayEntry to handle this failure.
@ -1316,10 +1326,10 @@ TEST_F(BasicPortAllocatorTest, TestGetAllPortsRestarts) {
AddInterface(kClientAddr); AddInterface(kClientAddr);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
EXPECT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_EQ(4U, ports_.size()); EXPECT_EQ(4U, ports_.size());
EXPECT_TRUE(candidate_allocation_done_);
// TODO(deadbeef): Extend this to verify ICE restart. // TODO(deadbeef): Extend this to verify ICE restart.
} }
@ -1335,10 +1345,10 @@ TEST_F(BasicPortAllocatorTest, TestSessionUsesOwnCandidateFilter) {
session_->StartGettingPorts(); session_->StartGettingPorts();
// 7 candidates and 4 ports is what we would normally get (see the // 7 candidates and 4 ports is what we would normally get (see the
// TestGetAllPorts* tests). // TestGetAllPorts* tests).
EXPECT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_EQ(4U, ports_.size()); EXPECT_EQ(4U, ports_.size());
EXPECT_TRUE(candidate_allocation_done_);
} }
// Test ICE candidate filter mechanism with options Relay/Host/Reflexive. // Test ICE candidate filter mechanism with options Relay/Host/Reflexive.
@ -1424,8 +1434,9 @@ TEST_F(BasicPortAllocatorTest, TestEnableSharedUfrag) {
AddInterface(kClientAddr); AddInterface(kClientAddr);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(7U, candidates_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
@ -1434,7 +1445,6 @@ TEST_F(BasicPortAllocatorTest, TestEnableSharedUfrag) {
EXPECT_EQ(kIceUfrag0, candidate.username()); EXPECT_EQ(kIceUfrag0, candidate.username());
EXPECT_EQ(kIcePwd0, candidate.password()); EXPECT_EQ(kIcePwd0, candidate.password());
} }
EXPECT_TRUE(candidate_allocation_done_);
} }
// Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port // Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port
@ -1493,17 +1503,15 @@ TEST_F(BasicPortAllocatorTest, TestSharedSocketWithoutNatUsingTurn) {
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
ASSERT_EQ(3U, candidates_.size());
ASSERT_EQ(3U, ports_.size()); ASSERT_EQ(3U, ports_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(3U, candidates_.size());
} }
// Test that if prune_turn_ports is set, TCP TURN port will not be used // Test that if prune_turn_ports is set, TCP TURN port will not be used
@ -1622,8 +1630,9 @@ TEST_F(BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurn) {
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(3U, candidates_.size());
ASSERT_EQ(2U, ports_.size()); ASSERT_EQ(2U, ports_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp", EXPECT_PRED4(HasCandidate, candidates_, "stun", "udp",
@ -1632,8 +1641,9 @@ TEST_F(BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurn) {
rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_, EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(3U, candidates_.size());
// Local port will be created first and then TURN port. // Local port will be created first and then TURN port.
// TODO(deadbeef): This isn't something the BasicPortAllocator API contract
// guarantees...
EXPECT_EQ(2U, ports_[0]->Candidates().size()); EXPECT_EQ(2U, ports_[0]->Candidates().size());
EXPECT_EQ(1U, ports_[1]->Candidates().size()); EXPECT_EQ(1U, ports_[1]->Candidates().size());
} }
@ -1659,8 +1669,9 @@ TEST_F(BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurnAsStun) {
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(3U, candidates_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
Candidate stun_candidate; Candidate stun_candidate;
EXPECT_PRED5(FindCandidate, candidates_, "stun", "udp", EXPECT_PRED5(FindCandidate, candidates_, "stun", "udp",
@ -1669,10 +1680,9 @@ TEST_F(BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurnAsStun) {
rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0), rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
stun_candidate.address()); stun_candidate.address());
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(3U, candidates_.size());
// Local port will be created first and then TURN port. // Local port will be created first and then TURN port.
// TODO(deadbeef): This isn't something the BasicPortAllocator API contract
// guarantees...
EXPECT_EQ(2U, ports_[0]->Candidates().size()); EXPECT_EQ(2U, ports_[0]->Candidates().size());
EXPECT_EQ(1U, ports_[1]->Candidates().size()); EXPECT_EQ(1U, ports_[1]->Candidates().size());
} }
@ -1693,15 +1703,13 @@ TEST_F(BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurnTcpOnly) {
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(2U, candidates_.size());
ASSERT_EQ(2U, ports_.size()); ASSERT_EQ(2U, ports_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp",
rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)); rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(2U, candidates_.size());
EXPECT_EQ(1U, ports_[0]->Candidates().size()); EXPECT_EQ(1U, ports_[0]->Candidates().size());
EXPECT_EQ(1U, ports_[1]->Candidates().size()); EXPECT_EQ(1U, ports_[1]->Candidates().size());
} }
@ -1722,8 +1730,9 @@ TEST_F(BasicPortAllocatorTest, TestNonSharedSocketWithNatUsingTurnAsStun) {
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(3U, candidates_.size());
ASSERT_EQ(3U, ports_.size()); ASSERT_EQ(3U, ports_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
Candidate stun_candidate; Candidate stun_candidate;
@ -1737,9 +1746,6 @@ TEST_F(BasicPortAllocatorTest, TestNonSharedSocketWithNatUsingTurnAsStun) {
// should be different than the TURN request's server reflexive address. // should be different than the TURN request's server reflexive address.
EXPECT_NE(turn_candidate.related_address(), stun_candidate.address()); EXPECT_NE(turn_candidate.related_address(), stun_candidate.address());
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(1U, ports_[0]->Candidates().size()); EXPECT_EQ(1U, ports_[0]->Candidates().size());
EXPECT_EQ(1U, ports_[1]->Candidates().size()); EXPECT_EQ(1U, ports_[1]->Candidates().size());
EXPECT_EQ(1U, ports_[2]->Candidates().size()); EXPECT_EQ(1U, ports_[2]->Candidates().size());
@ -1830,16 +1836,14 @@ TEST_F(BasicPortAllocatorTest, TestEnableIPv6Addresses) {
allocator_->set_step_delay(kMinimumStepDelay); allocator_->set_step_delay(kMinimumStepDelay);
EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP)); EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts(); session_->StartGettingPorts();
ASSERT_EQ_SIMULATED_WAIT(4U, ports_.size(), kDefaultAllocationTimeout, ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
fake_clock);
EXPECT_EQ(4U, candidates_.size());
EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
kDefaultAllocationTimeout, fake_clock); kDefaultAllocationTimeout, fake_clock);
EXPECT_EQ(4U, ports_.size());
EXPECT_EQ(4U, candidates_.size());
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientIPv6Addr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientIPv6Addr);
EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "udp", kClientAddr);
EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientIPv6Addr); EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientIPv6Addr);
EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr); EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
EXPECT_EQ(4U, candidates_.size());
} }
TEST_F(BasicPortAllocatorTest, TestStopGettingPorts) { TEST_F(BasicPortAllocatorTest, TestStopGettingPorts) {