Replace gunit.h macros with WaitUntil in P2P
Bug: webrtc:381524905
Change-Id: Ia2614729b17a40cd2f5f226e351b3f82c2038977
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/374181
Reviewed-by: Jonas Oreland <jonaso@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43758}
diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index 8ede171..05807b3 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -1206,6 +1206,7 @@
":p2p_server_utils",
":p2p_test_utils",
":p2p_transport_channel",
+ ":p2p_transport_channel_ice_field_trials",
":packet_transport_internal",
":port",
":port_allocator",
@@ -1230,6 +1231,8 @@
"../api:libjingle_peerconnection_api",
"../api:mock_async_dns_resolver",
"../api:packet_socket_factory",
+ "../api:rtc_error",
+ "../api:rtc_error_matchers",
"../api:scoped_refptr",
"../api/crypto:options",
"../api/task_queue",
@@ -1265,6 +1268,7 @@
"../rtc_base:socket_server",
"../rtc_base:ssl",
"../rtc_base:ssl_adapter",
+ "../rtc_base:stream",
"../rtc_base:stringutils",
"../rtc_base:testclient",
"../rtc_base:threading",
@@ -1277,6 +1281,7 @@
"../test:rtc_expect_death",
"../test:scoped_key_value_config",
"../test:test_support",
+ "../test:wait_until",
"//testing/gtest",
"//third_party/abseil-cpp/absl/algorithm:container",
"//third_party/abseil-cpp/absl/functional:any_invocable",
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index c23867e..b7fd49a 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -33,6 +33,7 @@
#include "api/scoped_refptr.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/test/mock_async_dns_resolver.h"
+#include "api/test/rtc_error_matchers.h"
#include "api/transport/enums.h"
#include "api/transport/stun.h"
#include "api/units/time_delta.h"
@@ -91,21 +92,23 @@
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
+#include "test/wait_until.h"
namespace {
using rtc::SocketAddress;
using ::testing::_;
using ::testing::Assign;
-using ::testing::Combine;
using ::testing::Contains;
using ::testing::DoAll;
-using ::testing::InSequence;
-using ::testing::InvokeWithoutArgs;
+using ::testing::Eq;
+using ::testing::Gt;
+using ::testing::IsFalse;
+using ::testing::IsTrue;
using ::testing::MockFunction;
+using ::testing::Ne;
using ::testing::Return;
using ::testing::ReturnRef;
-using ::testing::SaveArg;
using ::testing::SetArgPointee;
using ::testing::SizeIs;
using ::testing::Values;
@@ -286,6 +289,7 @@
} // namespace
namespace cricket {
+using ::testing::NotNull;
// This test simulates 2 P2P endpoints that want to establish connectivity
// with each other over various network topologies and conditions, which can be
@@ -707,8 +711,13 @@
// Create the channels and wait for them to connect.
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- expected.connect_wait + kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ expected.connect_wait + kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
connect_time = rtc::TimeMillis() - connect_start;
if (connect_time < expected.connect_wait) {
RTC_LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
@@ -726,9 +735,15 @@
// This is done only for the RFC 5245 as controlled agent will use
// USE-CANDIDATE from controlling (ep1) agent. We can easily predict from
// EP1 result matrix.
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidate1(expected) && CheckCandidate2(expected),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidate1(expected) &&
+ CheckCandidate2(expected);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Also do EXPECT_EQ on each part so that failures are more verbose.
ExpectCandidate1(expected);
ExpectCandidate2(expected);
@@ -754,14 +769,28 @@
const char* data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
int len = static_cast<int>(strlen(data));
// local_channel1 <==> remote_channel1
- EXPECT_EQ_SIMULATED_WAIT(len, SendData(ep1_ch1(), data, len),
- kMediumTimeout, *clock);
- EXPECT_TRUE_SIMULATED_WAIT(CheckDataOnChannel(ep2_ch1(), data, len),
- kMediumTimeout, *clock);
- EXPECT_EQ_SIMULATED_WAIT(len, SendData(ep2_ch1(), data, len),
- kMediumTimeout, *clock);
- EXPECT_TRUE_SIMULATED_WAIT(CheckDataOnChannel(ep1_ch1(), data, len),
- kMediumTimeout, *clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return SendData(ep1_ch1(), data, len); }, Eq(len),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &*clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return CheckDataOnChannel(ep2_ch1(), data, len); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &*clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return SendData(ep2_ch1(), data, len); }, Eq(len),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &*clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return CheckDataOnChannel(ep1_ch1(), data, len); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &*clock}),
+ webrtc::IsRtcOk());
}
}
@@ -774,8 +803,12 @@
rtc::ScopedFakeClock clock;
ep1_ch1()->SetRemoteIceParameters(kIceParams[1]);
ep2_ch1()->SetRemoteIceParameters(kIceParams[0]);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
const Candidate* old_local_candidate1 = LocalCandidate(ep1_ch1());
const Candidate* old_local_candidate2 = LocalCandidate(ep2_ch1());
@@ -790,18 +823,30 @@
ep2_ch1()->SetRemoteIceParameters(kIceParams[2]);
ep2_ch1()->MaybeStartGathering();
- EXPECT_TRUE_SIMULATED_WAIT(LocalCandidate(ep1_ch1())->generation() !=
- old_local_candidate1->generation(),
- kMediumTimeout, clock);
- EXPECT_TRUE_SIMULATED_WAIT(LocalCandidate(ep2_ch1())->generation() !=
- old_local_candidate2->generation(),
- kMediumTimeout, clock);
- EXPECT_TRUE_SIMULATED_WAIT(RemoteCandidate(ep1_ch1())->generation() !=
- old_remote_candidate1->generation(),
- kMediumTimeout, clock);
- EXPECT_TRUE_SIMULATED_WAIT(RemoteCandidate(ep2_ch1())->generation() !=
- old_remote_candidate2->generation(),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return LocalCandidate(ep1_ch1())->generation(); },
+ Ne(old_local_candidate1->generation()),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return LocalCandidate(ep2_ch1())->generation(); },
+ Ne(old_local_candidate2->generation()),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return RemoteCandidate(ep1_ch1())->generation(); },
+ Ne(old_remote_candidate1->generation()),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return RemoteCandidate(ep2_ch1())->generation(); },
+ Ne(old_remote_candidate2->generation()),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1u, RemoteCandidate(ep2_ch1())->generation());
EXPECT_EQ(1u, RemoteCandidate(ep1_ch1())->generation());
}
@@ -1303,10 +1348,15 @@
ConfigureEndpoints(OPEN, OPEN, kDefaultPortAllocatorFlags,
kDefaultPortAllocatorFlags);
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
- ep2_ch1()->receiving() &&
- ep2_ch1()->writable(),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->receiving() && ep1_ch1()->writable() &&
+ ep2_ch1()->receiving() && ep2_ch1()->writable();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Sends and receives 10 packets.
TestSendRecv(&clock);
@@ -1358,10 +1408,15 @@
AddAddress(0, kAlternateAddrs[1], "rmnet0", rtc::ADAPTER_TYPE_CELLULAR);
CreateChannels(continual_gathering_config, continual_gathering_config);
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
- ep2_ch1()->receiving() &&
- ep2_ch1()->writable(),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->receiving() && ep1_ch1()->writable() &&
+ ep2_ch1()->receiving() && ep2_ch1()->writable();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Sends and receives 10 packets.
TestSendRecv(&clock);
@@ -1392,8 +1447,11 @@
ep1_ch1()->RemoveConnectionForTest(
const_cast<Connection*>(old_selected_connection));
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() != nullptr,
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Sends and receives 10 packets.
TestSendRecv(&clock);
@@ -1430,15 +1488,24 @@
IceConfig default_config;
CreateChannels(continual_gathering_config, default_config);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Adding address in ep1 will trigger continual gathering.
AddAddress(0, kAlternateAddrs[0]);
- EXPECT_EQ_SIMULATED_WAIT(1,
- GetEndpoint(0)->GetIceRegatheringCountForReason(
- IceRegatheringReason::NETWORK_CHANGE),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return GetEndpoint(0)->GetIceRegatheringCountForReason(
+ IceRegatheringReason::NETWORK_CHANGE);
+ },
+ Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ep2_ch1()->SetIceParameters(kIceParams[3]);
ep2_ch1()->SetRemoteIceParameters(kIceParams[2]);
@@ -1467,8 +1534,12 @@
config2.regather_on_failed_networks_interval = 2000;
CreateChannels(config1, config2);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
// Timeout value such that all connections are deleted.
@@ -1499,7 +1570,10 @@
// Wait until the callee becomes writable to make sure that a ping request is
// received by the caller before their remote ICE credentials are set.
- ASSERT_TRUE_WAIT(ep2_ch1()->selected_connection() != nullptr, kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// Add two sets of remote ICE credentials, so that the ones used by the
// candidate will be generation 1 instead of 0.
ep1_ch1()->SetRemoteIceParameters(kIceParams[3]);
@@ -1507,9 +1581,13 @@
// The caller should have the selected connection connected to the peer
// reflexive candidate.
const Connection* selected_connection = nullptr;
- ASSERT_TRUE_WAIT(
- (selected_connection = ep1_ch1()->selected_connection()) != nullptr,
- kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return selected_connection = ep1_ch1()->selected_connection();
+ },
+ Ne(nullptr), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(selected_connection->remote_candidate().is_prflx());
EXPECT_EQ(kIceUfrag[1], selected_connection->remote_candidate().username());
EXPECT_EQ(kIcePwd[1], selected_connection->remote_candidate().password());
@@ -1517,9 +1595,16 @@
ResumeCandidates(1);
// Verify ep1's selected connection is updated to use the 'local' candidate.
- EXPECT_TRUE_WAIT(
- ep1_ch1()->selected_connection()->remote_candidate().is_local(),
- kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_local();
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(selected_connection, ep1_ch1()->selected_connection());
DestroyChannels();
}
@@ -1540,9 +1625,15 @@
// candidate.
PauseCandidates(1);
- ASSERT_TRUE_WAIT(ep2_ch1()->selected_connection() != nullptr, kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
ep1_ch1()->SetRemoteIceParameters(kIceParams[1]);
- ASSERT_TRUE_WAIT(ep1_ch1()->selected_connection() != nullptr, kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// Check the selected candidate pair.
auto pair_ep1 = ep1_ch1()->GetSelectedCandidatePair();
@@ -1563,10 +1654,17 @@
// Let ep1 receive the remote candidate to update its type from prflx to host.
ResumeCandidates(1);
- ASSERT_TRUE_WAIT(
- ep1_ch1()->selected_connection() != nullptr &&
- ep1_ch1()->selected_connection()->remote_candidate().is_local(),
- kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() != nullptr &&
+ ep1_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_local();
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// We should be able to reveal the address after it is learnt via
// AddIceCandidate.
@@ -1605,7 +1703,10 @@
// Wait until the callee becomes writable to make sure that a ping request is
// received by the caller before their remote ICE credentials are set.
- ASSERT_TRUE_WAIT(ep2_ch1()->selected_connection() != nullptr, kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// Add two sets of remote ICE credentials, so that the ones used by the
// candidate will be generation 1 instead of 0.
ep1_ch1()->SetRemoteIceParameters(kIceParams[3]);
@@ -1614,9 +1715,13 @@
// The caller's selected connection should be connected to the peer reflexive
// candidate.
const Connection* selected_connection = nullptr;
- ASSERT_TRUE_WAIT(
- (selected_connection = ep1_ch1()->selected_connection()) != nullptr,
- kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return selected_connection = ep1_ch1()->selected_connection();
+ },
+ Ne(nullptr), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(selected_connection->remote_candidate().is_prflx());
EXPECT_EQ(kIceUfrag[1], selected_connection->remote_candidate().username());
EXPECT_EQ(kIcePwd[1], selected_connection->remote_candidate().password());
@@ -1624,9 +1729,16 @@
ResumeCandidates(1);
- EXPECT_TRUE_WAIT(
- ep1_ch1()->selected_connection()->remote_candidate().is_prflx(),
- kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_prflx();
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(selected_connection, ep1_ch1()->selected_connection());
DestroyChannels();
}
@@ -1654,7 +1766,11 @@
// Wait for the initial connection to be made.
ep1_ch1()->SetRemoteIceParameters(kIceParams[1]);
ep2_ch1()->SetRemoteIceParameters(kIceParams[0]);
- EXPECT_TRUE_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()), kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return CheckConnected(ep1_ch1(), ep2_ch1()); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Simulate an ICE restart on ep2, but don't signal the candidate or new
// ICE parameters until after a prflx connection has been made.
@@ -1666,9 +1782,16 @@
// The caller should have the selected connection connected to the peer
// reflexive candidate.
- EXPECT_TRUE_WAIT(
- ep1_ch1()->selected_connection()->remote_candidate().is_prflx(),
- kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_prflx();
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const Connection* prflx_selected_connection =
ep1_ch1()->selected_connection();
@@ -1682,9 +1805,16 @@
// their information to update the peer reflexive candidate.
ResumeCandidates(1);
- EXPECT_TRUE_WAIT(
- ep1_ch1()->selected_connection()->remote_candidate().is_relay(),
- kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_relay();
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(prflx_selected_connection, ep1_ch1()->selected_connection());
DestroyChannels();
}
@@ -1698,9 +1828,15 @@
CreateChannels();
const Connection* selected_connection = NULL;
// Wait until the callee's connections are created.
- EXPECT_TRUE_SIMULATED_WAIT(
- (selected_connection = ep2_ch1()->selected_connection()) != NULL,
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return selected_connection =
+ ep2_ch1()->selected_connection();
+ },
+ NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Wait to make sure the selected connection is not changed.
SIMULATED_WAIT(ep2_ch1()->selected_connection() != selected_connection,
kShortTimeout, clock);
@@ -1741,8 +1877,12 @@
CreateChannels();
ep1_ch1()->set_incoming_only(true);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -1809,10 +1949,15 @@
ResumeCandidates(0);
ResumeCandidates(1);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kPublicAddrs[1]),
- kShortTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
TestSendRecv(&clock);
DestroyChannels();
@@ -1829,8 +1974,12 @@
SetAllowTcpListen(1, true); // actpass.
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
SIMULATED_WAIT(false, kDefaultTimeout, clock);
EXPECT_EQ(RemoteCandidate(ep1_ch1())->tcptype(), "passive");
@@ -1856,13 +2005,23 @@
GetEndpoint(1)->allocator_->ice_tiebreaker();
// Since both the channels initiated with controlling state, the channel with
// the lower tiebreaker should receive SignalRoleConflict.
- EXPECT_TRUE_SIMULATED_WAIT(
- GetRoleConflict(first_endpoint_has_lower_tiebreaker ? 0 : 1),
- kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return GetRoleConflict(first_endpoint_has_lower_tiebreaker ? 0 : 1);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_FALSE(GetRoleConflict(first_endpoint_has_lower_tiebreaker ? 1 : 0));
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection());
@@ -1884,7 +2043,11 @@
CreateChannels();
- EXPECT_EQ_SIMULATED_WAIT(2u, ep1_ch1()->ports().size(), kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep1_ch1()->ports().size(); }, Eq(2u),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
const std::vector<PortInterface*> ports_before = ep1_ch1()->ports();
for (size_t i = 0; i < ports_before.size(); ++i) {
@@ -1898,8 +2061,12 @@
EXPECT_EQ(ICEROLE_CONTROLLED, ports_before[i]->GetIceRole());
}
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection());
@@ -1946,10 +2113,16 @@
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kIPv6PublicAddrs[0],
- kIPv6PublicAddrs[1]),
- kShortTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
+ kIPv6PublicAddrs[0],
+ kIPv6PublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
TestSendRecv(&clock);
DestroyChannels();
@@ -1969,8 +2142,12 @@
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection() &&
ep2_ch1()->selected_connection());
@@ -1998,8 +2175,12 @@
IceConfig default_config;
CreateChannels(continual_gathering_config, default_config);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
SIMULATED_WAIT(
IceGatheringState::kIceGatheringComplete == ep1_ch1()->gathering_state(),
kShortTimeout, clock);
@@ -2041,8 +2222,12 @@
EXPECT_TRUE(pooled_session_2->ReadyCandidates().empty());
// Now let the endpoints connect and try exchanging some data.
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
TestSendRecv(&clock);
// Make sure the P2PTransportChannels are actually using ports from the
// pooled sessions.
@@ -2079,13 +2264,23 @@
ASSERT_NE(nullptr, pooled_session_2);
// Wait for the pooled sessions to finish gathering before the
// P2PTransportChannels try to use them.
- EXPECT_TRUE_SIMULATED_WAIT(pooled_session_1->CandidatesAllocationDone() &&
- pooled_session_2->CandidatesAllocationDone(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return pooled_session_1->CandidatesAllocationDone() &&
+ pooled_session_2->CandidatesAllocationDone();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Now let the endpoints connect and try exchanging some data.
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
TestSendRecv(&clock);
// Make sure the P2PTransportChannels are actually using ports from the
// pooled sessions.
@@ -2115,8 +2310,11 @@
config.presume_writable_when_fully_relayed = true;
ep1_ch1()->SetIceConfig(config);
ep1_ch1()->MaybeStartGathering();
- EXPECT_EQ_WAIT(IceGatheringState::kIceGatheringComplete,
- ep1_ch1()->gathering_state(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->gathering_state(); },
+ Eq(IceGatheringState::kIceGatheringComplete),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Add two remote candidates; a host candidate (with higher priority)
// and TURN candidate.
ep1_ch1()->AddRemoteCandidate(
@@ -2125,7 +2323,10 @@
CreateUdpCandidate(IceCandidateType::kRelay, "2.2.2.2", 2, 0));
// Expect that the TURN-TURN candidate pair will be prioritized since it's
// "probably writable".
- EXPECT_TRUE_WAIT(ep1_ch1()->selected_connection() != nullptr, kShortTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->is_relay());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->is_relay());
// Also expect that the channel instantly indicates that it's writable since
@@ -2171,8 +2372,13 @@
ep2_ch1()->MaybeStartGathering();
// Wait for the TURN<->prflx connection.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable(),
- kShortTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ep1_ch1()->receiving() && ep1_ch1()->writable(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_NE(nullptr, ep1_ch1()->selected_connection());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->is_relay());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->is_prflx());
@@ -2181,8 +2387,12 @@
EXPECT_FALSE(ep1_ch1()->selected_connection()->writable());
// Now wait for it to actually become writable.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection()->writable(),
- kShortTimeout, fake_clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection()->writable(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Explitly destroy channels, before fake clock is destroyed.
DestroyChannels();
@@ -2206,14 +2416,21 @@
ep1_ch1()->MaybeStartGathering();
ep2_ch1()->MaybeStartGathering();
// Wait for initial connection as usual.
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kShortTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
const Connection* old_selected_connection = ep1_ch1()->selected_connection();
// Destroy the second channel and wait for the current connection on the
// first channel to become "unreliable", making it no longer writable.
GetEndpoint(1)->cd1_.ch_.reset();
- EXPECT_TRUE_SIMULATED_WAIT(!ep1_ch1()->writable(), kDefaultTimeout,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !ep1_ch1()->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_NE(nullptr, ep1_ch1()->selected_connection());
// Add a remote TURN candidate. The first channel should still have a TURN
// port available to make a TURN<->TURN pair that's presumed writable.
@@ -2241,12 +2458,18 @@
config.presume_writable_when_fully_relayed = true;
ep1_ch1()->SetIceConfig(config);
ep1_ch1()->MaybeStartGathering();
- EXPECT_EQ_WAIT(IceGatheringState::kIceGatheringComplete,
- ep1_ch1()->gathering_state(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->gathering_state(); },
+ Eq(IceGatheringState::kIceGatheringComplete),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ep1_ch1()->AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 0));
// Sanity checking the type of the connection.
- EXPECT_TRUE_WAIT(ep1_ch1()->selected_connection() != nullptr, kShortTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->is_relay());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->is_relay());
@@ -2296,8 +2519,13 @@
ep1_ch1()->MaybeStartGathering();
ep2_ch1()->MaybeStartGathering();
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable(),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ep1_ch1()->receiving() && ep1_ch1()->writable(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ASSERT_NE(nullptr, ep1_ch1()->selected_connection());
@@ -2328,8 +2556,12 @@
CreateChannels(ep1_config, ep2_config);
// Wait until both sides become writable for the first time.
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Block the ingress traffic to ep1 so that there is no check response from
// ep2.
ASSERT_NE(nullptr, LocalCandidate(ep1_ch1()));
@@ -2337,8 +2569,13 @@
LocalCandidate(ep1_ch1())->address());
// Wait until ep1 becomes unwritable. At the same time ep2 should be still
// fine so that it will keep sending pings.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1() != nullptr && !ep1_ch1()->writable(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ep1_ch1() != nullptr && !ep1_ch1()->writable(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep2_ch1() != nullptr && ep2_ch1()->writable());
// Now let the pings from ep2 to flow but block any pings from ep1, so that
// ep1 can only become writable again after receiving an incoming ping from
@@ -2348,8 +2585,12 @@
fw()->ClearRules();
fw()->AddRule(false, rtc::FP_ANY, rtc::FD_OUT,
LocalCandidate(ep1_ch1())->address());
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1() != nullptr && ep1_ch1()->writable(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1() != nullptr && ep1_ch1()->writable(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -2486,10 +2727,15 @@
// Create channels and let them go writable, as usual.
CreateChannels(config, config);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kPublicAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
@@ -2497,14 +2743,23 @@
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
- EXPECT_TRUE_SIMULATED_WAIT(!selected_connection1->receiving(), kMediumTimeout,
- clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !selected_connection1->receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// We should switch over to use the alternate addr on both sides
// when we are not receiving.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection()->receiving() &&
- ep2_ch1()->selected_connection()->receiving(),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection()->receiving() &&
+ ep2_ch1()->selected_connection()->receiving();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]));
EXPECT_TRUE(
RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]));
@@ -2531,10 +2786,15 @@
IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
// Create channels and let them go writable, as usual.
CreateChannels(config, config);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kPublicAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
@@ -2543,10 +2803,16 @@
// We should detect loss of receiving within 1 second or so.
// We should switch over to use the alternate addr on both sides
// when we are not receiving.
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kAlternateAddrs[0],
- kPublicAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
+ kAlternateAddrs[0],
+ kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -2593,10 +2859,15 @@
IceConfig config = CreateIceConfig(1000, GATHER_CONTINUALLY);
// Create channels and let them go writable, as usual.
CreateChannels(config, config, true /* ice_renomination */);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), wifiIpv6[0],
- wifiIpv6[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), wifiIpv6[0], wifiIpv6[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Blackhole any traffic to or from the wifi on endpoint 1.
RTC_LOG(LS_INFO) << "Failing over...";
@@ -2606,9 +2877,15 @@
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
const Connection* selected_connection2 = ep2_ch1()->selected_connection();
- EXPECT_TRUE_SIMULATED_WAIT(
- !selected_connection1->receiving() && !selected_connection2->receiving(),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return !selected_connection1->receiving() &&
+ !selected_connection2->receiving();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Per-network best connections will be pinged at relatively higher rate when
// the selected connection becomes not receiving.
@@ -2617,9 +2894,13 @@
ASSERT_NE(nullptr, per_network_best_connection1);
int64_t last_ping_sent1 = per_network_best_connection1->last_ping_sent();
int num_pings_sent1 = per_network_best_connection1->num_pings_sent();
- EXPECT_TRUE_SIMULATED_WAIT(
- num_pings_sent1 < per_network_best_connection1->num_pings_sent(),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return per_network_best_connection1->num_pings_sent(); },
+ Gt(num_pings_sent1),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ASSERT_GT(per_network_best_connection1->num_pings_sent() - num_pings_sent1,
0);
int64_t ping_interval1 =
@@ -2632,10 +2913,15 @@
// It should switch over to use the cellular IPv6 addr on endpoint 1 before
// it timed out on writing.
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), cellularIpv6[0],
- wifiIpv6[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), cellularIpv6[0], wifiIpv6[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -2660,12 +2946,22 @@
IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
// Create channels with ICE renomination and let them go writable as usual.
CreateChannels(config, config, true);
- ASSERT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
- EXPECT_TRUE_SIMULATED_WAIT(
- ep2_ch1()->selected_connection()->remote_nomination() > 0 &&
- ep1_ch1()->selected_connection()->acked_nomination() > 0,
- kDefaultTimeout, clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep2_ch1()->selected_connection()->remote_nomination() > 0 &&
+ ep1_ch1()->selected_connection()->acked_nomination() > 0;
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
Connection* selected_connection2 =
const_cast<Connection*>(ep2_ch1()->selected_connection());
@@ -2681,15 +2977,21 @@
fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
// The selected connection on the controlling side should switch.
- EXPECT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() != selected_connection1, kMediumTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep1_ch1()->selected_connection(); },
+ Ne(selected_connection1),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// The connection on the controlled side should be nominated again
// and have an increased nomination.
- EXPECT_TRUE_SIMULATED_WAIT(
- ep2_ch1()->selected_connection()->remote_nomination() >
- remote_nomination2,
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection()->remote_nomination(); },
+ Gt(remote_nomination2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -2714,10 +3016,15 @@
// Create channels and let them go writable, as usual.
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kPublicAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Make the receiving timeout shorter for testing.
IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
@@ -2732,17 +3039,26 @@
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
- EXPECT_TRUE_SIMULATED_WAIT(!selected_connection1->receiving(), kMediumTimeout,
- clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !selected_connection1->receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// After a short while, the link recovers itself.
SIMULATED_WAIT(false, 10, clock);
fw()->ClearRules();
// We should remain on the public address on both sides and no connection
// switches should have happened.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection()->receiving() &&
- ep2_ch1()->selected_connection()->receiving(),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection()->receiving() &&
+ ep2_ch1()->selected_connection()->receiving();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
EXPECT_TRUE(LocalCandidate(ep2_ch1())->address().EqualIPs(kPublicAddrs[1]));
EXPECT_EQ(0, reset_selected_candidate_pair_switches());
@@ -2766,10 +3082,15 @@
// Create channels and let them go writable, as usual.
CreateChannels();
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kPublicAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Make the receiving timeout shorter for testing.
IceConfig config = CreateIceConfig(1000, GATHER_ONCE);
@@ -2783,18 +3104,26 @@
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
- EXPECT_TRUE_SIMULATED_WAIT(!selected_connection1->receiving(), kMediumTimeout,
- clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !selected_connection1->receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// The link recovers after a short while.
SIMULATED_WAIT(false, 10, clock);
fw()->ClearRules();
// We should not switch to the alternate addr on both sides because of the
// dampening.
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kPublicAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(0, reset_selected_candidate_pair_switches());
DestroyChannels();
}
@@ -2824,17 +3153,27 @@
ep1_ch1()->SetIceConfig(config);
ep2_ch1()->SetIceConfig(config);
// Need to wait to make sure the connections on both networks are writable.
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), wifi[0], wifi[1]),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
+ wifi[0], wifi[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
Connection* backup_conn =
GetConnectionWithLocalAddress(ep1_ch1(), cellular[0]);
ASSERT_NE(nullptr, backup_conn);
// After a short while, the backup connection will be writable but not
// receiving because backup connection is pinged at a slower rate.
- EXPECT_TRUE_SIMULATED_WAIT(
- backup_conn->writable() && !backup_conn->receiving(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return backup_conn->writable() && !backup_conn->receiving(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
reset_selected_candidate_pair_switches();
// Blackhole any traffic to or from the remote WiFi networks.
RTC_LOG(LS_INFO) << "Failing over...";
@@ -2867,9 +3206,13 @@
EXPECT_TRUE_WAIT_MARGIN(CheckConnected(ep1_ch1(), ep2_ch1()), 1000, 1000);
// Need to wait to make sure the connections on both networks are writable.
- EXPECT_TRUE_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), wifi[0], wifi[1]),
- 1000);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
+ wifi[0], wifi[1]);
+ },
+ IsTrue()),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -2918,16 +3261,22 @@
CreateIceConfig(2000, GATHER_ONCE, backup_ping_interval));
// After the state becomes COMPLETED, the backup connection will be pinged
// once every `backup_ping_interval` milliseconds.
- ASSERT_TRUE_WAIT(ep2_ch1()->GetState() == IceTransportState::STATE_COMPLETED,
- 1000);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return ep2_ch1()->GetState(); },
+ Eq(IceTransportState::STATE_COMPLETED)),
+ webrtc::IsRtcOk());
auto connections = ep2_ch1()->connections();
ASSERT_EQ(2U, connections.size());
Connection* backup_conn = GetBackupConnection(ep2_ch1());
- EXPECT_TRUE_WAIT(backup_conn->writable(), kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return backup_conn->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
int64_t last_ping_response_ms = backup_conn->last_ping_response_received();
- EXPECT_TRUE_WAIT(
- last_ping_response_ms < backup_conn->last_ping_response_received(),
- kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return backup_conn->last_ping_response_received(); },
+ Gt(last_ping_response_ms),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
int time_elapsed =
backup_conn->last_ping_response_received() - last_ping_response_ms;
RTC_LOG(LS_INFO) << "Time elapsed: " << time_elapsed;
@@ -2959,20 +3308,26 @@
ep2_ch1()->SetIceConfig(config);
// After the state becomes COMPLETED and is stable and writable, the
// connection will be pinged once every `ping_interval_ms` milliseconds.
- ASSERT_TRUE_WAIT(ep2_ch1()->GetState() == IceTransportState::STATE_COMPLETED,
- 1000);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return ep2_ch1()->GetState(); },
+ Eq(IceTransportState::STATE_COMPLETED)),
+ webrtc::IsRtcOk());
auto connections = ep2_ch1()->connections();
ASSERT_EQ(2U, connections.size());
Connection* conn = GetBestConnection(ep2_ch1());
- EXPECT_TRUE_WAIT(conn->writable(), kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
int64_t last_ping_response_ms;
// Burn through some pings so the connection is stable.
for (int i = 0; i < 5; i++) {
last_ping_response_ms = conn->last_ping_response_received();
- EXPECT_TRUE_WAIT(
- last_ping_response_ms < conn->last_ping_response_received(),
- kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn->last_ping_response_received(); },
+ Gt(last_ping_response_ms),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
EXPECT_TRUE(conn->stable(last_ping_response_ms)) << "Connection not stable";
int time_elapsed =
@@ -2992,10 +3347,18 @@
CreateChannels();
// Both transport channels will reach STATE_COMPLETED quickly.
- EXPECT_EQ_SIMULATED_WAIT(IceTransportState::STATE_COMPLETED,
- ep1_ch1()->GetState(), kShortTimeout, clock);
- EXPECT_EQ_SIMULATED_WAIT(IceTransportState::STATE_COMPLETED,
- ep2_ch1()->GetState(), kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep1_ch1()->GetState(); },
+ Eq(IceTransportState::STATE_COMPLETED),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep2_ch1()->GetState(); },
+ Eq(IceTransportState::STATE_COMPLETED),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -3014,8 +3377,12 @@
SetAllocatorFlags(0, kOnlyLocalPorts);
SetAllocatorFlags(1, kOnlyLocalPorts);
- ASSERT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kDefaultTimeout, clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// More than one port has been created.
EXPECT_LE(1U, ep1_ch1()->ports().size());
// Endpoint 1 enabled continual gathering; the port will be removed
@@ -3023,8 +3390,10 @@
RemoveAddress(0, kPublicAddrs[0]);
EXPECT_TRUE(ep1_ch1()->ports().empty());
// The remote candidates will be removed eventually.
- EXPECT_TRUE_SIMULATED_WAIT(ep2_ch1()->remote_candidates().empty(), 1000,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep2_ch1()->remote_candidates().empty(); },
+ IsTrue(), {.clock = &clock}),
+ webrtc::IsRtcOk());
size_t num_ports = ep2_ch1()->ports().size();
EXPECT_LE(1U, num_ports);
@@ -3034,9 +3403,12 @@
// other participant will not be removed.
RemoveAddress(1, kPublicAddrs[1]);
- EXPECT_EQ_SIMULATED_WAIT(0U, ep2_ch1()->ports().size(), kDefaultTimeout,
- clock);
- SIMULATED_WAIT(0U == ep1_ch1()->remote_candidates().size(), 500, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep2_ch1()->ports().size(); }, Eq(0U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ SIMULATED_WAIT(ep1_ch1()->remote_candidates().empty(), 500, clock);
EXPECT_EQ(num_remote_candidates, ep1_ch1()->remote_candidates().size());
DestroyChannels();
@@ -3063,36 +3435,58 @@
// to be created and the new one will be the best connection.
AddAddress(1, wifi[1], "test_wifi1", rtc::ADAPTER_TYPE_WIFI);
const Connection* conn;
- EXPECT_TRUE_WAIT((conn = ep1_ch1()->selected_connection()) != nullptr &&
- HasRemoteAddress(conn, wifi[1]),
- kDefaultTimeout);
- EXPECT_TRUE_WAIT((conn = ep2_ch1()->selected_connection()) != nullptr &&
- HasLocalAddress(conn, wifi[1]),
- kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return (conn = ep1_ch1()->selected_connection()) != nullptr &&
+ HasRemoteAddress(conn, wifi[1]);
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return (conn = ep2_ch1()->selected_connection()) != nullptr &&
+ HasLocalAddress(conn, wifi[1]);
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Add a new cellular interface on end point 1, we should expect a new
// backup connection created using this new interface.
AddAddress(0, cellular[0], "test_cellular0", rtc::ADAPTER_TYPE_CELLULAR);
- EXPECT_TRUE_WAIT(
- ep1_ch1()->GetState() == IceTransportState::STATE_COMPLETED &&
- absl::c_any_of(ep1_ch1()->connections(),
- [channel = ep1_ch1(),
- address = cellular[0]](const Connection* conn) {
- return HasLocalAddress(conn, address) &&
- conn != channel->selected_connection() &&
- conn->writable();
- }),
- kDefaultTimeout);
- EXPECT_TRUE_WAIT(
- ep2_ch1()->GetState() == IceTransportState::STATE_COMPLETED &&
- absl::c_any_of(ep2_ch1()->connections(),
- [channel = ep2_ch1(),
- address = cellular[0]](const Connection* conn) {
- return HasRemoteAddress(conn, address) &&
- conn != channel->selected_connection() &&
- conn->receiving();
- }),
- kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->GetState() ==
+ IceTransportState::STATE_COMPLETED &&
+ absl::c_any_of(
+ ep1_ch1()->connections(),
+ [channel = ep1_ch1(),
+ address = cellular[0]](const Connection* conn) {
+ return HasLocalAddress(conn, address) &&
+ conn != channel->selected_connection() &&
+ conn->writable();
+ });
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep2_ch1()->GetState() ==
+ IceTransportState::STATE_COMPLETED &&
+ absl::c_any_of(
+ ep2_ch1()->connections(),
+ [channel = ep2_ch1(),
+ address = cellular[0]](const Connection* conn) {
+ return HasRemoteAddress(conn, address) &&
+ conn != channel->selected_connection() &&
+ conn->receiving();
+ });
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -3112,29 +3506,46 @@
CreateIceConfig(1000, GATHER_CONTINUALLY);
// Create channels and let them go writable, as usual.
CreateChannels(continual_gathering_config, continual_gathering_config);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kPublicAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(
+ ep1_ch1(), ep2_ch1(), kPublicAddrs[0], kPublicAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Add the new address first and then remove the other one.
RTC_LOG(LS_INFO) << "Draining...";
AddAddress(1, kAlternateAddrs[1]);
RemoveAddress(1, kPublicAddrs[1]);
// We should switch to use the alternate address after an exchange of pings.
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kAlternateAddrs[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
+ kPublicAddrs[0],
+ kAlternateAddrs[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Remove one address first and then add another address.
RTC_LOG(LS_INFO) << "Draining again...";
RemoveAddress(1, kAlternateAddrs[1]);
AddAddress(1, kAlternateAddrs[0]);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), kPublicAddrs[0],
- kAlternateAddrs[0]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
+ kPublicAddrs[0],
+ kAlternateAddrs[0]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -3156,22 +3567,38 @@
IceConfig config = CreateIceConfig(1000, GATHER_CONTINUALLY);
config.regather_on_failed_networks_interval = 2000;
CreateChannels(config, config);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(), wifi[0], wifi[1]),
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckCandidatePairAndConnected(ep1_ch1(), ep2_ch1(),
+ wifi[0], wifi[1]);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Destroy all backup connections.
DestroyAllButBestConnection(ep1_ch1());
// Ensure the backup connection is removed first.
- EXPECT_TRUE_SIMULATED_WAIT(
- GetConnectionWithLocalAddress(ep1_ch1(), cellular[0]) == nullptr,
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetConnectionWithLocalAddress(ep1_ch1(), cellular[0]); },
+ Eq(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
const Connection* conn;
- EXPECT_TRUE_SIMULATED_WAIT(
- (conn = GetConnectionWithLocalAddress(ep1_ch1(), cellular[0])) !=
- nullptr &&
- conn != ep1_ch1()->selected_connection() && conn->writable(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return (conn = GetConnectionWithLocalAddress(
+ ep1_ch1(), cellular[0])) != nullptr &&
+ conn != ep1_ch1()->selected_connection() &&
+ conn->writable();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
DestroyChannels();
}
@@ -3184,10 +3611,16 @@
IceConfig config;
CreateChannels(config, config, false);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckConnected(ep1_ch1(), ep2_ch1()) &&
- !ep1_ch1()->selected_connection()->network()->IsVpn(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return CheckConnected(ep1_ch1(), ep2_ch1()) &&
+ !ep1_ch1()->selected_connection()->network()->IsVpn();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnPreferVpn) {
@@ -3201,19 +3634,30 @@
config.vpn_preference = webrtc::VpnPreference::kPreferVpn;
RTC_LOG(LS_INFO) << "KESO: config.vpn_preference: " << config.vpn_preference;
CreateChannels(config, config, false);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckConnected(ep1_ch1(), ep2_ch1()) &&
- ep1_ch1()->selected_connection()->network()->IsVpn(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckConnected(ep1_ch1(), ep2_ch1()) &&
+ ep1_ch1()->selected_connection()->network()->IsVpn();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Block VPN.
fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kAlternateAddrs[0]);
// Check that it switches to non-VPN
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckConnected(ep1_ch1(), ep2_ch1()) &&
- !ep1_ch1()->selected_connection()->network()->IsVpn(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return CheckConnected(ep1_ch1(), ep2_ch1()) &&
+ !ep1_ch1()->selected_connection()->network()->IsVpn();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnAvoidVpn) {
@@ -3226,19 +3670,30 @@
IceConfig config;
config.vpn_preference = webrtc::VpnPreference::kAvoidVpn;
CreateChannels(config, config, false);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckConnected(ep1_ch1(), ep2_ch1()) &&
- !ep1_ch1()->selected_connection()->network()->IsVpn(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return CheckConnected(ep1_ch1(), ep2_ch1()) &&
+ !ep1_ch1()->selected_connection()->network()->IsVpn();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Block non-VPN.
fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
// Check that it switches to VPN
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckConnected(ep1_ch1(), ep2_ch1()) &&
- ep1_ch1()->selected_connection()->network()->IsVpn(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckConnected(ep1_ch1(), ep2_ch1()) &&
+ ep1_ch1()->selected_connection()->network()->IsVpn();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnNeverVpn) {
@@ -3251,18 +3706,28 @@
IceConfig config;
config.vpn_preference = webrtc::VpnPreference::kNeverUseVpn;
CreateChannels(config, config, false);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckConnected(ep1_ch1(), ep2_ch1()) &&
- !ep1_ch1()->selected_connection()->network()->IsVpn(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return CheckConnected(ep1_ch1(), ep2_ch1()) &&
+ !ep1_ch1()->selected_connection()->network()->IsVpn();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Block non-VPN.
fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
// Check that it does not switches to VPN
clock.AdvanceTime(webrtc::TimeDelta::Millis(kDefaultTimeout));
- EXPECT_TRUE_SIMULATED_WAIT(!CheckConnected(ep1_ch1(), ep2_ch1()),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, TestVpnOnlyVpn) {
@@ -3275,18 +3740,27 @@
IceConfig config;
config.vpn_preference = webrtc::VpnPreference::kOnlyUseVpn;
CreateChannels(config, config, false);
- EXPECT_TRUE_SIMULATED_WAIT(
- CheckConnected(ep1_ch1(), ep2_ch1()) &&
- ep1_ch1()->selected_connection()->network()->IsVpn(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return CheckConnected(ep1_ch1(), ep2_ch1()) &&
+ ep1_ch1()->selected_connection()->network()->IsVpn();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Block VPN.
fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kAlternateAddrs[0]);
// Check that it does not switch to non-VPN
clock.AdvanceTime(webrtc::TimeDelta::Millis(kDefaultTimeout));
- EXPECT_TRUE_SIMULATED_WAIT(!CheckConnected(ep1_ch1(), ep2_ch1()),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelMultihomedTest, StunDictionaryPerformsSync) {
@@ -3317,8 +3791,12 @@
EXPECT_EQ(view.GetByteString(12)->string_view(), "keso");
});
EXPECT_CALL(writer_synced_func, Call).Times(1);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
// A collection of tests which tests a single P2PTransportChannel by sending
@@ -3355,11 +3833,18 @@
int port_num,
rtc::ThreadProcessingFakeClock* clock = nullptr) {
if (clock == nullptr) {
- EXPECT_TRUE_WAIT(GetConnectionTo(ch, ip, port_num) != nullptr,
- kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetConnectionTo(ch, ip, port_num); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
} else {
- EXPECT_TRUE_SIMULATED_WAIT(GetConnectionTo(ch, ip, port_num) != nullptr,
- kMediumTimeout, *clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetConnectionTo(ch, ip, port_num); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &*clock}),
+ webrtc::IsRtcOk());
}
return GetConnectionTo(ch, ip, port_num);
}
@@ -3413,9 +3898,12 @@
bool writable) {
channel->AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, ip_addr, port, priority));
- EXPECT_TRUE_SIMULATED_WAIT(
- GetConnectionTo(channel, ip_addr, port) != nullptr, kMediumTimeout,
- *clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return GetConnectionTo(channel, ip_addr, port); },
+ Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &*clock}),
+ webrtc::IsRtcOk());
Connection* conn = GetConnectionTo(channel, ip_addr, port);
if (conn && writable) {
@@ -3597,10 +4085,14 @@
// Low-priority connection becomes writable so that the other connection
// is not pruned.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_TRUE_WAIT(
- conn1->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL &&
- conn2->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL,
- kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return conn1->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL &&
+ conn2->num_pings_sent() >= MIN_PINGS_AT_WEAK_PING_INTERVAL;
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
// Verify that the connections are pinged at the right time.
@@ -3709,8 +4201,11 @@
ch.SetIceRole(ICEROLE_CONTROLLING);
ch.SetIceParameters(kIceParams[0]);
ch.MaybeStartGathering();
- EXPECT_EQ_WAIT(IceGatheringState::kIceGatheringComplete, ch.gathering_state(),
- kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.gathering_state(); },
+ Eq(IceGatheringState::kIceGatheringComplete),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Simulate a binding request being received, creating a peer reflexive
// candidate pair while we still don't have remote ICE parameters.
@@ -3736,7 +4231,9 @@
// the first ping is sent as soon as possible, within one simulated clock
// tick.
ch.SetRemoteIceParameters(kIceParams[1]);
- EXPECT_TRUE_SIMULATED_WAIT(conn->num_pings_sent() > 0, 1, clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return conn->num_pings_sent(); }, Gt(0),
+ {.clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestNoTriggeredChecksWhenWritable) {
@@ -3800,8 +4297,11 @@
// Pruning the connection reduces the set of active connections and changes
// the channel state.
conn1->Prune();
- EXPECT_EQ_WAIT(IceTransportState::STATE_FAILED, channel_state(),
- kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return channel_state(); }, Eq(IceTransportState::STATE_FAILED),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
// Test adding remote candidates with different ufrags. If a remote candidate
@@ -3845,8 +4345,11 @@
ch.AddRemoteCandidate(CreateUdpCandidate(IceCandidateType::kHost, "3.3.3.3",
3, 0, kIceUfrag[2]));
Connection* conn3 = nullptr;
- ASSERT_TRUE_WAIT((conn3 = GetConnectionTo(&ch, "3.3.3.3", 3)) != nullptr,
- kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return conn3 = GetConnectionTo(&ch, "3.3.3.3", 3); },
+ Ne(nullptr), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
const Candidate& new_candidate = conn3->remote_candidate();
EXPECT_EQ(kIcePwd[2], new_candidate.password());
EXPECT_EQ(1U, new_candidate.generation());
@@ -3887,11 +4390,17 @@
conn2->ReceivedPingResponse(LOW_RTT, "id");
// Wait for conn2 to be selected.
- EXPECT_EQ_WAIT(conn2, ch.selected_connection(), kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// Destroy the connection to test SignalUnknownAddress.
ch.RemoveConnectionForTest(conn1);
- EXPECT_TRUE_WAIT(GetConnectionTo(&ch, "1.1.1.1", 1) == nullptr,
- kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return GetConnectionTo(&ch, "1.1.1.1", 1); },
+ Eq(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// Create a minimal STUN message with prflx priority.
IceMessage request(STUN_BINDING_REQUEST);
@@ -3942,8 +4451,16 @@
conn1->OnReadPacket(
rtc::ReceivedPacket::CreateFromLegacy("ABC", 3, rtc::TimeMicros()));
- EXPECT_TRUE_SIMULATED_WAIT(ch.receiving(), kShortTimeout, clock);
- EXPECT_TRUE_SIMULATED_WAIT(!ch.receiving(), kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !ch.receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
// The controlled side will select a connection as the "selected connection"
@@ -3973,7 +4490,10 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn1, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
EXPECT_TRUE(ConnectionMatchesChangeEvent(
conn1, "remote candidate generation maybe changed"));
@@ -3986,7 +4506,10 @@
Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
ASSERT_TRUE(conn2 != nullptr);
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn2, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
EXPECT_TRUE(
ConnectionMatchesChangeEvent(conn2, "candidate pair state changed"));
@@ -4032,7 +4555,10 @@
reset_channel_ready_to_send();
// The selected connection switches after conn4 becomes writable.
conn4->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn4, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn4),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn4));
EXPECT_TRUE(
ConnectionMatchesChangeEvent(conn4, "candidate pair state changed"));
@@ -4062,7 +4588,10 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn1, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// When a higher priority candidate comes in, the new connection is chosen
@@ -4072,7 +4601,10 @@
Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
ASSERT_TRUE(conn2 != nullptr);
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn2, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
// Now nominate conn1 (low prio), it shall be choosen.
@@ -4106,7 +4638,10 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn1, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// When a higher priority candidate comes in, the new connection is chosen
@@ -4119,7 +4654,10 @@
const int before = conn2->num_pings_sent();
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn2, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
// And the additional ping should have been sent directly.
@@ -4149,7 +4687,10 @@
// A connection needs to be writable before it is selected for transmission.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn1, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// And the additional ping should have been sent directly.
@@ -4184,7 +4725,10 @@
EXPECT_EQ(conn1->stats().sent_ping_responses, 1u);
EXPECT_NE(conn1, ch.selected_connection());
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn1, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Another connection is nominated via use_candidate.
ch.AddRemoteCandidate(
@@ -4222,7 +4766,10 @@
// conn4 is not the selected connection yet because it is not writable.
EXPECT_EQ(conn2, ch.selected_connection());
conn4->ReceivedPingResponse(LOW_RTT, "id"); // Become writable.
- EXPECT_EQ_WAIT(conn4, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn4),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Test that the request from an unknown address contains a ufrag from an old
// generation.
@@ -4253,7 +4800,10 @@
Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_TRUE(conn1 != nullptr);
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn1, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// If a data packet is received on conn2, the selected connection should
// switch to conn2 because the controlled side must mirror the media path
@@ -4285,7 +4835,10 @@
ASSERT_TRUE(conn3 != nullptr);
EXPECT_NE(conn3, ch.selected_connection()); // Not writable yet.
conn3->ReceivedPingResponse(LOW_RTT, "id"); // Become writable.
- EXPECT_EQ_WAIT(conn3, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn3),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Now another data packet will not switch the selected connection because the
// selected connection was nominated by the controlling side.
@@ -4293,7 +4846,10 @@
conn2->ReceivedPingResponse(LOW_RTT, "id");
conn2->OnReadPacket(
rtc::ReceivedPacket::CreateFromLegacy("XYZ", 3, rtc::TimeMicros()));
- EXPECT_EQ_WAIT(conn3, ch.selected_connection(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn3),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest,
@@ -4412,8 +4968,11 @@
ASSERT_TRUE(conn2 != nullptr);
// conn1 is the selected connection because it has a higher priority,
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
reset_selected_candidate_pair_switches();
@@ -4461,8 +5020,11 @@
ASSERT_TRUE(conn2 != nullptr);
// conn1 is the selected connection because it has a higher priority,
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// No estimateded disconnect time at first connect <=> value is 0.
EXPECT_EQ(LastEstimatedDisconnectedTimeMs(), 0);
@@ -4544,18 +5106,32 @@
// conn2 becomes writable; it is selected even though it is not nominated.
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_SIMULATED_WAIT(1, reset_selected_candidate_pair_switches(),
- kDefaultTimeout, clock);
- EXPECT_EQ_SIMULATED_WAIT(conn2, ch.selected_connection(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return reset_selected_candidate_pair_switches(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
// If conn1 is also writable, it will become selected.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_SIMULATED_WAIT(1, reset_selected_candidate_pair_switches(),
- kDefaultTimeout, clock);
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return reset_selected_candidate_pair_switches(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
// Make sure sorting won't reselect candidate pair.
@@ -4628,11 +5204,19 @@
ASSERT_TRUE(conn2 != nullptr);
conn2->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
NominateConnection(conn2);
- EXPECT_TRUE_SIMULATED_WAIT(conn1->pruned(), kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn1->pruned(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ch.SetIceConfig(CreateIceConfig(500, GATHER_ONCE));
// Wait until conn2 becomes not receiving.
- EXPECT_TRUE_SIMULATED_WAIT(!conn2->receiving(), kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !conn2->receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "3.3.3.3", 3, 1));
@@ -4701,13 +5285,21 @@
EXPECT_EQ(webrtc::IceTransportState::kChecking, ch.GetIceTransportState());
// `conn1` becomes writable and receiving; it then should prune `conn2`.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_TRUE_SIMULATED_WAIT(conn2->pruned(), kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn2->pruned(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(IceTransportState::STATE_COMPLETED, ch.GetState());
EXPECT_EQ(webrtc::IceTransportState::kConnected, ch.GetIceTransportState());
conn1->Prune(); // All connections are pruned.
// Need to wait until the channel state is updated.
- EXPECT_EQ_SIMULATED_WAIT(IceTransportState::STATE_FAILED, ch.GetState(),
- kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.GetState(); },
+ Eq(IceTransportState::STATE_FAILED),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(webrtc::IceTransportState::kFailed, ch.GetIceTransportState());
}
@@ -4731,8 +5323,11 @@
ASSERT_TRUE(conn1 != nullptr);
EXPECT_EQ(nullptr, ch.selected_connection());
conn1->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Add a low-priority connection `conn2`, which will be pruned, but it will
// not be deleted right away. Once the current selected connection becomes not
@@ -4742,27 +5337,49 @@
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 1));
Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2, &clock);
ASSERT_TRUE(conn2 != nullptr);
- EXPECT_TRUE_SIMULATED_WAIT(!conn2->active(), kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !conn2->active(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// `conn2` should not send a ping yet.
EXPECT_EQ(IceCandidatePairState::WAITING, conn2->state());
EXPECT_EQ(IceTransportState::STATE_COMPLETED, ch.GetState());
// Wait for `conn1` becoming not receiving.
- EXPECT_TRUE_SIMULATED_WAIT(!conn1->receiving(), kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !conn1->receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Make sure conn2 is not deleted.
conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2, &clock);
ASSERT_TRUE(conn2 != nullptr);
- EXPECT_EQ_SIMULATED_WAIT(IceCandidatePairState::IN_PROGRESS, conn2->state(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn2->state(); },
+ Eq(IceCandidatePairState::IN_PROGRESS),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
conn2->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_SIMULATED_WAIT(conn2, ch.selected_connection(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(IceTransportState::STATE_CONNECTING, ch.GetState());
// When `conn1` comes back again, `conn2` will be pruned again.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), kDefaultTimeout,
- clock);
- EXPECT_TRUE_SIMULATED_WAIT(!conn2->active(), kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !conn2->active(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(IceTransportState::STATE_COMPLETED, ch.GetState());
}
@@ -4782,7 +5399,11 @@
ASSERT_TRUE(conn1 != nullptr);
conn1->ReceivedPing(); // Becomes receiving
conn1->Prune();
- EXPECT_TRUE_SIMULATED_WAIT(ch.connections().empty(), kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.connections().empty(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Have two connections but both become write-time-out later.
ch.AddRemoteCandidate(
@@ -4798,7 +5419,11 @@
// Now prune both conn2 and conn3; they will be deleted soon.
conn2->Prune();
conn3->Prune();
- EXPECT_TRUE_SIMULATED_WAIT(ch.connections().empty(), kShortTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch.connections().empty(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kShortTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
// Tests that after a port allocator session is started, it will be stopped
@@ -4922,8 +5547,12 @@
// If the session prunes all ports, the port will be destroyed.
ch.allocator_session()->PruneAllPorts();
- EXPECT_EQ_SIMULATED_WAIT(nullptr, GetPort(&ch), 1, fake_clock);
- EXPECT_EQ_SIMULATED_WAIT(nullptr, GetPrunedPort(&ch), 1, fake_clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return GetPort(&ch); }, Eq(nullptr),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil([&] { return GetPrunedPort(&ch); }, Eq(nullptr),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestMaxOutstandingPingsFieldTrial) {
@@ -4945,8 +5574,13 @@
ASSERT_TRUE(conn1 != nullptr);
ASSERT_TRUE(conn2 != nullptr);
- EXPECT_TRUE_WAIT(conn1->num_pings_sent() == 3 && conn2->num_pings_sent() == 3,
- kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return conn1->num_pings_sent() == 3 && conn2->num_pings_sent() == 3;
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Check that these connections don't send any more pings.
EXPECT_EQ(nullptr, ch.FindNextPingableConnection());
@@ -4983,7 +5617,7 @@
channel_->SetIceConfig(config);
PrepareChannel(channel_.get());
channel_->MaybeStartGathering();
- return *channel_.get();
+ return *channel_;
}
BasicPortAllocator* allocator() { return allocator_.get(); }
@@ -5020,7 +5654,10 @@
const int max_strong_interval = 500;
P2PTransportChannel& ch =
StartTransportChannel(true, max_strong_interval, &field_trials_);
- EXPECT_TRUE_WAIT(ch.ports().size() == 2, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.ports().size(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
@@ -5029,7 +5666,10 @@
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 2));
- EXPECT_TRUE_WAIT(ch.connections().size() == 4, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(4),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Relay/Relay should be the first pingable connection.
Connection* conn = FindNextPingableConnectionAndPingIt(&ch);
@@ -5081,13 +5721,19 @@
TEST_F(P2PTransportChannelMostLikelyToWorkFirstTest,
TestRelayRelayFirstWhenEverythingPinged) {
P2PTransportChannel& ch = StartTransportChannel(true, 500, &field_trials_);
- EXPECT_TRUE_WAIT(ch.ports().size() == 2, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.ports().size(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "1.1.1.1", 1, 1));
- EXPECT_TRUE_WAIT(ch.connections().size() == 2, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Initially, only have Local/Local and Local/Relay.
VerifyNextPingableConnection(IceCandidateType::kHost,
@@ -5098,7 +5744,10 @@
// Remote Relay candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "2.2.2.2", 2, 2));
- EXPECT_TRUE_WAIT(ch.connections().size() == 4, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(4),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Relay/Relay should be the first since it hasn't been pinged before.
VerifyNextPingableConnection(IceCandidateType::kRelay,
@@ -5119,13 +5768,19 @@
TEST_F(P2PTransportChannelMostLikelyToWorkFirstTest,
TestNoStarvationOnNonRelayConnection) {
P2PTransportChannel& ch = StartTransportChannel(true, 500, &field_trials_);
- EXPECT_TRUE_WAIT(ch.ports().size() == 2, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.ports().size(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 1));
- EXPECT_TRUE_WAIT(ch.connections().size() == 2, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Initially, only have Relay/Relay and Local/Relay. Ping Relay/Relay first.
VerifyNextPingableConnection(IceCandidateType::kRelay,
@@ -5138,7 +5793,10 @@
// Remote Local candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 2));
- EXPECT_TRUE_WAIT(ch.connections().size() == 4, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(4),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Local/Local should be the first since it hasn't been pinged before.
VerifyNextPingableConnection(IceCandidateType::kHost,
@@ -5162,19 +5820,28 @@
field_trials_,
"WebRTC-IceFieldTrials/skip_relay_to_non_relay_connections:true/");
P2PTransportChannel& ch = StartTransportChannel(true, 500, &field_trials);
- EXPECT_TRUE_WAIT(ch.ports().size() == 2, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.ports().size(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
// Remote Relay candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 1));
- EXPECT_TRUE_WAIT(ch.connections().size() == 1, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Remote Local candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kHost, "2.2.2.2", 2, 2));
- EXPECT_TRUE_WAIT(ch.connections().size() == 2, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
// Test the ping sequence is UDP Relay/Relay followed by TCP Relay/Relay,
@@ -5188,7 +5855,10 @@
allocator()->AddTurnServerForTesting(config);
P2PTransportChannel& ch = StartTransportChannel(true, 500, &field_trials_);
- EXPECT_TRUE_WAIT(ch.ports().size() == 3, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.ports().size(); }, Eq(3),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(ch.ports()[0]->Type(), IceCandidateType::kHost);
EXPECT_EQ(ch.ports()[1]->Type(), IceCandidateType::kRelay);
EXPECT_EQ(ch.ports()[2]->Type(), IceCandidateType::kRelay);
@@ -5196,7 +5866,10 @@
// Remote Relay candidate arrives.
ch.AddRemoteCandidate(
CreateUdpCandidate(IceCandidateType::kRelay, "1.1.1.1", 1, 1));
- EXPECT_TRUE_WAIT(ch.connections().size() == 3, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch.connections().size(); }, Eq(3),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// UDP Relay/Relay should be pinged first.
VerifyNextPingableConnection(IceCandidateType::kRelay,
@@ -5233,7 +5906,10 @@
hostname_candidate.set_address(hostname_address);
channel->AddRemoteCandidate(hostname_candidate);
- ASSERT_EQ_WAIT(1u, channel->remote_candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return channel->remote_candidates().size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const RemoteCandidate& candidate = channel->remote_candidates()[0];
EXPECT_FALSE(candidate.address().IsUnresolvedIP());
}
@@ -5259,7 +5935,11 @@
// number is assgined to ep1's host candidate.
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_EQ_WAIT(1u, GetEndpoint(0)->saved_candidates_.size(), kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetEndpoint(0)->saved_candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
const auto& local_candidate = GetEndpoint(0)->saved_candidates_[0].candidate;
// The IP address of ep1's host candidate should be obfuscated.
EXPECT_TRUE(local_candidate.address().IsUnresolvedIP());
@@ -5271,13 +5951,20 @@
// pair and start to ping. After receiving the ping, ep2 discovers a prflx
// remote candidate and form a candidate pair as well.
ResumeCandidates(1);
- ASSERT_TRUE_WAIT(ep1_ch1()->selected_connection() != nullptr, kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// ep2 should have the selected connection connected to the prflx remote
// candidate.
const Connection* selected_connection = nullptr;
- ASSERT_TRUE_WAIT(
- (selected_connection = ep2_ch1()->selected_connection()) != nullptr,
- kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return selected_connection = ep2_ch1()->selected_connection();
+ },
+ Ne(nullptr), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(selected_connection->remote_candidate().is_prflx());
EXPECT_EQ(kIceUfrag[0], selected_connection->remote_candidate().username());
EXPECT_EQ(kIcePwd[0], selected_connection->remote_candidate().password());
@@ -5285,9 +5972,16 @@
resolver_fixture.SetAddressToReturn(local_address);
ResumeCandidates(0);
// Verify ep2's selected connection is updated to use the 'local' candidate.
- EXPECT_TRUE_WAIT(
- ep2_ch1()->selected_connection()->remote_candidate().is_local(),
- kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep2_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_local();
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(selected_connection, ep2_ch1()->selected_connection());
DestroyChannels();
@@ -5317,7 +6011,11 @@
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_EQ_WAIT(1u, GetEndpoint(0)->saved_candidates_.size(), kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetEndpoint(0)->saved_candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
const auto& local_candidate = GetEndpoint(0)->saved_candidates_[0].candidate;
// The IP address of ep1's host candidate should be obfuscated.
ASSERT_TRUE(local_candidate.address().IsUnresolvedIP());
@@ -5330,7 +6028,10 @@
// by ep1. Let ep2 signal its host candidate with an IP address to ep1, so
// that ep1 can form a candidate pair, select it and start to ping ep2.
ResumeCandidates(1);
- ASSERT_TRUE_WAIT(ep1_ch1()->selected_connection() != nullptr, kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// Let the mock resolver of ep2 receives the correct resolution.
resolver_fixture.SetAddressToReturn(local_address);
@@ -5339,16 +6040,26 @@
//
// There is a caveat in our implementation associated with this expectation.
// See the big comment in P2PTransportChannel::OnUnknownAddress.
- ASSERT_TRUE_WAIT(ep2_ch1()->selected_connection() != nullptr, kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_prflx());
// ep2 should also be able resolve the hostname candidate. The resolved remote
// host candidate should be merged with the prflx remote candidate.
resolver_fixture.FireDelayedResolution();
- EXPECT_TRUE_WAIT(
- ep2_ch1()->selected_connection()->remote_candidate().is_local(),
- kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep2_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_local();
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1u, ep2_ch1()->remote_candidates().size());
DestroyChannels();
@@ -5373,7 +6084,11 @@
// number is assgined to ep1's host candidate.
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_EQ_WAIT(1u, GetEndpoint(0)->saved_candidates_.size(), kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetEndpoint(0)->saved_candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
const auto& local_candidate_ep1 =
GetEndpoint(0)->saved_candidates_[0].candidate;
// The IP address of ep1's host candidate should be obfuscated.
@@ -5389,8 +6104,10 @@
// We should be able to receive a ping from ep2 and establish a connection
// with a peer reflexive candidate from ep2.
- ASSERT_TRUE_WAIT((ep1_ch1()->selected_connection()) != nullptr,
- kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->local_candidate().is_local());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_prflx());
@@ -5424,8 +6141,16 @@
PauseCandidates(0);
PauseCandidates(1);
// Ep1 has a UDP host, a srflx and a relay candidates.
- ASSERT_EQ_WAIT(3u, GetEndpoint(0)->saved_candidates_.size(), kMediumTimeout);
- ASSERT_EQ_WAIT(1u, GetEndpoint(1)->saved_candidates_.size(), kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetEndpoint(0)->saved_candidates_.size(); }, Eq(3u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetEndpoint(1)->saved_candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
for (const auto& candidates_data : GetEndpoint(0)->saved_candidates_) {
const auto& local_candidate_ep1 = candidates_data.candidate;
@@ -5441,12 +6166,21 @@
ResumeCandidates(0);
ResumeCandidates(1);
- ASSERT_EQ_WAIT(kIceGatheringComplete, ep1_ch1()->gathering_state(),
- kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ep1_ch1()->gathering_state(); },
+ Eq(kIceGatheringComplete),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
// We should have the following candidate pairs on both endpoints:
// ep1_host <-> ep2_host, ep1_srflx <-> ep2_host, ep1_relay <-> ep2_host
- ASSERT_EQ_WAIT(3u, ep1_ch1()->connections().size(), kMediumTimeout);
- ASSERT_EQ_WAIT(3u, ep2_ch1()->connections().size(), kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ep1_ch1()->connections().size(); }, Eq(3u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ep2_ch1()->connections().size(); }, Eq(3u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
IceTransportStats ice_transport_stats1;
IceTransportStats ice_transport_stats2;
@@ -5501,8 +6235,11 @@
EXPECT_EQ(0u, ice_transport_stats.selected_candidate_pair_changes);
// Let the channels connect.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() != nullptr,
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(1u, ice_transport_stats.selected_candidate_pair_changes);
@@ -5522,8 +6259,11 @@
EXPECT_EQ(0u, ice_transport_stats.selected_candidate_pair_changes);
// Let the channels connect.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() != nullptr,
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(1u, ice_transport_stats.selected_candidate_pair_changes);
@@ -5532,8 +6272,11 @@
for (Connection* con : ep1_ch1()->connections()) {
con->Prune();
}
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() == nullptr,
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Eq(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(2u, ice_transport_stats.selected_candidate_pair_changes);
@@ -5553,8 +6296,11 @@
EXPECT_EQ(0u, ice_transport_stats.selected_candidate_pair_changes);
// Let the channels connect.
- EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() != nullptr,
- kMediumTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_EQ(1u, ice_transport_stats.selected_candidate_pair_changes);
@@ -5567,11 +6313,17 @@
con->Prune();
}
}
- EXPECT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() != nullptr &&
- (ep1_ch1()->GetStats(&ice_transport_stats),
- ice_transport_stats.selected_candidate_pair_changes >= 2u),
- kMediumTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() != nullptr &&
+ (ep1_ch1()->GetStats(&ice_transport_stats),
+ ice_transport_stats.selected_candidate_pair_changes >= 2u);
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ASSERT_TRUE(ep1_ch1()->GetStats(&ice_transport_stats));
EXPECT_GE(ice_transport_stats.selected_candidate_pair_changes, 2u);
@@ -5598,7 +6350,11 @@
// number is assigned to ep1's host candidate.
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_EQ_WAIT(1u, GetEndpoint(0)->saved_candidates_.size(), kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetEndpoint(0)->saved_candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
const auto& candidates_data = GetEndpoint(0)->saved_candidates_[0];
const auto& local_candidate_ep1 = candidates_data.candidate;
ASSERT_TRUE(local_candidate_ep1.is_local());
@@ -5611,9 +6367,14 @@
ResumeCandidates(0);
ResumeCandidates(1);
- ASSERT_TRUE_WAIT(ep1_ch1()->selected_connection() != nullptr &&
- ep2_ch1()->selected_connection() != nullptr,
- kMediumTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() != nullptr &&
+ ep2_ch1()->selected_connection() != nullptr;
+ },
+ IsTrue(), {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
const auto pair_ep1 = ep1_ch1()->GetSelectedCandidatePair();
ASSERT_TRUE(pair_ep1.has_value());
@@ -5642,8 +6403,11 @@
// Start gathering and we should have only a single relay port.
ep1_ch1()->SetIceConfig(config);
ep1_ch1()->MaybeStartGathering();
- EXPECT_EQ_WAIT(IceGatheringState::kIceGatheringComplete,
- ep1_ch1()->gathering_state(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->gathering_state(); },
+ Eq(IceGatheringState::kIceGatheringComplete),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1u, ep1_ch1()->ports().size());
// Add a plain remote host candidate and three remote mDNS candidates with the
// host, srflx and relay types. Note that the candidates differ in their
@@ -5723,8 +6487,10 @@
CreateChannels();
// We should be able to form a srflx-host connection to ep2.
- ASSERT_TRUE_WAIT((ep1_ch1()->selected_connection()) != nullptr,
- kMediumTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->local_candidate().is_stun());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_local());
@@ -5753,27 +6519,49 @@
IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
CreateChannels(ice_config, ice_config);
- ASSERT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
- ASSERT_TRUE_SIMULATED_WAIT(ep2_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->local_candidate().is_relay());
EXPECT_TRUE(ep2_ch1()->selected_connection()->local_candidate().is_relay());
// Loosen the candidate filter at ep1.
ep1->allocator_->SetCandidateFilter(CF_ALL);
- EXPECT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() != nullptr &&
- ep1_ch1()->selected_connection()->local_candidate().is_local(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() != nullptr &&
+ ep1_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_local();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
// Loosen the candidate filter at ep2.
ep2->allocator_->SetCandidateFilter(CF_ALL);
- EXPECT_TRUE_SIMULATED_WAIT(
- ep2_ch1()->selected_connection() != nullptr &&
- ep2_ch1()->selected_connection()->local_candidate().is_local(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep2_ch1()->selected_connection() != nullptr &&
+ ep2_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_local();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// We have migrated to a host-host candidate pair.
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_local());
@@ -5784,9 +6572,17 @@
fw()->AddRule(false, rtc::FP_ANY, kPublicAddrs[1], kTurnUdpExtAddr);
// We should be able to reuse the previously gathered relay candidates.
- EXPECT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection()->local_candidate().is_relay(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_relay();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
DestroyChannels();
}
@@ -5817,25 +6613,47 @@
IceConfig ice_config = CreateIceConfig(1000, GATHER_CONTINUALLY);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
CreateChannels(ice_config, ice_config);
- ASSERT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
- ASSERT_TRUE_SIMULATED_WAIT(ep2_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
const uint32_t kCandidateFilterNoHost = CF_ALL & ~CF_HOST;
// Loosen the candidate filter at ep1.
ep1->allocator_->SetCandidateFilter(kCandidateFilterNoHost);
- EXPECT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() != nullptr &&
- ep1_ch1()->selected_connection()->local_candidate().is_stun(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() != nullptr &&
+ ep1_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_stun();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
// Loosen the candidate filter at ep2.
ep2->allocator_->SetCandidateFilter(kCandidateFilterNoHost);
- EXPECT_TRUE_SIMULATED_WAIT(
- ep2_ch1()->selected_connection() != nullptr &&
- ep2_ch1()->selected_connection()->local_candidate().is_stun(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep2_ch1()->selected_connection() != nullptr &&
+ ep2_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_stun();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// We have migrated to a srflx-srflx candidate pair.
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_stun());
@@ -5845,9 +6663,17 @@
fw()->AddRule(false, rtc::FP_ANY, kPrivateAddrs[0], kTurnUdpExtAddr);
fw()->AddRule(false, rtc::FP_ANY, kPrivateAddrs[1], kTurnUdpExtAddr);
// We should be able to reuse the previously gathered relay candidates.
- EXPECT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection()->local_candidate().is_relay(),
- kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_relay();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(ep1_ch1()->selected_connection()->remote_candidate().is_relay());
DestroyChannels();
}
@@ -5873,10 +6699,16 @@
IceConfig ice_config = CreateIceConfig(1000, GATHER_ONCE);
ice_config.surface_ice_candidates_on_ice_transport_type_changed = true;
CreateChannels(ice_config, ice_config);
- ASSERT_TRUE_SIMULATED_WAIT(ep1_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
- ASSERT_TRUE_SIMULATED_WAIT(ep2_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep1_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Loosen the candidate filter at ep1.
ep1->allocator_->SetCandidateFilter(CF_ALL);
// Wait for a period for any potential surfacing of new candidates.
@@ -5916,18 +6748,35 @@
CreateChannels(ice_config, ice_config);
// We have gathered host, srflx and relay candidates.
- EXPECT_TRUE_SIMULATED_WAIT(ep1->saved_candidates_.size() == 3u,
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep1->saved_candidates_.size(); }, Eq(3u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
- ASSERT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() != nullptr &&
- ep1_ch1()->selected_connection()->local_candidate().is_local() &&
- ep2_ch1()->selected_connection() != nullptr &&
- ep1_ch1()->selected_connection()->remote_candidate().is_local(),
- kDefaultTimeout, clock);
- ASSERT_TRUE_SIMULATED_WAIT(ep2_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() != nullptr &&
+ ep1_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_local() &&
+ ep2_ch1()->selected_connection() != nullptr &&
+ ep1_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_local();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Test that we have a host-host candidate pair selected and the number of
// candidates signaled to the remote peer stays the same.
auto test_invariants = [this]() {
@@ -5987,21 +6836,41 @@
// On the caller we only have relay,
// on the callee we have host, srflx and relay.
- EXPECT_TRUE_SIMULATED_WAIT(ep1->saved_candidates_.size() == 1u,
- kDefaultTimeout, clock);
- EXPECT_TRUE_SIMULATED_WAIT(ep2->saved_candidates_.size() == 3u,
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep1->saved_candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ep2->saved_candidates_.size(); }, Eq(3u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
- ASSERT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() != nullptr &&
- ep1_ch1()->selected_connection()->local_candidate().is_relay() &&
- ep2_ch1()->selected_connection() != nullptr &&
- ep1_ch1()->selected_connection()->remote_candidate().is_relay(),
- kDefaultTimeout, clock);
- ASSERT_TRUE_SIMULATED_WAIT(ep2_ch1()->selected_connection() != nullptr,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() != nullptr &&
+ ep1_ch1()
+ ->selected_connection()
+ ->local_candidate()
+ .is_relay() &&
+ ep2_ch1()->selected_connection() != nullptr &&
+ ep1_ch1()
+ ->selected_connection()
+ ->remote_candidate()
+ .is_relay();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ep2_ch1()->selected_connection(); }, Ne(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Wait until the callee discards it's candidates
// since they don't manage to connect.
@@ -6044,7 +6913,11 @@
conn1->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
// It shall not be selected until 0ms has passed....i.e it should be connected
// directly.
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), kMargin, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kMargin), .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampening) {
@@ -6070,7 +6943,11 @@
conn1->ReceivedPingResponse(LOW_RTT, "id"); // Becomes writable and receiving
// It shall not be selected until 100ms has passed.
SIMULATED_WAIT(conn1 == ch.selected_connection(), 100 - kMargin, clock);
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), 2 * kMargin, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(2 * kMargin), .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampeningPingReceived) {
@@ -6098,7 +6975,11 @@
conn1->ReceivedPing("id1"); //
// It shall not be selected until 100ms has passed.
SIMULATED_WAIT(conn1 == ch.selected_connection(), 100 - kMargin, clock);
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), 2 * kMargin, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(2 * kMargin), .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelPingTest, TestInitialSelectDampeningBoth) {
@@ -6129,7 +7010,11 @@
SIMULATED_WAIT(conn1 == ch.selected_connection(), 50 - kMargin, clock);
// Now receiving ping and new timeout should kick in.
conn1->ReceivedPing("id1"); //
- EXPECT_EQ_SIMULATED_WAIT(conn1, ch.selected_connection(), 2 * kMargin, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ch.selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(2 * kMargin), .clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST(P2PTransportChannelIceControllerTest, InjectIceController) {
@@ -6236,7 +7121,10 @@
// Wait for conn1 to be selected.
conn1->ReceivedPingResponse(LOW_RTT, "id");
- EXPECT_EQ_WAIT(conn1, ch->selected_connection(), kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch->selected_connection(); }, Eq(conn1),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
conn2->ReceivedPingResponse(LOW_RTT, "id");
EXPECT_TRUE(conn2->writable());
@@ -6248,7 +7136,10 @@
// We don't have a mock Connection, so verify this by checking that it
// is no longer writable.
- EXPECT_EQ_WAIT(false, conn2->writable(), kMediumTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn2->writable(); }, IsFalse(),
+ {.timeout = webrtc::TimeDelta::Millis(kMediumTimeout)}),
+ webrtc::IsRtcOk());
}
TEST_F(P2PTransportChannelTest, DisableDnsLookupsWithTransportPolicyRelay) {
@@ -6367,9 +7258,15 @@
PauseCandidates(1);
// We have gathered host candidates but not relay.
- ASSERT_TRUE_SIMULATED_WAIT(ep1->saved_candidates_.size() == 1u &&
- ep2->saved_candidates_.size() == 1u,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1->saved_candidates_.size() == 1u &&
+ ep2->saved_candidates_.size() == 1u;
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
@@ -6377,13 +7274,25 @@
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_TRUE_SIMULATED_WAIT(ep1_ch1()->remote_candidates().size() == 1 &&
- ep2_ch1()->remote_candidates().size() == 1,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->remote_candidates().size() == 1 &&
+ ep2_ch1()->remote_candidates().size() == 1;
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
- ASSERT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() && ep2_ch1()->selected_connection(),
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() &&
+ ep2_ch1()->selected_connection();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
clock.AdvanceTime(webrtc::TimeDelta::Millis(10 * delay));
@@ -6429,9 +7338,15 @@
PauseCandidates(1);
// We have gathered host candidates but not relay.
- ASSERT_TRUE_SIMULATED_WAIT(ep1->saved_candidates_.size() == 2u &&
- ep2->saved_candidates_.size() == 1u,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1->saved_candidates_.size() == 2u &&
+ ep2->saved_candidates_.size() == 1u;
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ResumeCandidates(0);
ResumeCandidates(1);
@@ -6439,13 +7354,25 @@
PauseCandidates(0);
PauseCandidates(1);
- ASSERT_TRUE_SIMULATED_WAIT(ep1_ch1()->remote_candidates().size() == 1 &&
- ep2_ch1()->remote_candidates().size() == 2,
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->remote_candidates().size() == 1 &&
+ ep2_ch1()->remote_candidates().size() == 2;
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
- ASSERT_TRUE_SIMULATED_WAIT(
- ep1_ch1()->selected_connection() && ep2_ch1()->selected_connection(),
- kDefaultTimeout, clock);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] {
+ return ep1_ch1()->selected_connection() &&
+ ep2_ch1()->selected_connection();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
clock.AdvanceTime(webrtc::TimeDelta::Millis(10 * delay));
@@ -6472,16 +7399,24 @@
IceConfig config = CreateIceConfig(1000, GATHER_CONTINUALLY);
CreateChannels(config, config);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnected(ep1_ch1(), ep2_ch1()),
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnected(ep1_ch1(), ep2_ch1()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
PauseCandidates(0);
ep1_ch1()->SetIceParameters(kIceParams[3]);
ep1_ch1()->MaybeStartGathering();
- EXPECT_TRUE_SIMULATED_WAIT(GetEndpoint(0)->saved_candidates_.size() > 0,
- kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return GetEndpoint(0)->saved_candidates_.size(); }, Gt(0),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
for (const auto& cd : GetEndpoint(0)->saved_candidates_) {
EXPECT_EQ(cd.candidate.username(), kIceUfrag[3]);
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 4238757..14786ba 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -12,6 +12,7 @@
#include <string.h>
+#include <cmath>
#include <cstdint>
#include <limits>
#include <list>
@@ -24,12 +25,17 @@
#include "absl/memory/memory.h"
#include "absl/strings/string_view.h"
#include "api/array_view.h"
+#include "api/async_dns_resolver.h"
#include "api/candidate.h"
#include "api/packet_socket_factory.h"
+#include "api/rtc_error.h"
+#include "api/test/rtc_error_matchers.h"
#include "api/transport/stun.h"
#include "api/units/time_delta.h"
#include "p2p/base/basic_packet_socket_factory.h"
+#include "p2p/base/connection.h"
#include "p2p/base/p2p_constants.h"
+#include "p2p/base/p2p_transport_channel_ice_field_trials.h"
#include "p2p/base/port_allocator.h"
#include "p2p/base/port_interface.h"
#include "p2p/base/stun_port.h"
@@ -66,8 +72,10 @@
#include "rtc_base/thread.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/virtual_socket_server.h"
+#include "test/gmock.h"
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
+#include "test/wait_until.h"
using rtc::AsyncListenSocket;
using rtc::AsyncPacketSocket;
@@ -81,6 +89,10 @@
using rtc::PacketSocketFactory;
using rtc::Socket;
using rtc::SocketAddress;
+using ::testing::Eq;
+using ::testing::IsNull;
+using ::testing::IsTrue;
+using ::testing::NotNull;
using webrtc::IceCandidateType;
namespace cricket {
@@ -259,13 +271,19 @@
rtc::ScopedFakeClock* clock,
int64_t ms) {
lconn->Ping(rtc::TimeMillis());
- ASSERT_TRUE_WAIT(lport->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
clock->AdvanceTime(webrtc::TimeDelta::Millis(ms));
- ASSERT_TRUE_WAIT(rport->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
@@ -286,7 +304,7 @@
int complete_count() { return complete_count_; }
Connection* conn() { return conn_; }
const SocketAddress& remote_address() { return remote_address_; }
- const std::string remote_fragment() { return remote_frag_; }
+ std::string remote_fragment() { return remote_frag_; }
void Start() { port_->PrepareAddress(); }
void CreateConnection(const Candidate& remote_candidate) {
@@ -684,16 +702,21 @@
// TCP reconnecting mechanism before entering this function.
void ConnectStartedChannels(TestChannel* ch1, TestChannel* ch2) {
ASSERT_TRUE(ch1->conn());
- EXPECT_TRUE_WAIT(ch1->conn()->connected(),
- kDefaultTimeout); // for TCP connect
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1->conn()->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk()); // for TCP connect
ch1->Ping();
WAIT(!ch2->remote_address().IsNil(), kShortTimeout);
// Send a ping from dst to src.
ch2->AcceptConnection(GetCandidate(ch1->port()));
ch2->Ping();
- EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch2->conn()->write_state(),
- kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch2->conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
// This connects and disconnects the provided channels in the same sequence as
@@ -722,8 +745,14 @@
tcp_conn2->socket()->GetLocalAddress()));
// Wait for both OnClose are delivered.
- EXPECT_TRUE_WAIT(!ch1->conn()->connected(), kDefaultTimeout);
- EXPECT_TRUE_WAIT(!ch2->conn()->connected(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !ch1->conn()->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !ch2->conn()->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Ensure redundant SignalClose events on TcpConnection won't break tcp
// reconnection. Chromium will fire SignalClose for all outstanding IPC
@@ -734,7 +763,10 @@
// Speed up destroying ch2's connection such that the test is ready to
// accept a new connection from ch1 before ch1's connection destroys itself.
ch2->Stop();
- EXPECT_TRUE_WAIT(ch2->conn() == NULL, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch2->conn(); }, IsNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
void TestTcpReconnect(bool ping_after_disconnected,
@@ -755,8 +787,14 @@
ch1.Start();
ch2.Start();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
- ASSERT_EQ_WAIT(1, ch2.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Initial connecting the channel, create connection on channel1.
ch1.CreateConnection(GetCandidate(ch2.port()));
@@ -788,11 +826,18 @@
}
// Wait for channel's outgoing TCPConnection connected.
- EXPECT_TRUE_WAIT(ch1.conn()->connected(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn()->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Verify that we could still connect channels.
ConnectStartedChannels(&ch1, &ch2);
- EXPECT_TRUE_WAIT(ch1.connection_ready_to_send(), kTcpReconnectTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ch1.connection_ready_to_send(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTcpReconnectTimeout)}),
+ webrtc::IsRtcOk());
// Channel2 is the passive one so a new connection is created during
// reconnect. This new connection should never have issued ENOTCONN
// hence the connection_ready_to_send() should be false.
@@ -801,15 +846,25 @@
EXPECT_EQ(ch1.conn()->write_state(), Connection::STATE_WRITABLE);
// Since the reconnection never happens, the connections should have been
// destroyed after the timeout.
- EXPECT_TRUE_WAIT(!ch1.conn(), kTcpReconnectTimeout + kDefaultTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ kTcpReconnectTimeout + kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(!ch2.conn());
}
// Tear down and ensure that goes smoothly.
ch1.Stop();
ch2.Stop();
- EXPECT_TRUE_WAIT(ch1.conn() == NULL, kDefaultTimeout);
- EXPECT_TRUE_WAIT(ch2.conn() == NULL, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn(); }, IsNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch2.conn(); }, IsNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
std::unique_ptr<IceMessage> CreateStunMessage(StunMessageType type) {
@@ -926,14 +981,25 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_EQ_SIMULATED_WAIT(1, ch1.complete_count(), kDefaultTimeout, clock);
- ASSERT_EQ_SIMULATED_WAIT(1, ch2.complete_count(), kDefaultTimeout, clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Send a ping from src to dst. This may or may not make it.
ch1.CreateConnection(GetCandidate(ch2.port()));
ASSERT_TRUE(ch1.conn() != NULL);
- EXPECT_TRUE_SIMULATED_WAIT(ch1.conn()->connected(), kDefaultTimeout,
- clock); // for TCP connect
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk()); // for TCP connect
ch1.Ping();
SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
@@ -953,8 +1019,12 @@
ch2.AcceptConnection(GetCandidate(ch1.port()));
ASSERT_TRUE(ch2.conn() != NULL);
ch2.Ping();
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
- ch2.conn()->write_state(), kDefaultTimeout, clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch2.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
} else {
// We can't send a ping from src to dst, so flip it around. This will happen
// when the destination NAT is addr/port restricted or symmetric.
@@ -977,9 +1047,12 @@
// through. So we will have to do another.
if (ch1.conn()->write_state() == Connection::STATE_WRITE_INIT) {
ch1.Ping();
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
- ch1.conn()->write_state(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
} else if (!same_addr1 && possible) {
// The new ping went to the candidate address, but that address was bad.
@@ -990,8 +1063,11 @@
// However, since we have now sent a ping to the source IP, we should be
// able to get a ping from it. This gives us the real source address.
ch1.Ping();
- EXPECT_TRUE_SIMULATED_WAIT(!ch2.remote_address().IsNil(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_FALSE(ch2.conn()->receiving());
EXPECT_TRUE(ch1.remote_address().IsNil());
@@ -999,9 +1075,12 @@
ch2.AcceptConnection(GetCandidate(ch1.port()));
ASSERT_TRUE(ch2.conn() != NULL);
ch2.Ping();
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
- ch2.conn()->write_state(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch2.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
} else if (!same_addr2 && possible) {
// The new ping came in, but from an unexpected address. This will happen
// when the destination NAT is symmetric.
@@ -1011,9 +1090,12 @@
// Update our address and complete the connection.
ch1.AcceptConnection(GetCandidate(ch2.port()));
ch1.Ping();
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
- ch1.conn()->write_state(), kDefaultTimeout,
- clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
} else { // (!possible)
// There should be s no way for the pings to reach each other. Check it.
EXPECT_TRUE(ch1.remote_address().IsNil());
@@ -1043,8 +1125,16 @@
// Tear down and ensure that goes smoothly.
ch1.Stop();
ch2.Stop();
- EXPECT_TRUE_SIMULATED_WAIT(ch1.conn() == NULL, kDefaultTimeout, clock);
- EXPECT_TRUE_SIMULATED_WAIT(ch2.conn() == NULL, kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch1.conn(); }, IsNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch2.conn(); }, IsNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
}
class FakePacketSocketFactory : public rtc::PacketSocketFactory {
@@ -1325,7 +1415,10 @@
EXPECT_EQ(0, ch1.complete_count());
ch1.Start();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
std::unique_ptr<rtc::Socket> server(
vss()->CreateSocket(kLocalAddr2.family(), SOCK_STREAM));
@@ -1337,7 +1430,10 @@
ch1.CreateConnection(c);
EXPECT_TRUE(ch1.conn());
- EXPECT_TRUE_WAIT(!ch1.conn(), kDefaultTimeout); // for TCP connect
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !ch1.conn(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk()); // for TCP connect
}
/* TODO(?): Enable these once testrelayserver can accept external TCP.
@@ -1372,8 +1468,14 @@
// Acquire address.
ch1.Start();
ch2.Start();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
- ASSERT_EQ_WAIT(1, ch2.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Test case that the connection has never received anything.
int64_t before_created = rtc::TimeMillis();
@@ -1392,7 +1494,10 @@
EXPECT_TRUE(ch1.conn() != nullptr);
// It will be dead after MIN_CONNECTION_LIFETIME and pruned.
conn->UpdateState(after_created + MIN_CONNECTION_LIFETIME + 1);
- EXPECT_TRUE_WAIT(ch1.conn() == nullptr, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn(); }, Eq(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Test case that the connection has received something.
// Create a connection again and receive a ping.
@@ -1408,7 +1513,10 @@
rtc::Thread::Current()->ProcessMessages(100);
EXPECT_TRUE(ch1.conn() != nullptr);
conn->UpdateState(after_last_receiving + DEAD_CONNECTION_RECEIVE_TIMEOUT + 1);
- EXPECT_TRUE_WAIT(ch1.conn() == nullptr, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn(); }, Eq(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
TEST_F(PortTest, TestConnectionDeadWithDeadConnectionTimeout) {
@@ -1417,8 +1525,14 @@
// Acquire address.
ch1.Start();
ch2.Start();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
- ASSERT_EQ_WAIT(1, ch2.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Note: set field trials manually since they are parsed by
// P2PTransportChannel but P2PTransportChannel is not used in this test.
@@ -1439,7 +1553,10 @@
rtc::Thread::Current()->ProcessMessages(100);
EXPECT_TRUE(ch1.conn() != nullptr);
conn->UpdateState(after_last_receiving + 90000 + 1);
- EXPECT_TRUE_WAIT(ch1.conn() == nullptr, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn(); }, Eq(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
TEST_F(PortTest, TestConnectionDeadOutstandingPing) {
@@ -1455,8 +1572,14 @@
// Acquire address.
ch1.Start();
ch2.Start();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
- ASSERT_EQ_WAIT(1, ch2.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Note: set field trials manually since they are parsed by
// P2PTransportChannel but P2PTransportChannel is not used in this test.
@@ -1479,7 +1602,10 @@
rtc::Thread::Current()->ProcessMessages(100);
EXPECT_TRUE(ch1.conn() != nullptr);
conn->UpdateState(send_ping_timestamp + DEAD_CONNECTION_RECEIVE_TIMEOUT + 1);
- EXPECT_TRUE_WAIT(ch1.conn() == nullptr, kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn(); }, Eq(nullptr),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
}
// This test case verifies standard ICE features in STUN messages. Currently it
@@ -1511,12 +1637,18 @@
lport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
conn->Ping(0);
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
conn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
@@ -1529,7 +1661,10 @@
lport->CreateConnection(lport->Candidates()[1], Port::ORIGIN_MESSAGE);
conn1->Ping(0);
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
std::unique_ptr<IceMessage> modified_req(
@@ -1551,7 +1686,10 @@
conn1->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
reinterpret_cast<const char*>(buf->Data()), buf->Length(),
/*packet_time_us=*/-1));
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
}
@@ -1579,14 +1717,20 @@
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
rconn->Ping(0);
- ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
EXPECT_TRUE(role_conflict());
}
@@ -1610,13 +1754,24 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_EQ_SIMULATED_WAIT(1, ch1.complete_count(), kDefaultTimeout, clock);
- ASSERT_EQ_SIMULATED_WAIT(1, ch2.complete_count(), kDefaultTimeout, clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Connect and send a ping from src to dst.
ch1.CreateConnection(GetCandidate(ch2.port()));
ASSERT_TRUE(ch1.conn() != NULL);
- EXPECT_TRUE_SIMULATED_WAIT(ch1.conn()->connected(), kDefaultTimeout,
- clock); // for TCP connect
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk()); // for TCP connect
ch1.Ping();
SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
@@ -1884,7 +2039,10 @@
lconn->Ping(0);
// Check that it's a proper BINDING-REQUEST.
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
EXPECT_FALSE(msg->IsLegacy());
@@ -1986,7 +2144,10 @@
rconn->Ping(0);
rconn->Ping(0);
rconn->Ping(0);
- ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
const StunUInt64Attribute* ice_controlled_attr =
@@ -2057,7 +2218,10 @@
// Send ping (including the nomination value) from `lconn` to `rconn`. This
// should set the remote nomination of `rconn`.
lconn->Ping(0);
- ASSERT_TRUE_WAIT(lport->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
@@ -2070,7 +2234,10 @@
// This should result in an acknowledgment sent back from `rconn` to `lconn`,
// updating the acknowledged nomination of `lconn`.
- ASSERT_TRUE_WAIT(rport->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
@@ -2138,7 +2305,10 @@
Connection* lconn =
lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
lconn->Ping(0);
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
const StunUInt64Attribute* ice_controlling_attr =
msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
@@ -2196,7 +2366,10 @@
// message is handled in rconn, The rconn's remote candidate will have cost
// rtc::kNetworkCostHigh;
EXPECT_EQ(rtc::kNetworkCostLow, rconn->remote_candidate().network_cost());
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Pass the binding request to rport.
@@ -2204,7 +2377,10 @@
rtc::SocketAddress(), std::nullopt));
// Wait until rport sends the response and then check the remote network cost.
- ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(rtc::kNetworkCostHigh, rconn->remote_candidate().network_cost());
}
@@ -2225,7 +2401,10 @@
Connection* lconn =
lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
lconn->Ping(0);
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
const StunUInt32Attribute* network_info_attr =
msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO);
@@ -2243,7 +2422,10 @@
Connection* rconn =
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
rconn->Ping(0);
- ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
msg = rport->last_stun_msg();
network_info_attr = msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO);
ASSERT_TRUE(network_info_attr != NULL);
@@ -2530,12 +2712,18 @@
// Send request.
lconn->Ping(0);
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
// Intercept request and add comprehension required attribute.
- ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
auto modified_response = rport->last_stun_msg()->Clone();
modified_response->AddAttribute(StunAttribute::CreateUInt32(0x7777));
modified_response->RemoveAttribute(STUN_ATTR_FINGERPRINT);
@@ -2615,14 +2803,20 @@
rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
rconn->Ping(0);
- ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
- ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
int64_t last_ping_received1 = lconn->last_ping_received();
@@ -2742,7 +2936,10 @@
tcpport2->Candidates()[0].foundation());
auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1());
stunport->PrepareAddress();
- ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return stunport->Candidates().size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_NE(tcpport1->Candidates()[0].foundation(),
stunport->Candidates()[0].foundation());
EXPECT_NE(tcpport2->Candidates()[0].foundation(),
@@ -2755,7 +2952,10 @@
auto turnport1 =
CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
turnport1->PrepareAddress();
- ASSERT_EQ_WAIT(1U, turnport1->Candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turnport1->Candidates().size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_NE(udpport1->Candidates()[0].foundation(),
turnport1->Candidates()[0].foundation());
EXPECT_NE(udpport2->Candidates()[0].foundation(),
@@ -2765,7 +2965,10 @@
auto turnport2 =
CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
turnport2->PrepareAddress();
- ASSERT_EQ_WAIT(1U, turnport2->Candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turnport2->Candidates().size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(turnport1->Candidates()[0].foundation(),
turnport2->Candidates()[0].foundation());
@@ -2777,7 +2980,10 @@
auto turnport3 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP,
PROTO_UDP, kTurnUdpIntAddr2);
turnport3->PrepareAddress();
- ASSERT_EQ_WAIT(1U, turnport3->Candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turnport3->Candidates().size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_NE(turnport3->Candidates()[0].foundation(),
turnport2->Candidates()[0].foundation());
@@ -2788,7 +2994,10 @@
auto turnport4 =
CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_TCP, PROTO_UDP);
turnport4->PrepareAddress();
- ASSERT_EQ_WAIT(1U, turnport4->Candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turnport4->Candidates().size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_NE(turnport2->Candidates()[0].foundation(),
turnport4->Candidates()[0].foundation());
}
@@ -2806,7 +3015,10 @@
// socket address.
auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1());
stunport->PrepareAddress();
- ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return stunport->Candidates().size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Check STUN candidate address.
EXPECT_EQ(stunport->Candidates()[0].address().ipaddr(), kNatAddr1.ipaddr());
// Check STUN candidate related address.
@@ -2817,7 +3029,10 @@
auto turnport =
CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
turnport->PrepareAddress();
- ASSERT_EQ_WAIT(1U, turnport->Candidates().size(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turnport->Candidates().size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
turnport->Candidates()[0].address().ipaddr());
EXPECT_EQ(kNatAddr1.ipaddr(),
@@ -2938,15 +3153,27 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_EQ_SIMULATED_WAIT(1, ch1.complete_count(), kDefaultTimeout, clock);
- ASSERT_EQ_SIMULATED_WAIT(1, ch2.complete_count(), kDefaultTimeout, clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Send a ping from src to dst.
ch1.CreateConnection(GetCandidate(ch2.port()));
ASSERT_TRUE(ch1.conn() != NULL);
EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
// for TCP connect
- EXPECT_TRUE_SIMULATED_WAIT(ch1.conn()->connected(), kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ch1.Ping();
SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
@@ -2959,8 +3186,12 @@
// Accept the connection to return the binding response, transition to
// writable, and allow data to be sent.
ch2.AcceptConnection(GetCandidate(ch1.port()));
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
- ch1.conn()->write_state(), kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size, options));
// Ask the connection to update state as if enough time has passed to lose
@@ -2979,8 +3210,12 @@
// And now allow the other side to process the pings and send binding
// responses.
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
- ch1.conn()->write_state(), kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Wait long enough for a full timeout (past however long we've already
// waited).
for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
@@ -3015,8 +3250,16 @@
// Acquire addresses.
ch1.Start();
ch2.Start();
- ASSERT_EQ_SIMULATED_WAIT(1, ch1.complete_count(), kDefaultTimeout, clock);
- ASSERT_EQ_SIMULATED_WAIT(1, ch2.complete_count(), kDefaultTimeout, clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
// Send a ping from src to dst.
ch1.CreateConnection(GetCandidate(ch2.port()));
@@ -3027,8 +3270,12 @@
// Accept the connection to return the binding response, transition to
// writable, and allow data to be sent.
ch2.AcceptConnection(GetCandidate(ch1.port()));
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE,
- ch1.conn()->write_state(), kDefaultTimeout, clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout),
+ .clock = &clock}),
+ webrtc::IsRtcOk());
ch1.conn()->set_unwritable_timeout(1000);
ch1.conn()->set_unwritable_min_checks(3);
@@ -3102,7 +3349,10 @@
ch1.Start();
ice_lite_port->PrepareAddress();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_FALSE(ice_lite_port->Candidates().empty());
ch1.CreateConnection(GetCandidate(ice_lite_port.get()));
@@ -3115,7 +3365,10 @@
// Verify stun ping is without USE_CANDIDATE_ATTR. Getting message directly
// from port.
- ASSERT_TRUE_WAIT(ice_full_port_ptr->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
IceMessage* msg = ice_full_port_ptr->last_stun_msg();
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == NULL);
@@ -3133,16 +3386,25 @@
ice_lite_port->last_stun_buf(), rtc::SocketAddress(), std::nullopt));
// Verifying full mode connection becomes writable from the response.
- EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
- kDefaultTimeout);
- EXPECT_TRUE_WAIT(ch1.nominated(), kDefaultTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.conn()->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.nominated(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// Clear existing stun messsages. Otherwise we will process old stun
// message right after we send ping.
ice_full_port_ptr->Reset();
// Send ping. This must have USE_CANDIDATE_ATTR.
ch1.Ping();
- ASSERT_TRUE_WAIT(ice_full_port_ptr->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
msg = ice_full_port_ptr->last_stun_msg();
EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL);
ch1.Stop();
@@ -3215,7 +3477,10 @@
ch1.Start();
port2->PrepareAddress();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3226,7 +3491,10 @@
// Send ping.
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* request1 = port1->last_stun_msg();
ASSERT_EQ(trials.enable_goog_ping,
@@ -3254,7 +3522,10 @@
port2->Reset();
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* request2 = port1->last_stun_msg();
// It should be a GOOG_PING if both of these are TRUE
@@ -3306,7 +3577,10 @@
ch1.Start();
port2->PrepareAddress();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3317,7 +3591,10 @@
// Send ping.
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* request1 = port1->last_stun_msg();
ASSERT_TRUE(GetSupportedGoogPingVersion(request1) &&
@@ -3377,7 +3654,10 @@
ch1.Start();
port2->PrepareAddress();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3388,7 +3668,10 @@
// Send ping.
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* request1 = port1->last_stun_msg();
ASSERT_TRUE(GetSupportedGoogPingVersion(request1) &&
@@ -3438,7 +3721,10 @@
port2->Reset();
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
// This should now be a STUN_BINDING...without a kGoogPingVersion
const IceMessage* request2 = port1->last_stun_msg();
@@ -3478,7 +3764,10 @@
ch1.Start();
port2->PrepareAddress();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3489,7 +3778,10 @@
// Send ping.
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* msg = port1->last_stun_msg();
auto* con = port2->CreateConnection(port1->Candidates()[0],
cricket::Port::ORIGIN_MESSAGE);
@@ -3511,7 +3803,10 @@
port2->Reset();
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* msg2 = port1->last_stun_msg();
// It should be a GOOG_PING if both of these are TRUE
@@ -3532,7 +3827,10 @@
ch1.conn()->set_use_candidate_attr(!ch1.conn()->use_candidate_attr());
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* msg3 = port1->last_stun_msg();
// It should be a STUN_BINDING_REQUEST
@@ -3563,7 +3861,10 @@
ch1.Start();
port2->PrepareAddress();
- ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return ch1.complete_count(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_FALSE(port2->Candidates().empty());
ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3574,7 +3875,10 @@
// Send ping.
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* msg = port1->last_stun_msg();
auto* con = port2->CreateConnection(port1->Candidates()[0],
cricket::Port::ORIGIN_MESSAGE);
@@ -3596,7 +3900,10 @@
port2->Reset();
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* msg2 = port1->last_stun_msg();
// It should be a GOOG_PING.
@@ -3624,7 +3931,10 @@
port2->Reset();
ch1.Ping();
- ASSERT_TRUE_WAIT(port1->last_stun_msg() != NULL, kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return port1->last_stun_msg(); }, NotNull(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
const IceMessage* msg3 = port1->last_stun_msg();
// It should be a STUN_BINDING_REQUEST
@@ -3659,7 +3969,9 @@
StartConnectAndStopChannels(&ch1, &ch2);
// After the connection is destroyed, the port will be destroyed because
// none of them is marked as "keep alive until pruned.
- EXPECT_EQ_SIMULATED_WAIT(2, ports_destroyed(), 110, clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return ports_destroyed(); }, Eq(2),
+ {.clock = &clock}),
+ webrtc::IsRtcOk());
}
// Test that if after all connection are destroyed, new connections are created
@@ -3700,7 +4012,9 @@
EXPECT_EQ(0, ports_destroyed());
// The ports on both sides should be destroyed after timeout.
- EXPECT_TRUE_SIMULATED_WAIT(ports_destroyed() == 2, 30, clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return ports_destroyed(); }, Eq(2),
+ {.clock = &clock}),
+ webrtc::IsRtcOk());
}
// This test case verifies that neither the controlling port nor the controlled
@@ -3741,7 +4055,9 @@
ch1.port()->Prune();
ch2.port()->Prune();
// The ports on both sides should be destroyed after timeout.
- EXPECT_TRUE_SIMULATED_WAIT(ports_destroyed() == 2, 1, clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return ports_destroyed(); }, Eq(2),
+ {.clock = &clock}),
+ webrtc::IsRtcOk());
}
TEST_F(PortTest, TestSupportsProtocol) {
@@ -3853,13 +4169,19 @@
TestPort* rport =
rconn->PortForTest() == rport_.get() ? rport_.get() : lport_.get();
lconn->Ping(rtc::TimeMillis());
- ASSERT_TRUE_WAIT(lport->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
rconn->OnReadPacket(rtc::ReceivedPacket(
lport->last_stun_buf(), rtc::SocketAddress(), std::nullopt));
clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
- ASSERT_TRUE_WAIT(rport->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
reply->SetData(rport->last_stun_buf());
}
@@ -4003,14 +4325,20 @@
[](webrtc::RTCErrorOr<const StunUInt64Attribute*> error_or__ack) {});
lconn->Ping(rtc::TimeMillis(), std::move(delta));
- ASSERT_TRUE_WAIT(lport_->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport_->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(lport_->last_stun_buf().size(), 0u);
rconn->OnReadPacket(rtc::ReceivedPacket(lport_->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
EXPECT_TRUE(received_goog_delta);
clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
- ASSERT_TRUE_WAIT(rport_->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport_->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(rport_->last_stun_buf().size(), 0u);
lconn->OnReadPacket(rtc::ReceivedPacket(rport_->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
@@ -4041,13 +4369,19 @@
});
lconn->Ping(rtc::TimeMillis(), std::move(delta));
- ASSERT_TRUE_WAIT(lport_->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return lport_->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(lport_->last_stun_buf().size(), 0u);
rconn->OnReadPacket(rtc::ReceivedPacket(lport_->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
- ASSERT_TRUE_WAIT(rport_->last_stun_msg(), kDefaultTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return rport_->last_stun_msg(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
+ webrtc::IsRtcOk());
ASSERT_GT(rport_->last_stun_buf().size(), 0u);
lconn->OnReadPacket(rtc::ReceivedPacket(rport_->last_stun_buf(),
rtc::SocketAddress(), std::nullopt));
diff --git a/p2p/base/pseudo_tcp_unittest.cc b/p2p/base/pseudo_tcp_unittest.cc
index 4057e84..fd12410 100644
--- a/p2p/base/pseudo_tcp_unittest.cc
+++ b/p2p/base/pseudo_tcp_unittest.cc
@@ -14,21 +14,28 @@
#include <algorithm>
#include <cstddef>
+#include <cstdint>
#include <string>
#include <utility>
#include <vector>
+#include "api/array_view.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/task_queue_base.h"
+#include "api/test/rtc_error_matchers.h"
#include "api/units/time_delta.h"
#include "rtc_base/crypto_random.h"
-#include "rtc_base/gunit.h"
#include "rtc_base/logging.h"
#include "rtc_base/memory_stream.h"
+#include "rtc_base/stream.h"
+#include "rtc_base/thread.h"
#include "rtc_base/time_utils.h"
+#include "test/gmock.h"
#include "test/gtest.h"
+#include "test/wait_until.h"
using ::cricket::PseudoTcp;
+using ::testing::IsTrue;
using ::webrtc::ScopedTaskSafety;
using ::webrtc::TaskQueueBase;
using ::webrtc::TimeDelta;
@@ -243,10 +250,16 @@
// Connect and wait until connected.
start = rtc::Time32();
EXPECT_EQ(0, Connect());
- EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return have_connected_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kConnectTimeoutMs)}),
+ webrtc::IsRtcOk());
// Sending will start from OnTcpWriteable and complete when all data has
// been received.
- EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return have_disconnected_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTransferTimeoutMs)}),
+ webrtc::IsRtcOk());
elapsed = rtc::Time32() - start;
recv_stream_.GetSize(&received);
// Ensure we closed down OK and we got the right data.
@@ -366,10 +379,16 @@
// Connect and wait until connected.
start = rtc::Time32();
EXPECT_EQ(0, Connect());
- EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return have_connected_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kConnectTimeoutMs)}),
+ webrtc::IsRtcOk());
// Sending will start from OnTcpWriteable and stop when the required
// number of iterations have completed.
- EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return have_disconnected_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTransferTimeoutMs)}),
+ webrtc::IsRtcOk());
elapsed = rtc::TimeSince(start);
RTC_LOG(LS_INFO) << "Performed " << iterations << " pings in " << elapsed
<< " ms";
@@ -488,10 +507,16 @@
// Connect and wait until connected.
EXPECT_EQ(0, Connect());
- EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return have_connected_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kConnectTimeoutMs)}),
+ webrtc::IsRtcOk());
TaskQueueBase::Current()->PostTask([this] { WriteData(); });
- EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return have_disconnected_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTransferTimeoutMs)}),
+ webrtc::IsRtcOk());
ASSERT_EQ(2u, send_position_.size());
ASSERT_EQ(2u, recv_position_.size());
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index 2c50784..ac812da 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -10,21 +10,45 @@
#include "p2p/base/stun_port.h"
+#include <cstddef>
+#include <cstdint>
#include <memory>
+#include <optional>
+#include <string>
+#include "absl/functional/any_invocable.h"
+#include "api/candidate.h"
+#include "api/field_trials_view.h"
+#include "api/packet_socket_factory.h"
#include "api/test/mock_async_dns_resolver.h"
+#include "api/test/rtc_error_matchers.h"
+#include "api/transport/stun.h"
+#include "api/units/time_delta.h"
#include "p2p/base/basic_packet_socket_factory.h"
#include "p2p/base/mock_dns_resolving_packet_socket_factory.h"
+#include "p2p/base/port.h"
+#include "p2p/base/stun_request.h"
#include "p2p/base/test_stun_server.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/crypto_random.h"
+#include "rtc_base/dscp.h"
+#include "rtc_base/fake_clock.h"
#include "rtc_base/gunit.h"
+#include "rtc_base/ip_address.h"
+#include "rtc_base/mdns_responder_interface.h"
+#include "rtc_base/net_helpers.h"
+#include "rtc_base/network.h"
#include "rtc_base/network/received_packet.h"
+#include "rtc_base/network_constants.h"
+#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
-#include "rtc_base/ssl_adapter.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
+#include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h"
#include "test/gmock.h"
+#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
+#include "test/wait_until.h"
namespace {
@@ -32,6 +56,8 @@
using rtc::SocketAddress;
using ::testing::_;
using ::testing::DoAll;
+using ::testing::Eq;
+using ::testing::IsTrue;
using ::testing::Return;
using ::testing::ReturnPointee;
using ::testing::SetArgPointee;
@@ -286,7 +312,11 @@
TEST_F(StunPortTest, TestPrepareAddress) {
CreateStunPort(kStunAddr1);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
std::string expected_server_url = "stun:127.0.0.1:5000";
@@ -297,12 +327,19 @@
TEST_F(StunPortTest, TestPrepareAddressFail) {
CreateStunPort(kBadAddr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(error());
EXPECT_EQ(0U, port()->Candidates().size());
- EXPECT_EQ_SIMULATED_WAIT(error_event_.error_code,
- cricket::STUN_ERROR_SERVER_NOT_REACHABLE, kTimeoutMs,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.error_code; },
+ Eq(cricket::STUN_ERROR_SERVER_NOT_REACHABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_NE(error_event_.error_text.find('.'), std::string::npos);
EXPECT_NE(error_event_.address.find(kLocalAddr.HostAsSensitiveURIString()),
std::string::npos);
@@ -315,7 +352,11 @@
TEST_F(StunPortTest, TestServerAddressFamilyMismatch) {
CreateStunPort(kIPv6StunAddr1);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(error());
EXPECT_EQ(0U, port()->Candidates().size());
EXPECT_EQ(0, error_event_.error_code);
@@ -356,7 +397,11 @@
});
CreateStunPort(kValidHostnameAddr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_EQ(kStunCandidatePriority, port()->Candidates()[0].priority());
@@ -381,7 +426,11 @@
});
CreateStunPort(kValidHostnameAddr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_EQ(kStunCandidatePriority + (cricket::kMaxTurnServers << 8),
@@ -392,11 +441,17 @@
TEST_F(StunPortTestWithRealClock, TestPrepareAddressHostnameFail) {
CreateStunPort(kBadHostnameAddr);
PrepareAddress();
- EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(error());
EXPECT_EQ(0U, port()->Candidates().size());
- EXPECT_EQ_WAIT(error_event_.error_code,
- cricket::STUN_ERROR_SERVER_NOT_REACHABLE, kTimeoutMs);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.error_code; },
+ Eq(cricket::STUN_ERROR_SERVER_NOT_REACHABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}),
+ webrtc::IsRtcOk());
}
// This test verifies keepalive response messages don't result in
@@ -405,7 +460,11 @@
SetKeepaliveDelay(500); // 500ms of keepalive delay.
CreateStunPort(kStunAddr1);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
SIMULATED_WAIT(false, 1000, fake_clock);
@@ -416,7 +475,11 @@
TEST_F(StunPortTest, TestSharedSocketPrepareAddress) {
CreateSharedUdpPort(kStunAddr1, nullptr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
}
@@ -428,7 +491,10 @@
TestSharedSocketPrepareAddressInvalidHostname) {
CreateSharedUdpPort(kBadHostnameAddr, nullptr);
PrepareAddress();
- EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
@@ -444,7 +510,11 @@
TEST_F(StunPortTest, TestStunCandidateDiscardedWithMdnsObfuscationNotEnabled) {
CreateSharedUdpPort(kStunAddr1, nullptr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_TRUE(port()->Candidates()[0].is_local());
@@ -456,7 +526,11 @@
EnableMdnsObfuscation();
CreateSharedUdpPort(kStunAddr1, nullptr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(2U, port()->Candidates().size());
// The addresses of the candidates are both equal to kLocalAddr.
@@ -483,7 +557,11 @@
CreateStunPort(stun_servers);
EXPECT_EQ(IceCandidateType::kSrflx, port()->Type());
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, port()->Candidates().size());
EXPECT_EQ(port()->Candidates()[0].relay_protocol(), "");
}
@@ -497,11 +575,18 @@
CreateStunPort(stun_servers);
EXPECT_EQ(IceCandidateType::kSrflx, port()->Type());
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, port()->Candidates().size());
std::string server_url = "stun:" + kBadAddr.ToString();
- ASSERT_EQ_SIMULATED_WAIT(error_event_.url, server_url, kTimeoutMs,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.url; }, Eq(server_url),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
// Test that two candidates are allocated if the two STUN servers return
@@ -518,7 +603,11 @@
CreateStunPort(stun_servers);
EXPECT_EQ(IceCandidateType::kSrflx, port()->Type());
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, port()->Candidates().size());
EXPECT_EQ(port()->Candidates()[0].relay_protocol(), "");
EXPECT_EQ(port()->Candidates()[1].relay_protocol(), "");
@@ -567,9 +656,16 @@
SetKeepaliveLifetime(100);
CreateStunPort(kStunAddr1);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
- EXPECT_TRUE_SIMULATED_WAIT(!HasPendingRequest(cricket::STUN_BINDING_REQUEST),
- 2000, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return !HasPendingRequest(cricket::STUN_BINDING_REQUEST); },
+ IsTrue(), {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
// Test that by default, the STUN binding requests will last for a long time.
@@ -577,9 +673,16 @@
SetKeepaliveDelay(101);
CreateStunPort(kStunAddr1);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
- EXPECT_TRUE_SIMULATED_WAIT(HasPendingRequest(cricket::STUN_BINDING_REQUEST),
- 1000, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return HasPendingRequest(cricket::STUN_BINDING_REQUEST); },
+ IsTrue(), {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
class MockAsyncPacketSocket : public rtc::AsyncPacketSocket {
@@ -621,10 +724,9 @@
EXPECT_CALL(*socket, SetOption(_, _)).WillRepeatedly(Return(0));
// If DSCP is not set on the socket, stun packets should have no value.
- EXPECT_CALL(*socket,
- SendTo(_, _, _,
- ::testing::Field(&rtc::PacketOptions::dscp,
- ::testing::Eq(rtc::DSCP_NO_CHANGE))))
+ EXPECT_CALL(*socket, SendTo(_, _, _,
+ ::testing::Field(&rtc::PacketOptions::dscp,
+ Eq(rtc::DSCP_NO_CHANGE))))
.WillOnce(Return(100));
PrepareAddress();
@@ -632,9 +734,13 @@
port()->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
EXPECT_CALL(*socket, SendTo(_, _, _,
::testing::Field(&rtc::PacketOptions::dscp,
- ::testing::Eq(rtc::DSCP_AF41))))
+ Eq(rtc::DSCP_AF41))))
.WillRepeatedly(Return(100));
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
class StunIPv6PortTestBase : public StunPortTestBase {
@@ -661,7 +767,11 @@
TEST_F(StunIPv6PortTest, TestPrepareAddress) {
CreateStunPort(kIPv6StunAddr1);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kIPv6LocalAddr.EqualIPs(port()->Candidates()[0].address()));
std::string expected_server_url = "stun:::1:5000";
@@ -672,12 +782,19 @@
TEST_F(StunIPv6PortTest, TestPrepareAddressFail) {
CreateStunPort(kIPv6BadAddr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(error());
EXPECT_EQ(0U, port()->Candidates().size());
- EXPECT_EQ_SIMULATED_WAIT(error_event_.error_code,
- cricket::STUN_ERROR_SERVER_NOT_REACHABLE, kTimeoutMs,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.error_code; },
+ Eq(cricket::STUN_ERROR_SERVER_NOT_REACHABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_NE(error_event_.error_text.find('.'), std::string::npos);
EXPECT_NE(
error_event_.address.find(kIPv6LocalAddr.HostAsSensitiveURIString()),
@@ -691,7 +808,11 @@
TEST_F(StunIPv6PortTest, TestServerAddressFamilyMismatch) {
CreateStunPort(kStunAddr1);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(error());
EXPECT_EQ(0U, port()->Candidates().size());
EXPECT_EQ(0, error_event_.error_code);
@@ -701,11 +822,17 @@
TEST_F(StunIPv6PortTestWithRealClock, TestPrepareAddressHostnameFail) {
CreateStunPort(kBadHostnameAddr);
PrepareAddress();
- EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(error());
EXPECT_EQ(0U, port()->Candidates().size());
- EXPECT_EQ_WAIT(error_event_.error_code,
- cricket::STUN_ERROR_SERVER_NOT_REACHABLE, kTimeoutMs);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.error_code; },
+ Eq(cricket::STUN_ERROR_SERVER_NOT_REACHABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}),
+ webrtc::IsRtcOk());
}
class StunIPv6PortTestWithMockDnsResolver : public StunIPv6PortTest {
@@ -745,7 +872,11 @@
});
CreateStunPort(kValidHostnameAddr);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kIPv6LocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_EQ(kIPv6StunCandidatePriority, port()->Candidates()[0].priority());
@@ -772,7 +903,11 @@
});
CreateStunPort(kValidHostnameAddr, &field_trials);
PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return done(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, port()->Candidates().size());
EXPECT_TRUE(kIPv6LocalAddr.EqualIPs(port()->Candidates()[0].address()));
EXPECT_EQ(kIPv6StunCandidatePriority + (cricket::kMaxTurnServers << 8),
diff --git a/p2p/base/stun_request_unittest.cc b/p2p/base/stun_request_unittest.cc
index 188ffbf..8cb8bbe 100644
--- a/p2p/base/stun_request_unittest.cc
+++ b/p2p/base/stun_request_unittest.cc
@@ -10,18 +10,28 @@
#include "p2p/base/stun_request.h"
-#include <utility>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
#include <vector>
-#include "rtc_base/crypto_random.h"
+#include "api/test/rtc_error_matchers.h"
+#include "api/transport/stun.h"
+#include "api/units/time_delta.h"
#include "rtc_base/fake_clock.h"
#include "rtc_base/gunit.h"
#include "rtc_base/logging.h"
+#include "rtc_base/thread.h"
#include "rtc_base/time_utils.h"
+#include "test/gmock.h"
#include "test/gtest.h"
+#include "test/wait_until.h"
namespace cricket {
namespace {
+
+using ::testing::Ne;
+
std::unique_ptr<StunMessage> CreateStunMessage(
StunMessageType type,
const StunMessage* req = nullptr) {
@@ -149,8 +159,11 @@
int64_t start = rtc::TimeMillis();
manager_.Send(request);
for (int i = 0; i < 9; ++i) {
- EXPECT_TRUE_SIMULATED_WAIT(request_count_ != i, STUN_TOTAL_TIMEOUT,
- fake_clock);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return request_count_; }, Ne(i),
+ {.timeout = webrtc::TimeDelta::Millis(STUN_TOTAL_TIMEOUT),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
int64_t elapsed = rtc::TimeMillis() - start;
RTC_DLOG(LS_INFO) << "STUN request #" << (i + 1) << " sent at " << elapsed
<< " ms";
diff --git a/p2p/base/tcp_port_unittest.cc b/p2p/base/tcp_port_unittest.cc
index 9adda3b..81d6e89 100644
--- a/p2p/base/tcp_port_unittest.cc
+++ b/p2p/base/tcp_port_unittest.cc
@@ -10,23 +10,36 @@
#include "p2p/base/tcp_port.h"
+#include <cstdint>
#include <list>
#include <memory>
+#include <string>
#include <vector>
+#include "api/candidate.h"
+#include "api/test/rtc_error_matchers.h"
+#include "api/units/time_delta.h"
#include "p2p/base/basic_packet_socket_factory.h"
+#include "p2p/base/connection.h"
#include "p2p/base/p2p_constants.h"
+#include "p2p/base/port.h"
#include "p2p/base/transport_description.h"
+#include "rtc_base/async_packet_socket.h"
+#include "rtc_base/checks.h"
#include "rtc_base/crypto_random.h"
-#include "rtc_base/gunit.h"
#include "rtc_base/ip_address.h"
+#include "rtc_base/network.h"
+#include "rtc_base/network/sent_packet.h"
+#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/virtual_socket_server.h"
+#include "test/gmock.h"
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
+#include "test/wait_until.h"
using cricket::Connection;
using cricket::ICE_PWD_LENGTH;
@@ -34,6 +47,8 @@
using cricket::Port;
using cricket::TCPPort;
using rtc::SocketAddress;
+using ::testing::Eq;
+using ::testing::IsTrue;
static int kTimeout = 1000;
static const SocketAddress kLocalAddr("11.11.11.11", 0);
@@ -135,7 +150,10 @@
remote_port->PrepareAddress();
Connection* conn = local_port->CreateConnection(remote_port->Candidates()[0],
Port::ORIGIN_MESSAGE);
- EXPECT_TRUE_WAIT(conn->connected(), kTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Verify that the socket actually used localhost, otherwise this test isn't
// doing what it meant to.
ASSERT_EQ(local_address.ipaddr(),
@@ -164,7 +182,10 @@
Connection* conn = local_port->CreateConnection(remote_port->Candidates()[0],
Port::ORIGIN_MESSAGE);
ConnectionObserver observer(conn);
- EXPECT_TRUE_WAIT(observer.connection_destroyed(), kTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return observer.connection_destroyed(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
}
// A caveat for the above logic: if the socket ends up bound to one of the IPs
@@ -189,7 +210,10 @@
// Expect connection to succeed.
Connection* conn = local_port->CreateConnection(remote_port->Candidates()[0],
Port::ORIGIN_MESSAGE);
- EXPECT_TRUE_WAIT(conn->connected(), kTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Verify that the socket actually used the alternate address, otherwise this
// test isn't doing what it meant to.
@@ -213,7 +237,10 @@
Connection* conn = local_port->CreateConnection(remote_port->Candidates()[0],
Port::ORIGIN_MESSAGE);
ASSERT_NE(nullptr, conn);
- EXPECT_TRUE_WAIT(conn->connected(), kTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
}
class SentPacketCounter : public sigslot::has_slots<> {
@@ -243,7 +270,10 @@
Connection* client_conn =
client->CreateConnection(server->Candidates()[0], Port::ORIGIN_MESSAGE);
ASSERT_NE(nullptr, client_conn);
- ASSERT_TRUE_WAIT(client_conn->connected(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return client_conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Need to get the port of the actual outgoing socket, not the server socket..
cricket::Candidate client_candidate = client->Candidates()[0];
@@ -253,12 +283,21 @@
Connection* server_conn =
server->CreateConnection(client_candidate, Port::ORIGIN_THIS_PORT);
ASSERT_NE(nullptr, server_conn);
- ASSERT_TRUE_WAIT(server_conn->connected(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return server_conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
client_conn->Ping(rtc::TimeMillis());
server_conn->Ping(rtc::TimeMillis());
- ASSERT_TRUE_WAIT(client_conn->writable(), kTimeout);
- ASSERT_TRUE_WAIT(server_conn->writable(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return client_conn->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return server_conn->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
SentPacketCounter client_counter(client.get());
SentPacketCounter server_counter(server.get());
@@ -267,8 +306,14 @@
client_conn->Send(&kData, sizeof(kData), rtc::PacketOptions());
server_conn->Send(&kData, sizeof(kData), rtc::PacketOptions());
}
- EXPECT_EQ_WAIT(10, client_counter.sent_packets(), kTimeout);
- EXPECT_EQ_WAIT(10, server_counter.sent_packets(), kTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return client_counter.sent_packets(); }, Eq(10),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return server_counter.sent_packets(); }, Eq(10),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
}
// Test that SignalSentPacket is fired when a packet is successfully sent, even
@@ -287,7 +332,10 @@
Connection* client_conn =
client->CreateConnection(server->Candidates()[0], Port::ORIGIN_MESSAGE);
ASSERT_NE(nullptr, client_conn);
- ASSERT_TRUE_WAIT(client_conn->connected(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return client_conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Need to get the port of the actual outgoing socket.
cricket::Candidate client_candidate = client->Candidates()[0];
@@ -297,10 +345,16 @@
client_candidate.set_tcptype("");
Connection* server_conn =
server->CreateConnection(client_candidate, Port::ORIGIN_THIS_PORT);
- ASSERT_TRUE_WAIT(server_conn->connected(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return server_conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_FALSE(client_conn->writable());
client_conn->Ping(rtc::TimeMillis());
- ASSERT_TRUE_WAIT(client_conn->writable(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return client_conn->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
SentPacketCounter client_counter(client.get());
static const char kData[] = "hello";
@@ -310,7 +364,10 @@
// Deleting the server port should break the current connection.
server = nullptr;
server_conn = nullptr;
- ASSERT_TRUE_WAIT(!client_conn->connected(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return !client_conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Recreate the server port with the same port number.
server = CreateTCPPort(kRemoteAddr, /*allow_listen=*/true, kServerPort);
@@ -321,7 +378,10 @@
// packet will be discarded.
result = client_conn->Send(&kData, sizeof(kData), rtc::PacketOptions());
EXPECT_EQ(result, SOCKET_ERROR);
- ASSERT_TRUE_WAIT(client_conn->connected(), kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return client_conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// For unknown reasons, connection is still supposed to be writable....
EXPECT_TRUE(client_conn->writable());
for (int i = 0; i < 10; ++i) {
@@ -330,7 +390,10 @@
SOCKET_ERROR);
}
// And are not reported as sent.
- EXPECT_EQ_WAIT(client_counter.sent_packets(), 1, kTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return client_counter.sent_packets(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Create the server connection again so server can reply to STUN pings.
// Client outgoing socket port will have changed since the client create a new
@@ -342,13 +405,22 @@
client_candidate.set_tcptype("");
server_conn =
server->CreateConnection(client_candidate, Port::ORIGIN_THIS_PORT);
- ASSERT_TRUE_WAIT(server_conn->connected(), kTimeout);
- EXPECT_EQ_WAIT(client_counter.sent_packets(), 1, kTimeout);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return server_conn->connected(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return client_counter.sent_packets(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Send Stun Binding request.
client_conn->Ping(rtc::TimeMillis());
// The Stun Binding request is reported as sent.
- EXPECT_EQ_WAIT(client_counter.sent_packets(), 2, kTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return client_counter.sent_packets(); }, Eq(2),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
// Wait a bit for the Stun response to be received.
rtc::Thread::Current()->ProcessMessages(100);
@@ -358,5 +430,8 @@
EXPECT_EQ(client_conn->Send(&kData, sizeof(kData), rtc::PacketOptions()),
6);
}
- EXPECT_EQ_WAIT(client_counter.sent_packets(), 2 + 5, kTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return client_counter.sent_packets(); }, Eq(2 + 5),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
}
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index d1f9709..f081529 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -7,10 +7,29 @@
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
+#include <cstddef>
#include <cstdint>
+#include <string>
+#include "absl/functional/any_invocable.h"
#include "api/array_view.h"
+#include "api/candidate.h"
+#include "api/test/mock_async_dns_resolver.h"
+#include "api/test/rtc_error_matchers.h"
+#include "api/transport/stun.h"
+#include "p2p/base/connection_info.h"
+#include "p2p/base/port.h"
+#include "p2p/base/port_interface.h"
+#include "p2p/base/stun_request.h"
+#include "p2p/client/relay_port_factory_interface.h"
+#include "rtc_base/async_packet_socket.h"
+#include "rtc_base/ip_address.h"
+#include "rtc_base/net_helpers.h"
+#include "rtc_base/network.h"
#include "rtc_base/network/received_packet.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
+#include "test/gmock.h"
+#include "test/wait_until.h"
#if defined(WEBRTC_POSIX)
#include <dirent.h>
@@ -54,6 +73,9 @@
using ::testing::_;
using ::testing::DoAll;
+using ::testing::Eq;
+using ::testing::IsTrue;
+using ::testing::Ne;
using ::testing::Return;
using ::testing::ReturnPointee;
using ::testing::SetArgPointee;
@@ -384,12 +406,19 @@
// turn_port_ should have been created.
ASSERT_TRUE(turn_port_ != nullptr);
turn_port_->PrepareAddress();
- ASSERT_TRUE_SIMULATED_WAIT(
- turn_ready_, TimeToGetTurnCandidate(protocol_type), fake_clock_);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ TimeToGetTurnCandidate(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
CreateUdpPort();
udp_port_->PrepareAddress();
- ASSERT_TRUE_SIMULATED_WAIT(udp_ready_, kSimulatedRtt, fake_clock_);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return udp_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
}
// Returns the fake clock time to establish a connection over the given
@@ -453,7 +482,11 @@
void TestTurnAllocateSucceeds(unsigned int timeout) {
ASSERT_TRUE(turn_port_);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, timeout, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(timeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, turn_port_->Candidates().size());
EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
turn_port_->Candidates()[0].address().ipaddr());
@@ -464,8 +497,11 @@
absl::string_view expected_url) {
ASSERT_TRUE(turn_port_);
turn_port_->PrepareAddress();
- ASSERT_TRUE_SIMULATED_WAIT(
- turn_ready_, TimeToGetTurnCandidate(protocol_type), fake_clock_);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ TimeToGetTurnCandidate(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, turn_port_->Candidates().size());
EXPECT_EQ(turn_port_->Candidates()[0].url(), expected_url);
}
@@ -486,9 +522,12 @@
const SocketAddress old_addr = turn_port_->server_address().address;
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_,
- TimeToGetAlternateTurnCandidate(protocol_type),
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ TimeToGetAlternateTurnCandidate(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Retrieve the address again, the turn port's address should be
// changed.
const SocketAddress new_addr = turn_port_->server_address().address;
@@ -511,8 +550,12 @@
turn_port_->PrepareAddress();
// Need time to connect to TURN server, send Allocate request and receive
// redirect notice.
- EXPECT_TRUE_SIMULATED_WAIT(
- turn_error_, kSimulatedRtt + TimeToConnect(protocol_type), fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ kSimulatedRtt + TimeToConnect(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
}
void TestTurnAlternateServerPingPong(ProtocolType protocol_type) {
@@ -529,9 +572,12 @@
ProtocolAddress(kTurnIntAddr, protocol_type));
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_error_,
- TimeToGetAlternateTurnCandidate(protocol_type),
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ TimeToGetAlternateTurnCandidate(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(0U, turn_port_->Candidates().size());
rtc::SocketAddress address;
// Verify that we have exhausted all alternate servers instead of
@@ -553,9 +599,12 @@
ProtocolAddress(kTurnIntAddr, protocol_type));
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_error_,
- TimeToGetAlternateTurnCandidate(protocol_type),
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ TimeToGetAlternateTurnCandidate(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(0U, turn_port_->Candidates().size());
}
@@ -593,8 +642,11 @@
ProtocolAddress(server_address, protocol_type));
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(
- turn_error_, TimeToGetTurnCandidate(protocol_type), fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(
+ TimeToGetTurnCandidate(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Wait for some extra time, and make sure no packets were received on the
// loopback port we created (or in the case of TCP, no connection attempt
@@ -629,21 +681,32 @@
Connection* conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
Port::ORIGIN_MESSAGE);
ASSERT_TRUE(conn2 != NULL);
- ASSERT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
- fake_clock_);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turn_create_permission_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
conn2->Ping(0);
// Two hops from TURN port to UDP port through TURN server, thus two RTTs.
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn2->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(conn1->receiving());
EXPECT_TRUE(conn2->receiving());
EXPECT_EQ(Connection::STATE_WRITE_INIT, conn1->write_state());
// Send another ping from UDP to TURN.
conn1->Ping(0);
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn1->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(conn2->receiving());
}
@@ -661,12 +724,19 @@
turn_port_->set_timeout_delay(10 * 60 * 1000);
ASSERT_TRUE(conn2 != NULL);
- ASSERT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
- fake_clock_);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turn_create_permission_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Make sure turn connection can receive.
conn1->Ping(0);
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn1->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_FALSE(turn_unknown_address_);
// Destroy the connection on the TURN port. The TurnEntry still exists, so
@@ -674,8 +744,11 @@
turn_port_->DestroyConnection(conn2);
conn1->Ping(0);
- EXPECT_TRUE_SIMULATED_WAIT(turn_unknown_address_, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_unknown_address_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Wait for TurnEntry to expire. Timeout is 5 minutes.
// Expect that it still processes an incoming ping and signals the
@@ -707,14 +780,21 @@
conn1->set_remote_password_for_test(pwd);
conn1->Ping(0);
- EXPECT_TRUE_SIMULATED_WAIT(turn_unknown_address_, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_unknown_address_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// If the connection is created again, it will start to receive pings.
conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
Port::ORIGIN_MESSAGE);
conn1->Ping(0);
- EXPECT_TRUE_SIMULATED_WAIT(conn2->receiving(), kSimulatedRtt, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return conn2->receiving(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
}
void TestTurnSendData(ProtocolType protocol_type) {
@@ -742,11 +822,19 @@
conn2->SignalDestroyed.connect(this,
&TurnPortTest::OnConnectionSignalDestroyed);
conn1->Ping(0);
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn1->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
conn2->Ping(0);
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn2->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Send some data.
size_t num_packets = 256;
@@ -774,8 +862,12 @@
void TestTurnReleaseAllocation(ProtocolType protocol_type) {
PrepareTurnAndUdpPorts(protocol_type);
turn_port_.reset();
- EXPECT_EQ_SIMULATED_WAIT(0U, turn_server_.server()->allocations().size(),
- kSimulatedRtt, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return turn_server_.server()->allocations().size(); }, Eq(0U),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
}
// Test that the TURN allocation is released by sending a refresh request
@@ -806,11 +898,19 @@
&TurnPortTest::OnConnectionSignalDestroyed);
conn1->Ping(0);
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn1->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
conn2->Ping(0);
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn2->write_state(); },
+ Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Send some data from Udp to TurnPort.
unsigned char buf[256] = {0};
@@ -821,7 +921,11 @@
turn_port_->Release();
// Wait for the TurnPort to signal closed.
- ASSERT_TRUE_SIMULATED_WAIT(turn_port_closed_, kSimulatedRtt, fake_clock_);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return turn_port_closed_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// But the data should have arrived first.
ASSERT_EQ(1ul, turn_packets_.size());
@@ -908,7 +1012,10 @@
// As VSS doesn't provide DNS resolution, name resolve will fail,
// the error will be set and contain the url.
turn_port_->PrepareAddress();
- EXPECT_TRUE_WAIT(turn_error_, kResolverTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kResolverTimeout)}),
+ webrtc::IsRtcOk());
std::string server_url =
"turn:" + kTurnInvalidAddr.ToString() + "?transport=udp";
ASSERT_EQ(error_event_.url, server_url);
@@ -963,10 +1070,18 @@
TEST_F(TurnPortTest, TestTurnBadCredentials) {
CreateTurnPort(kTurnUsername, "bad", kTurnUdpProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(0U, turn_port_->Candidates().size());
- EXPECT_EQ_SIMULATED_WAIT(error_event_.error_code, STUN_ERROR_UNAUTHORIZED,
- kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return error_event_.error_code; }, Eq(STUN_ERROR_UNAUTHORIZED),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_EQ(error_event_.error_text, "Unauthorized");
}
@@ -975,7 +1090,11 @@
TEST_F(TurnPortTest, TestServerAddressFamilyMismatch) {
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpIPv6ProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(0U, turn_port_->Candidates().size());
EXPECT_EQ(0, error_event_.error_code);
}
@@ -986,7 +1105,11 @@
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
kTurnUdpProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(0U, turn_port_->Candidates().size());
EXPECT_EQ(0, error_event_.error_code);
}
@@ -1039,10 +1162,17 @@
// Shouldn't take more than 1 RTT to realize the bound address isn't the one
// expected.
- EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt, fake_clock_);
- EXPECT_EQ_SIMULATED_WAIT(error_event_.error_code,
- STUN_ERROR_SERVER_NOT_REACHABLE, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.error_code; },
+ Eq(STUN_ERROR_SERVER_NOT_REACHABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_NE(error_event_.error_text.find('.'), std::string::npos);
EXPECT_NE(error_event_.address.find(kLocalAddr2.HostAsSensitiveURIString()),
std::string::npos);
@@ -1074,7 +1204,11 @@
turn_port_->PrepareAddress();
// Candidate should be gathered as normally.
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, turn_port_->Candidates().size());
// Verify that the socket actually used the alternate address, otherwise this
@@ -1101,7 +1235,11 @@
turn_port_->PrepareAddress();
// Candidate should be gathered as normally.
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, turn_port_->Candidates().size());
}
@@ -1112,14 +1250,20 @@
CreateTurnPort(kTurnUsername, kTurnPassword,
ProtocolAddress(kTurnInvalidAddr, PROTO_TCP));
turn_port_->PrepareAddress();
- EXPECT_TRUE_WAIT(turn_error_, kResolverTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kResolverTimeout)}),
+ webrtc::IsRtcOk());
// As VSS doesn't provide DNS resolution, name resolve will fail. TurnPort
// will proceed in creating a TCP socket which will fail as there is no
// server on the above domain and error will be set to SOCKET_ERROR.
EXPECT_EQ(SOCKET_ERROR, turn_port_->error());
- EXPECT_EQ_SIMULATED_WAIT(error_event_.error_code,
- STUN_ERROR_SERVER_NOT_REACHABLE, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.error_code; },
+ Eq(STUN_ERROR_SERVER_NOT_REACHABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
std::string server_url =
"turn:" + kTurnInvalidAddr.ToString() + "?transport=tcp";
ASSERT_EQ(error_event_.url, server_url);
@@ -1132,7 +1276,10 @@
CreateTurnPort(kTurnUsername, kTurnPassword,
ProtocolAddress(kTurnInvalidAddr, PROTO_TLS));
turn_port_->PrepareAddress();
- EXPECT_TRUE_WAIT(turn_error_, kResolverTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kResolverTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_EQ(SOCKET_ERROR, turn_port_->error());
}
@@ -1142,7 +1289,10 @@
CreateTurnPort(kTurnUsername, kTurnPassword,
ProtocolAddress(kTurnInvalidAddr, PROTO_UDP));
turn_port_->PrepareAddress();
- EXPECT_TRUE_WAIT(turn_error_, kResolverTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kResolverTimeout)}),
+ webrtc::IsRtcOk());
// Error from turn port will not be socket error.
EXPECT_NE(SOCKET_ERROR, turn_port_->error());
}
@@ -1151,7 +1301,11 @@
TEST_F(TurnPortTest, TestTurnAllocateBadPassword) {
CreateTurnPort(kTurnUsername, "bad", kTurnUdpProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(0U, turn_port_->Candidates().size());
}
@@ -1161,7 +1315,11 @@
// Do a normal allocation first.
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Destroy the turnport while keeping the drop probability to 1 to
// suppress the release of the allocation at the server.
@@ -1187,7 +1345,11 @@
// Four round trips; first we'll get "stale nonce", then
// "allocate mismatch", then "stale nonce" again, then finally it will
// succeed.
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 4, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 4),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_NE(first_nonce, turn_port_->nonce());
}
@@ -1197,7 +1359,11 @@
// Do a normal allocation first.
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Clear connected_ flag on turnport to suppress the release of
@@ -1217,7 +1383,11 @@
// Four round trips; first we'll get "stale nonce", then
// "allocate mismatch", then "stale nonce" again, then finally it will
// succeed.
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 4, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 4),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Verifies that the new port has a different address now.
EXPECT_NE(first_addr, turn_port_->socket()->GetLocalAddress());
@@ -1237,7 +1407,11 @@
// Do a normal allocation first.
CreateSharedTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Clear connected_ flag on turnport to suppress the release of
@@ -1253,7 +1427,11 @@
turn_port_->PrepareAddress();
// Extra 2 round trips due to allocate mismatch.
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 4, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 4),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Verifies that the new port has a different address now.
EXPECT_NE(first_addr, turn_port_->socket()->GetLocalAddress());
@@ -1266,7 +1444,11 @@
// Do a normal allocation first.
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Clear connected_ flag on turnport to suppress the release of
@@ -1284,7 +1466,11 @@
EXPECT_EQ(first_addr, turn_port_->socket()->GetLocalAddress());
// Extra 2 round trips due to allocate mismatch.
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 5, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 5),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Verifies that the new port has a different address now.
EXPECT_NE(first_addr, turn_port_->socket()->GetLocalAddress());
@@ -1303,11 +1489,18 @@
// When this succeeds, it will schedule a new RefreshRequest with the bad
// credential.
turn_port_->request_manager().FlushForTest(TURN_REFRESH_REQUEST);
- EXPECT_TRUE_SIMULATED_WAIT(turn_refresh_success_, kSimulatedRtt, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return turn_refresh_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Flush it again, it will receive a bad response.
turn_port_->request_manager().FlushForTest(TURN_REFRESH_REQUEST);
- EXPECT_TRUE_SIMULATED_WAIT(!turn_refresh_success_, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !turn_refresh_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_FALSE(turn_port_->connected());
EXPECT_TRUE(CheckAllConnectionsFailedAndPruned());
EXPECT_FALSE(turn_port_->HasRequests());
@@ -1326,8 +1519,12 @@
ASSERT_TRUE(conn2 != NULL);
// Make sure conn2 is writable.
conn2->Ping(0);
- EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
- kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return conn2->write_state(); }, Eq(Connection::STATE_WRITABLE),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
turn_port_->CloseForTest();
SIMULATED_WAIT(false, kSimulatedRtt, fake_clock_);
@@ -1367,8 +1564,12 @@
EXPECT_NE(nullptr, conn);
EXPECT_TRUE(!turn_port_->connections().empty());
turn_port_->socket()->NotifyClosedForTest(1);
- EXPECT_TRUE_SIMULATED_WAIT(turn_port_->connections().empty(),
- kConnectionDestructionDelay, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return turn_port_->connections().empty(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kConnectionDestructionDelay),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
}
// Test try-alternate-server feature.
@@ -1511,8 +1712,11 @@
Connection* conn = turn_port_->CreateConnection(udp_port_->Candidates()[0],
Port::ORIGIN_MESSAGE);
ASSERT_TRUE(conn != NULL);
- EXPECT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_create_permission_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
turn_create_permission_success_ = false;
// A create-permission-request should be pending.
// After the next create-permission-response is received, it will schedule
@@ -1520,12 +1724,18 @@
RelayCredentials bad_credentials("bad_user", "bad_pwd");
turn_port_->set_credentials(bad_credentials);
turn_port_->request_manager().FlushForTest(kAllRequestsForTest);
- EXPECT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_create_permission_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Flush the requests again; the create-permission-request will fail.
turn_port_->request_manager().FlushForTest(kAllRequestsForTest);
- EXPECT_TRUE_SIMULATED_WAIT(!turn_create_permission_success_, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !turn_create_permission_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(CheckConnectionFailedAndPruned(conn));
}
@@ -1540,7 +1750,11 @@
ASSERT_TRUE(conn2 != nullptr);
conn1->Ping(0);
- EXPECT_TRUE_SIMULATED_WAIT(conn1->writable(), kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return conn1->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Tell the TURN server to reject all bind requests from now on.
turn_server_.server()->set_reject_bind_requests(true);
@@ -1548,8 +1762,12 @@
std::string data = "ABC";
conn1->Send(data.data(), data.length(), options);
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnectionFailedAndPruned(conn1),
- kSimulatedRtt, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return CheckConnectionFailedAndPruned(conn1); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Verify that packets are allowed to be sent after a bind request error.
// They'll just use a send indication instead.
@@ -1561,7 +1779,11 @@
rtc::Buffer(packet.payload().data(), packet.payload().size()));
});
conn1->Send(data.data(), data.length(), options);
- EXPECT_TRUE_SIMULATED_WAIT(!udp_packets_.empty(), kSimulatedRtt, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return !udp_packets_.empty(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
conn2->DeregisterReceivedPacketCallback();
}
@@ -1597,7 +1819,11 @@
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
kTurnUdpProtoAddr);
turn_port_->PrepareAddress();
- ASSERT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt, fake_clock_);
+ ASSERT_THAT(
+ webrtc::WaitUntil([&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(turn_port_->Candidates().empty());
}
@@ -1621,7 +1847,11 @@
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
kTurnUdpIPv6ProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
ASSERT_EQ(1U, turn_port_->Candidates().size());
// Create an IPv4 candidate. It will match the TURN candidate.
@@ -1647,11 +1877,19 @@
turn_server_.server()->set_reject_private_addresses(true);
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
turn_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return turn_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
CreateUdpPort(SocketAddress("10.0.0.10", 0));
udp_port_->PrepareAddress();
- EXPECT_TRUE_SIMULATED_WAIT(udp_ready_, kSimulatedRtt, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return udp_ready_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Create a connection.
TestConnectionWrapper conn(turn_port_->CreateConnection(
udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE));
@@ -1659,10 +1897,18 @@
// Asynchronously, CreatePermission request should be sent and fail, which
// will make the connection pruned and failed.
- EXPECT_TRUE_SIMULATED_WAIT(CheckConnectionFailedAndPruned(conn.connection()),
- kSimulatedRtt, fake_clock_);
- EXPECT_TRUE_SIMULATED_WAIT(!turn_create_permission_success_, kSimulatedRtt,
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return CheckConnectionFailedAndPruned(conn.connection()); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return !turn_create_permission_success_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Check that the connection is not deleted asynchronously.
SIMULATED_WAIT(conn.connection() == nullptr, kConnectionDestructionDelay,
fake_clock_);
@@ -1730,12 +1976,17 @@
CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
ProtocolAddress(kTurnInvalidAddr, PROTO_UDP));
turn_port_->PrepareAddress();
- ASSERT_TRUE_WAIT(turn_error_, kResolverTimeout);
+ ASSERT_THAT(webrtc::WaitUntil(
+ [&] { return turn_error_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kResolverTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(turn_port_->Candidates().empty());
turn_port_.reset();
rtc::Thread::Current()->PostTask([this] { test_finish_ = true; });
// Waiting for above message to be processed.
- ASSERT_TRUE_SIMULATED_WAIT(test_finish_, 1, fake_clock_);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return test_finish_; }, IsTrue(),
+ {.clock = &fake_clock_}),
+ webrtc::IsRtcOk());
EXPECT_EQ(last_fd_count, GetFDCount());
}
#endif
@@ -1924,9 +2175,12 @@
turn_port_->PrepareAddress();
// This should result in an error event.
- EXPECT_TRUE_SIMULATED_WAIT(error_event_.error_code != 0,
- TimeToGetAlternateTurnCandidate(protocol_type),
- fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return error_event_.error_code; }, Ne(0),
+ {.timeout = webrtc::TimeDelta::Millis(
+ TimeToGetAlternateTurnCandidate(protocol_type)),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// but should NOT result in the port turning ready, and no candidates
// should be gathered.
EXPECT_FALSE(turn_ready_);
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index e68013e..1026122 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -10,12 +10,24 @@
#include "p2p/client/basic_port_allocator.h"
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
#include <memory>
+#include <string>
+#include <vector>
#include "absl/algorithm/container.h"
#include "absl/strings/string_view.h"
+#include "api/candidate.h"
+#include "api/test/rtc_error_matchers.h"
+#include "api/transport/enums.h"
+#include "api/units/time_delta.h"
#include "p2p/base/basic_packet_socket_factory.h"
#include "p2p/base/p2p_constants.h"
+#include "p2p/base/port.h"
+#include "p2p/base/port_allocator.h"
+#include "p2p/base/port_interface.h"
#include "p2p/base/stun_port.h"
#include "p2p/base/stun_request.h"
#include "p2p/base/stun_server.h"
@@ -32,24 +44,26 @@
#include "rtc_base/nat_socket_factory.h"
#include "rtc_base/nat_types.h"
#include "rtc_base/net_helper.h"
-#include "rtc_base/net_helpers.h"
#include "rtc_base/net_test_helpers.h"
#include "rtc_base/network.h"
#include "rtc_base/network_constants.h"
#include "rtc_base/network_monitor.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
-#include "rtc_base/socket_address_pair.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h"
#include "system_wrappers/include/metrics.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
+#include "test/wait_until.h"
using rtc::IPAddress;
using rtc::SocketAddress;
using testing::Contains;
+using ::testing::Eq;
+using ::testing::IsTrue;
using testing::Not;
using webrtc::IceCandidateType;
@@ -532,8 +546,12 @@
PORTALLOCATOR_ENABLE_SHARED_SOCKET);
allocator().set_allow_tcp_listen(false);
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
uint32_t total_candidates = 0;
if (!host_candidate_addr.IsNil()) {
@@ -591,8 +609,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Three ports (one IPv4 STUN, one IPv6 STUN and one TURN) will be ready.
EXPECT_EQ(3U, session_->ReadyPorts().size());
EXPECT_EQ(3U, ports_.size());
@@ -635,8 +657,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Only 2 ports (one STUN and one TURN) are actually being used.
EXPECT_EQ(2U, session_->ReadyPorts().size());
// We have verified that each port, when it is added to `ports_`, it is
@@ -693,8 +719,12 @@
PORTALLOCATOR_ENABLE_IPV6 | PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// 10 ports (4 STUN and 1 TURN ports on each interface) will be ready to
// use.
EXPECT_EQ(10U, session_->ReadyPorts().size());
@@ -773,8 +803,12 @@
session_->set_flags(PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY |
PORTALLOCATOR_DISABLE_TCP);
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(4U, candidates_.size());
for (const Candidate& candidate : candidates_) {
EXPECT_LT(candidate.address().ip(), 0x12345604U);
@@ -795,8 +829,12 @@
session_->set_flags(PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY |
PORTALLOCATOR_DISABLE_TCP);
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, candidates_.size());
EXPECT_EQ(0x12345602U, candidates_[0].address().ip());
}
@@ -816,8 +854,12 @@
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Should only get one Wi-Fi candidate.
EXPECT_EQ(1U, candidates_.size());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kHost, "udp", wifi));
@@ -842,8 +884,12 @@
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Should only get two candidates, none of which is cell.
EXPECT_EQ(2U, candidates_.size());
EXPECT_TRUE(
@@ -872,8 +918,12 @@
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Should only get one Wi-Fi candidate.
EXPECT_EQ(1U, candidates_.size());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kHost, "udp", wifi));
@@ -893,8 +943,12 @@
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Make sure we got the cell candidate.
EXPECT_EQ(1U, candidates_.size());
EXPECT_TRUE(
@@ -917,8 +971,12 @@
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Make sure we got both wifi and cell candidates.
EXPECT_EQ(2U, candidates_.size());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kHost, "udp",
@@ -946,8 +1004,12 @@
cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Make sure we got only wifi candidates.
EXPECT_EQ(2U, candidates_.size());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kHost, "udp", wifi));
@@ -968,8 +1030,12 @@
PORTALLOCATOR_DISABLE_TCP);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// The VPN tap0 network should be filtered out as a costly network, and we
// should have a UDP port and a STUN port from the Ethernet eth0.
ASSERT_EQ(2U, ports_.size());
@@ -993,8 +1059,12 @@
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, candidates_.size());
// Ensure the expected two interfaces (eth0 and eth1) were used.
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kHost, "udp",
@@ -1020,8 +1090,12 @@
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
// Ensure that only one IPv6 interface was used, but both IPv4 interfaces
// were used.
@@ -1041,8 +1115,12 @@
session_->set_flags(PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY |
PORTALLOCATOR_DISABLE_TCP);
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, candidates_.size());
}
@@ -1051,8 +1129,12 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(3U, ports_.size());
EXPECT_TRUE(
@@ -1071,8 +1153,12 @@
AddInterface(kClientAddr, if_name);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(3U, ports_.size());
candidate_allocation_done_ = false;
@@ -1095,8 +1181,12 @@
fss_->set_tcp_sockets_enabled(true);
fss_->set_udp_sockets_enabled(true);
AddInterface(kClientAddr, if_name);
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(3U, ports_.size());
}
@@ -1109,8 +1199,12 @@
AddInterface(kClientAddr, if_name);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(3U, ports_.size());
session_->StopGettingPorts();
@@ -1147,8 +1241,12 @@
fss_->set_udp_sockets_enabled(false);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Make sure we actually prevented candidates from being gathered (other than
// a single TCP active candidate, since that doesn't require creating a
// socket).
@@ -1162,8 +1260,12 @@
fss_->set_tcp_sockets_enabled(true);
fss_->set_udp_sockets_enabled(true);
AddInterface(kClientAddr, if_name);
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Should get UDP and TCP candidate.
ASSERT_EQ(2U, candidates_.size());
EXPECT_TRUE(
@@ -1181,12 +1283,18 @@
allocator_->set_step_delay(kDefaultStepDelay);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), 1000, fake_clock);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return candidates_.size(); }, Eq(2U),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, ports_.size());
- ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), 2000, fake_clock);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return candidates_.size(); }, Eq(3U),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, ports_.size());
- ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), 1500, fake_clock);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return candidates_.size(); }, Eq(3U),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "tcp", kClientAddr));
EXPECT_EQ(3U, ports_.size());
@@ -1199,8 +1307,12 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP, CN_VIDEO));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
// If we Stop gathering now, we shouldn't get a second "done" callback.
session_->StopGettingPorts();
@@ -1215,12 +1327,20 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(2U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, ports_.size());
session_->StopGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
// Test that we restrict client ports appropriately when a port range is set.
@@ -1236,8 +1356,12 @@
EXPECT_TRUE(SetPortRange(kMinPort, kMaxPort));
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(3U, ports_.size());
@@ -1263,8 +1387,12 @@
AddTurnServers(kTurnUdpIntIPv6Addr, kTurnTcpIntIPv6Addr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(4U, ports_.size());
EXPECT_EQ(1,
CountPorts(ports_, IceCandidateType::kSrflx, PROTO_UDP, kAnyAddr));
@@ -1406,8 +1534,12 @@
PORTALLOCATOR_ENABLE_SHARED_SOCKET);
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Expect to see 2 ports and 2 candidates - TURN/TCP and TCP ports, TCP and
// TURN/TCP candidates.
@@ -1430,7 +1562,9 @@
session_->set_flags(PORTALLOCATOR_DISABLE_UDP | PORTALLOCATOR_DISABLE_STUN |
PORTALLOCATOR_DISABLE_RELAY | PORTALLOCATOR_DISABLE_TCP);
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_, 1000, fake_clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return candidate_allocation_done_; },
+ IsTrue(), {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(0U, candidates_.size());
}
@@ -1440,8 +1574,12 @@
fss_->set_udp_sockets_enabled(false);
ASSERT_TRUE(CreateSession(1));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, candidates_.size());
EXPECT_EQ(1U, ports_.size());
EXPECT_TRUE(
@@ -1457,8 +1595,12 @@
fss_->set_tcp_listen_enabled(false);
ASSERT_TRUE(CreateSession(1));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, candidates_.size());
EXPECT_EQ(1U, ports_.size());
EXPECT_TRUE(
@@ -1473,7 +1615,7 @@
fss_->set_udp_sockets_enabled(false);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- SIMULATED_WAIT(candidates_.size() > 0, 2000, fake_clock);
+ SIMULATED_WAIT(!candidates_.empty(), 2000, fake_clock);
// TODO(deadbeef): Check candidate_allocation_done signal.
// In case of Relay, ports creation will succeed but sockets will fail.
// There is no error reporting from RelayEntry to handle this failure.
@@ -1485,8 +1627,12 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_EQ_SIMULATED_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(2U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, ports_.size());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
@@ -1494,8 +1640,12 @@
HasCandidate(candidates_, IceCandidateType::kHost, "tcp", kClientAddr));
// We wait at least for a full STUN timeout, which
// cricket::STUN_TOTAL_TIMEOUT seconds.
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- cricket::STUN_TOTAL_TIMEOUT, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(cricket::STUN_TOTAL_TIMEOUT),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// No additional (STUN) candidates.
EXPECT_EQ(2U, candidates_.size());
}
@@ -1509,8 +1659,12 @@
PORTALLOCATOR_DISABLE_RELAY);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(2U, candidates_.size());
EXPECT_EQ(2U, ports_.size());
// Candidates priorities should be different.
@@ -1522,8 +1676,12 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(3U, ports_.size());
// TODO(deadbeef): Extend this to verify ICE restart.
@@ -1541,8 +1699,12 @@
session_->StartGettingPorts();
// 7 candidates and 4 ports is what we would normally get (see the
// TestGetAllPorts* tests).
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_EQ(3U, ports_.size());
}
@@ -1559,8 +1721,12 @@
allocator().SetCandidateFilter(CF_RELAY);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kRelay, "udp",
rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
@@ -1578,8 +1744,12 @@
allocator().SetCandidateFilter(CF_HOST);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, candidates_.size()); // Host UDP/TCP candidates only.
EXPECT_EQ(2U, ports_.size()); // UDP/TCP ports only.
for (const Candidate& candidate : candidates_) {
@@ -1596,8 +1766,12 @@
allocator().SetCandidateFilter(CF_REFLEXIVE);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Host is behind NAT, no private address will be exposed. Hence only UDP
// port with STUN candidate will be sent outside.
EXPECT_EQ(1U, candidates_.size()); // Only STUN candidate.
@@ -1615,8 +1789,12 @@
allocator().SetCandidateFilter(CF_REFLEXIVE);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Host has a public address, both UDP and TCP candidates will be exposed.
EXPECT_EQ(2U, candidates_.size()); // Local UDP + TCP candidate.
EXPECT_EQ(2U, ports_.size()); // UDP and TCP ports will be in ready state.
@@ -1630,8 +1808,12 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
@@ -1656,13 +1838,21 @@
PORTALLOCATOR_ENABLE_SHARED_SOCKET);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(2U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, ports_.size());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
// Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port
@@ -1676,15 +1866,23 @@
PORTALLOCATOR_ENABLE_SHARED_SOCKET);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(3U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(2U, ports_.size());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kSrflx, "udp",
rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
}
@@ -1705,8 +1903,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
ASSERT_EQ(3U, candidates_.size());
ASSERT_EQ(3U, ports_.size());
EXPECT_TRUE(
@@ -1845,7 +2047,11 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_EQ_WAIT(2U, ports_.size(), kDefaultAllocationTimeout);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ports_.size(); }, Eq(2U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout)}),
+ webrtc::IsRtcOk());
}
// Test that when PORTALLOCATOR_ENABLE_SHARED_SOCKET is enabled only one port
@@ -1864,8 +2070,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
ASSERT_EQ(2U, ports_.size());
EXPECT_TRUE(
@@ -1874,8 +2084,12 @@
rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kRelay, "udp",
rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Local port will be created first and then TURN port.
// TODO(deadbeef): This isn't something the BasicPortAllocator API contract
// guarantees...
@@ -1904,8 +2118,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
@@ -1941,8 +2159,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, candidates_.size());
ASSERT_EQ(2U, ports_.size());
EXPECT_TRUE(
@@ -1969,8 +2191,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
ASSERT_EQ(3U, ports_.size());
EXPECT_TRUE(
@@ -2009,8 +2235,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(3U, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(3U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
Candidate stun_candidate;
@@ -2037,14 +2267,21 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(1U, ports_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ports_.size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, candidates_.size());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
// STUN timeout is 9.5sec. We need to wait to get candidate done signal.
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_, kStunTimeoutMs,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil([&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kStunTimeoutMs),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, candidates_.size());
}
@@ -2064,8 +2301,12 @@
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
EXPECT_EQ(0U, session_->flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION);
session_->StartGettingPorts();
- EXPECT_EQ_SIMULATED_WAIT(1U, ports_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return ports_.size(); }, Eq(1U),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(1U, candidates_.size());
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kPrivateAddr));
@@ -2082,8 +2323,12 @@
allocator_->set_step_delay(kMinimumStepDelay);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(4U, ports_.size());
EXPECT_EQ(4U, candidates_.size());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kHost, "udp",
@@ -2101,10 +2346,14 @@
allocator_->set_step_delay(kDefaultStepDelay);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), 1000, fake_clock);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return candidates_.size(); }, Eq(2U),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, ports_.size());
session_->StopGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_, 1000, fake_clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return candidate_allocation_done_; },
+ IsTrue(), {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
// After stopping getting ports, adding a new interface will not start
// getting ports again.
@@ -2123,10 +2372,14 @@
allocator_->set_step_delay(kDefaultStepDelay);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), 1000, fake_clock);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return candidates_.size(); }, Eq(2U),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, ports_.size());
session_->ClearGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_, 1000, fake_clock);
+ EXPECT_THAT(webrtc::WaitUntil([&] { return candidate_allocation_done_; },
+ IsTrue(), {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
// After clearing getting ports, adding a new interface will start getting
// ports again.
@@ -2135,10 +2388,16 @@
ports_.clear();
candidate_allocation_done_ = false;
network_manager_.AddInterface(kClientAddr2);
- ASSERT_EQ_SIMULATED_WAIT(2U, candidates_.size(), 1000, fake_clock);
+ ASSERT_THAT(webrtc::WaitUntil([&] { return candidates_.size(); }, Eq(2U),
+ {.clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, ports_.size());
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
}
// Test that the ports and candidates are updated with new ufrag/pwd/etc. when
@@ -2151,8 +2410,12 @@
webrtc::NO_PRUNE);
const PortAllocatorSession* peeked_session = allocator_->GetPooledSession();
ASSERT_NE(nullptr, peeked_session);
- EXPECT_EQ_SIMULATED_WAIT(true, peeked_session->CandidatesAllocationDone(),
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return peeked_session->CandidatesAllocationDone(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
// Expect that when TakePooledSession is called,
// UpdateTransportInformationInternal will be called and the
// BasicPortAllocatorSession will update the ufrag/pwd of ports and
@@ -2188,8 +2451,12 @@
webrtc::NO_PRUNE);
const PortAllocatorSession* peeked_session = allocator_->GetPooledSession();
ASSERT_NE(nullptr, peeked_session);
- EXPECT_EQ_SIMULATED_WAIT(true, peeked_session->CandidatesAllocationDone(),
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return peeked_session->CandidatesAllocationDone(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
size_t initial_candidates_size = peeked_session->ReadyCandidates().size();
size_t initial_ports_size = peeked_session->ReadyPorts().size();
allocator_->SetCandidateFilter(CF_RELAY);
@@ -2236,29 +2503,45 @@
allocator_->SetCandidateFilter(CF_NONE);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.empty());
EXPECT_TRUE(ports_.empty());
// Surface the relay candidate previously gathered but not signaled.
session_->SetCandidateFilter(CF_RELAY);
- ASSERT_EQ_SIMULATED_WAIT(1u, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.back().is_relay());
EXPECT_EQ(1u, ports_.size());
// Surface the srflx candidate previously gathered but not signaled.
session_->SetCandidateFilter(CF_RELAY | CF_REFLEXIVE);
- ASSERT_EQ_SIMULATED_WAIT(2u, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(2u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.back().is_stun());
EXPECT_EQ(2u, ports_.size());
// Surface the srflx candidate previously gathered but not signaled.
session_->SetCandidateFilter(CF_ALL);
- ASSERT_EQ_SIMULATED_WAIT(3u, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(3u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.back().is_local());
EXPECT_EQ(2u, ports_.size());
}
@@ -2286,29 +2569,45 @@
allocator_->SetCandidateFilter(CF_NONE);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.empty());
EXPECT_TRUE(ports_.empty());
// Surface the relay candidate previously gathered but not signaled.
session_->SetCandidateFilter(CF_RELAY);
- EXPECT_EQ_SIMULATED_WAIT(1u, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(1u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.back().is_relay());
EXPECT_EQ(1u, ports_.size());
// Surface the srflx candidate previously gathered but not signaled.
session_->SetCandidateFilter(CF_REFLEXIVE);
- EXPECT_EQ_SIMULATED_WAIT(2u, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(2u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.back().is_stun());
EXPECT_EQ(2u, ports_.size());
// Surface the host candidate previously gathered but not signaled.
session_->SetCandidateFilter(CF_HOST);
- EXPECT_EQ_SIMULATED_WAIT(3u, candidates_.size(), kDefaultAllocationTimeout,
- fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidates_.size(); }, Eq(3u),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_TRUE(candidates_.back().is_local());
// We use a shared socket and cricket::UDPPort handles the srflx candidate.
EXPECT_EQ(2u, ports_.size());
@@ -2331,8 +2630,12 @@
allocator_->SetCandidateFilter(CF_NONE);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
auto test_invariants = [this]() {
EXPECT_TRUE(candidates_.empty());
EXPECT_TRUE(ports_.empty());
@@ -2364,8 +2667,12 @@
webrtc::NO_PRUNE, nullptr, expected_stun_keepalive_interval);
auto* pooled_session = allocator_->GetPooledSession();
ASSERT_NE(nullptr, pooled_session);
- EXPECT_EQ_SIMULATED_WAIT(true, pooled_session->CandidatesAllocationDone(),
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return pooled_session->CandidatesAllocationDone(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
CheckStunKeepaliveIntervalOfAllReadyPorts(pooled_session,
expected_stun_keepalive_interval);
}
@@ -2379,8 +2686,12 @@
webrtc::NO_PRUNE, nullptr, 123 /* stun keepalive interval */);
auto* pooled_session = allocator_->GetPooledSession();
ASSERT_NE(nullptr, pooled_session);
- EXPECT_EQ_SIMULATED_WAIT(true, pooled_session->CandidatesAllocationDone(),
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return pooled_session->CandidatesAllocationDone(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
const int expected_stun_keepalive_interval = 321;
allocator_->SetConfiguration(
allocator_->stun_servers(), allocator_->turn_servers(), pool_size,
@@ -2401,8 +2712,12 @@
webrtc::NO_PRUNE, nullptr, expected_stun_keepalive_interval);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
CheckStunKeepaliveIntervalOfAllReadyPorts(session_.get(),
expected_stun_keepalive_interval);
}
@@ -2419,8 +2734,12 @@
webrtc::NO_PRUNE, nullptr, expected_stun_keepalive_interval);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
CheckStunKeepaliveIntervalOfAllReadyPorts(session_.get(),
expected_stun_keepalive_interval);
}
@@ -2442,8 +2761,12 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(5u, candidates_.size());
int num_host_udp_candidates = 0;
int num_host_tcp_candidates = 0;
@@ -2520,8 +2843,12 @@
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- ASSERT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ ASSERT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3u, candidates_.size());
EXPECT_GT((candidates_[0].priority() >> 8) & 0xFFFF,
(candidates_[1].priority() >> 8) & 0xFFFF);
@@ -2675,8 +3002,12 @@
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(2U, candidates_.size());
// ethe1 and wifi1 were selected.
@@ -2702,8 +3033,12 @@
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(3U, candidates_.size());
// ethe1, wifi1, and cell1 were selected.
@@ -2731,8 +3066,12 @@
ASSERT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
- EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
- kDefaultAllocationTimeout, fake_clock);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return candidate_allocation_done_; }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kDefaultAllocationTimeout),
+ .clock = &fake_clock}),
+ webrtc::IsRtcOk());
EXPECT_EQ(4U, candidates_.size());
// ethe1, ethe2, wifi1, and cell1 were selected.
diff --git a/p2p/dtls/dtls_transport_unittest.cc b/p2p/dtls/dtls_transport_unittest.cc
index 2eed02e..75a31bc 100644
--- a/p2p/dtls/dtls_transport_unittest.cc
+++ b/p2p/dtls/dtls_transport_unittest.cc
@@ -28,6 +28,7 @@
#include "api/crypto/crypto_options.h"
#include "api/dtls_transport_interface.h"
#include "api/scoped_refptr.h"
+#include "api/test/rtc_error_matchers.h"
#include "api/units/time_delta.h"
#include "p2p/base/fake_ice_transport.h"
#include "p2p/base/packet_transport_internal.h"
@@ -39,7 +40,6 @@
#include "rtc_base/checks.h"
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/fake_clock.h"
-#include "rtc_base/gunit.h"
#include "rtc_base/logging.h"
#include "rtc_base/network/received_packet.h"
#include "rtc_base/rtc_certificate.h"
@@ -48,7 +48,9 @@
#include "rtc_base/ssl_stream_adapter.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h"
+#include "test/gmock.h"
#include "test/gtest.h"
+#include "test/wait_until.h"
#define MAYBE_SKIP_TEST(feature) \
if (!(rtc::SSLStreamAdapter::feature())) { \
@@ -58,6 +60,9 @@
namespace cricket {
+using ::testing::Eq;
+using ::testing::IsTrue;
+
static const size_t kPacketNumOffset = 8;
static const size_t kPacketHeaderLen = 12;
static const int kFakePacketId = 0x1234;
@@ -380,9 +385,15 @@
Negotiate(client1_server);
EXPECT_TRUE(client1_.Connect(&client2_, false));
- EXPECT_TRUE_SIMULATED_WAIT(client1_.dtls_transport()->writable() &&
- client2_.dtls_transport()->writable(),
- kTimeout, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return client1_.dtls_transport()->writable() &&
+ client2_.dtls_transport()->writable();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
if (!client1_.dtls_transport()->writable() ||
!client2_.dtls_transport()->writable())
return false;
@@ -432,8 +443,11 @@
RTC_LOG(LS_INFO) << "Expect packets, size=" << size;
client2_.ExpectPackets(size);
client1_.SendPackets(size, count, srtp);
- EXPECT_EQ_SIMULATED_WAIT(count, client2_.NumPacketsReceived(), kTimeout,
- fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return client2_.NumPacketsReceived(); }, Eq(count),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
}
protected:
@@ -630,9 +644,15 @@
EXPECT_TRUE(client1_.Connect(&client2_, false));
- EXPECT_TRUE_SIMULATED_WAIT(client1_.dtls_transport()->writable() &&
- client2_.dtls_transport()->writable(),
- kTimeout, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return client1_.dtls_transport()->writable() &&
+ client2_.dtls_transport()->writable();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
client1_.fake_ice_transport()->set_packet_send_filter(nullptr);
client2_.fake_ice_transport()->set_packet_send_filter(nullptr);
@@ -842,9 +862,15 @@
Negotiate();
Negotiate();
EXPECT_TRUE(client1_.Connect(&client2_, false));
- EXPECT_TRUE_SIMULATED_WAIT(client1_.dtls_transport()->writable() &&
- client2_.dtls_transport()->writable(),
- kTimeout, fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] {
+ return client1_.dtls_transport()->writable() &&
+ client2_.dtls_transport()->writable();
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
TestTransfer(1000, 100, true);
}
@@ -905,11 +931,18 @@
// Make client2_ writable, but not client1_.
// This means client1_ will send DTLS client hellos but get no response.
EXPECT_TRUE(client2_.Connect(&client1_, true));
- EXPECT_TRUE_SIMULATED_WAIT(client2_.fake_ice_transport()->writable(),
- kTimeout, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return client2_.fake_ice_transport()->writable(); }, IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Wait for the first client hello to be sent.
- EXPECT_EQ_WAIT(1, client1_.received_dtls_client_hellos(), kTimeout);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return client1_.received_dtls_client_hellos(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout)}),
+ webrtc::IsRtcOk());
EXPECT_FALSE(client1_.fake_ice_transport()->writable());
static int timeout_schedule_ms[] = {50, 100, 200, 400, 800, 1600,
@@ -992,29 +1025,49 @@
break;
case CALLER_WRITABLE:
EXPECT_TRUE(client1_.Connect(&client2_, true));
- EXPECT_TRUE_SIMULATED_WAIT(client1_.fake_ice_transport()->writable(),
- kTimeout, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return client1_.fake_ice_transport()->writable(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
break;
case CALLER_RECEIVES_CLIENTHELLO:
// Sanity check that a ClientHello hasn't already been received.
EXPECT_EQ(0, client1_.received_dtls_client_hellos());
// Making client2_ writable will cause it to send the ClientHello.
EXPECT_TRUE(client2_.Connect(&client1_, true));
- EXPECT_TRUE_SIMULATED_WAIT(client2_.fake_ice_transport()->writable(),
- kTimeout, fake_clock_);
- EXPECT_EQ_SIMULATED_WAIT(1, client1_.received_dtls_client_hellos(),
- kTimeout, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return client2_.fake_ice_transport()->writable(); },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] { return client1_.received_dtls_client_hellos(); }, Eq(1),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
break;
case HANDSHAKE_FINISHES:
// Sanity check that the handshake hasn't already finished.
EXPECT_FALSE(client1_.dtls_transport()->IsDtlsConnected() ||
client1_.dtls_transport()->dtls_state() ==
webrtc::DtlsTransportState::kFailed);
- EXPECT_TRUE_SIMULATED_WAIT(
- client1_.dtls_transport()->IsDtlsConnected() ||
- client1_.dtls_transport()->dtls_state() ==
- webrtc::DtlsTransportState::kFailed,
- kTimeout, fake_clock_);
+ EXPECT_THAT(
+ webrtc::WaitUntil(
+ [&] {
+ return client1_.dtls_transport()->IsDtlsConnected() ||
+ client1_.dtls_transport()->dtls_state() ==
+ webrtc::DtlsTransportState::kFailed;
+ },
+ IsTrue(),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
break;
}
}
@@ -1022,12 +1075,18 @@
webrtc::DtlsTransportState expected_final_state =
valid_fingerprint ? webrtc::DtlsTransportState::kConnected
: webrtc::DtlsTransportState::kFailed;
- EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
- client1_.dtls_transport()->dtls_state(), kTimeout,
- fake_clock_);
- EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
- client2_.dtls_transport()->dtls_state(), kTimeout,
- fake_clock_);
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return client1_.dtls_transport()->dtls_state(); },
+ Eq(expected_final_state),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return client2_.dtls_transport()->dtls_state(); },
+ Eq(expected_final_state),
+ {.timeout = webrtc::TimeDelta::Millis(kTimeout),
+ .clock = &fake_clock_}),
+ webrtc::IsRtcOk());
// Transports should be writable iff there was a valid fingerprint.
EXPECT_EQ(valid_fingerprint, client1_.dtls_transport()->writable());
