Refactor stun_port_unittest to use GlobalSimulatedTimeController Bug: webrtc:381524905 Bug: webrtc:42223992 Bug: webrtc:469327588 Change-Id: Ib2db3c582aaf3f7b6e8e0dee39e87e666a6a6964 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/454380 Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org> Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org> Auto-Submit: Evan Shrubsole <eshr@webrtc.org> Cr-Commit-Position: refs/heads/main@{#47258}
diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn index d59a176..a18edbb 100644 --- a/p2p/BUILD.gn +++ b/p2p/BUILD.gn
@@ -1223,6 +1223,7 @@ "../system_wrappers:metrics", "../test:create_test_environment", "../test:create_test_field_trials", + "../test:run_loop", "../test:test_support", "../test:wait_until", "../test/time_controller",
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc index fbdb534..71d5779 100644 --- a/p2p/base/stun_port_unittest.cc +++ b/p2p/base/stun_port_unittest.cc
@@ -28,9 +28,9 @@ #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 "api/units/timestamp.h" #include "p2p/base/basic_packet_socket_factory.h" #include "p2p/base/port.h" #include "p2p/base/stun_request.h" @@ -43,8 +43,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/ip_address.h" #include "rtc_base/mdns_responder_interface.h" #include "rtc_base/net_helpers.h" @@ -62,6 +60,7 @@ #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 { @@ -79,23 +78,22 @@ const SocketAddress kPrivateIP("192.168.1.12", 0); const SocketAddress kMsdnAddress("unittest-mdns-host-name.local", 0); const SocketAddress kPublicIP("212.116.91.133", 0); -const SocketAddress kNatAddr(kPublicIP.ipaddr(), webrtc::NAT_SERVER_UDP_PORT); +const SocketAddress kNatAddr(kPublicIP.ipaddr(), NAT_SERVER_UDP_PORT); const SocketAddress kStunServerAddr1("34.38.54.120", 5000); const SocketAddress kStunServerAddr2("34.38.54.120", 4000); const SocketAddress kPrivateIPv6("2001:4860:4860::8844", 0); const SocketAddress kPublicIPv6("2002:4860:4860::8844", 5000); -const SocketAddress kNatAddrIPv6(kPublicIPv6.ipaddr(), - webrtc::NAT_SERVER_UDP_PORT); +const SocketAddress kNatAddrIPv6(kPublicIPv6.ipaddr(), NAT_SERVER_UDP_PORT); const SocketAddress kStunServerAddrIPv6Addr("2003:4860:4860::8844", 5000); const SocketAddress kBadAddr("0.0.0.1", 5000); const SocketAddress kIPv6BadAddr("::ffff:0:1", 5000); const SocketAddress kValidHostnameAddr("valid-hostname", 5000); const SocketAddress kBadHostnameAddr("not-a-real-hostname", 5000); -// STUN timeout (with all retries) is webrtc::STUN_TOTAL_TIMEOUT. +// STUN timeout (with all retries) is STUN_TOTAL_TIMEOUT. // Add some margin of error for slow bots. -constexpr int kTimeoutMs = webrtc::STUN_TOTAL_TIMEOUT; +constexpr TimeDelta kTimeout = TimeDelta::Millis(STUN_TOTAL_TIMEOUT + 5000); // stun prio = 100 (srflx) << 24 | 30 (IPv4) << 8 | 256 - 1 (component) constexpr uint32_t kStunCandidatePriority = (100 << 24) | (30 << 8) | (256 - 1); // stun prio = 100 (srflx) << 24 | 40 (IPv6) << 8 | 256 - 1 (component) @@ -105,81 +103,76 @@ struct IPAddressTypeTestConfig { absl::string_view address; - webrtc::IPAddressType address_type; + IPAddressType address_type; }; -// Used by the test framework to print the param value for parameterized tests. -std::string PrintToString(const IPAddressTypeTestConfig& param) { - return std::string(param.address); -} - -class FakeMdnsResponder : public webrtc::MdnsResponderInterface { +class FakeMdnsResponder : public MdnsResponderInterface { public: - void CreateNameForAddress(const webrtc::IPAddress& addr, + void CreateNameForAddress(const IPAddress& addr, NameCreatedCallback callback) override { callback(addr, kMsdnAddress.HostAsSensitiveURIString()); } - void RemoveNameForAddress(const webrtc::IPAddress& addr, + void RemoveNameForAddress(const IPAddress& addr, NameRemovedCallback callback) override {} }; -class FakeMdnsResponderProvider : public webrtc::MdnsResponderProvider { +class FakeMdnsResponderProvider : public MdnsResponderProvider { public: FakeMdnsResponderProvider() : mdns_responder_(new FakeMdnsResponder()) {} - webrtc::MdnsResponderInterface* GetMdnsResponder() const override { + MdnsResponderInterface* GetMdnsResponder() const override { return mdns_responder_.get(); } private: - std::unique_ptr<webrtc::MdnsResponderInterface> mdns_responder_; + std::unique_ptr<MdnsResponderInterface> mdns_responder_; }; // Base class for tests connecting a StunPort to a fake STUN server -// (webrtc::StunServer). -class StunPortTestBase : public ::testing::Test { +// (StunServer). +class StunPortTest : public ::testing::Test { public: - StunPortTestBase() - : StunPortTestBase(kPrivateIP.ipaddr(), - {kStunServerAddr1, kStunServerAddr2}, - kNatAddr) {} + StunPortTest() + : StunPortTest(kPrivateIP.ipaddr(), + {kStunServerAddr1, kStunServerAddr2}, + kNatAddr) {} - StunPortTestBase(const webrtc::IPAddress address, - const std::set<webrtc::SocketAddress>& stun_server_addresses, - const webrtc::SocketAddress& nat_server_address) - : env_(CreateTestEnvironment()), - ss_(new webrtc::VirtualSocketServer()), - thread_(ss_.get()), + StunPortTest(const IPAddress address, + const std::set<SocketAddress>& stun_server_addresses, + const SocketAddress& nat_server_address) + : ss_(std::make_unique<VirtualSocketServer>()), + time_controller_(Timestamp::Zero(), ss_.get()), + env_(CreateTestEnvironment({.time = &time_controller_})), + network_thread_(time_controller_.GetMainThread()), nat_factory_(ss_.get(), nat_server_address, nat_server_address), nat_socket_factory_(&nat_factory_), mdns_responder_provider_(new FakeMdnsResponderProvider()), - nat_server_(CreateNatServer(nat_server_address, webrtc::NAT_OPEN_CONE)), done_(false), error_(false), stun_keepalive_delay_(TimeDelta::Millis(1)) { + nat_server_ = CreateNatServer(nat_server_address, NAT_OPEN_CONE); network_ = MakeNetwork(address); RTC_CHECK(address.family() == nat_server_address.family()); for (const auto& addr : stun_server_addresses) { RTC_CHECK(addr.family() == address.family()); stun_servers_.push_back( - webrtc::TestStunServer::Create(env_, addr, *ss_, thread_)); + TestStunServer::Create(env_, addr, *ss_, *network_thread_)); } } - std::unique_ptr<webrtc::NATServer> CreateNatServer(const SocketAddress& addr, - webrtc::NATType type) { - return std::make_unique<webrtc::NATServer>( - env_, type, thread_, ss_.get(), addr, addr, thread_, ss_.get(), addr); + std::unique_ptr<NATServer> CreateNatServer(const SocketAddress& addr, + NATType type) { + return std::make_unique<NATServer>(env_, type, *network_thread_, ss_.get(), + addr, addr, *network_thread_, ss_.get(), + addr); } - virtual webrtc::PacketSocketFactory* socket_factory() { - return &nat_socket_factory_; - } + virtual PacketSocketFactory* socket_factory() { return &nat_socket_factory_; } - webrtc::SocketServer* ss() const { return ss_.get(); } - webrtc::UDPPort* port() const { return stun_port_.get(); } - webrtc::AsyncPacketSocket* socket() const { return socket_.get(); } + SocketServer* ss() const { return ss_.get(); } + UDPPort* port() const { return stun_port_.get(); } + AsyncPacketSocket* socket() const { return socket_.get(); } bool done() const { return done_; } bool error() const { return error_; } @@ -187,32 +180,32 @@ return stun_port_->request_manager().HasRequestForTest(msg_type); } - void SetNetworkType(webrtc::AdapterType adapter_type) { + void SetNetworkType(AdapterType adapter_type) { network_->set_type(adapter_type); } - void CreateStunPort(const webrtc::SocketAddress& server_addr, - const webrtc::FieldTrialsView* field_trials = nullptr) { + void CreateStunPort(const SocketAddress& server_addr, + const FieldTrialsView* field_trials = nullptr) { ServerAddresses stun_servers; stun_servers.insert(server_addr); CreateStunPort(stun_servers, field_trials); } void CreateStunPort(const ServerAddresses& stun_servers, - const webrtc::FieldTrialsView* field_trials = nullptr) { + const FieldTrialsView* field_trials = nullptr) { // Overwrite field trials if provided. EnvironmentFactory env_factory(env_); env_factory.Set(field_trials); Environment env = env_factory.Create(); - stun_port_ = webrtc::StunPort::Create( - {.env = env, - .network_thread = &thread_, - .socket_factory = socket_factory(), - .network = network_, - .ice_username_fragment = webrtc::CreateRandomString(16), - .ice_password = webrtc::CreateRandomString(22)}, - 0, 0, stun_servers, std::nullopt); + stun_port_ = + StunPort::Create({.env = env, + .network_thread = network_thread_, + .socket_factory = socket_factory(), + .network = network_, + .ice_username_fragment = CreateRandomString(16), + .ice_password = CreateRandomString(22)}, + 0, 0, stun_servers, std::nullopt); stun_port_->SetIceTiebreaker(kTiebreakerDefault); stun_port_->set_stun_keepalive_delay(stun_keepalive_delay_); // If `stun_keepalive_lifetime_` is not set, let the stun port choose its @@ -245,20 +238,19 @@ } ASSERT_TRUE(socket_ != nullptr); socket_->RegisterReceivedPacketCallback( - [&](webrtc::AsyncPacketSocket* socket, - const webrtc::ReceivedIpPacket& packet) { + [&](AsyncPacketSocket* socket, const ReceivedIpPacket& packet) { OnReadPacket(socket, packet); }); ServerAddresses stun_servers; stun_servers.insert(server_addr); - stun_port_ = webrtc::UDPPort::Create( - {.env = env_, - .network_thread = &thread_, - .socket_factory = socket_factory(), - .network = network_, - .ice_username_fragment = webrtc::CreateRandomString(16), - .ice_password = webrtc::CreateRandomString(22)}, - socket_.get(), false, std::nullopt); + stun_port_ = + UDPPort::Create({.env = env_, + .network_thread = network_thread_, + .socket_factory = socket_factory(), + .network = network_, + .ice_username_fragment = CreateRandomString(16), + .ice_password = CreateRandomString(22)}, + socket_.get(), false, std::nullopt); stun_port_->set_server_addresses(stun_servers); ASSERT_TRUE(stun_port_ != nullptr); stun_port_->SetIceTiebreaker(kTiebreakerDefault); @@ -268,18 +260,20 @@ [this](Port* port) { OnPortError(port); }); } - void PrepareAddress() { stun_port_->PrepareAddress(); } + void PrepareAddress() { + stun_port_->PrepareAddress(); + time_controller_.AdvanceTime(TimeDelta::Zero()); + } - void OnReadPacket(webrtc::AsyncPacketSocket* socket, - const webrtc::ReceivedIpPacket& packet) { + void OnReadPacket(AsyncPacketSocket* socket, const ReceivedIpPacket& packet) { stun_port_->HandleIncomingPacket(socket, packet); } void SendData(const char* data, size_t len) { stun_port_->HandleIncomingPacket( - socket_.get(), webrtc::ReceivedIpPacket::CreateFromLegacy( - data, len, /* packet_time_us */ -1, - webrtc::SocketAddress("22.22.22.22", 0))); + socket_.get(), + ReceivedIpPacket::CreateFromLegacy(data, len, /* packet_time_us */ -1, + SocketAddress("22.22.22.22", 0))); } void EnableMdnsObfuscation() { @@ -287,17 +281,16 @@ } protected: - void OnPortComplete(webrtc::Port* /* port */) { + void OnPortComplete(Port* /* port */) { ASSERT_FALSE(done_); done_ = true; error_ = false; } - void OnPortError(webrtc::Port* /* port */) { + void OnPortError(Port* /* port */) { done_ = true; error_ = true; } - void OnCandidateError(webrtc::Port* /* port */, - const webrtc::IceCandidateErrorEvent& event) { + void OnCandidateError(Port* /* port */, const IceCandidateErrorEvent& event) { error_event_ = event; } void SetKeepaliveDelay(TimeDelta delay) { stun_keepalive_delay_ = delay; } @@ -306,53 +299,45 @@ stun_keepalive_lifetime_ = lifetime; } - webrtc::Network* MakeNetwork(const webrtc::IPAddress& addr) { + Network* MakeNetwork(const IPAddress& addr) { networks_.emplace_back( std::make_unique<Network>("unittest", "unittest", addr, 32)); networks_.back()->AddIP(addr); return networks_.back().get(); } - webrtc::TestStunServer* stun_server_1() { return stun_servers_[0].get(); } - webrtc::TestStunServer* stun_server_2() { return stun_servers_[1].get(); } + TestStunServer* stun_server_1() { return stun_servers_[0].get(); } + TestStunServer* stun_server_2() { return stun_servers_[1].get(); } - webrtc::AutoSocketServerThread& thread() { return thread_; } - webrtc::SocketFactory* nat_factory() { return &nat_factory_; } + Thread& thread() { return *network_thread_; } + SocketFactory* nat_factory() { return &nat_factory_; } - private: + protected: + std::unique_ptr<VirtualSocketServer> ss_; + GlobalSimulatedTimeController time_controller_; const Environment env_; - std::vector<std::unique_ptr<webrtc::Network>> networks_; - webrtc::Network* network_; + std::vector<std::unique_ptr<Network>> networks_; + Network* network_; - std::unique_ptr<webrtc::VirtualSocketServer> ss_; - webrtc::AutoSocketServerThread thread_; - webrtc::NATSocketFactory nat_factory_; - webrtc::BasicPacketSocketFactory nat_socket_factory_; + Thread* network_thread_; + NATSocketFactory nat_factory_; + BasicPacketSocketFactory nat_socket_factory_; // Note that stun_port_ can refer to socket_, so must be destroyed // before it. - std::unique_ptr<webrtc::AsyncPacketSocket> socket_; - std::unique_ptr<webrtc::UDPPort> stun_port_; - std::vector<webrtc::TestStunServer::StunServerPtr> stun_servers_; - std::unique_ptr<webrtc::MdnsResponderProvider> mdns_responder_provider_; - std::unique_ptr<webrtc::NATServer> nat_server_; + std::unique_ptr<AsyncPacketSocket> socket_; + std::unique_ptr<UDPPort> stun_port_; + std::vector<TestStunServer::StunServerPtr> stun_servers_; + std::unique_ptr<MdnsResponderProvider> mdns_responder_provider_; + std::unique_ptr<NATServer> nat_server_; bool done_; bool error_; TimeDelta stun_keepalive_delay_; std::optional<TimeDelta> stun_keepalive_lifetime_; protected: - webrtc::IceCandidateErrorEvent error_event_; + IceCandidateErrorEvent error_event_; }; -class StunPortTestWithRealClock : public StunPortTestBase {}; - -class FakeClockBase { - public: - webrtc::ScopedFakeClock fake_clock; -}; - -class StunPortTest : public FakeClockBase, public StunPortTestBase {}; - // Test that we can create a STUN port. TEST_F(StunPortTest, TestCreateStunPort) { CreateStunPort(kStunServerAddr1); @@ -371,11 +356,8 @@ TEST_F(StunPortTest, TestPrepareAddress) { CreateStunPort(kStunServerAddr1); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPublicIP.EqualIPs(port()->Candidates()[0].address())); std::string expected_server_url = "stun:" + kStunServerAddr1.ToString(); @@ -386,19 +368,11 @@ TEST_F(StunPortTest, TestPrepareAddressFail) { CreateStunPort(kBadAddr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_TRUE(error()); EXPECT_EQ(0U, port()->Candidates().size()); - EXPECT_THAT( - webrtc::WaitUntil([&] { return error_event_.error_code; }, - Eq(webrtc::STUN_ERROR_SERVER_NOT_REACHABLE), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_EQ(error_event_.error_code, STUN_ERROR_SERVER_NOT_REACHABLE); EXPECT_NE(error_event_.error_text.find('.'), std::string::npos); EXPECT_NE(error_event_.address.find(kPrivateIP.HostAsSensitiveURIString()), std::string::npos); @@ -411,11 +385,8 @@ TEST_F(StunPortTest, TestServerAddressFamilyMismatch) { CreateStunPort(kStunServerAddrIPv6Addr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_TRUE(error()); EXPECT_EQ(0U, port()->Candidates().size()); EXPECT_EQ(0, error_event_.error_code); @@ -426,42 +397,35 @@ StunPortWithMockDnsResolverTest() : StunPortTest(), socket_factory_(nat_factory()) {} - webrtc::PacketSocketFactory* socket_factory() override { - return &socket_factory_; - } + PacketSocketFactory* socket_factory() override { return &socket_factory_; } void SetDnsResolverExpectations( - webrtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) { + MockDnsResolvingPacketSocketFactory::Expectations expectations) { socket_factory_.SetExpectations(expectations); } private: - webrtc::MockDnsResolvingPacketSocketFactory socket_factory_; + MockDnsResolvingPacketSocketFactory socket_factory_; }; // Test that we can get an address from a STUN server specified by a hostname. TEST_F(StunPortWithMockDnsResolverTest, TestPrepareAddressHostname) { - SetDnsResolverExpectations( - [](webrtc::MockAsyncDnsResolver* resolver, - webrtc::MockAsyncDnsResolverResult* resolver_result) { - EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _)) - .WillOnce([](const webrtc::SocketAddress& /* addr */, - int /* family */, - absl::AnyInvocable<void()> callback) { callback(); }); + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _)) + .WillOnce([](const SocketAddress& /* addr */, int /* family */, + absl::AnyInvocable<void()> callback) { callback(); }); - EXPECT_CALL(*resolver, result) - .WillRepeatedly(ReturnPointee(resolver_result)); - EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); - EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET, _)) - .WillOnce(DoAll(SetArgPointee<1>(kStunServerAddr1), Return(true))); - }); + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); + EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET, _)) + .WillOnce(DoAll(SetArgPointee<1>(kStunServerAddr1), Return(true))); + }); CreateStunPort(kValidHostnameAddr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPublicIP.EqualIPs(port()->Candidates()[0].address())); EXPECT_EQ(kStunCandidatePriority, port()->Candidates()[0].priority()); @@ -471,47 +435,47 @@ TestPrepareAddressHostnameWithPriorityAdjustment) { FieldTrials field_trials = CreateTestFieldTrials( "WebRTC-IncreaseIceCandidatePriorityHostSrflx/Enabled/"); - SetDnsResolverExpectations( - [](webrtc::MockAsyncDnsResolver* resolver, - webrtc::MockAsyncDnsResolverResult* resolver_result) { - EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _)) - .WillOnce([](const webrtc::SocketAddress& /* addr */, - int /* family */, - absl::AnyInvocable<void()> callback) { callback(); }); - EXPECT_CALL(*resolver, result) - .WillRepeatedly(ReturnPointee(resolver_result)); - EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); - EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET, _)) - .WillOnce(DoAll(SetArgPointee<1>(kStunServerAddr1), Return(true))); - }); + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _)) + .WillOnce([](const SocketAddress& /* addr */, int /* family */, + absl::AnyInvocable<void()> callback) { callback(); }); + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); + EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET, _)) + .WillOnce(DoAll(SetArgPointee<1>(kStunServerAddr1), Return(true))); + }); CreateStunPort(kValidHostnameAddr, &field_trials); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPublicIP.EqualIPs(port()->Candidates()[0].address())); - EXPECT_EQ(kStunCandidatePriority + (webrtc::kMaxTurnServers << 8), + EXPECT_EQ(kStunCandidatePriority + (kMaxTurnServers << 8), port()->Candidates()[0].priority()); } // Test that we handle hostname lookup failures properly. -TEST_F(StunPortTestWithRealClock, TestPrepareAddressHostnameFail) { +// Test that we fail to get an address from a STUN server specified by an +// invalid hostname. +TEST_F(StunPortWithMockDnsResolverTest, TestPrepareAddressHostnameFail) { + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(kBadHostnameAddr, /*family=*/AF_INET, _)) + .WillOnce([](const SocketAddress& /* addr */, int /* family */, + absl::AnyInvocable<void()> callback) { callback(); }); + + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(-2)); + }); CreateStunPort(kBadHostnameAddr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}), - webrtc::IsRtcOk()); - EXPECT_TRUE(error()); + EXPECT_TRUE(WaitUntil([this] { return error(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_EQ(0U, port()->Candidates().size()); - EXPECT_THAT( - webrtc::WaitUntil([&] { return error_event_.error_code; }, - Eq(webrtc::STUN_ERROR_SERVER_NOT_REACHABLE), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}), - webrtc::IsRtcOk()); + EXPECT_EQ(error_event_.error_code, STUN_ERROR_SERVER_NOT_REACHABLE); } // This test verifies keepalive response messages don't result in @@ -520,14 +484,11 @@ SetKeepaliveDelay(TimeDelta::Millis(500)); CreateStunPort(kStunServerAddr1); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPublicIP.EqualIPs(port()->Candidates()[0].address())); - SIMULATED_WAIT(false, 1000, fake_clock); + time_controller_.AdvanceTime(TimeDelta::Millis(1000)); EXPECT_EQ(1U, port()->Candidates().size()); } @@ -535,11 +496,8 @@ TEST_F(StunPortTest, TestSharedSocketPrepareAddress) { CreateSharedUdpPort(kStunServerAddr1, nullptr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(2U, port()->Candidates().size()); EXPECT_EQ(port()->Candidates()[0].type(), IceCandidateType::kHost); EXPECT_TRUE(kPrivateIP.EqualIPs(port()->Candidates()[0].address())); @@ -550,20 +508,28 @@ // Test that we still get a local candidate with invalid stun server hostname. // Also verifing that UDPPort can receive packets when stun address can't be // resolved. -TEST_F(StunPortTestWithRealClock, +TEST_F(StunPortWithMockDnsResolverTest, TestSharedSocketPrepareAddressInvalidHostname) { + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(kBadHostnameAddr, /*family=*/AF_INET, _)) + .WillOnce([](const SocketAddress& /* addr */, int /* family */, + absl::AnyInvocable<void()> callback) { callback(); }); + + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(-2)); + }); CreateSharedUdpPort(kBadHostnameAddr, nullptr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPrivateIP.EqualIPs(port()->Candidates()[0].address())); // Send data to port after it's ready. This is to make sure, UDP port can // handle data with unresolved stun server address. - std::string data = "some random data, sending to webrtc::Port."; + std::string data = "some random data, sending to Port."; SendData(data.c_str(), data.length()); // No crash is success. } @@ -574,11 +540,8 @@ EnableMdnsObfuscation(); CreateSharedUdpPort(kStunServerAddr1, nullptr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(2U, port()->Candidates().size()); // One of the generated candidates is a local candidate and the other is a @@ -607,11 +570,8 @@ CreateStunPort(stun_servers); EXPECT_EQ(IceCandidateType::kSrflx, port()->Type()); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_EQ(1U, port()->Candidates().size()); EXPECT_EQ(port()->Candidates()[0].relay_protocol(), ""); } @@ -625,18 +585,11 @@ CreateStunPort(stun_servers); EXPECT_EQ(IceCandidateType::kSrflx, port()->Type()); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_EQ(1U, port()->Candidates().size()); std::string server_url = "stun:" + kBadAddr.ToString(); - ASSERT_THAT( - webrtc::WaitUntil([&] { return error_event_.url; }, Eq(server_url), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_EQ(error_event_.url, server_url); } // Test that two candidates are allocated if the two STUN servers return @@ -653,11 +606,8 @@ CreateStunPort(stun_servers); EXPECT_EQ(IceCandidateType::kSrflx, port()->Type()); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_EQ(2U, port()->Candidates().size()); EXPECT_EQ(port()->Candidates()[0].relay_protocol(), ""); EXPECT_EQ(port()->Candidates()[1].relay_protocol(), ""); @@ -671,11 +621,11 @@ CreateStunPort(kStunServerAddr1); EXPECT_EQ(port()->stun_keepalive_lifetime(), TimeDelta::PlusInfinity()); // Lifetime for the cellular network is `kHighCostPortKeepaliveLifetime` - SetNetworkType(webrtc::ADAPTER_TYPE_CELLULAR); + SetNetworkType(ADAPTER_TYPE_CELLULAR); EXPECT_EQ(port()->stun_keepalive_lifetime(), kHighCostPortKeepaliveLifetime); // Lifetime for the wifi network is infinite. - SetNetworkType(webrtc::ADAPTER_TYPE_WIFI); + SetNetworkType(ADAPTER_TYPE_WIFI); CreateStunPort(kStunServerAddr2); EXPECT_EQ(port()->stun_keepalive_lifetime(), TimeDelta::PlusInfinity()); } @@ -688,11 +638,11 @@ CreateSharedUdpPort(kStunServerAddr1, nullptr); EXPECT_EQ(port()->stun_keepalive_lifetime(), TimeDelta::PlusInfinity()); // Lifetime for the cellular network is `kHighCostPortKeepaliveLifetime`. - SetNetworkType(webrtc::ADAPTER_TYPE_CELLULAR); + SetNetworkType(ADAPTER_TYPE_CELLULAR); EXPECT_EQ(port()->stun_keepalive_lifetime(), kHighCostPortKeepaliveLifetime); // Lifetime for the wifi network type is infinite. - SetNetworkType(webrtc::ADAPTER_TYPE_WIFI); + SetNetworkType(ADAPTER_TYPE_WIFI); CreateSharedUdpPort(kStunServerAddr2, nullptr); EXPECT_EQ(port()->stun_keepalive_lifetime(), TimeDelta::PlusInfinity()); } @@ -704,16 +654,11 @@ SetKeepaliveLifetime(TimeDelta::Millis(100)); CreateStunPort(kStunServerAddr1); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); - EXPECT_THAT( - webrtc::WaitUntil( - [&] { return !HasPendingRequest(webrtc::STUN_BINDING_REQUEST); }, - IsTrue(), {.clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); + EXPECT_TRUE( + WaitUntil([&] { return !HasPendingRequest(STUN_BINDING_REQUEST); }, + {.timeout = kTimeout, .clock = &time_controller_})); } // Test that by default, the STUN binding requests will last for a long time. @@ -721,16 +666,10 @@ SetKeepaliveDelay(TimeDelta::Millis(101)); CreateStunPort(kStunServerAddr1); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); - EXPECT_THAT( - webrtc::WaitUntil( - [&] { return HasPendingRequest(webrtc::STUN_BINDING_REQUEST); }, - IsTrue(), {.clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); + EXPECT_TRUE(WaitUntil([&] { return HasPendingRequest(STUN_BINDING_REQUEST); }, + {.timeout = kTimeout, .clock = &time_controller_})); } class StunPortIPAddressTypeMetricsTest @@ -738,51 +677,46 @@ public ::testing::WithParamInterface<IPAddressTypeTestConfig> {}; TEST_P(StunPortIPAddressTypeMetricsTest, TestIPAddressTypeMetrics) { - SetDnsResolverExpectations( - [](webrtc::MockAsyncDnsResolver* resolver, - webrtc::MockAsyncDnsResolverResult* resolver_result) { - EXPECT_CALL(*resolver, Start(SocketAddress("localhost", 5000), - /*family=*/AF_INET, _)) - .WillOnce([](const webrtc::SocketAddress& /* addr */, - int /* family */, - absl::AnyInvocable<void()> callback) { callback(); }); + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(SocketAddress("localhost", 5000), + /*family=*/AF_INET, _)) + .WillOnce([](const SocketAddress& /* addr */, int /* family */, + absl::AnyInvocable<void()> callback) { callback(); }); - EXPECT_CALL(*resolver, result) - .WillRepeatedly(ReturnPointee(resolver_result)); - EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); - EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET, _)) - .WillOnce(DoAll(SetArgPointee<1>(SocketAddress("127.0.0.1", 5000)), - Return(true))); - }); + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); + EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET, _)) + .WillOnce(DoAll(SetArgPointee<1>(SocketAddress("127.0.0.1", 5000)), + Return(true))); + }); - webrtc::metrics::Reset(); + metrics::Reset(); CreateStunPort({GetParam().address, 5000}); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); auto samples = - webrtc::metrics::Samples("WebRTC.PeerConnection.Stun.ServerAddressType"); + metrics::Samples("WebRTC.PeerConnection.Stun.ServerAddressType"); ASSERT_EQ(samples.size(), 1u); EXPECT_EQ(samples[static_cast<int>(GetParam().address_type)], 1); } const IPAddressTypeTestConfig kAllIPAddressTypeTestConfigs[] = { - {.address = "127.0.0.1", .address_type = webrtc::IPAddressType::kLoopback}, - {.address = "localhost", .address_type = webrtc::IPAddressType::kLoopback}, - {.address = "10.0.0.3", .address_type = webrtc::IPAddressType::kPrivate}, - {.address = "1.1.1.1", .address_type = webrtc::IPAddressType::kPublic}, + {.address = "127.0.0.1", .address_type = IPAddressType::kLoopback}, + {.address = "localhost", .address_type = IPAddressType::kLoopback}, + {.address = "10.0.0.3", .address_type = IPAddressType::kPrivate}, + {.address = "1.1.1.1", .address_type = IPAddressType::kPublic}, }; INSTANTIATE_TEST_SUITE_P(All, StunPortIPAddressTypeMetricsTest, ::testing::ValuesIn(kAllIPAddressTypeTestConfigs)); -class MockAsyncPacketSocket : public webrtc::AsyncPacketSocket { +class MockAsyncPacketSocket : public AsyncPacketSocket { public: ~MockAsyncPacketSocket() override = default; @@ -792,7 +726,7 @@ Send, (const void* pv, size_t cb, - const webrtc::AsyncSocketPacketOptions& options), + const AsyncSocketPacketOptions& options), (override)); MOCK_METHOD(int, @@ -800,18 +734,12 @@ (const void* pv, size_t cb, const SocketAddress& addr, - const webrtc::AsyncSocketPacketOptions& options), + const AsyncSocketPacketOptions& options), (override)); MOCK_METHOD(int, Close, (), (override)); MOCK_METHOD(State, GetState, (), (const, override)); - MOCK_METHOD(int, - GetOption, - (webrtc::Socket::Option opt, int* value), - (override)); - MOCK_METHOD(int, - SetOption, - (webrtc::Socket::Option opt, int value), - (override)); + MOCK_METHOD(int, GetOption, (Socket::Option opt, int* value), (override)); + MOCK_METHOD(int, SetOption, (Socket::Option opt, int value), (override)); MOCK_METHOD(int, GetError, (), (const, override)); MOCK_METHOD(void, SetError, (int error), (override)); }; @@ -833,6 +761,7 @@ Eq(DSCP_NO_CHANGE)))) .WillOnce(Return(100)); PrepareAddress(); + port()->request_manager().Clear(); // Once it is set transport wide, they should inherit that value. port()->SetOption(Socket::OPT_DSCP, DSCP_AF41); @@ -841,32 +770,25 @@ SendTo(_, _, _, Field(&AsyncSocketPacketOptions::dscp, Eq(DSCP_AF41)))) .WillRepeatedly(Return(100)); - EXPECT_TRUE(WaitUntil( - [&] { return done(); }, - {.timeout = TimeDelta::Millis(kTimeoutMs), .clock = &fake_clock})); + PrepareAddress(); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); } -class StunIPv6PortTestBase : public StunPortTestBase { +class StunIPv6PortTest : public StunPortTest { public: - StunIPv6PortTestBase() - : StunPortTestBase(kPrivateIPv6.ipaddr(), - {kStunServerAddrIPv6Addr}, - kNatAddrIPv6) {} + StunIPv6PortTest() + : StunPortTest(kPrivateIPv6.ipaddr(), + {kStunServerAddrIPv6Addr}, + kNatAddrIPv6) {} }; -class StunIPv6PortTestWithRealClock : public StunIPv6PortTestBase {}; - -class StunIPv6PortTest : public FakeClockBase, public StunIPv6PortTestBase {}; - // Test that we can get an address from a STUN server. TEST_F(StunIPv6PortTest, TestPrepareAddress) { CreateStunPort(kStunServerAddrIPv6Addr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPublicIPv6.EqualIPs(port()->Candidates()[0].address())); std::string expected_server_url = "stun:2003:4860:4860::8844:5000"; @@ -877,19 +799,11 @@ TEST_F(StunIPv6PortTest, TestPrepareAddressFail) { CreateStunPort(kIPv6BadAddr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_TRUE(error()); EXPECT_EQ(0U, port()->Candidates().size()); - EXPECT_THAT( - webrtc::WaitUntil([&] { return error_event_.error_code; }, - Eq(webrtc::STUN_ERROR_SERVER_NOT_REACHABLE), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_EQ(error_event_.error_code, STUN_ERROR_SERVER_NOT_REACHABLE); EXPECT_NE(error_event_.error_text.find('.'), std::string::npos); EXPECT_NE(error_event_.address.find(kPrivateIPv6.HostAsSensitiveURIString()), std::string::npos); @@ -902,75 +816,68 @@ TEST_F(StunIPv6PortTest, TestServerAddressFamilyMismatch) { CreateStunPort(kStunServerAddr1); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); - EXPECT_TRUE(error()); + EXPECT_TRUE(WaitUntil([this] { return error(); }, + {.timeout = kTimeout, .clock = &time_controller_})); EXPECT_EQ(0U, port()->Candidates().size()); EXPECT_EQ(0, error_event_.error_code); } -// Test that we handle hostname lookup failures properly with a real clock. -TEST_F(StunIPv6PortTestWithRealClock, TestPrepareAddressHostnameFail) { - CreateStunPort(kBadHostnameAddr); - PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}), - webrtc::IsRtcOk()); - EXPECT_TRUE(error()); - EXPECT_EQ(0U, port()->Candidates().size()); - EXPECT_THAT( - webrtc::WaitUntil([&] { return error_event_.error_code; }, - Eq(webrtc::STUN_ERROR_SERVER_NOT_REACHABLE), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs)}), - webrtc::IsRtcOk()); -} - class StunIPv6PortTestWithMockDnsResolver : public StunIPv6PortTest { public: StunIPv6PortTestWithMockDnsResolver() : StunIPv6PortTest(), socket_factory_(ss()) {} - webrtc::PacketSocketFactory* socket_factory() override { - return &socket_factory_; - } + PacketSocketFactory* socket_factory() override { return &socket_factory_; } void SetDnsResolverExpectations( - webrtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) { + MockDnsResolvingPacketSocketFactory::Expectations expectations) { socket_factory_.SetExpectations(expectations); } private: - webrtc::MockDnsResolvingPacketSocketFactory socket_factory_; + MockDnsResolvingPacketSocketFactory socket_factory_; }; +// Test that we fail to get an address from a STUN server specified by an +// invalid hostname. +TEST_F(StunIPv6PortTestWithMockDnsResolver, TestPrepareAddressHostnameFail) { + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(kBadHostnameAddr, /*family=*/AF_INET6, _)) + .WillOnce([](const SocketAddress& /* addr */, int /* family */, + absl::AnyInvocable<void()> callback) { callback(); }); + + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(-2)); + }); + CreateStunPort(kBadHostnameAddr); + PrepareAddress(); + EXPECT_TRUE(WaitUntil([this] { return error(); }, + {.timeout = kTimeout, .clock = &time_controller_})); + EXPECT_EQ(0U, port()->Candidates().size()); + EXPECT_EQ(error_event_.error_code, STUN_ERROR_SERVER_NOT_REACHABLE); +} + // Test that we can get an address from a STUN server specified by a hostname. TEST_F(StunIPv6PortTestWithMockDnsResolver, TestPrepareAddressHostname) { - SetDnsResolverExpectations( - [](webrtc::MockAsyncDnsResolver* resolver, - webrtc::MockAsyncDnsResolverResult* resolver_result) { - EXPECT_CALL(*resolver, - Start(kValidHostnameAddr, /*family=*/AF_INET6, _)) - .WillOnce([](const webrtc::SocketAddress& addr, int family, - absl::AnyInvocable<void()> callback) { callback(); }); + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET6, _)) + .WillOnce([](const SocketAddress& addr, int family, + absl::AnyInvocable<void()> callback) { callback(); }); - EXPECT_CALL(*resolver, result) - .WillRepeatedly(ReturnPointee(resolver_result)); - EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); - EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _)) - .WillOnce( - DoAll(SetArgPointee<1>(kStunServerAddrIPv6Addr), Return(true))); - }); + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); + EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _)) + .WillOnce( + DoAll(SetArgPointee<1>(kStunServerAddrIPv6Addr), Return(true))); + }); CreateStunPort(kValidHostnameAddr); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPrivateIPv6.EqualIPs(port()->Candidates()[0].address())); EXPECT_EQ(kIPv6StunCandidatePriority, port()->Candidates()[0].priority()); @@ -981,30 +888,25 @@ TestPrepareAddressHostnameWithPriorityAdjustment) { FieldTrials field_trials = CreateTestFieldTrials( "WebRTC-IncreaseIceCandidatePriorityHostSrflx/Enabled/"); - SetDnsResolverExpectations( - [](webrtc::MockAsyncDnsResolver* resolver, - webrtc::MockAsyncDnsResolverResult* resolver_result) { - EXPECT_CALL(*resolver, - Start(kValidHostnameAddr, /*family=*/AF_INET6, _)) - .WillOnce([](const webrtc::SocketAddress& addr, int family, - absl::AnyInvocable<void()> callback) { callback(); }); - EXPECT_CALL(*resolver, result) - .WillRepeatedly(ReturnPointee(resolver_result)); - EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); - EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _)) - .WillOnce( - DoAll(SetArgPointee<1>(kStunServerAddrIPv6Addr), Return(true))); - }); + SetDnsResolverExpectations([](MockAsyncDnsResolver* resolver, + MockAsyncDnsResolverResult* resolver_result) { + EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET6, _)) + .WillOnce([](const SocketAddress& addr, int family, + absl::AnyInvocable<void()> callback) { callback(); }); + EXPECT_CALL(*resolver, result) + .WillRepeatedly(ReturnPointee(resolver_result)); + EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0)); + EXPECT_CALL(*resolver_result, GetResolvedAddress(AF_INET6, _)) + .WillOnce( + DoAll(SetArgPointee<1>(kStunServerAddrIPv6Addr), Return(true))); + }); CreateStunPort(kValidHostnameAddr, &field_trials); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); ASSERT_EQ(1U, port()->Candidates().size()); EXPECT_TRUE(kPrivateIPv6.EqualIPs(port()->Candidates()[0].address())); - EXPECT_EQ(kIPv6StunCandidatePriority + (webrtc::kMaxTurnServers << 8), + EXPECT_EQ(kIPv6StunCandidatePriority + (kMaxTurnServers << 8), port()->Candidates()[0].priority()); } @@ -1013,28 +915,24 @@ public ::testing::WithParamInterface<IPAddressTypeTestConfig> {}; TEST_P(StunIPv6PortIPAddressTypeMetricsTest, TestIPAddressTypeMetrics) { - webrtc::metrics::Reset(); + metrics::Reset(); CreateStunPort({GetParam().address, 5000}); PrepareAddress(); - EXPECT_THAT( - webrtc::WaitUntil([&] { return done(); }, IsTrue(), - {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs), - .clock = &fake_clock}), - webrtc::IsRtcOk()); + EXPECT_TRUE(WaitUntil([this] { return done(); }, + {.timeout = kTimeout, .clock = &time_controller_})); auto samples = - webrtc::metrics::Samples("WebRTC.PeerConnection.Stun.ServerAddressType"); + metrics::Samples("WebRTC.PeerConnection.Stun.ServerAddressType"); ASSERT_EQ(samples.size(), 1u); EXPECT_EQ(samples[static_cast<int>(GetParam().address_type)], 1); } const IPAddressTypeTestConfig kAllIPv6AddressTypeTestConfigs[] = { - {.address = "::1", .address_type = webrtc::IPAddressType::kLoopback}, + {.address = "::1", .address_type = IPAddressType::kLoopback}, {.address = "fd00:4860:4860::8844", - .address_type = webrtc::IPAddressType::kPrivate}, - {.address = "2001:4860:4860::8888", - .address_type = webrtc::IPAddressType::kPublic}, + .address_type = IPAddressType::kPrivate}, + {.address = "2001:4860:4860::8888", .address_type = IPAddressType::kPublic}, }; INSTANTIATE_TEST_SUITE_P(All,