Use GlobalSimulatedTimeController in PortTest Bug: webrtc:381524905,webrtc:42223992,webrtc:469327588 Change-Id: If4bb795c0ab03e889fbe71b968c4be786a6a6964 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/458301 Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org> Auto-Submit: Evan Shrubsole <eshr@webrtc.org> Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org> Cr-Commit-Position: refs/heads/main@{#47271}
diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn index a18edbb..bc12178 100644 --- a/p2p/BUILD.gn +++ b/p2p/BUILD.gn
@@ -1220,6 +1220,7 @@ "../rtc_base:timeutils", "../rtc_base/network:received_packet", "../rtc_base/network:sent_packet", + "../rtc_base/system:unused", "../system_wrappers:metrics", "../test:create_test_environment", "../test:create_test_field_trials",
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc index 82b005c..45d1d90 100644 --- a/p2p/base/port_unittest.cc +++ b/p2p/base/port_unittest.cc
@@ -25,7 +25,6 @@ #include "api/async_dns_resolver.h" #include "api/candidate.h" #include "api/environment/environment.h" -#include "api/environment/environment_factory.h" #include "api/field_trials.h" #include "api/packet_socket_factory.h" #include "api/test/mock_packet_socket_factory.h" @@ -56,8 +55,6 @@ #include "rtc_base/checks.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/logging.h" #include "rtc_base/net_helper.h" #include "rtc_base/network.h" @@ -65,12 +62,14 @@ #include "rtc_base/network_constants.h" #include "rtc_base/socket.h" #include "rtc_base/socket_address.h" +#include "rtc_base/system/unused.h" #include "rtc_base/thread.h" #include "rtc_base/virtual_socket_server.h" #include "test/create_test_environment.h" #include "test/create_test_field_trials.h" #include "test/gmock.h" #include "test/gtest.h" +#include "test/time_controller/simulated_time_controller.h" #include "test/wait_until.h" namespace webrtc { @@ -82,8 +81,8 @@ using ::testing::NotNull; using ::testing::Return; -constexpr int kDefaultTimeout = 3000; -constexpr int kShortTimeout = 1000; +constexpr TimeDelta kDefaultTimeout = TimeDelta::Millis(3000); +constexpr TimeDelta kShortTimeout = TimeDelta::Millis(1000); constexpr TimeDelta kMaxExpectedSimulatedRtt = TimeDelta::Millis(200); constexpr TimeDelta kEpsilon = TimeDelta::Millis(1); const SocketAddress kLocalAddr1("192.168.1.2", 0); @@ -132,7 +131,6 @@ return msg.Write(buf); } - bool GetStunMessageFromBufferWriter(TestPort* port, ByteBufferWriter* buf, const SocketAddress& addr, @@ -146,20 +144,22 @@ TestPort* lport, Connection* rconn, TestPort* rport, - ScopedFakeClock* clock, + GlobalSimulatedTimeController& time_controller, int64_t ms) { lconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller}), + IsRtcOk()); ASSERT_GT(lport->last_stun_buf().size(), 0u); rconn->OnReadPacket( ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt)); - clock->AdvanceTime(TimeDelta::Millis(ms)); - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + time_controller.AdvanceTime(TimeDelta::Millis(ms)); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller}), + IsRtcOk()); ASSERT_GT(rport->last_stun_buf().size(), 0u); lconn->OnReadPacket( ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt)); @@ -168,7 +168,9 @@ class TestChannel { public: // Takes ownership of `p1` (but not `p2`). - explicit TestChannel(std::unique_ptr<Port> p1) : port_(std::move(p1)) { + TestChannel(std::unique_ptr<Port> p1, + GlobalSimulatedTimeController& time_controller) + : time_controller_(time_controller), port_(std::move(p1)) { port_->SubscribePortComplete(this, [this](Port* port) { OnPortComplete(port); }); port_->SubscribeUnknownAddress( @@ -188,7 +190,10 @@ const SocketAddress& remote_address() { return remote_address_; } std::string remote_fragment() { return remote_frag_; } - void Start() { port_->PrepareAddress(); } + void Start() { + port_->PrepareAddress(); + time_controller_.AdvanceTime(TimeDelta::Zero()); + } void CreateConnection(const Candidate& remote_candidate) { RTC_DCHECK(!conn_); conn_ = port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE); @@ -298,6 +303,7 @@ connection_ready_to_send_ = true; } + GlobalSimulatedTimeController& time_controller_; IceMode ice_mode_ = ICEMODE_FULL; std::unique_ptr<Port> port_; @@ -314,14 +320,16 @@ public: PortTest() : ss_(new VirtualSocketServer()), - main_(ss_.get()), + time_controller_(Timestamp::Millis(1000), ss_.get()), + main_(time_controller_.GetMainThread()), + env_(CreateTestEnvironment({.time = &time_controller_})), socket_factory_(ss_.get()), nat_factory1_(ss_.get(), kNatAddr1, SocketAddress()), nat_factory2_(ss_.get(), kNatAddr2, SocketAddress()), nat_socket_factory1_(&nat_factory1_), nat_socket_factory2_(&nat_factory2_), - stun_server_(TestStunServer::Create(env_, kStunAddr, *ss_, main_)), - turn_server_(env_, &main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr), + stun_server_(TestStunServer::Create(env_, kStunAddr, *ss_, *main_)), + turn_server_(env_, main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr), username_(CreateRandomString(ICE_UFRAG_LENGTH)), password_(CreateRandomString(ICE_PWD_LENGTH)), role_conflict_(false), @@ -331,10 +339,13 @@ // Workaround for tests that trigger async destruction of objects that we // need to give an opportunity here to run, before proceeding with other // teardown. - Thread::Current()->ProcessMessages(0); + time_controller_.AdvanceTime(TimeDelta::Zero()); } protected: + VirtualSocketServer* vss() { return ss_.get(); } + const Environment& env() const { return env_; } + std::string password() { return password_; } void TestLocalToLocal() { @@ -442,7 +453,7 @@ std::unique_ptr<UDPPort> CreateUdpPort(const SocketAddress& addr, PacketSocketFactory* socket_factory) { auto port = UDPPort::Create({.env = env_, - .network_thread = &main_, + .network_thread = main_, .socket_factory = socket_factory, .network = MakeNetwork(addr), .ice_username_fragment = username_, @@ -458,7 +469,7 @@ PacketSocketFactory* socket_factory) { auto port = UDPPort::Create( {.env = env_, - .network_thread = &main_, + .network_thread = main_, .socket_factory = socket_factory, .network = MakeNetworkMultipleAddrs(global_addr, link_local_addr), .ice_username_fragment = username_, @@ -473,7 +484,7 @@ std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr, PacketSocketFactory* socket_factory) { auto port = TCPPort::Create({.env = env_, - .network_thread = &main_, + .network_thread = main_, .socket_factory = socket_factory, .network = MakeNetwork(addr), .ice_username_fragment = username_, @@ -488,7 +499,7 @@ ServerAddresses stun_servers; stun_servers.insert(kStunAddr); auto port = StunPort::Create({.env = env_, - .network_thread = &main_, + .network_thread = main_, .socket_factory = socket_factory, .network = MakeNetwork(addr), .ice_username_fragment = username_, @@ -520,7 +531,7 @@ config.credentials = kRelayCredentials; ProtocolAddress server_address(server_addr, int_proto); CreateRelayPortArgs args = {.env = env_}; - args.network_thread = &main_; + args.network_thread = main_; args.socket_factory = socket_factory; args.network = MakeNetwork(addr); args.username = username_; @@ -535,8 +546,8 @@ std::unique_ptr<NATServer> CreateNatServer(const SocketAddress& addr, NATType type) { - return std::make_unique<NATServer>(env_, type, main_, ss_.get(), addr, addr, - main_, ss_.get(), addr); + return std::make_unique<NATServer>(env_, type, *main_, ss_.get(), addr, + addr, *main_, ss_.get(), addr); } static const char* StunName(NATType type) { switch (type) { @@ -586,20 +597,23 @@ // TCP reconnecting mechanism before entering this function. void ConnectStartedChannels(TestChannel* ch1, TestChannel* ch2) { ASSERT_TRUE(ch1->conn()); - EXPECT_THAT(WaitUntil([&] { return ch1->conn()->connected(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); // for TCP connect + EXPECT_THAT( + WaitUntil([&] { return ch1->conn()->connected(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // for TCP connect ch1->Ping(); - EXPECT_TRUE(WaitUntil([&] { return !ch2->remote_address().IsNil(); }, - {.timeout = TimeDelta::Millis(kShortTimeout)})); + EXPECT_TRUE( + WaitUntil([&] { return !ch2->remote_address().IsNil(); }, + {.timeout = kShortTimeout, .clock = &time_controller_})); // Send a ping from dst to src. ch2->AcceptConnection(GetCandidate(ch1->port())); ch2->Ping(); - EXPECT_THAT(WaitUntil([&] { return ch2->conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch2->conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } // This connects and disconnects the provided channels in the same sequence as @@ -628,12 +642,14 @@ tcp_conn2->socket()->GetLocalAddress())); // Wait for both OnClose are delivered. - EXPECT_THAT(WaitUntil([&] { return !ch1->conn()->connected(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); - EXPECT_THAT(WaitUntil([&] { return !ch2->conn()->connected(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return !ch1->conn()->connected(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return !ch2->conn()->connected(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Ensure redundant SignalClose events on TcpConnection won't break tcp // reconnection. Chromium will fire SignalClose for all outstanding IPC @@ -644,9 +660,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_THAT(WaitUntil([&] { return ch2->conn(); }, IsNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch2->conn(); }, IsNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } void TestTcpReconnect(bool ping_after_disconnected, @@ -660,30 +677,32 @@ port2->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT); // Set up channels and ensure both ports will be deleted. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); EXPECT_EQ(0, ch1.complete_count()); EXPECT_EQ(0, ch2.complete_count()); ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Initial connecting the channel, create connection on channel1. ch1.CreateConnection(GetCandidate(ch2.port())); ConnectStartedChannels(&ch1, &ch2); // Shorten the timeout period. - const int kTcpReconnectTimeout = kDefaultTimeout; + const TimeDelta kTcpReconnectTimeout = kDefaultTimeout; static_cast<TCPConnection*>(ch1.conn()) - ->set_reconnection_timeout(kTcpReconnectTimeout); + ->set_reconnection_timeout(kTcpReconnectTimeout.ms()); static_cast<TCPConnection*>(ch2.conn()) - ->set_reconnection_timeout(kTcpReconnectTimeout); + ->set_reconnection_timeout(kTcpReconnectTimeout.ms()); EXPECT_FALSE(ch1.connection_ready_to_send()); EXPECT_FALSE(ch2.connection_ready_to_send()); @@ -705,15 +724,17 @@ } // Wait for channel's outgoing TCPConnection connected. - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Verify that we could still connect channels. ConnectStartedChannels(&ch1, &ch2); EXPECT_THAT( - WaitUntil([&] { return ch1.connection_ready_to_send(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kTcpReconnectTimeout)}), + WaitUntil( + [&] { return ch1.connection_ready_to_send(); }, IsTrue(), + {.timeout = kTcpReconnectTimeout, .clock = &time_controller_}), IsRtcOk()); // Channel2 is the passive one so a new connection is created during // reconnect. This new connection should never have issued ENOTCONN @@ -724,8 +745,8 @@ // Since the reconnection never happens, the connections should have been // destroyed after the timeout. EXPECT_THAT(WaitUntil([&] { return !ch1.conn(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kTcpReconnectTimeout + - kDefaultTimeout)}), + {.timeout = kTcpReconnectTimeout + kDefaultTimeout, + .clock = &time_controller_}), IsRtcOk()); EXPECT_TRUE(!ch2.conn()); } @@ -733,12 +754,14 @@ // Tear down and ensure that goes smoothly. ch1.Stop(); ch2.Stop(); - EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, IsNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); - EXPECT_THAT(WaitUntil([&] { return ch2.conn(); }, IsNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn(); }, IsNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch2.conn(); }, IsNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } std::unique_ptr<IceMessage> CreateStunMessage(StunMessageType type) { @@ -758,12 +781,14 @@ absl::string_view username, absl::string_view password, const FieldTrialsView* field_trials = nullptr) { - Port::PortParametersRef args = {.env = CreateEnvironment(field_trials), - .network_thread = &main_, - .socket_factory = &socket_factory_, - .network = MakeNetwork(addr), - .ice_username_fragment = username, - .ice_password = password}; + Port::PortParametersRef args = { + .env = CreateTestEnvironment( + {.field_trials = field_trials, .time = &time_controller_}), + .network_thread = main_, + .socket_factory = &socket_factory_, + .network = MakeNetwork(addr), + .ice_username_fragment = username, + .ice_password = password}; auto port = std::make_unique<TestPort>(args, 0, 0); port->SubscribeRoleConflict([this]() { OnRoleConflict(); }); return port; @@ -783,7 +808,7 @@ absl::string_view username, absl::string_view password) { Port::PortParametersRef args = {.env = env_, - .network_thread = &main_, + .network_thread = main_, .socket_factory = &socket_factory_, .network = network, .ice_username_fragment = username, @@ -796,7 +821,7 @@ std::unique_ptr<TestPort> CreateRawTestPort() { Port::PortParametersRef args = { .env = env_, - .network_thread = &main_, + .network_thread = main_, .socket_factory = &socket_factory_, .network = MakeNetwork(kLocalAddr1), }; @@ -818,18 +843,16 @@ return &nat_socket_factory1_; } - VirtualSocketServer* vss() { return ss_.get(); } + protected: + std::unique_ptr<VirtualSocketServer> ss_; + GlobalSimulatedTimeController time_controller_; + Thread* main_; + const Environment env_; - const Environment& env() const { return env_; } - - private: - const Environment env_ = CreateTestEnvironment(); // When a "create port" helper method is called with an IP, we create a // Network with that IP and add it to this list. Using a list instead of a // vector so that when it grows, pointers aren't invalidated. std::list<Network> networks_; - std::unique_ptr<VirtualSocketServer> ss_; - AutoSocketServerThread main_; BasicPacketSocketFactory socket_factory_; std::unique_ptr<NATServer> nat_server1_; std::unique_ptr<NATServer> nat_server2_; @@ -853,40 +876,43 @@ bool same_addr1, bool same_addr2, bool possible) { - ScopedFakeClock clock; RTC_LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": "; port1->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT); port2->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT); // Set up channels and ensure both ports will be deleted. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); EXPECT_EQ(0, ch1.complete_count()); EXPECT_EQ(0, ch2.complete_count()); // Acquire addresses. ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Send a ping from src to dst. This may or may not make it. ch1.CreateConnection(GetCandidate(ch2.port())); ASSERT_TRUE(ch1.conn() != nullptr); - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); // for TCP connect - ch1.Ping(); - SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // for TCP connect + ch1.Ping(); if (accept) { + EXPECT_THAT( + WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(), + {.timeout = kShortTimeout, .clock = &time_controller_}), + IsRtcOk()); + // We are able to send a ping from src to dst. This is the case when // sending to UDP ports and cone NATs. EXPECT_TRUE(ch1.remote_address().IsNil()); @@ -901,12 +927,13 @@ // Send a ping from dst to src. ch2.AcceptConnection(GetCandidate(ch1.port())); ASSERT_TRUE(ch2.conn() != nullptr); + ch2.Ping(); - EXPECT_THAT(WaitUntil([&] { return ch2.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch2.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + 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. @@ -916,9 +943,12 @@ // Send a ping from dst to src. Again, this may or may not make it. ch2.CreateConnection(GetCandidate(ch1.port())); ASSERT_TRUE(ch2.conn() != nullptr); + ch2.Ping(); - SIMULATED_WAIT(ch2.conn()->write_state() == Connection::STATE_WRITABLE, - kShortTimeout, clock); + RTC_UNUSED( + WaitUntil([&] { return ch2.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kShortTimeout, .clock = &time_controller_})); if (same_addr1 && same_addr2) { // The new ping got back to the source. @@ -929,25 +959,24 @@ // through. So we will have to do another. if (ch1.conn()->write_state() == Connection::STATE_WRITE_INIT) { ch1.Ping(); - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } } else if (!same_addr1 && possible) { // The new ping went to the candidate address, but that address was bad. // This will happen when the source NAT is symmetric. - EXPECT_TRUE(ch1.remote_address().IsNil()); - EXPECT_TRUE(ch2.remote_address().IsNil()); + // With simulated time and some NAT types (like Turn/AR-Nat), the packet + // can be delivered early. // 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_THAT( - WaitUntil( - [&] { return !ch2.remote_address().IsNil(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}), + WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), IsRtcOk()); EXPECT_FALSE(ch2.conn()->receiving()); EXPECT_TRUE(ch1.remote_address().IsNil()); @@ -955,12 +984,13 @@ // Pick up the actual address and establish the connection. ch2.AcceptConnection(GetCandidate(ch1.port())); ASSERT_TRUE(ch2.conn() != nullptr); + ch2.Ping(); - EXPECT_THAT(WaitUntil([&] { return ch2.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch2.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + 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. @@ -969,18 +999,21 @@ // Update our address and complete the connection. ch1.AcceptConnection(GetCandidate(ch2.port())); + ch1.Ping(); - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } else { // (!possible) // There should be s no way for the pings to reach each other. Check it. EXPECT_TRUE(ch1.remote_address().IsNil()); EXPECT_TRUE(ch2.remote_address().IsNil()); ch1.Ping(); - SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock); + RTC_UNUSED( + WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(), + {.timeout = kShortTimeout, .clock = &time_controller_})); EXPECT_TRUE(ch1.remote_address().IsNil()); EXPECT_TRUE(ch2.remote_address().IsNil()); } @@ -990,9 +1023,13 @@ ASSERT_TRUE(ch1.conn() != nullptr); ASSERT_TRUE(ch2.conn() != nullptr); if (possible) { - EXPECT_TRUE(ch1.conn()->receiving()); + EXPECT_THAT(WaitUntil([&] { return ch1.conn()->receiving(); }, IsTrue(), + {.clock = &time_controller_}), + IsRtcOk()); EXPECT_EQ(Connection::STATE_WRITABLE, ch1.conn()->write_state()); - EXPECT_TRUE(ch2.conn()->receiving()); + EXPECT_THAT(WaitUntil([&] { return ch2.conn()->receiving(); }, IsTrue(), + {.clock = &time_controller_}), + IsRtcOk()); EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state()); } else { EXPECT_FALSE(ch1.conn()->receiving()); @@ -1004,14 +1041,14 @@ // Tear down and ensure that goes smoothly. ch1.Stop(); ch2.Stop(); - EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, IsNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); - EXPECT_THAT(WaitUntil([&] { return ch2.conn(); }, IsNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn(); }, IsNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch2.conn(); }, IsNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } class FakePacketSocketFactory : public PacketSocketFactory { @@ -1301,13 +1338,14 @@ port1->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT); // Set up a channel and ensure the port will be deleted. - TestChannel ch1(std::move(port1)); + TestChannel ch1(std::move(port1), time_controller_); EXPECT_EQ(0, ch1.complete_count()); ch1.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); std::unique_ptr<Socket> server( vss()->CreateSocket(kLocalAddr2.family(), SOCK_STREAM)); @@ -1319,9 +1357,10 @@ ch1.CreateConnection(c); EXPECT_TRUE(ch1.conn()); - EXPECT_THAT(WaitUntil([&] { return !ch1.conn(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); // for TCP connect + EXPECT_THAT( + WaitUntil([&] { return !ch1.conn(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // for TCP connect } /* TODO(?): Enable these once testrelayserver can accept external TCP. @@ -1351,17 +1390,19 @@ // ii) it has not received anything for kDeadConnectionReceiveTimeout since // last receiving. TEST_F(PortTest, TestConnectionDead) { - TestChannel ch1(CreateUdpPort(kLocalAddr1)); - TestChannel ch2(CreateUdpPort(kLocalAddr2)); + TestChannel ch1(CreateUdpPort(kLocalAddr1), time_controller_); + TestChannel ch2(CreateUdpPort(kLocalAddr2), time_controller_); // Acquire address. ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Test case that the connection has never received anything. Timestamp before_created = env().clock().CurrentTime(); @@ -1371,18 +1412,19 @@ ASSERT_NE(conn, nullptr); // It is not dead if it is after kMinConnectionLifetime but not pruned. conn->UpdateState(after_created + kMinConnectionLifetime + kEpsilon); - Thread::Current()->ProcessMessages(0); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_TRUE(ch1.conn() != nullptr); // It is not dead if it is before kMinConnectionLifetime and pruned. conn->UpdateState(before_created + kMinConnectionLifetime - kEpsilon); conn->Prune(); - Thread::Current()->ProcessMessages(0); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_TRUE(ch1.conn() != nullptr); // It will be dead after kMinConnectionLifetime and pruned. conn->UpdateState(after_created + kMinConnectionLifetime + kEpsilon); - EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Test case that the connection has received something. // Create a connection again and receive a ping. @@ -1395,27 +1437,30 @@ // The connection will be dead after kDeadConnectionReceiveTimeout conn->UpdateState(before_last_receiving + kDeadConnectionReceiveTimeout - kEpsilon); - Thread::Current()->ProcessMessages(100); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_TRUE(ch1.conn() != nullptr); conn->UpdateState(after_last_receiving + kDeadConnectionReceiveTimeout + kEpsilon); - EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } TEST_F(PortTest, TestConnectionDeadWithDeadConnectionTimeout) { - TestChannel ch1(CreateUdpPort(kLocalAddr1)); - TestChannel ch2(CreateUdpPort(kLocalAddr2)); + TestChannel ch1(CreateUdpPort(kLocalAddr1), time_controller_); + TestChannel ch2(CreateUdpPort(kLocalAddr2), time_controller_); // Acquire address. ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Note: set field trials manually since they are parsed by // P2PTransportChannel but P2PTransportChannel is not used in this test. @@ -1433,12 +1478,13 @@ Timestamp after_last_receiving = env().clock().CurrentTime(); // The connection will be dead after 90s conn->UpdateState(before_last_receiving + TimeDelta::Seconds(90) - kEpsilon); - Thread::Current()->ProcessMessages(100); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_TRUE(ch1.conn() != nullptr); conn->UpdateState(after_last_receiving + TimeDelta::Seconds(90) + kEpsilon); - EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } TEST_F(PortTest, TestConnectionDeadOutstandingPing) { @@ -1449,17 +1495,19 @@ port2->SetIceRole(ICEROLE_CONTROLLED); port2->SetIceTiebreaker(kTiebreaker2); - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Acquire address. ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Note: set field trials manually since they are parsed by // P2PTransportChannel but P2PTransportChannel is not used in this test. @@ -1480,13 +1528,14 @@ // The connection will be dead 30s after the ping was sent. conn->UpdateState(send_ping_timestamp + kDeadConnectionReceiveTimeout - kEpsilon); - Thread::Current()->ProcessMessages(100); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_TRUE(ch1.conn() != nullptr); conn->UpdateState(send_ping_timestamp + kDeadConnectionReceiveTimeout + kEpsilon); - EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn(); }, Eq(nullptr), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); } // This test case verifies standard ICE features in STUN messages. Currently it @@ -1518,16 +1567,18 @@ lport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE); conn->Ping(); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); IceMessage* msg = lport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); conn->OnReadPacket( ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt)); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); msg = lport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type()); @@ -1540,9 +1591,10 @@ lport->CreateConnection(lport->Candidates()[1], Port::ORIGIN_MESSAGE); conn1->Ping(); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); msg = lport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); std::unique_ptr<IceMessage> modified_req( @@ -1564,9 +1616,10 @@ conn1->OnReadPacket(ReceivedIpPacket::CreateFromLegacy( reinterpret_cast<const char*>(buf->Data()), buf->Length(), /*packet_time_us=*/-1)); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); msg = lport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type()); } @@ -1594,24 +1647,25 @@ rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE); rconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); IceMessage* msg = rport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); // Send rport binding request to lport. lconn->OnReadPacket( ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt)); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type()); EXPECT_TRUE(role_conflict()); } TEST_F(PortTest, TestTcpNoDelay) { - ScopedFakeClock clock; auto port1 = CreateTcpPort(kLocalAddr1); port1->SetIceRole(ICEROLE_CONTROLLING); int option_value = -1; @@ -1624,28 +1678,30 @@ // Set up a connection, and verify that option is set on connected sockets at // both ends. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Acquire addresses. ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Connect and send a ping from src to dst. ch1.CreateConnection(GetCandidate(ch2.port())); ASSERT_TRUE(ch1.conn() != nullptr); - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); // for TCP connect + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // for TCP connect ch1.Ping(); - SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock); + EXPECT_THAT(WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(), + {.clock = &time_controller_}), + IsRtcOk()); // Accept the connection. ch2.AcceptConnection(GetCandidate(ch1.port())); @@ -1917,9 +1973,10 @@ lconn->Ping(); // Check that it's a proper BINDING-REQUEST. - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); IceMessage* msg = lport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); EXPECT_FALSE(msg->IsLegacy()); @@ -2021,9 +2078,10 @@ rconn->Ping(); rconn->Ping(); rconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); msg = rport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); const StunUInt64Attribute* ice_controlled_attr = @@ -2094,9 +2152,10 @@ // Send ping (including the nomination value) from `lconn` to `rconn`. This // should set the remote nomination of `rconn`. lconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_GT(lport->last_stun_buf().size(), 0u); rconn->OnReadPacket( ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt)); @@ -2109,9 +2168,10 @@ // This should result in an acknowledgment sent back from `rconn` to `lconn`, // updating the acknowledged nomination of `lconn`. - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_GT(rport->last_stun_buf().size(), 0u); lconn->OnReadPacket( ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt)); @@ -2124,8 +2184,6 @@ } TEST_F(PortTest, TestRoundTripTime) { - ScopedFakeClock clock; - auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass"); auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass"); lport->SetIceRole(ICEROLE_CONTROLLING); @@ -2145,20 +2203,20 @@ EXPECT_EQ(0u, lconn->stats().total_round_trip_time_ms); EXPECT_FALSE(lconn->stats().current_round_trip_time_ms); - SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), &clock, - 10); + SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), + time_controller_, 10); EXPECT_EQ(10u, lconn->stats().total_round_trip_time_ms); ASSERT_TRUE(lconn->stats().current_round_trip_time_ms); EXPECT_EQ(10u, *lconn->stats().current_round_trip_time_ms); - SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), &clock, - 20); + SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), + time_controller_, 20); EXPECT_EQ(30u, lconn->stats().total_round_trip_time_ms); ASSERT_TRUE(lconn->stats().current_round_trip_time_ms); EXPECT_EQ(20u, *lconn->stats().current_round_trip_time_ms); - SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), &clock, - 30); + SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), + time_controller_, 30); EXPECT_EQ(60u, lconn->stats().total_round_trip_time_ms); ASSERT_TRUE(lconn->stats().current_round_trip_time_ms); EXPECT_EQ(30u, *lconn->stats().current_round_trip_time_ms); @@ -2179,9 +2237,10 @@ Connection* lconn = lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE); lconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); IceMessage* msg = lport->last_stun_msg(); const StunUInt64Attribute* ice_controlling_attr = msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING); @@ -2239,9 +2298,10 @@ // message is handled in rconn, The rconn's remote candidate will have cost // kNetworkCostHigh; EXPECT_EQ(kNetworkCostLow, rconn->remote_candidate().network_cost()); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); IceMessage* msg = lport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); // Pass the binding request to rport. @@ -2249,9 +2309,10 @@ ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt)); // Wait until rport sends the response and then check the remote network cost. - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_EQ(kNetworkCostHigh, rconn->remote_candidate().network_cost()); } @@ -2272,9 +2333,10 @@ Connection* lconn = lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE); lconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); IceMessage* msg = lport->last_stun_msg(); const StunUInt32Attribute* network_info_attr = msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO); @@ -2292,9 +2354,10 @@ Connection* rconn = rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE); rconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); msg = rport->last_stun_msg(); network_info_attr = msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO); ASSERT_TRUE(network_info_attr != nullptr); @@ -2581,16 +2644,18 @@ // Send request. lconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); rconn->OnReadPacket( ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt)); // Intercept request and add comprehension required attribute. - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); auto modified_response = rport->last_stun_msg()->Clone(); modified_response->AddAttribute(StunAttribute::CreateUInt32(0x7777)); modified_response->RemoveAttribute(STUN_ATTR_FINGERPRINT); @@ -2670,23 +2735,25 @@ rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE); rconn->Ping(); - ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); IceMessage* msg = rport->last_stun_msg(); EXPECT_EQ(STUN_BINDING_REQUEST, msg->type()); // Send rport binding request to lport. lconn->OnReadPacket( ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt)); - ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type()); Timestamp last_ping_received1 = lconn->LastPingReceived(); // Adding a delay of 100ms. - Thread::Current()->ProcessMessages(100); + time_controller_.AdvanceTime(TimeDelta::Millis(100)); // Pinging lconn using stun indication message. lconn->OnReadPacket(ReceivedIpPacket::CreateFromLegacy( buf->Data(), buf->Length(), /*packet_time_us=*/-1)); @@ -2801,9 +2868,10 @@ tcpport2->Candidates()[0].foundation()); auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1()); stunport->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_NE(tcpport1->Candidates()[0].foundation(), stunport->Candidates()[0].foundation()); EXPECT_NE(tcpport2->Candidates()[0].foundation(), @@ -2816,9 +2884,10 @@ auto turnport1 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP); turnport1->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return turnport1->Candidates().size(); }, Eq(1U), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return turnport1->Candidates().size(); }, Eq(1U), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_NE(udpport1->Candidates()[0].foundation(), turnport1->Candidates()[0].foundation()); EXPECT_NE(udpport2->Candidates()[0].foundation(), @@ -2828,9 +2897,10 @@ auto turnport2 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP); turnport2->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return turnport2->Candidates().size(); }, Eq(1U), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return turnport2->Candidates().size(); }, Eq(1U), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_EQ(turnport1->Candidates()[0].foundation(), turnport2->Candidates()[0].foundation()); @@ -2842,9 +2912,10 @@ auto turnport3 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP, kTurnUdpIntAddr2); turnport3->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return turnport3->Candidates().size(); }, Eq(1U), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return turnport3->Candidates().size(); }, Eq(1U), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_NE(turnport3->Candidates()[0].foundation(), turnport2->Candidates()[0].foundation()); @@ -2855,9 +2926,10 @@ auto turnport4 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_TCP, PROTO_UDP); turnport4->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return turnport4->Candidates().size(); }, Eq(1U), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return turnport4->Candidates().size(); }, Eq(1U), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_NE(turnport2->Candidates()[0].foundation(), turnport4->Candidates()[0].foundation()); } @@ -2875,9 +2947,10 @@ // socket address. auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1()); stunport->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Check STUN candidate address. EXPECT_EQ(stunport->Candidates()[0].address().ipaddr(), kNatAddr1.ipaddr()); // Check STUN candidate related address. @@ -2888,9 +2961,10 @@ auto turnport = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP); turnport->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return turnport->Candidates().size(); }, Eq(1U), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return turnport->Candidates().size(); }, Eq(1U), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); EXPECT_EQ(kTurnUdpExtAddr.ipaddr(), turnport->Candidates()[0].address().ipaddr()); EXPECT_EQ(kNatAddr1.ipaddr(), @@ -3004,39 +3078,40 @@ // the default setup where the RTT is deterministically one, which generates an // estimate given by `MINIMUM_RTT` = 100. TEST_F(PortTest, TestWritableState) { - ScopedFakeClock clock; auto port1 = CreateUdpPort(kLocalAddr1); port1->SetIceRole(ICEROLE_CONTROLLING); auto port2 = CreateUdpPort(kLocalAddr2); port2->SetIceRole(ICEROLE_CONTROLLED); // Set up channels. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Acquire addresses. ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Send a ping from src to dst. ch1.CreateConnection(GetCandidate(ch2.port())); ASSERT_TRUE(ch1.conn() != nullptr); EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state()); // for TCP connect - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ch1.Ping(); - SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock); + EXPECT_THAT(WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(), + {.clock = &time_controller_}), + IsRtcOk()); // Data should be sendable before the connection is accepted. char data[] = "abcd"; @@ -3047,11 +3122,11 @@ // Accept the connection to return the binding response, transition to // writable, and allow data to be sent. ch2.AcceptConnection(GetCandidate(ch1.port())); - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + 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 @@ -3071,11 +3146,11 @@ // And now allow the other side to process the pings and send binding // responses. - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Wait long enough for a full timeout (past however long we've already // waited). for (uint32_t i = 1; i <= kConnectionWriteConnectFailures; ++i) { @@ -3097,42 +3172,43 @@ // the default value given by `kConnectionWriteConnectTimeout` and // `kConnectionWriteConnectFailures`. TEST_F(PortTest, TestWritableStateWithConfiguredThreshold) { - ScopedFakeClock clock; auto port1 = CreateUdpPort(kLocalAddr1); port1->SetIceRole(ICEROLE_CONTROLLING); auto port2 = CreateUdpPort(kLocalAddr2); port2->SetIceRole(ICEROLE_CONTROLLED); // Set up channels. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Acquire addresses. ch1.Start(); ch2.Start(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); - ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch2.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Send a ping from src to dst. ch1.CreateConnection(GetCandidate(ch2.port())); ASSERT_TRUE(ch1.conn() != nullptr); ch1.Ping(); - SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock); + EXPECT_THAT(WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(), + {.clock = &time_controller_}), + IsRtcOk()); // Accept the connection to return the binding response, transition to // writable, and allow data to be sent. ch2.AcceptConnection(GetCandidate(ch1.port())); - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout), - .clock = &clock}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ch1.conn()->SetUnwritableTimeout(TimeDelta::Seconds(1)); ch1.conn()->set_unwritable_min_checks(3); @@ -3167,8 +3243,8 @@ port2->SetIceRole(ICEROLE_CONTROLLED); // Set up channels. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Acquire addresses. ch1.Start(); @@ -3180,11 +3256,14 @@ // Attempt to go directly to write timeout. for (uint32_t i = 1; i <= kConnectionWriteConnectFailures; ++i) { - ch1.Ping(Timestamp::Millis(i)); + time_controller_.AdvanceTime(TimeDelta::Millis(1)); + ch1.Ping(); } - ch1.conn()->UpdateState(Timestamp::Zero() + kConnectionWriteTimeout + - kMaxExpectedSimulatedRtt); - EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state()); + time_controller_.AdvanceTime(kConnectionWriteTimeout); + ch1.conn()->UpdateState(env_.clock().CurrentTime()); + // The connection should be destroyed because no data received before the + // write timeout. + EXPECT_THAT(ch1.conn(), IsNull()); } // This test verifies the connection setup between ICEMODE_FULL @@ -3199,16 +3278,17 @@ auto ice_lite_port = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED, kTiebreaker2); // Setup TestChannel. This behaves like FULL mode client. - TestChannel ch1(std::move(ice_full_port)); + TestChannel ch1(std::move(ice_full_port), time_controller_); ch1.SetIceMode(ICEMODE_FULL); // Start gathering candidates. ch1.Start(); ice_lite_port->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_FALSE(ice_lite_port->Candidates().empty()); ch1.CreateConnection(GetCandidate(ice_lite_port.get())); @@ -3223,7 +3303,7 @@ // from port. ASSERT_THAT( WaitUntil([&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), IsRtcOk()); IceMessage* msg = ice_full_port_ptr->last_stun_msg(); EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == nullptr); @@ -3242,13 +3322,15 @@ SocketAddress(), std::nullopt)); // Verifying full mode connection becomes writable from the response. - EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); }, - Eq(Connection::STATE_WRITABLE), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); - EXPECT_THAT(WaitUntil([&] { return ch1.nominated(); }, IsTrue(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.conn()->write_state(); }, + Eq(Connection::STATE_WRITABLE), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); + EXPECT_THAT( + WaitUntil([&] { return ch1.nominated(); }, IsTrue(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // Clear existing stun messsages. Otherwise we will process old stun // message right after we send ping. @@ -3257,7 +3339,7 @@ ch1.Ping(); ASSERT_THAT( WaitUntil([&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), IsRtcOk()); msg = ice_full_port_ptr->last_stun_msg(); EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != nullptr); @@ -3321,7 +3403,7 @@ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED, kTiebreaker2); - TestChannel ch1(std::move(port1_unique)); + TestChannel ch1(std::move(port1_unique), time_controller_); // Block usage of STUN_ATTR_USE_CANDIDATE so that // ch1.conn() will sent GOOG_PING_REQUEST directly. // This only makes test a bit shorter... @@ -3330,9 +3412,10 @@ ch1.Start(); port2->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_FALSE(port2->Candidates().empty()); ch1.CreateConnection(GetCandidate(port2.get())); @@ -3343,9 +3426,10 @@ // Send ping. ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* request1 = port1->last_stun_msg(); ASSERT_EQ(trials.enable_goog_ping, @@ -3373,9 +3457,10 @@ port2->Reset(); ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* request2 = port1->last_stun_msg(); // It should be a GOOG_PING if both of these are TRUE @@ -3417,7 +3502,7 @@ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED, kTiebreaker2); - TestChannel ch1(std::move(port1_unique)); + TestChannel ch1(std::move(port1_unique), time_controller_); // Block usage of STUN_ATTR_USE_CANDIDATE so that // ch1.conn() will sent GOOG_PING_REQUEST directly. // This only makes test a bit shorter... @@ -3426,9 +3511,10 @@ ch1.Start(); port2->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_FALSE(port2->Candidates().empty()); ch1.CreateConnection(GetCandidate(port2.get())); @@ -3439,9 +3525,10 @@ // Send ping. ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* request1 = port1->last_stun_msg(); ASSERT_TRUE(GetSupportedGoogPingVersion(request1) && @@ -3490,7 +3577,7 @@ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED, kTiebreaker2); - TestChannel ch1(std::move(port1_unique)); + TestChannel ch1(std::move(port1_unique), time_controller_); // Block usage of STUN_ATTR_USE_CANDIDATE so that // ch1.conn() will sent GOOG_PING_REQUEST directly. // This only makes test a bit shorter... @@ -3499,9 +3586,10 @@ ch1.Start(); port2->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_FALSE(port2->Candidates().empty()); ch1.CreateConnection(GetCandidate(port2.get())); @@ -3512,9 +3600,10 @@ // Send ping. ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* request1 = port1->last_stun_msg(); ASSERT_TRUE(GetSupportedGoogPingVersion(request1) && @@ -3563,9 +3652,10 @@ port2->Reset(); ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); // This should now be a STUN_BINDING...without a kGoogPingVersion const IceMessage* request2 = port1->last_stun_msg(); @@ -3595,7 +3685,7 @@ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED, kTiebreaker2); - TestChannel ch1(std::move(port1_unique)); + TestChannel ch1(std::move(port1_unique), time_controller_); // Block usage of STUN_ATTR_USE_CANDIDATE so that // ch1.conn() will sent GOOG_PING_REQUEST directly. // This only makes test a bit shorter... @@ -3604,9 +3694,10 @@ ch1.Start(); port2->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_FALSE(port2->Candidates().empty()); ch1.CreateConnection(GetCandidate(port2.get())); @@ -3617,9 +3708,10 @@ // Send ping. ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* msg = port1->last_stun_msg(); auto* con = port2->CreateConnection(port1->Candidates()[0], Port::ORIGIN_MESSAGE); @@ -3641,9 +3733,10 @@ port2->Reset(); ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* msg2 = port1->last_stun_msg(); // It should be a GOOG_PING if both of these are TRUE @@ -3664,9 +3757,10 @@ ch1.conn()->set_use_candidate_attr(!ch1.conn()->use_candidate_attr()); ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* msg3 = port1->last_stun_msg(); // It should be a STUN_BINDING_REQUEST @@ -3687,7 +3781,7 @@ auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED, kTiebreaker2); - TestChannel ch1(std::move(port1_unique)); + TestChannel ch1(std::move(port1_unique), time_controller_); // Block usage of STUN_ATTR_USE_CANDIDATE so that // ch1.conn() will sent GOOG_PING_REQUEST directly. // This only makes test a bit shorter... @@ -3696,9 +3790,10 @@ ch1.Start(); port2->PrepareAddress(); - ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return ch1.complete_count(); }, Eq(1), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); ASSERT_FALSE(port2->Candidates().empty()); ch1.CreateConnection(GetCandidate(port2.get())); @@ -3709,9 +3804,10 @@ // Send ping. ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* msg = port1->last_stun_msg(); auto* con = port2->CreateConnection(port1->Candidates()[0], Port::ORIGIN_MESSAGE); @@ -3733,9 +3829,10 @@ port2->Reset(); ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* msg2 = port1->last_stun_msg(); // It should be a GOOG_PING. @@ -3763,9 +3860,10 @@ port2->Reset(); ch1.Ping(); - ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), - {.timeout = TimeDelta::Millis(kDefaultTimeout)}), - IsRtcOk()); + ASSERT_THAT( + WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(), + {.timeout = kDefaultTimeout, .clock = &time_controller_}), + IsRtcOk()); const IceMessage* msg3 = port1->last_stun_msg(); // It should be a STUN_BINDING_REQUEST @@ -3778,7 +3876,6 @@ // port will time out after connectivity is lost, if they are not marked as // "keep alive until pruned." TEST_F(PortTest, TestPortTimeoutIfNotKeptAlive) { - ScopedFakeClock clock; int timeout_delay = 100; auto port1 = CreateUdpPort(kLocalAddr1); ConnectToSignalDestroyed(port1.get()); @@ -3793,23 +3890,22 @@ port2->SetIceTiebreaker(kTiebreaker2); // Set up channels and ensure both ports will be deleted. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Simulate a connection that succeeds, and then is destroyed. 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_THAT( - WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}), - IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return ports_destroyed(); }, Eq(2), + {.clock = &time_controller_}), + IsRtcOk()); } // Test that if after all connection are destroyed, new connections are created // and destroyed again, ports won't be destroyed until a timeout period passes // after the last set of connections are all destroyed. TEST_F(PortTest, TestPortTimeoutAfterNewConnectionCreatedAndDestroyed) { - ScopedFakeClock clock; int timeout_delay = 100; auto port1 = CreateUdpPort(kLocalAddr1); ConnectToSignalDestroyed(port1.get()); @@ -3825,12 +3921,12 @@ port2->SetIceTiebreaker(kTiebreaker2); // Set up channels and ensure both ports will be deleted. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Simulate a connection that succeeds, and then is destroyed. StartConnectAndStopChannels(&ch1, &ch2); - SIMULATED_WAIT(ports_destroyed() > 0, 80, clock); + time_controller_.AdvanceTime(TimeDelta::Millis(80)); EXPECT_EQ(0, ports_destroyed()); // Start the second set of connection and destroy them. @@ -3839,20 +3935,19 @@ ch1.Stop(); ch2.Stop(); - SIMULATED_WAIT(ports_destroyed() > 0, 80, clock); + time_controller_.AdvanceTime(TimeDelta::Millis(80)); EXPECT_EQ(0, ports_destroyed()); // The ports on both sides should be destroyed after timeout. - EXPECT_THAT( - WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}), - IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return ports_destroyed(); }, Eq(2), + {.clock = &time_controller_}), + IsRtcOk()); } // This test case verifies that neither the controlling port nor the controlled // port will time out after connectivity is lost if they are marked as "keep // alive until pruned". They will time out after they are pruned. TEST_F(PortTest, TestPortNotTimeoutUntilPruned) { - ScopedFakeClock clock; int timeout_delay = 100; auto port1 = CreateUdpPort(kLocalAddr1); ConnectToSignalDestroyed(port1.get()); @@ -3872,23 +3967,23 @@ port2->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT); // Set up channels and keep the port alive. - TestChannel ch1(std::move(port1)); - TestChannel ch2(std::move(port2)); + TestChannel ch1(std::move(port1), time_controller_); + TestChannel ch2(std::move(port2), time_controller_); // Simulate a connection that succeeds, and then is destroyed. But ports // are kept alive. Ports won't be destroyed. StartConnectAndStopChannels(&ch1, &ch2); ch1.port()->KeepAliveUntilPruned(); ch2.port()->KeepAliveUntilPruned(); - SIMULATED_WAIT(ports_destroyed() > 0, 150, clock); + time_controller_.AdvanceTime(TimeDelta::Millis(150)); EXPECT_EQ(0, ports_destroyed()); // If they are pruned now, they will be destroyed right away. ch1.port()->Prune(); ch2.port()->Prune(); // The ports on both sides should be destroyed after timeout. - EXPECT_THAT( - WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}), - IsRtcOk()); + EXPECT_THAT(WaitUntil([&] { return ports_destroyed(); }, Eq(2), + {.clock = &time_controller_}), + IsRtcOk()); } TEST_F(PortTest, TestSupportsProtocol) { @@ -3951,7 +4046,7 @@ EXPECT_EQ(2u, conn_in_use->remote_candidate().generation()); // Make sure the new connection was not deleted. - Thread::Current()->ProcessMessages(300); + time_controller_.AdvanceTime(TimeDelta::Millis(300)); EXPECT_TRUE(port->GetConnection(address) != nullptr); }