diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn index 0cd28c73e9..ccdecd0832 100644 --- a/rtc_base/BUILD.gn +++ b/rtc_base/BUILD.gn @@ -873,8 +873,15 @@ rtc_library("async_dns_resolver_unittests") { deps = [ ":async_dns_resolver", ":gunit_helpers", + ":logging", + ":net_helpers", + ":socket_address", + ":threading", + "../api:rtc_error_matchers", + "../api/units:time_delta", "../test:run_loop", "../test:test_support", + "../test:wait_until", ] } @@ -1649,12 +1656,16 @@ rtc_library("testclient") { "test_client.h", ] deps = [ + ":async_packet_socket", ":async_udp_socket", ":buffer", ":gunit_helpers", ":rtc_base_tests_utils", + ":socket", + ":socket_address", ":threading", ":timeutils", + "../api/units:time_delta", "../api/units:timestamp", "network:received_packet", "synchronization:mutex", @@ -1804,11 +1815,16 @@ if (rtc_include_tests) { sources = [ "operations_chain_unittest.cc" ] deps = [ + ":checks", ":gunit_helpers", ":rtc_event", ":rtc_operations_chain", ":threading", + "../api:rtc_error_matchers", + "../api:scoped_refptr", + "../api/units:time_delta", "../test:test_support", + "../test:wait_until", ] } @@ -1842,10 +1858,12 @@ if (rtc_include_tests) { ":rtc_base_tests_utils", ":socket", ":socket_address", + ":socket_factory", ":socket_server", ":testclient", ":threading", ":timeutils", + "../api:rtc_error_matchers", "../api/units:time_delta", "../api/units:timestamp", "../system_wrappers", @@ -1853,6 +1871,8 @@ if (rtc_include_tests) { "../test:fileutils", "../test:test_main", "../test:test_support", + "../test:wait_until", + "network:ecn_marking", "third_party/sigslot", "//testing/gtest", "//third_party/abseil-cpp/absl/memory", @@ -2104,6 +2124,7 @@ if (rtc_include_tests) { ":net_helpers", ":net_test_helpers", ":network", + ":network_constants", ":network_route", ":null_socket_server", ":refcount", @@ -2129,6 +2150,8 @@ if (rtc_include_tests) { "../api:array_view", "../api:field_trials_view", "../api:make_ref_counted", + "../api:rtc_error_matchers", + "../api:scoped_refptr", "../api:sequence_checker", "../api/task_queue", "../api/task_queue:pending_task_safety_flag", @@ -2140,6 +2163,7 @@ if (rtc_include_tests) { "../test:scoped_key_value_config", "../test:test_main", "../test:test_support", + "../test:wait_until", "memory:fifo_buffer", "network:received_packet", "synchronization:mutex", diff --git a/rtc_base/async_dns_resolver_unittest.cc b/rtc_base/async_dns_resolver_unittest.cc index 11f8b1b6f4..23f541b70b 100644 --- a/rtc_base/async_dns_resolver_unittest.cc +++ b/rtc_base/async_dns_resolver_unittest.cc @@ -10,13 +10,25 @@ #include "rtc_base/async_dns_resolver.h" -#include "rtc_base/gunit.h" +#include + +#include "api/test/rtc_error_matchers.h" +#include "api/units/time_delta.h" +#include "rtc_base/logging.h" +#include "rtc_base/net_helpers.h" +#include "rtc_base/socket_address.h" +#include "rtc_base/thread.h" +#include "test/gmock.h" #include "test/gtest.h" #include "test/run_loop.h" +#include "test/wait_until.h" namespace webrtc { namespace { -const int kDefaultTimeout = 1000; + +using ::testing::IsTrue; + +const webrtc::TimeDelta kDefaultTimeout = webrtc::TimeDelta::Millis(1000); const int kPortNumber = 3027; TEST(AsyncDnsResolver, ConstructorWorks) { @@ -31,7 +43,9 @@ TEST(AsyncDnsResolver, ResolvingLocalhostWorks) { rtc::SocketAddress resolved_address; bool done = false; resolver.Start(address, [&done] { done = true; }); - ASSERT_TRUE_WAIT(done, kDefaultTimeout); + ASSERT_THAT( + WaitUntil([&] { return done; }, IsTrue(), {.timeout = kDefaultTimeout}), + IsRtcOk()); EXPECT_EQ(resolver.result().GetError(), 0); if (resolver.result().GetResolvedAddress(AF_INET, &resolved_address)) { EXPECT_EQ(resolved_address, rtc::SocketAddress("127.0.0.1", kPortNumber)); diff --git a/rtc_base/nat_unittest.cc b/rtc_base/nat_unittest.cc index 978a30aefe..a1cc1b5d49 100644 --- a/rtc_base/nat_unittest.cc +++ b/rtc_base/nat_unittest.cc @@ -13,16 +13,13 @@ #include #include #include -#include #include #include "absl/memory/memory.h" -#include "api/units/time_delta.h" -#include "rtc_base/async_packet_socket.h" +#include "api/test/rtc_error_matchers.h" #include "rtc_base/async_tcp_socket.h" #include "rtc_base/async_udp_socket.h" -#include "rtc_base/event.h" -#include "rtc_base/gunit.h" +#include "rtc_base/buffer.h" #include "rtc_base/ip_address.h" #include "rtc_base/logging.h" #include "rtc_base/nat_server.h" @@ -40,8 +37,10 @@ #include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/thread.h" #include "rtc_base/virtual_socket_server.h" +#include "test/gmock.h" #include "test/gtest.h" #include "test/scoped_key_value_config.h" +#include "test/wait_until.h" namespace rtc { namespace { @@ -408,7 +407,9 @@ TEST_F(NatTcpTest, DISABLED_TestConnectOut) { ConnectEvents(); - EXPECT_TRUE_WAIT(connected_, 1000); + EXPECT_THAT( + webrtc::WaitUntil([&] { return connected_; }, ::testing::IsTrue()), + webrtc::IsRtcOk()); EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress()); EXPECT_EQ(accepted_->GetRemoteAddress().ipaddr(), ext_addr_.ipaddr()); diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc index d1999f349c..f838a21822 100644 --- a/rtc_base/network_unittest.cc +++ b/rtc_base/network_unittest.cc @@ -12,26 +12,39 @@ #include -#include +#include +#include #include +#include +#include #include #include "absl/algorithm/container.h" #include "absl/strings/match.h" #include "absl/strings/string_view.h" +#include "api/array_view.h" +#include "api/sequence_checker.h" +#include "api/test/rtc_error_matchers.h" #include "rtc_base/checks.h" +#include "rtc_base/ip_address.h" #include "rtc_base/net_helpers.h" #include "rtc_base/net_test_helpers.h" +#include "rtc_base/network_constants.h" #include "rtc_base/network_monitor.h" #include "rtc_base/network_monitor_factory.h" #include "rtc_base/physical_socket_server.h" +#include "rtc_base/socket_address.h" +#include "rtc_base/socket_factory.h" +#include "rtc_base/third_party/sigslot/sigslot.h" +#include "rtc_base/thread.h" +#include "test/gtest.h" +#include "test/wait_until.h" #if defined(WEBRTC_POSIX) #include #include #include "rtc_base/ifaddrs_converter.h" #endif // defined(WEBRTC_POSIX) -#include "rtc_base/gunit.h" #include "test/gmock.h" #if defined(WEBRTC_WIN) #include "rtc_base/logging.h" // For RTC_LOG_GLE @@ -40,6 +53,7 @@ #include "test/scoped_key_value_config.h" using ::testing::Contains; +using ::testing::IsTrue; using ::testing::Not; using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAreArray; @@ -93,7 +107,7 @@ class FakeNetworkMonitor : public NetworkMonitorInterface { } for (auto const& iter : adapters_) { - if (if_name.find(iter) != absl::string_view::npos) { + if (absl::StrContains(if_name, iter)) { return NetworkBindingResult::SUCCESS; } } @@ -1248,7 +1262,8 @@ TEST_F(NetworkTest, TestNetworkMonitoring) { manager.StartUpdating(); FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager); EXPECT_TRUE(network_monitor && network_monitor->started()); - EXPECT_TRUE_WAIT(callback_called_, 1000); + EXPECT_THAT(webrtc::WaitUntil([&] { return callback_called_; }, IsTrue()), + webrtc::IsRtcOk()); callback_called_ = false; // Clear the networks so that there will be network changes below. @@ -1256,7 +1271,8 @@ TEST_F(NetworkTest, TestNetworkMonitoring) { // Network manager is started, so the callback is called when the network // monitor fires the network-change event. network_monitor->InovkeNetworksChangedCallbackForTesting(); - EXPECT_TRUE_WAIT(callback_called_, 1000); + EXPECT_THAT(webrtc::WaitUntil([&] { return callback_called_; }, IsTrue()), + webrtc::IsRtcOk()); // Network manager is stopped. manager.StopUpdating(); @@ -1278,7 +1294,8 @@ TEST_F(NetworkTest, MAYBE_DefaultLocalAddress) { manager.SignalNetworksChanged.connect(static_cast(this), &NetworkTest::OnNetworksChanged); manager.StartUpdating(); - EXPECT_TRUE_WAIT(callback_called_, 1000); + EXPECT_THAT(webrtc::WaitUntil([&] { return callback_called_; }, IsTrue()), + webrtc::IsRtcOk()); // Make sure we can query default local address when an address for such // address family exists. diff --git a/rtc_base/null_socket_server_unittest.cc b/rtc_base/null_socket_server_unittest.cc index 58a6211aba..d6366be17d 100644 --- a/rtc_base/null_socket_server_unittest.cc +++ b/rtc_base/null_socket_server_unittest.cc @@ -14,22 +14,30 @@ #include +#include "api/test/rtc_error_matchers.h" #include "api/units/time_delta.h" -#include "rtc_base/gunit.h" +#include "rtc_base/socket_server.h" #include "rtc_base/thread.h" #include "rtc_base/time_utils.h" +#include "test/gmock.h" #include "test/gtest.h" +#include "test/wait_until.h" namespace rtc { TEST(NullSocketServerTest, WaitAndSet) { + AutoThread main_thread; NullSocketServer ss; auto thread = Thread::Create(); EXPECT_TRUE(thread->Start()); thread->PostTask([&ss] { ss.WakeUp(); }); // The process_io will be ignored. const bool process_io = true; - EXPECT_TRUE_WAIT(ss.Wait(SocketServer::kForever, process_io), 5'000); + EXPECT_THAT( + webrtc::WaitUntil( + [&] { return ss.Wait(SocketServer::kForever, process_io); }, + ::testing::IsTrue(), {.timeout = webrtc::TimeDelta::Millis(5'000)}), + webrtc::IsRtcOk()); } TEST(NullSocketServerTest, TestWait) { diff --git a/rtc_base/operations_chain_unittest.cc b/rtc_base/operations_chain_unittest.cc index 4f44423b19..78e02ed9e0 100644 --- a/rtc_base/operations_chain_unittest.cc +++ b/rtc_base/operations_chain_unittest.cc @@ -11,16 +11,21 @@ #include "rtc_base/operations_chain.h" #include +#include #include #include #include #include +#include "api/scoped_refptr.h" +#include "api/test/rtc_error_matchers.h" +#include "api/units/time_delta.h" +#include "rtc_base/checks.h" #include "rtc_base/event.h" -#include "rtc_base/gunit.h" #include "rtc_base/thread.h" #include "test/gmock.h" #include "test/gtest.h" +#include "test/wait_until.h" namespace rtc { @@ -28,7 +33,7 @@ using ::testing::ElementsAre; namespace { -constexpr int kDefaultTimeout = 3000; +constexpr webrtc::TimeDelta kDefaultTimeout = webrtc::TimeDelta::Millis(3000); } // namespace @@ -386,7 +391,7 @@ TEST(OperationsChainTest, IsEmpty) { unblock_async_operation_event1.Set(); async_operation_completed_event1->Wait(Event::kForever); EXPECT_FALSE(operation_tracker_proxy.IsEmpty()); - // Completing the last evenet empties the chain. + // Completing the last event empties the chain. unblock_async_operation_event2.Set(); async_operation_completed_event2->Wait(Event::kForever); EXPECT_TRUE(operation_tracker_proxy.IsEmpty()); @@ -411,7 +416,10 @@ TEST(OperationsChainTest, OnChainEmptyCallback) { // Completing the operation empties the chain, invoking the callback. unblock_async_operation_event0.Set(); async_operation_completed_event0->Wait(Event::kForever); - EXPECT_TRUE_WAIT(1u == on_empty_callback_counter, kDefaultTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; }, + ::testing::IsTrue(), {.timeout = kDefaultTimeout}), + webrtc::IsRtcOk()); // Chain multiple events. Event unblock_async_operation_event1; @@ -423,16 +431,25 @@ TEST(OperationsChainTest, OnChainEmptyCallback) { operation_tracker_proxy.PostAsynchronousOperation( &unblock_async_operation_event2); // Again, the callback is not invoked until the operation has completed. - EXPECT_TRUE_WAIT(1u == on_empty_callback_counter, kDefaultTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; }, + ::testing::IsTrue(), {.timeout = kDefaultTimeout}), + webrtc::IsRtcOk()); // Upon completing the first event, the chain is still not empty, so the // callback must not be invoked yet. unblock_async_operation_event1.Set(); async_operation_completed_event1->Wait(Event::kForever); - EXPECT_TRUE_WAIT(1u == on_empty_callback_counter, kDefaultTimeout); - // Completing the last evenet empties the chain, invoking the callback. + EXPECT_THAT( + webrtc::WaitUntil([&] { return on_empty_callback_counter == 1u; }, + ::testing::IsTrue(), {.timeout = kDefaultTimeout}), + webrtc::IsRtcOk()); + // Completing the last event empties the chain, invoking the callback. unblock_async_operation_event2.Set(); async_operation_completed_event2->Wait(Event::kForever); - EXPECT_TRUE_WAIT(2u == on_empty_callback_counter, kDefaultTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return on_empty_callback_counter == 2u; }, + ::testing::IsTrue(), {.timeout = kDefaultTimeout}), + webrtc::IsRtcOk()); } TEST(OperationsChainTest, diff --git a/rtc_base/physical_socket_server_unittest.cc b/rtc_base/physical_socket_server_unittest.cc index c61e9b4c78..cf12955cb9 100644 --- a/rtc_base/physical_socket_server_unittest.cc +++ b/rtc_base/physical_socket_server_unittest.cc @@ -10,22 +10,24 @@ #include "rtc_base/physical_socket_server.h" -#include - #include +#include #include -#include "rtc_base/gunit.h" +#include "api/test/rtc_error_matchers.h" #include "rtc_base/ip_address.h" #include "rtc_base/logging.h" #include "rtc_base/net_helpers.h" #include "rtc_base/net_test_helpers.h" #include "rtc_base/network_monitor.h" +#include "rtc_base/socket.h" +#include "rtc_base/socket_address.h" #include "rtc_base/socket_unittest.h" #include "rtc_base/test_utils.h" #include "rtc_base/thread.h" -#include "test/field_trial.h" +#include "test/gmock.h" #include "test/gtest.h" +#include "test/wait_until.h" namespace rtc { @@ -238,8 +240,11 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) { EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE)); // Server has pending connection, try to accept it (will fail). - EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)), - kTimeout); + EXPECT_THAT( + webrtc::WaitUntil( + [&] { return (sink.Check(server.get(), webrtc::testing::SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); // Simulate "::accept" returning an error. SetFailAccept(true); std::unique_ptr accepted(server->Accept(&accept_addr)); @@ -262,8 +267,11 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) { EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_CLOSE)); // Server has pending connection, try to accept it (will succeed). - EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)), - kTimeout); + EXPECT_THAT( + webrtc::WaitUntil( + [&] { return (sink.Check(server.get(), webrtc::testing::SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); SetFailAccept(false); std::unique_ptr accepted2(server->Accept(&accept_addr)); ASSERT_TRUE(accepted2); diff --git a/rtc_base/rtc_certificate_generator_unittest.cc b/rtc_base/rtc_certificate_generator_unittest.cc index 84a15d49e3..c36d6d528e 100644 --- a/rtc_base/rtc_certificate_generator_unittest.cc +++ b/rtc_base/rtc_certificate_generator_unittest.cc @@ -10,14 +10,21 @@ #include "rtc_base/rtc_certificate_generator.h" +#include #include #include +#include -#include "api/make_ref_counted.h" +#include "api/scoped_refptr.h" +#include "api/test/rtc_error_matchers.h" +#include "api/units/time_delta.h" #include "rtc_base/checks.h" -#include "rtc_base/gunit.h" +#include "rtc_base/rtc_certificate.h" +#include "rtc_base/ssl_identity.h" #include "rtc_base/thread.h" +#include "test/gmock.h" #include "test/gtest.h" +#include "test/wait_until.h" namespace rtc { @@ -65,7 +72,8 @@ class RTCCertificateGeneratorFixture { class RTCCertificateGeneratorTest : public ::testing::Test { public: protected: - static constexpr int kGenerationTimeoutMs = 10000; + static constexpr webrtc::TimeDelta kGenerationTimeoutMs = + webrtc::TimeDelta::Millis(10000); rtc::AutoThread main_thread_; RTCCertificateGeneratorFixture fixture_; @@ -90,7 +98,10 @@ TEST_F(RTCCertificateGeneratorTest, GenerateAsyncECDSA) { // posted to this thread (which is done by `EXPECT_TRUE_WAIT`). EXPECT_FALSE(fixture_.GenerateAsyncCompleted()); EXPECT_FALSE(fixture_.certificate()); - EXPECT_TRUE_WAIT(fixture_.GenerateAsyncCompleted(), kGenerationTimeoutMs); + EXPECT_THAT( + webrtc::WaitUntil([&] { return fixture_.GenerateAsyncCompleted(); }, + ::testing::IsTrue(), {.timeout = kGenerationTimeoutMs}), + webrtc::IsRtcOk()); EXPECT_TRUE(fixture_.certificate()); } @@ -118,7 +129,7 @@ TEST_F(RTCCertificateGeneratorTest, GenerateWithExpires) { EXPECT_GT(cert_b->Expires(), cert_a->Expires()); uint64_t expires_diff = cert_b->Expires() - cert_a->Expires(); EXPECT_GE(expires_diff, kExpiresMs); - EXPECT_LE(expires_diff, kExpiresMs + 2 * kGenerationTimeoutMs + 1000); + EXPECT_LE(expires_diff, kExpiresMs + 2 * kGenerationTimeoutMs.ms() + 1000); } TEST_F(RTCCertificateGeneratorTest, GenerateWithInvalidParamsShouldFail) { @@ -130,7 +141,10 @@ TEST_F(RTCCertificateGeneratorTest, GenerateWithInvalidParamsShouldFail) { fixture_.generator()->GenerateCertificateAsync(invalid_params, std::nullopt, fixture_.OnGenerated()); - EXPECT_TRUE_WAIT(fixture_.GenerateAsyncCompleted(), kGenerationTimeoutMs); + EXPECT_THAT( + webrtc::WaitUntil([&] { return fixture_.GenerateAsyncCompleted(); }, + ::testing::IsTrue(), {.timeout = kGenerationTimeoutMs}), + webrtc::IsRtcOk()); EXPECT_FALSE(fixture_.certificate()); } diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc index 43dc1ae20e..11b40ee3a8 100644 --- a/rtc_base/socket_unittest.cc +++ b/rtc_base/socket_unittest.cc @@ -17,18 +17,22 @@ #include #include #include +#include +#include #include "absl/memory/memory.h" #include "absl/strings/string_view.h" -#include "api/units/timestamp.h" +#include "api/test/rtc_error_matchers.h" +#include "api/units/time_delta.h" #include "rtc_base/arraysize.h" -#include "rtc_base/async_packet_socket.h" #include "rtc_base/async_udp_socket.h" #include "rtc_base/buffer.h" #include "rtc_base/gunit.h" +#include "rtc_base/ip_address.h" #include "rtc_base/logging.h" #include "rtc_base/net_helpers.h" #include "rtc_base/net_test_helpers.h" +#include "rtc_base/network/ecn_marking.h" #include "rtc_base/socket_address.h" #include "rtc_base/socket_server.h" #include "rtc_base/socket_unittest.h" @@ -37,6 +41,9 @@ #include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/thread.h" #include "rtc_base/time_utils.h" +#include "test/gmock.h" +#include "test/gtest.h" +#include "test/wait_until.h" namespace rtc { @@ -288,7 +295,10 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) { EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); // Server has pending connection, accept it. - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); EXPECT_FALSE(accept_addr.IsNil()); @@ -300,7 +310,9 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) { EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); // Connected from client perspective, check the addresses are correct. - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); @@ -337,7 +349,10 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback, EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); // Server has pending connection, accept it. - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); EXPECT_FALSE(accept_addr.IsNil()); @@ -349,7 +364,9 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback, EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); // Connected from client perspective, check the addresses are correct. - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); @@ -378,7 +395,9 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(bogus_addr)); // Wait for connection to fail (ECONNREFUSED). - EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CLOSED)), + webrtc::IsRtcOk()); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(client->GetRemoteAddress().IsNil()); @@ -412,14 +431,16 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) { // Wait for connection to fail (EHOSTNOTFOUND). bool dns_lookup_finished = false; - WAIT_(client->GetState() == Socket::CS_CLOSED, kTimeout, dns_lookup_finished); + WAIT_(client->GetState() == Socket::CS_CLOSED, 5000, dns_lookup_finished); if (!dns_lookup_finished) { RTC_LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 " "seconds."; return; } - EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CLOSED)), + webrtc::IsRtcOk()); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(client->GetRemoteAddress().IsNil()); @@ -466,7 +487,10 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) { // Accept the original connection. SocketAddress accept_addr; - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); EXPECT_FALSE(accept_addr.IsNil()); @@ -475,7 +499,9 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) { EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); @@ -508,11 +534,16 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); // Close down the server while the socket is in the accept queue. - EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(server.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); server->Close(); // This should fail the connection for the client. Clean up. - EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CLOSED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); client->Close(); } @@ -537,7 +568,10 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); // Close down the client while the socket is in the accept queue. - EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(server.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); client->Close(); // The connection should still be able to be accepted. @@ -547,7 +581,9 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) { EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); // The accepted socket should then close (possibly with err, timing-related) - EXPECT_EQ_WAIT(Socket::CS_CLOSED, accepted->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return accepted->GetState(); }, + ::testing::Eq(Socket::CS_CLOSED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) || sink.Check(accepted.get(), SSE_ERROR)); @@ -575,13 +611,18 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); // Accept connection. - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); @@ -592,7 +633,10 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { EXPECT_EQ(Socket::CS_CLOSED, accepted->GetState()); // Expect that the client is notified, and has not yet closed. - EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(client.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_EQ(Socket::CS_CONNECTED, client->GetState()); @@ -602,7 +646,9 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { EXPECT_EQ('a', buffer[0]); // Now we should close, but the remote address will remain. - EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CLOSED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP()); @@ -650,13 +696,18 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); // Accept connection. - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); @@ -670,7 +721,9 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) { EXPECT_EQ(Socket::CS_CONNECTED, client->GetState()); // Now we should be closed and invalidated - EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CLOSED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_TRUE(Socket::CS_CLOSED == client->GetState()); } @@ -708,7 +761,9 @@ void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) { // event. SocketDeleter deleter(std::move(socket2)); socket1->SignalReadEvent.connect(&deleter, &SocketDeleter::Delete); - EXPECT_TRUE_WAIT(deleter.deleted(), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return deleter.deleted(); }, ::testing::IsTrue()), + webrtc::IsRtcOk()); } void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) { @@ -726,7 +781,10 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) { EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); @@ -735,7 +793,9 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) { EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); @@ -755,7 +815,10 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) { EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ)); // But should signal when process_io is true. - EXPECT_TRUE_WAIT((sink.Check(accepted.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(accepted.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr)); } @@ -781,13 +844,18 @@ void SocketTest::TcpInternal(const IPAddress& loopback, EXPECT_EQ(0, receiver->Connect(server->GetLocalAddress())); // Accept connection which will be used for sending. - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr sender(server->Accept(&accept_addr)); ASSERT_TRUE(sender); sink.Monitor(sender.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, receiver->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return receiver->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(receiver.get(), SSE_OPEN)); EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress()); EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress()); @@ -840,7 +908,10 @@ void SocketTest::TcpInternal(const IPAddress& loopback, while (recv_buffer.size() < sent_size) { if (!readable) { // Wait until data is available. - EXPECT_TRUE_WAIT(sink.Check(receiver.get(), SSE_READ), kTimeout); + EXPECT_THAT(webrtc::WaitUntil( + [&] { return sink.Check(receiver.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); readable = true; recv_called = false; } @@ -869,7 +940,10 @@ void SocketTest::TcpInternal(const IPAddress& loopback, // Once all that we've sent has been received, expect to be able to send // again. if (!writable) { - ASSERT_TRUE_WAIT(sink.Check(sender.get(), SSE_WRITE), kTimeout); + ASSERT_THAT( + webrtc::WaitUntil([&] { return sink.Check(sender.get(), SSE_WRITE); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); writable = true; send_called = false; } @@ -882,7 +956,9 @@ void SocketTest::TcpInternal(const IPAddress& loopback, // Close down. sender->Close(); - EXPECT_EQ_WAIT(Socket::CS_CLOSED, receiver->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return receiver->GetState(); }, + ::testing::Eq(Socket::CS_CLOSED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE)); receiver->Close(); } @@ -907,19 +983,27 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); // Accept connection. - EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->GetState(); }, + ::testing::Eq(Socket::CS_CONNECTED)), + webrtc::IsRtcOk()); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); // Expect a writable callback from the connect. - EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(accepted.get(), SSE_WRITE); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); // Fill the socket buffer. char buf[1024 * 16] = {0}; @@ -929,7 +1013,10 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) { EXPECT_TRUE(accepted->IsBlocking()); // Wait until data is available. - EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(client.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); // Pull data. for (int i = 0; i < sends; ++i) { @@ -937,7 +1024,10 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) { } // Expect at least one additional writable callback. - EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(accepted.get(), SSE_WRITE); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); // Adding data in response to the writeable callback shouldn't cause infinite // callbacks. @@ -1030,7 +1120,7 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) { uint32_t start_ms = Time(); int sent_packet_num = 0; int expected_error = EWOULDBLOCK; - while (start_ms + kTimeout > Time()) { + while (start_ms + 5000 > Time()) { int ret = client->SendTo(test_packet.get(), test_packet_size, test_addr); ++sent_packet_num; if (ret != test_packet_size) { @@ -1044,7 +1134,9 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) { } EXPECT_EQ(expected_error, error); EXPECT_FALSE(client->ready_to_send()); - EXPECT_TRUE_WAIT(client->ready_to_send(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return client->ready_to_send(); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); RTC_LOG(LS_INFO) << "Got SignalReadyToSend"; } @@ -1153,7 +1245,10 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) { socket->SendTo("foo", 3, address); // Wait until data is available. - EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); rtc::Buffer buffer; Socket::ReceiveBuffer receive_buffer_1(buffer); ASSERT_GT(socket->RecvFrom(receive_buffer_1), 0); @@ -1164,7 +1259,10 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) { int64_t send_time_2 = TimeMicros(); socket->SendTo("bar", 3, address); // Wait until data is available. - EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); Socket::ReceiveBuffer receive_buffer_2(buffer); ASSERT_GT(socket->RecvFrom(receive_buffer_2), 0); @@ -1214,7 +1312,10 @@ void SocketTest::SocketSendRecvWithEcn(const IPAddress& loopback) { Socket::ReceiveBuffer receive_buffer(buffer); socket->SendTo("foo", 3, address); - EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); ASSERT_GT(socket->RecvFrom(receive_buffer), 0); EXPECT_EQ(receive_buffer.ecn, EcnMarking::kNotEct); @@ -1222,19 +1323,28 @@ void SocketTest::SocketSendRecvWithEcn(const IPAddress& loopback) { socket->SetOption(Socket::OPT_RECV_ECN, 1); socket->SendTo("bar", 3, address); - EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); ASSERT_GT(socket->RecvFrom(receive_buffer), 0); EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct1); socket->SetOption(Socket::OPT_SEND_ECN, 2); // Ect(0) socket->SendTo("bar", 3, address); - EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); ASSERT_GT(socket->RecvFrom(receive_buffer), 0); EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct0); socket->SetOption(Socket::OPT_SEND_ECN, 3); // Ce socket->SendTo("bar", 3, address); - EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); ASSERT_GT(socket->RecvFrom(receive_buffer), 0); EXPECT_EQ(receive_buffer.ecn, EcnMarking::kCe); } diff --git a/rtc_base/socket_unittest.h b/rtc_base/socket_unittest.h index 4d24f3641d..00011b48b6 100644 --- a/rtc_base/socket_unittest.h +++ b/rtc_base/socket_unittest.h @@ -11,13 +11,16 @@ #ifndef RTC_BASE_SOCKET_UNITTEST_H_ #define RTC_BASE_SOCKET_UNITTEST_H_ +#include + #include "absl/strings/string_view.h" -#include "rtc_base/gunit.h" -#include "rtc_base/thread.h" +#include "rtc_base/ip_address.h" +#include "rtc_base/socket_factory.h" +#include "test/gtest.h" namespace rtc { -// Generic socket tests, to be used when testing individual socketservers. +// Generic socket tests, to be used when testing individual socket servers. // Derive your specific test class from SocketTest, install your // socketserver, and call the SocketTest test methods. class SocketTest : public ::testing::Test { @@ -67,7 +70,6 @@ class SocketTest : public ::testing::Test { void TestSocketSendRecvWithEcnIPV4(); void TestSocketSendRecvWithEcnIPV6(); - static const int kTimeout = 5000; // ms const IPAddress kIPv4Loopback; const IPAddress kIPv6Loopback; diff --git a/rtc_base/ssl_adapter_unittest.cc b/rtc_base/ssl_adapter_unittest.cc index 211042d1df..59aedb3927 100644 --- a/rtc_base/ssl_adapter_unittest.cc +++ b/rtc_base/ssl_adapter_unittest.cc @@ -10,37 +10,33 @@ #include "rtc_base/ssl_adapter.h" -#include -#include #include #include #include #include #include "absl/strings/string_view.h" -#include "api/array_view.h" -#include "api/sequence_checker.h" -#include "rtc_base/checks.h" -#include "rtc_base/gunit.h" +#include "api/test/rtc_error_matchers.h" +#include "api/units/time_delta.h" #include "rtc_base/ip_address.h" #include "rtc_base/logging.h" -#include "rtc_base/message_digest.h" #include "rtc_base/socket.h" #include "rtc_base/socket_address.h" #include "rtc_base/ssl_certificate.h" #include "rtc_base/ssl_identity.h" -#include "rtc_base/stream.h" +#include "rtc_base/ssl_stream_adapter.h" #include "rtc_base/string_encode.h" #include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/thread.h" #include "rtc_base/virtual_socket_server.h" #include "test/gmock.h" #include "test/gtest.h" +#include "test/wait_until.h" using ::testing::_; using ::testing::Return; -static const int kTimeout = 5000; +static const webrtc::TimeDelta kTimeout = webrtc::TimeDelta::Millis(5000); static rtc::Socket* CreateSocket() { rtc::SocketAddress address(rtc::IPAddress(INADDR_ANY), 0); @@ -207,9 +203,11 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> { thread_(vss_.get()), server_(new SSLAdapterTestDummyServer(key_params)), client_(new SSLAdapterTestDummyClient()), - handshake_wait_(kTimeout) {} + handshake_wait_(webrtc::TimeDelta::Millis(kTimeout.ms())) {} - void SetHandshakeWait(int wait) { handshake_wait_ = wait; } + void SetHandshakeWait(int wait) { + handshake_wait_ = webrtc::TimeDelta::Millis(wait); + } void SetIgnoreBadCert(bool ignore_bad_cert) { client_->SetIgnoreBadCert(ignore_bad_cert); @@ -252,15 +250,19 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> { if (expect_success) { // If expecting success, the client should end up in the CS_CONNECTED // state after handshake. - EXPECT_EQ_WAIT(rtc::Socket::CS_CONNECTED, client_->GetState(), - handshake_wait_); + EXPECT_THAT(webrtc::WaitUntil([&] { return client_->GetState(); }, + ::testing::Eq(rtc::Socket::CS_CONNECTED), + {.timeout = handshake_wait_}), + webrtc::IsRtcOk()); RTC_LOG(LS_INFO) << "TLS handshake complete."; } else { // On handshake failure the client should end up in the CS_CLOSED state. - EXPECT_EQ_WAIT(rtc::Socket::CS_CLOSED, client_->GetState(), - handshake_wait_); + EXPECT_THAT(webrtc::WaitUntil([&] { return client_->GetState(); }, + ::testing::Eq(rtc::Socket::CS_CLOSED), + {.timeout = handshake_wait_}), + webrtc::IsRtcOk()); RTC_LOG(LS_INFO) << "TLS handshake failed."; } @@ -273,13 +275,19 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> { ASSERT_EQ(static_cast(message.length()), rv); // The server should have received the client's message. - EXPECT_EQ_WAIT(message, server_->GetReceivedData(), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return server_->GetReceivedData(); }, + ::testing::Eq(message), {.timeout = kTimeout}), + webrtc::IsRtcOk()); rv = server_->Send(message); ASSERT_EQ(static_cast(message.length()), rv); // The client should have received the server's message. - EXPECT_EQ_WAIT(message, client_->GetReceivedData(), kTimeout); + EXPECT_THAT( + webrtc::WaitUntil([&] { return client_->GetReceivedData(); }, + ::testing::Eq(message), {.timeout = kTimeout}), + webrtc::IsRtcOk()); RTC_LOG(LS_INFO) << "Transfer complete."; } @@ -291,7 +299,7 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> { std::unique_ptr client_; std::unique_ptr cert_verifier_; - int handshake_wait_; + webrtc::TimeDelta handshake_wait_; }; class SSLAdapterTestTLS_RSA : public SSLAdapterTestBase { @@ -383,14 +391,18 @@ TEST_F(SSLAdapterTestTLS_RSA, TestTLSTransferWithBlockedSocket) { // Unblock the underlying socket. All of the buffered messages should be sent // without any further action. vss_->SetSendingBlocked(false); - EXPECT_EQ_WAIT(expected, server_->GetReceivedData(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return server_->GetReceivedData(); }, + ::testing::Eq(expected), {.timeout = kTimeout}), + webrtc::IsRtcOk()); // Send another message. This previously wasn't working std::string final_message = "Fin."; expected += final_message; EXPECT_EQ(static_cast(final_message.size()), client_->Send(final_message)); - EXPECT_EQ_WAIT(expected, server_->GetReceivedData(), kTimeout); + EXPECT_THAT(webrtc::WaitUntil([&] { return server_->GetReceivedData(); }, + ::testing::Eq(expected), {.timeout = kTimeout}), + webrtc::IsRtcOk()); } // Test transfer between client and server, using ECDSA diff --git a/rtc_base/ssl_stream_adapter_unittest.cc b/rtc_base/ssl_stream_adapter_unittest.cc index cf19a028b6..8def128920 100644 --- a/rtc_base/ssl_stream_adapter_unittest.cc +++ b/rtc_base/ssl_stream_adapter_unittest.cc @@ -33,6 +33,7 @@ #include "api/array_view.h" #include "api/sequence_checker.h" #include "api/task_queue/pending_task_safety_flag.h" +#include "api/test/rtc_error_matchers.h" #include "api/units/time_delta.h" #include "rtc_base/buffer.h" #include "rtc_base/buffer_queue.h" @@ -40,7 +41,6 @@ #include "rtc_base/checks.h" #include "rtc_base/crypto_random.h" #include "rtc_base/fake_clock.h" -#include "rtc_base/gunit.h" #include "rtc_base/logging.h" #include "rtc_base/message_digest.h" #include "rtc_base/ssl_identity.h" @@ -51,6 +51,7 @@ #include "test/field_trial.h" #include "test/gmock.h" #include "test/gtest.h" +#include "test/wait_until.h" using ::testing::Combine; using ::testing::NotNull; @@ -423,7 +424,7 @@ class SSLStreamAdapterTestBase : public ::testing::Test, lose_first_packet_(false), damage_(false), dtls_(dtls), - handshake_wait_(5000), + handshake_wait_(webrtc::TimeDelta::Millis(5000)), identities_set_(false) { // Set use of the test RNG to get predictable loss patterns. rtc::SetRandomTestMode(true); @@ -587,12 +588,20 @@ class SSLStreamAdapterTestBase : public ::testing::Test, // Now run the handshake if (expect_success) { - EXPECT_TRUE_SIMULATED_WAIT((client_ssl_->GetState() == rtc::SS_OPEN) && - (server_ssl_->GetState() == rtc::SS_OPEN), - handshake_wait_, clock_); + EXPECT_THAT(webrtc::WaitUntil( + [&] { + return (client_ssl_->GetState() == rtc::SS_OPEN) && + (server_ssl_->GetState() == rtc::SS_OPEN); + }, + ::testing::IsTrue(), + {.timeout = handshake_wait_, .clock = &clock_}), + webrtc::IsRtcOk()); } else { - EXPECT_TRUE_SIMULATED_WAIT(client_ssl_->GetState() == rtc::SS_CLOSED, - handshake_wait_, clock_); + EXPECT_THAT( + webrtc::WaitUntil([&] { return client_ssl_->GetState(); }, + ::testing::Eq(rtc::SS_CLOSED), + {.timeout = handshake_wait_, .clock = &clock_}), + webrtc::IsRtcOk()); } } @@ -629,9 +638,13 @@ class SSLStreamAdapterTestBase : public ::testing::Test, while (client_ssl_->GetState() == rtc::SS_OPENING && (rtc::TimeDiff(clock_.TimeNanos(), time_start) < 3600 * rtc::kNumNanosecsPerSec)) { - EXPECT_TRUE_SIMULATED_WAIT(!((client_ssl_->GetState() == rtc::SS_OPEN) && - (server_ssl_->GetState() == rtc::SS_OPEN)), - 1000, clock_); + EXPECT_THAT(webrtc::WaitUntil( + [&] { + return !((client_ssl_->GetState() == rtc::SS_OPEN) && + (server_ssl_->GetState() == rtc::SS_OPEN)); + }, + ::testing::IsTrue(), {.clock = &clock_}), + webrtc::IsRtcOk()); clock_.AdvanceTime(time_increment); } EXPECT_EQ(client_ssl_->GetState(), rtc::SS_CLOSED); @@ -656,9 +669,14 @@ class SSLStreamAdapterTestBase : public ::testing::Test, ASSERT_EQ(0, client_ssl_->StartSSL()); // Now run the handshake. - EXPECT_TRUE_SIMULATED_WAIT( - client_ssl_->IsTlsConnected() && server_ssl_->IsTlsConnected(), - handshake_wait_, clock_); + EXPECT_THAT(webrtc::WaitUntil( + [&] { + return client_ssl_->IsTlsConnected() && + server_ssl_->IsTlsConnected(); + }, + ::testing::IsTrue(), + {.timeout = handshake_wait_, .clock = &clock_}), + webrtc::IsRtcOk()); // Until the identity has been verified, the state should still be // SS_OPENING and writes should return SR_BLOCK. @@ -779,7 +797,9 @@ class SSLStreamAdapterTestBase : public ::testing::Test, void SetMtu(size_t mtu) { mtu_ = mtu; } - void SetHandshakeWait(int wait) { handshake_wait_ = wait; } + void SetHandshakeWait(int wait) { + handshake_wait_ = webrtc::TimeDelta::Millis(wait); + } void SetDtlsSrtpCryptoSuites(const std::vector& ciphers, bool client) { if (client) @@ -875,7 +895,7 @@ class SSLStreamAdapterTestBase : public ::testing::Test, bool lose_first_packet_; bool damage_; bool dtls_; - int handshake_wait_; + webrtc::TimeDelta handshake_wait_; bool identities_set_; }; @@ -978,15 +998,20 @@ class SSLStreamAdapterTestDTLSBase : public SSLStreamAdapterTestBase { WriteData(); - EXPECT_TRUE_SIMULATED_WAIT(sent_ == count_, 10000, clock_); + EXPECT_THAT(webrtc::WaitUntil([&] { return sent_; }, ::testing::Eq(count_), + {.timeout = webrtc::TimeDelta::Millis(10000), + .clock = &clock_}), + webrtc::IsRtcOk()); RTC_LOG(LS_INFO) << "sent_ == " << sent_; if (damage_) { - SIMULATED_WAIT(false, 2000, clock_); + clock_.AdvanceTime(webrtc::TimeDelta::Millis(2000)); EXPECT_EQ(0U, received_.size()); } else if (loss_ == 0) { - EXPECT_EQ_SIMULATED_WAIT(static_cast(sent_), received_.size(), - 1000, clock_); + EXPECT_THAT(webrtc::WaitUntil([&] { return received_.size(); }, + ::testing::Eq(static_cast(sent_)), + {.clock = &clock_}), + webrtc::IsRtcOk()); } else { RTC_LOG(LS_INFO) << "Sent " << sent_ << " packets; received " << received_.size(); diff --git a/rtc_base/test_client.cc b/rtc_base/test_client.cc index 3bcc5098e6..062da32716 100644 --- a/rtc_base/test_client.cc +++ b/rtc_base/test_client.cc @@ -12,12 +12,19 @@ #include +#include #include +#include #include +#include "api/units/time_delta.h" #include "api/units/timestamp.h" -#include "rtc_base/gunit.h" +#include "rtc_base/async_packet_socket.h" +#include "rtc_base/fake_clock.h" #include "rtc_base/network/received_packet.h" +#include "rtc_base/socket.h" +#include "rtc_base/socket_address.h" +#include "rtc_base/synchronization/mutex.h" #include "rtc_base/thread.h" #include "rtc_base/time_utils.h" @@ -79,7 +86,7 @@ std::unique_ptr TestClient::NextPacket(int timeout_ms) { while (TimeUntil(end) > 0) { { webrtc::MutexLock lock(&mutex_); - if (packets_.size() != 0) { + if (!packets_.empty()) { break; } } @@ -89,7 +96,7 @@ std::unique_ptr TestClient::NextPacket(int timeout_ms) { // Return the first packet placed in the queue. std::unique_ptr packet; webrtc::MutexLock lock(&mutex_); - if (packets_.size() > 0) { + if (!packets_.empty()) { packet = std::move(packets_.front()); packets_.erase(packets_.begin()); } @@ -131,7 +138,9 @@ void TestClient::AdvanceTime(int ms) { // If the test is using a fake clock, we must advance the fake clock to // advance time. Otherwise, ProcessMessages will work. if (fake_clock_) { - SIMULATED_WAIT(false, ms, *fake_clock_); + for (int64_t start = rtc ::TimeMillis(); rtc ::TimeMillis() < start + ms;) { + fake_clock_->AdvanceTime(webrtc ::TimeDelta ::Millis(1)); + }; } else { Thread::Current()->ProcessMessages(1); } diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc index 11ee2abc9f..da7a36e512 100644 --- a/rtc_base/thread_unittest.cc +++ b/rtc_base/thread_unittest.cc @@ -10,27 +10,39 @@ #include "rtc_base/thread.h" +#include +#include +#include #include +#include +#include +#include "absl/strings/string_view.h" #include "api/field_trials_view.h" +#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_factory.h" #include "api/task_queue/task_queue_test.h" +#include "api/test/rtc_error_matchers.h" #include "api/units/time_delta.h" +#include "rtc_base/async_packet_socket.h" #include "rtc_base/async_udp_socket.h" #include "rtc_base/checks.h" #include "rtc_base/event.h" #include "rtc_base/fake_clock.h" -#include "rtc_base/gunit.h" #include "rtc_base/internal/default_socket_server.h" #include "rtc_base/network/received_packet.h" #include "rtc_base/null_socket_server.h" -#include "rtc_base/physical_socket_server.h" -#include "rtc_base/ref_counted_object.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_address.h" +#include "rtc_base/socket_server.h" #include "rtc_base/synchronization/mutex.h" #include "rtc_base/third_party/sigslot/sigslot.h" +#include "rtc_base/thread_annotations.h" +#include "rtc_base/time_utils.h" #include "test/gmock.h" +#include "test/gtest.h" #include "test/testsupport/rtc_expect_death.h" +#include "test/wait_until.h" #if defined(WEBRTC_WIN) #include // NOLINT @@ -457,7 +469,9 @@ TEST(ThreadTest, ThreeThreadsBlockingCall) { SetAndInvokeSet(&async_invoked, thread2, out); }); - EXPECT_TRUE_WAIT(async_invoked.Get(), 2000); + EXPECT_THAT(webrtc::WaitUntil([&] { return async_invoked.Get(); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); } }; @@ -472,7 +486,9 @@ TEST(ThreadTest, ThreeThreadsBlockingCall) { }); EXPECT_FALSE(thread_a_called.Get()); - EXPECT_TRUE_WAIT(thread_a_called.Get(), 2000); + EXPECT_THAT(webrtc::WaitUntil([&] { return thread_a_called.Get(); }, + ::testing::IsTrue()), + webrtc::IsRtcOk()); } static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(