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

Replace gunit.h macros with WaitUntil in rtc_base/

Browse Source 
Bug: webrtc:381524905
Change-Id: I7a78269586ee3556c0b3de63f5add393f12f4fa1
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/374223
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43757}
This commit is contained in:
Evan Shrubsole 2025-01-17 13:19:45 +00:00 committed by WebRTC LUCI CQ
parent 762753d0a2
commit d9593037dd
14 changed files with 412 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
rtc_base/BUILD.gn
View File

@ -873,8 +873,15 @@ rtc_library("async_dns_resolver_unittests") {
deps = [ deps = [
":async_dns_resolver", ":async_dns_resolver",
":gunit_helpers", ":gunit_helpers",
":logging",
":net_helpers",
":socket_address",
":threading",
"../api:rtc_error_matchers",
"../api/units:time_delta",
"../test:run_loop", "../test:run_loop",
"../test:test_support", "../test:test_support",
"../test:wait_until",
] ]
} }
@ -1649,12 +1656,16 @@ rtc_library("testclient") {
"test_client.h", "test_client.h",
] ]
deps = [ deps = [
":async_packet_socket",
":async_udp_socket", ":async_udp_socket",
":buffer", ":buffer",
":gunit_helpers", ":gunit_helpers",
":rtc_base_tests_utils", ":rtc_base_tests_utils",
":socket",
":socket_address",
":threading", ":threading",
":timeutils", ":timeutils",
"../api/units:time_delta",
"../api/units:timestamp", "../api/units:timestamp",
"network:received_packet", "network:received_packet",
"synchronization:mutex", "synchronization:mutex",
@ -1804,11 +1815,16 @@ if (rtc_include_tests) {
sources = [ "operations_chain_unittest.cc" ] sources = [ "operations_chain_unittest.cc" ]
deps = [ deps = [
":checks",
":gunit_helpers", ":gunit_helpers",
":rtc_event", ":rtc_event",
":rtc_operations_chain", ":rtc_operations_chain",
":threading", ":threading",
"../api:rtc_error_matchers",
"../api:scoped_refptr",
"../api/units:time_delta",
"../test:test_support", "../test:test_support",
"../test:wait_until",
] ]
} }
@ -1842,10 +1858,12 @@ if (rtc_include_tests) {
":rtc_base_tests_utils", ":rtc_base_tests_utils",
":socket", ":socket",
":socket_address", ":socket_address",
":socket_factory",
":socket_server", ":socket_server",
":testclient", ":testclient",
":threading", ":threading",
":timeutils", ":timeutils",
"../api:rtc_error_matchers",
"../api/units:time_delta", "../api/units:time_delta",
"../api/units:timestamp", "../api/units:timestamp",
"../system_wrappers", "../system_wrappers",
@ -1853,6 +1871,8 @@ if (rtc_include_tests) {
"../test:fileutils", "../test:fileutils",
"../test:test_main", "../test:test_main",
"../test:test_support", "../test:test_support",
"../test:wait_until",
"network:ecn_marking",
"third_party/sigslot", "third_party/sigslot",
"//testing/gtest", "//testing/gtest",
"//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/memory",
@ -2104,6 +2124,7 @@ if (rtc_include_tests) {
":net_helpers", ":net_helpers",
":net_test_helpers", ":net_test_helpers",
":network", ":network",
":network_constants",
":network_route", ":network_route",
":null_socket_server", ":null_socket_server",
":refcount", ":refcount",
@ -2129,6 +2150,8 @@ if (rtc_include_tests) {
"../api:array_view", "../api:array_view",
"../api:field_trials_view", "../api:field_trials_view",
"../api:make_ref_counted", "../api:make_ref_counted",
"../api:rtc_error_matchers",
"../api:scoped_refptr",
"../api:sequence_checker", "../api:sequence_checker",
"../api/task_queue", "../api/task_queue",
"../api/task_queue:pending_task_safety_flag", "../api/task_queue:pending_task_safety_flag",
@ -2140,6 +2163,7 @@ if (rtc_include_tests) {
"../test:scoped_key_value_config", "../test:scoped_key_value_config",
"../test:test_main", "../test:test_main",
"../test:test_support", "../test:test_support",
"../test:wait_until",
"memory:fifo_buffer", "memory:fifo_buffer",
"network:received_packet", "network:received_packet",
"synchronization:mutex", "synchronization:mutex",

20
rtc_base/async_dns_resolver_unittest.cc
View File

@ -10,13 +10,25 @@
#include "rtc_base/async_dns_resolver.h" #include "rtc_base/async_dns_resolver.h"
#include "rtc_base/gunit.h" #include <memory>
#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/gtest.h"
#include "test/run_loop.h" #include "test/run_loop.h"
#include "test/wait_until.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
const int kDefaultTimeout = 1000;
using ::testing::IsTrue;
const webrtc::TimeDelta kDefaultTimeout = webrtc::TimeDelta::Millis(1000);
const int kPortNumber = 3027; const int kPortNumber = 3027;
TEST(AsyncDnsResolver, ConstructorWorks) { TEST(AsyncDnsResolver, ConstructorWorks) {
@ -31,7 +43,9 @@ TEST(AsyncDnsResolver, ResolvingLocalhostWorks) {
rtc::SocketAddress resolved_address; rtc::SocketAddress resolved_address;
bool done = false; bool done = false;
resolver.Start(address, [&done] { done = true; }); 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); EXPECT_EQ(resolver.result().GetError(), 0);
if (resolver.result().GetResolvedAddress(AF_INET, &resolved_address)) { if (resolver.result().GetResolvedAddress(AF_INET, &resolved_address)) {
EXPECT_EQ(resolved_address, rtc::SocketAddress("127.0.0.1", kPortNumber)); EXPECT_EQ(resolved_address, rtc::SocketAddress("127.0.0.1", kPortNumber));

13
rtc_base/nat_unittest.cc
View File

@ -13,16 +13,13 @@
#include <algorithm> #include <algorithm>
#include <cstddef> #include <cstddef>
#include <memory> #include <memory>
#include <string>
#include <vector> #include <vector>
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "api/units/time_delta.h" #include "api/test/rtc_error_matchers.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_tcp_socket.h" #include "rtc_base/async_tcp_socket.h"
#include "rtc_base/async_udp_socket.h" #include "rtc_base/async_udp_socket.h"
#include "rtc_base/event.h" #include "rtc_base/buffer.h"
#include "rtc_base/gunit.h"
#include "rtc_base/ip_address.h" #include "rtc_base/ip_address.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/nat_server.h" #include "rtc_base/nat_server.h"
@ -40,8 +37,10 @@
#include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h" #include "rtc_base/virtual_socket_server.h"
#include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/scoped_key_value_config.h" #include "test/scoped_key_value_config.h"
#include "test/wait_until.h"
namespace rtc { namespace rtc {
namespace { namespace {
@ -408,7 +407,9 @@ TEST_F(NatTcpTest, DISABLED_TestConnectOut) {
ConnectEvents(); ConnectEvents();
EXPECT_TRUE_WAIT(connected_, 1000); EXPECT_THAT(
webrtc::WaitUntil([&] { return connected_; }, ::testing::IsTrue()),
webrtc::IsRtcOk());
EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress()); EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress());
EXPECT_EQ(accepted_->GetRemoteAddress().ipaddr(), ext_addr_.ipaddr()); EXPECT_EQ(accepted_->GetRemoteAddress().ipaddr(), ext_addr_.ipaddr());

29
rtc_base/network_unittest.cc
View File

@ -12,26 +12,39 @@
#include <stdlib.h> #include <stdlib.h>
#include <algorithm> #include <cstdint>
#include <cstring>
#include <memory> #include <memory>
#include <string>
#include <utility>
#include <vector> #include <vector>
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "absl/strings/match.h" #include "absl/strings/match.h"
#include "absl/strings/string_view.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/checks.h"
#include "rtc_base/ip_address.h"
#include "rtc_base/net_helpers.h" #include "rtc_base/net_helpers.h"
#include "rtc_base/net_test_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.h"
#include "rtc_base/network_monitor_factory.h" #include "rtc_base/network_monitor_factory.h"
#include "rtc_base/physical_socket_server.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) #if defined(WEBRTC_POSIX)
#include <net/if.h> #include <net/if.h>
#include <sys/types.h> #include <sys/types.h>
#include "rtc_base/ifaddrs_converter.h" #include "rtc_base/ifaddrs_converter.h"
#endif // defined(WEBRTC_POSIX) #endif // defined(WEBRTC_POSIX)
#include "rtc_base/gunit.h"
#include "test/gmock.h" #include "test/gmock.h"
#if defined(WEBRTC_WIN) #if defined(WEBRTC_WIN)
#include "rtc_base/logging.h" // For RTC_LOG_GLE #include "rtc_base/logging.h" // For RTC_LOG_GLE
@ -40,6 +53,7 @@
#include "test/scoped_key_value_config.h" #include "test/scoped_key_value_config.h"
using ::testing::Contains; using ::testing::Contains;
using ::testing::IsTrue;
using ::testing::Not; using ::testing::Not;
using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAre;
using ::testing::UnorderedElementsAreArray; using ::testing::UnorderedElementsAreArray;
@ -93,7 +107,7 @@ class FakeNetworkMonitor : public NetworkMonitorInterface {
} }
for (auto const& iter : adapters_) { for (auto const& iter : adapters_) {
if (if_name.find(iter) != absl::string_view::npos) { if (absl::StrContains(if_name, iter)) {
return NetworkBindingResult::SUCCESS; return NetworkBindingResult::SUCCESS;
} }
} }
@ -1248,7 +1262,8 @@ TEST_F(NetworkTest, TestNetworkMonitoring) {
manager.StartUpdating(); manager.StartUpdating();
FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager); FakeNetworkMonitor* network_monitor = GetNetworkMonitor(manager);
EXPECT_TRUE(network_monitor && network_monitor->started()); 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; callback_called_ = false;
// Clear the networks so that there will be network changes below. // 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 // Network manager is started, so the callback is called when the network
// monitor fires the network-change event. // monitor fires the network-change event.
network_monitor->InovkeNetworksChangedCallbackForTesting(); network_monitor->InovkeNetworksChangedCallbackForTesting();
EXPECT_TRUE_WAIT(callback_called_, 1000); EXPECT_THAT(webrtc::WaitUntil([&] { return callback_called_; }, IsTrue()),
webrtc::IsRtcOk());
// Network manager is stopped. // Network manager is stopped.
manager.StopUpdating(); manager.StopUpdating();
@ -1278,7 +1294,8 @@ TEST_F(NetworkTest, MAYBE_DefaultLocalAddress) {
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this), manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged); &NetworkTest::OnNetworksChanged);
manager.StartUpdating(); 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 // Make sure we can query default local address when an address for such
// address family exists. // address family exists.

12
rtc_base/null_socket_server_unittest.cc
View File

@ -14,22 +14,30 @@
#include <memory> #include <memory>
#include "api/test/rtc_error_matchers.h"
#include "api/units/time_delta.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/thread.h"
#include "rtc_base/time_utils.h" #include "rtc_base/time_utils.h"
#include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/wait_until.h"
namespace rtc { namespace rtc {
TEST(NullSocketServerTest, WaitAndSet) { TEST(NullSocketServerTest, WaitAndSet) {
AutoThread main_thread;
NullSocketServer ss; NullSocketServer ss;
auto thread = Thread::Create(); auto thread = Thread::Create();
EXPECT_TRUE(thread->Start()); EXPECT_TRUE(thread->Start());
thread->PostTask([&ss] { ss.WakeUp(); }); thread->PostTask([&ss] { ss.WakeUp(); });
// The process_io will be ignored. // The process_io will be ignored.
const bool process_io = true; 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) { TEST(NullSocketServerTest, TestWait) {

33
rtc_base/operations_chain_unittest.cc
View File

@ -11,16 +11,21 @@
#include "rtc_base/operations_chain.h" #include "rtc_base/operations_chain.h"
#include <atomic> #include <atomic>
#include <cstddef>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <utility> #include <utility>
#include <vector> #include <vector>
#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/event.h"
#include "rtc_base/gunit.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/wait_until.h"
namespace rtc { namespace rtc {
@ -28,7 +33,7 @@ using ::testing::ElementsAre;
namespace { namespace {
constexpr int kDefaultTimeout = 3000; constexpr webrtc::TimeDelta kDefaultTimeout = webrtc::TimeDelta::Millis(3000);
} // namespace } // namespace
@ -386,7 +391,7 @@ TEST(OperationsChainTest, IsEmpty) {
unblock_async_operation_event1.Set(); unblock_async_operation_event1.Set();
async_operation_completed_event1->Wait(Event::kForever); async_operation_completed_event1->Wait(Event::kForever);
EXPECT_FALSE(operation_tracker_proxy.IsEmpty()); 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(); unblock_async_operation_event2.Set();
async_operation_completed_event2->Wait(Event::kForever); async_operation_completed_event2->Wait(Event::kForever);
EXPECT_TRUE(operation_tracker_proxy.IsEmpty()); EXPECT_TRUE(operation_tracker_proxy.IsEmpty());
@ -411,7 +416,10 @@ TEST(OperationsChainTest, OnChainEmptyCallback) {
// Completing the operation empties the chain, invoking the callback. // Completing the operation empties the chain, invoking the callback.
unblock_async_operation_event0.Set(); unblock_async_operation_event0.Set();
async_operation_completed_event0->Wait(Event::kForever); 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. // Chain multiple events.
Event unblock_async_operation_event1; Event unblock_async_operation_event1;
@ -423,16 +431,25 @@ TEST(OperationsChainTest, OnChainEmptyCallback) {
operation_tracker_proxy.PostAsynchronousOperation( operation_tracker_proxy.PostAsynchronousOperation(
&unblock_async_operation_event2); &unblock_async_operation_event2);
// Again, the callback is not invoked until the operation has completed. // 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 // Upon completing the first event, the chain is still not empty, so the
// callback must not be invoked yet. // callback must not be invoked yet.
unblock_async_operation_event1.Set(); unblock_async_operation_event1.Set();
async_operation_completed_event1->Wait(Event::kForever); async_operation_completed_event1->Wait(Event::kForever);
EXPECT_TRUE_WAIT(1u == on_empty_callback_counter, kDefaultTimeout); EXPECT_THAT(
// Completing the last evenet empties the chain, invoking the callback. 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(); unblock_async_operation_event2.Set();
async_operation_completed_event2->Wait(Event::kForever); 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, TEST(OperationsChainTest,

24
rtc_base/physical_socket_server_unittest.cc
View File

@ -10,22 +10,24 @@
#include "rtc_base/physical_socket_server.h" #include "rtc_base/physical_socket_server.h"
#include <signal.h>
#include <algorithm> #include <algorithm>
#include <cstddef>
#include <memory> #include <memory>
#include "rtc_base/gunit.h" #include "api/test/rtc_error_matchers.h"
#include "rtc_base/ip_address.h" #include "rtc_base/ip_address.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/net_helpers.h" #include "rtc_base/net_helpers.h"
#include "rtc_base/net_test_helpers.h" #include "rtc_base/net_test_helpers.h"
#include "rtc_base/network_monitor.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/socket_unittest.h"
#include "rtc_base/test_utils.h" #include "rtc_base/test_utils.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "test/field_trial.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/wait_until.h"
namespace rtc { namespace rtc {
@ -238,8 +240,11 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE)); EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE));
// Server has pending connection, try to accept it (will fail). // Server has pending connection, try to accept it (will fail).
EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)), EXPECT_THAT(
kTimeout); webrtc::WaitUntil(
[&] { return (sink.Check(server.get(), webrtc::testing::SSE_READ)); },
::testing::IsTrue()),
webrtc::IsRtcOk());
// Simulate "::accept" returning an error. // Simulate "::accept" returning an error.
SetFailAccept(true); SetFailAccept(true);
std::unique_ptr<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> 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)); EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_CLOSE));
// Server has pending connection, try to accept it (will succeed). // Server has pending connection, try to accept it (will succeed).
EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)), EXPECT_THAT(
kTimeout); webrtc::WaitUntil(
[&] { return (sink.Check(server.get(), webrtc::testing::SSE_READ)); },
::testing::IsTrue()),
webrtc::IsRtcOk());
SetFailAccept(false); SetFailAccept(false);
std::unique_ptr<Socket> accepted2(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted2(server->Accept(&accept_addr));
ASSERT_TRUE(accepted2); ASSERT_TRUE(accepted2);

26
rtc_base/rtc_certificate_generator_unittest.cc
View File

@ -10,14 +10,21 @@
#include "rtc_base/rtc_certificate_generator.h" #include "rtc_base/rtc_certificate_generator.h"
#include <cstdint>
#include <memory> #include <memory>
#include <optional> #include <optional>
#include <utility>
#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/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 "rtc_base/thread.h"
#include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/wait_until.h"
namespace rtc { namespace rtc {
@ -65,7 +72,8 @@ class RTCCertificateGeneratorFixture {
class RTCCertificateGeneratorTest : public ::testing::Test { class RTCCertificateGeneratorTest : public ::testing::Test {
public: public:
protected: protected:
static constexpr int kGenerationTimeoutMs = 10000; static constexpr webrtc::TimeDelta kGenerationTimeoutMs =
webrtc::TimeDelta::Millis(10000);
rtc::AutoThread main_thread_; rtc::AutoThread main_thread_;
RTCCertificateGeneratorFixture fixture_; RTCCertificateGeneratorFixture fixture_;
@ -90,7 +98,10 @@ TEST_F(RTCCertificateGeneratorTest, GenerateAsyncECDSA) {
// posted to this thread (which is done by `EXPECT_TRUE_WAIT`). // posted to this thread (which is done by `EXPECT_TRUE_WAIT`).
EXPECT_FALSE(fixture_.GenerateAsyncCompleted()); EXPECT_FALSE(fixture_.GenerateAsyncCompleted());
EXPECT_FALSE(fixture_.certificate()); 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()); EXPECT_TRUE(fixture_.certificate());
} }
@ -118,7 +129,7 @@ TEST_F(RTCCertificateGeneratorTest, GenerateWithExpires) {
EXPECT_GT(cert_b->Expires(), cert_a->Expires()); EXPECT_GT(cert_b->Expires(), cert_a->Expires());
uint64_t expires_diff = cert_b->Expires() - cert_a->Expires(); uint64_t expires_diff = cert_b->Expires() - cert_a->Expires();
EXPECT_GE(expires_diff, kExpiresMs); 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) { TEST_F(RTCCertificateGeneratorTest, GenerateWithInvalidParamsShouldFail) {
@ -130,7 +141,10 @@ TEST_F(RTCCertificateGeneratorTest, GenerateWithInvalidParamsShouldFail) {
fixture_.generator()->GenerateCertificateAsync(invalid_params, std::nullopt, fixture_.generator()->GenerateCertificateAsync(invalid_params, std::nullopt,
fixture_.OnGenerated()); 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()); EXPECT_FALSE(fixture_.certificate());
} }

198
rtc_base/socket_unittest.cc
View File

@ -17,18 +17,22 @@
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <memory> #include <memory>
#include <string>
#include <utility>
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "absl/strings/string_view.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/arraysize.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_udp_socket.h" #include "rtc_base/async_udp_socket.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
#include "rtc_base/gunit.h" #include "rtc_base/gunit.h"
#include "rtc_base/ip_address.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/net_helpers.h" #include "rtc_base/net_helpers.h"
#include "rtc_base/net_test_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_address.h"
#include "rtc_base/socket_server.h" #include "rtc_base/socket_server.h"
#include "rtc_base/socket_unittest.h" #include "rtc_base/socket_unittest.h"
@ -37,6 +41,9 @@
#include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "rtc_base/time_utils.h" #include "rtc_base/time_utils.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/wait_until.h"
namespace rtc { namespace rtc {
@ -288,7 +295,10 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it. // 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<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted); ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil()); EXPECT_FALSE(accept_addr.IsNil());
@ -300,7 +310,9 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
// Connected from client perspective, check the addresses are correct. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@ -337,7 +349,10 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it. // 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<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted); ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil()); EXPECT_FALSE(accept_addr.IsNil());
@ -349,7 +364,9 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
// Connected from client perspective, check the addresses are correct. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@ -378,7 +395,9 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(bogus_addr)); EXPECT_EQ(0, client->Connect(bogus_addr));
// Wait for connection to fail (ECONNREFUSED). // 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_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil()); EXPECT_TRUE(client->GetRemoteAddress().IsNil());
@ -412,14 +431,16 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
// Wait for connection to fail (EHOSTNOTFOUND). // Wait for connection to fail (EHOSTNOTFOUND).
bool dns_lookup_finished = false; 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) { if (!dns_lookup_finished) {
RTC_LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 " RTC_LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 "
"seconds."; "seconds.";
return; 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_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil()); EXPECT_TRUE(client->GetRemoteAddress().IsNil());
@ -466,7 +487,10 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Accept the original connection. // Accept the original connection.
SocketAddress accept_addr; 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<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted); ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil()); EXPECT_FALSE(accept_addr.IsNil());
@ -475,7 +499,9 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); 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(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
@ -508,11 +534,16 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Close down the server while the socket is in the accept queue. // 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(); server->Close();
// This should fail the connection for the client. Clean up. // 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)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
client->Close(); client->Close();
} }
@ -537,7 +568,10 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Close down the client while the socket is in the accept queue. // 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(); client->Close();
// The connection should still be able to be accepted. // 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()); EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
// The accepted socket should then close (possibly with err, timing-related) // 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) || EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) ||
sink.Check(accepted.get(), SSE_ERROR)); sink.Check(accepted.get(), SSE_ERROR));
@ -575,13 +611,18 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection. // 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<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); sink.Monitor(accepted.get());
// Both sides are now connected. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->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_EQ(Socket::CS_CLOSED, accepted->GetState());
// Expect that the client is notified, and has not yet closed. // 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_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(Socket::CS_CONNECTED, client->GetState()); EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
@ -602,7 +646,9 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
EXPECT_EQ('a', buffer[0]); EXPECT_EQ('a', buffer[0]);
// Now we should close, but the remote address will remain. // 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_TRUE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP()); EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP());
@ -650,13 +696,18 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection. // 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<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); sink.Monitor(accepted.get());
// Both sides are now connected. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
@ -670,7 +721,9 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
EXPECT_EQ(Socket::CS_CONNECTED, client->GetState()); EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
// Now we should be closed and invalidated // 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(sink.Check(client.get(), SSE_CLOSE));
EXPECT_TRUE(Socket::CS_CLOSED == client->GetState()); EXPECT_TRUE(Socket::CS_CLOSED == client->GetState());
} }
@ -708,7 +761,9 @@ void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) {
// event. // event.
SocketDeleter deleter(std::move(socket2)); SocketDeleter deleter(std::move(socket2));
socket1->SignalReadEvent.connect(&deleter, &SocketDeleter::Delete); 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) { 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, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); 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<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted); ASSERT_TRUE(accepted);
@ -735,7 +793,9 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@ -755,7 +815,10 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ)); EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
// But should signal when process_io is true. // 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)); 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())); EXPECT_EQ(0, receiver->Connect(server->GetLocalAddress()));
// Accept connection which will be used for sending. // 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<Socket> sender(server->Accept(&accept_addr)); std::unique_ptr<Socket> sender(server->Accept(&accept_addr));
ASSERT_TRUE(sender); ASSERT_TRUE(sender);
sink.Monitor(sender.get()); sink.Monitor(sender.get());
// Both sides are now connected. // 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_TRUE(sink.Check(receiver.get(), SSE_OPEN));
EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress()); EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress()); EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
@ -840,7 +908,10 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
while (recv_buffer.size() < sent_size) { while (recv_buffer.size() < sent_size) {
if (!readable) { if (!readable) {
// Wait until data is available. // 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; readable = true;
recv_called = false; 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 // Once all that we've sent has been received, expect to be able to send
// again. // again.
if (!writable) { 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; writable = true;
send_called = false; send_called = false;
} }
@ -882,7 +956,9 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
// Close down. // Close down.
sender->Close(); 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)); EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE));
receiver->Close(); receiver->Close();
} }
@ -907,19 +983,27 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
// Accept connection. // 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<Socket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(accepted); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); sink.Monitor(accepted.get());
// Both sides are now connected. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
// Expect a writable callback from the connect. // 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. // Fill the socket buffer.
char buf[1024 * 16] = {0}; char buf[1024 * 16] = {0};
@ -929,7 +1013,10 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
EXPECT_TRUE(accepted->IsBlocking()); EXPECT_TRUE(accepted->IsBlocking());
// Wait until data is available. // 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. // Pull data.
for (int i = 0; i < sends; ++i) { 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 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 // Adding data in response to the writeable callback shouldn't cause infinite
// callbacks. // callbacks.
@ -1030,7 +1120,7 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
uint32_t start_ms = Time(); uint32_t start_ms = Time();
int sent_packet_num = 0; int sent_packet_num = 0;
int expected_error = EWOULDBLOCK; 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); int ret = client->SendTo(test_packet.get(), test_packet_size, test_addr);
++sent_packet_num; ++sent_packet_num;
if (ret != test_packet_size) { if (ret != test_packet_size) {
@ -1044,7 +1134,9 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
} }
EXPECT_EQ(expected_error, error); EXPECT_EQ(expected_error, error);
EXPECT_FALSE(client->ready_to_send()); 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"; RTC_LOG(LS_INFO) << "Got SignalReadyToSend";
} }
@ -1153,7 +1245,10 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
socket->SendTo("foo", 3, address); socket->SendTo("foo", 3, address);
// Wait until data is available. // 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; rtc::Buffer buffer;
Socket::ReceiveBuffer receive_buffer_1(buffer); Socket::ReceiveBuffer receive_buffer_1(buffer);
ASSERT_GT(socket->RecvFrom(receive_buffer_1), 0); ASSERT_GT(socket->RecvFrom(receive_buffer_1), 0);
@ -1164,7 +1259,10 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
int64_t send_time_2 = TimeMicros(); int64_t send_time_2 = TimeMicros();
socket->SendTo("bar", 3, address); socket->SendTo("bar", 3, address);
// Wait until data is available. // 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); Socket::ReceiveBuffer receive_buffer_2(buffer);
ASSERT_GT(socket->RecvFrom(receive_buffer_2), 0); ASSERT_GT(socket->RecvFrom(receive_buffer_2), 0);
@ -1214,7 +1312,10 @@ void SocketTest::SocketSendRecvWithEcn(const IPAddress& loopback) {
Socket::ReceiveBuffer receive_buffer(buffer); Socket::ReceiveBuffer receive_buffer(buffer);
socket->SendTo("foo", 3, address); 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); ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kNotEct); 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->SetOption(Socket::OPT_RECV_ECN, 1);
socket->SendTo("bar", 3, address); 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); ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct1); EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct1);
socket->SetOption(Socket::OPT_SEND_ECN, 2); // Ect(0) socket->SetOption(Socket::OPT_SEND_ECN, 2); // Ect(0)
socket->SendTo("bar", 3, address); 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); ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct0); EXPECT_EQ(receive_buffer.ecn, EcnMarking::kEct0);
socket->SetOption(Socket::OPT_SEND_ECN, 3); // Ce socket->SetOption(Socket::OPT_SEND_ECN, 3); // Ce
socket->SendTo("bar", 3, address); 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); ASSERT_GT(socket->RecvFrom(receive_buffer), 0);
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kCe); EXPECT_EQ(receive_buffer.ecn, EcnMarking::kCe);
} }

8
rtc_base/socket_unittest.h
View File

@ -11,9 +11,12 @@
#ifndef RTC_BASE_SOCKET_UNITTEST_H_ #ifndef RTC_BASE_SOCKET_UNITTEST_H_
#define RTC_BASE_SOCKET_UNITTEST_H_ #define RTC_BASE_SOCKET_UNITTEST_H_
#include <cstddef>
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
#include "rtc_base/gunit.h" #include "rtc_base/ip_address.h"
#include "rtc_base/thread.h" #include "rtc_base/socket_factory.h"
#include "test/gtest.h"
namespace rtc { namespace rtc {
@ -67,7 +70,6 @@ class SocketTest : public ::testing::Test {
void TestSocketSendRecvWithEcnIPV4(); void TestSocketSendRecvWithEcnIPV4();
void TestSocketSendRecvWithEcnIPV6(); void TestSocketSendRecvWithEcnIPV6();
static const int kTimeout = 5000; // ms
const IPAddress kIPv4Loopback; const IPAddress kIPv4Loopback;
const IPAddress kIPv6Loopback; const IPAddress kIPv6Loopback;

52
rtc_base/ssl_adapter_unittest.cc
View File

@ -10,37 +10,33 @@
#include "rtc_base/ssl_adapter.h" #include "rtc_base/ssl_adapter.h"
#include <cstddef>
#include <cstdint>
#include <memory> #include <memory>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
#include "api/array_view.h" #include "api/test/rtc_error_matchers.h"
#include "api/sequence_checker.h" #include "api/units/time_delta.h"
#include "rtc_base/checks.h"
#include "rtc_base/gunit.h"
#include "rtc_base/ip_address.h" #include "rtc_base/ip_address.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/message_digest.h"
#include "rtc_base/socket.h" #include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
#include "rtc_base/ssl_certificate.h" #include "rtc_base/ssl_certificate.h"
#include "rtc_base/ssl_identity.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/string_encode.h"
#include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h" #include "rtc_base/virtual_socket_server.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/wait_until.h"
using ::testing::_; using ::testing::_;
using ::testing::Return; using ::testing::Return;
static const int kTimeout = 5000; static const webrtc::TimeDelta kTimeout = webrtc::TimeDelta::Millis(5000);
static rtc::Socket* CreateSocket() { static rtc::Socket* CreateSocket() {
rtc::SocketAddress address(rtc::IPAddress(INADDR_ANY), 0); rtc::SocketAddress address(rtc::IPAddress(INADDR_ANY), 0);
@ -207,9 +203,11 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> {
thread_(vss_.get()), thread_(vss_.get()),
server_(new SSLAdapterTestDummyServer(key_params)), server_(new SSLAdapterTestDummyServer(key_params)),
client_(new SSLAdapterTestDummyClient()), 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) { void SetIgnoreBadCert(bool ignore_bad_cert) {
client_->SetIgnoreBadCert(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 (expect_success) {
// If expecting success, the client should end up in the CS_CONNECTED // If expecting success, the client should end up in the CS_CONNECTED
// state after handshake. // state after handshake.
EXPECT_EQ_WAIT(rtc::Socket::CS_CONNECTED, client_->GetState(), EXPECT_THAT(webrtc::WaitUntil([&] { return client_->GetState(); },
handshake_wait_); ::testing::Eq(rtc::Socket::CS_CONNECTED),
{.timeout = handshake_wait_}),
webrtc::IsRtcOk());
RTC_LOG(LS_INFO) << "TLS handshake complete."; RTC_LOG(LS_INFO) << "TLS handshake complete.";
} else { } else {
// On handshake failure the client should end up in the CS_CLOSED state. // On handshake failure the client should end up in the CS_CLOSED state.
EXPECT_EQ_WAIT(rtc::Socket::CS_CLOSED, client_->GetState(), EXPECT_THAT(webrtc::WaitUntil([&] { return client_->GetState(); },
handshake_wait_); ::testing::Eq(rtc::Socket::CS_CLOSED),
{.timeout = handshake_wait_}),
webrtc::IsRtcOk());
RTC_LOG(LS_INFO) << "TLS handshake failed."; RTC_LOG(LS_INFO) << "TLS handshake failed.";
} }
@ -273,13 +275,19 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> {
ASSERT_EQ(static_cast<int>(message.length()), rv); ASSERT_EQ(static_cast<int>(message.length()), rv);
// The server should have received the client's message. // 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); rv = server_->Send(message);
ASSERT_EQ(static_cast<int>(message.length()), rv); ASSERT_EQ(static_cast<int>(message.length()), rv);
// The client should have received the server's message. // 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."; RTC_LOG(LS_INFO) << "Transfer complete.";
} }
@ -291,7 +299,7 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> {
std::unique_ptr<SSLAdapterTestDummyClient> client_; std::unique_ptr<SSLAdapterTestDummyClient> client_;
std::unique_ptr<rtc::SSLCertificateVerifier> cert_verifier_; std::unique_ptr<rtc::SSLCertificateVerifier> cert_verifier_;
int handshake_wait_; webrtc::TimeDelta handshake_wait_;
}; };
class SSLAdapterTestTLS_RSA : public SSLAdapterTestBase { 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 // Unblock the underlying socket. All of the buffered messages should be sent
// without any further action. // without any further action.
vss_->SetSendingBlocked(false); 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 // Send another message. This previously wasn't working
std::string final_message = "Fin."; std::string final_message = "Fin.";
expected += final_message; expected += final_message;
EXPECT_EQ(static_cast<int>(final_message.size()), EXPECT_EQ(static_cast<int>(final_message.size()),
client_->Send(final_message)); 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 // Test transfer between client and server, using ECDSA

63
rtc_base/ssl_stream_adapter_unittest.cc
View File

@ -33,6 +33,7 @@
#include "api/array_view.h" #include "api/array_view.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/task_queue/pending_task_safety_flag.h" #include "api/task_queue/pending_task_safety_flag.h"
#include "api/test/rtc_error_matchers.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
#include "rtc_base/buffer_queue.h" #include "rtc_base/buffer_queue.h"
@ -40,7 +41,6 @@
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/crypto_random.h" #include "rtc_base/crypto_random.h"
#include "rtc_base/fake_clock.h" #include "rtc_base/fake_clock.h"
#include "rtc_base/gunit.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/message_digest.h" #include "rtc_base/message_digest.h"
#include "rtc_base/ssl_identity.h" #include "rtc_base/ssl_identity.h"
@ -51,6 +51,7 @@
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/wait_until.h"
using ::testing::Combine; using ::testing::Combine;
using ::testing::NotNull; using ::testing::NotNull;
@ -423,7 +424,7 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
lose_first_packet_(false), lose_first_packet_(false),
damage_(false), damage_(false),
dtls_(dtls), dtls_(dtls),
handshake_wait_(5000), handshake_wait_(webrtc::TimeDelta::Millis(5000)),
identities_set_(false) { identities_set_(false) {
// Set use of the test RNG to get predictable loss patterns. // Set use of the test RNG to get predictable loss patterns.
rtc::SetRandomTestMode(true); rtc::SetRandomTestMode(true);
@ -587,12 +588,20 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
// Now run the handshake // Now run the handshake
if (expect_success) { if (expect_success) {
EXPECT_TRUE_SIMULATED_WAIT((client_ssl_->GetState() == rtc::SS_OPEN) && EXPECT_THAT(webrtc::WaitUntil(
(server_ssl_->GetState() == rtc::SS_OPEN), [&] {
handshake_wait_, clock_); return (client_ssl_->GetState() == rtc::SS_OPEN) &&
(server_ssl_->GetState() == rtc::SS_OPEN);
},
::testing::IsTrue(),
{.timeout = handshake_wait_, .clock = &clock_}),
webrtc::IsRtcOk());
} else { } else {
EXPECT_TRUE_SIMULATED_WAIT(client_ssl_->GetState() == rtc::SS_CLOSED, EXPECT_THAT(
handshake_wait_, clock_); 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 && while (client_ssl_->GetState() == rtc::SS_OPENING &&
(rtc::TimeDiff(clock_.TimeNanos(), time_start) < (rtc::TimeDiff(clock_.TimeNanos(), time_start) <
3600 * rtc::kNumNanosecsPerSec)) { 3600 * rtc::kNumNanosecsPerSec)) {
EXPECT_TRUE_SIMULATED_WAIT(!((client_ssl_->GetState() == rtc::SS_OPEN) && EXPECT_THAT(webrtc::WaitUntil(
(server_ssl_->GetState() == rtc::SS_OPEN)), [&] {
1000, clock_); return !((client_ssl_->GetState() == rtc::SS_OPEN) &&
(server_ssl_->GetState() == rtc::SS_OPEN));
},
::testing::IsTrue(), {.clock = &clock_}),
webrtc::IsRtcOk());
clock_.AdvanceTime(time_increment); clock_.AdvanceTime(time_increment);
} }
EXPECT_EQ(client_ssl_->GetState(), rtc::SS_CLOSED); EXPECT_EQ(client_ssl_->GetState(), rtc::SS_CLOSED);
@ -656,9 +669,14 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
ASSERT_EQ(0, client_ssl_->StartSSL()); ASSERT_EQ(0, client_ssl_->StartSSL());
// Now run the handshake. // Now run the handshake.
EXPECT_TRUE_SIMULATED_WAIT( EXPECT_THAT(webrtc::WaitUntil(
client_ssl_->IsTlsConnected() && server_ssl_->IsTlsConnected(), [&] {
handshake_wait_, clock_); 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 // Until the identity has been verified, the state should still be
// SS_OPENING and writes should return SR_BLOCK. // 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 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<int>& ciphers, bool client) { void SetDtlsSrtpCryptoSuites(const std::vector<int>& ciphers, bool client) {
if (client) if (client)
@ -875,7 +895,7 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
bool lose_first_packet_; bool lose_first_packet_;
bool damage_; bool damage_;
bool dtls_; bool dtls_;
int handshake_wait_; webrtc::TimeDelta handshake_wait_;
bool identities_set_; bool identities_set_;
}; };
@ -978,15 +998,20 @@ class SSLStreamAdapterTestDTLSBase : public SSLStreamAdapterTestBase {
WriteData(); 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_; RTC_LOG(LS_INFO) << "sent_ == " << sent_;
if (damage_) { if (damage_) {
SIMULATED_WAIT(false, 2000, clock_); clock_.AdvanceTime(webrtc::TimeDelta::Millis(2000));
EXPECT_EQ(0U, received_.size()); EXPECT_EQ(0U, received_.size());
} else if (loss_ == 0) { } else if (loss_ == 0) {
EXPECT_EQ_SIMULATED_WAIT(static_cast<size_t>(sent_), received_.size(), EXPECT_THAT(webrtc::WaitUntil([&] { return received_.size(); },
1000, clock_); ::testing::Eq(static_cast<size_t>(sent_)),
{.clock = &clock_}),
webrtc::IsRtcOk());
} else { } else {
RTC_LOG(LS_INFO) << "Sent " << sent_ << " packets; received " RTC_LOG(LS_INFO) << "Sent " << sent_ << " packets; received "
<< received_.size(); << received_.size();

17
rtc_base/test_client.cc
View File

@ -12,12 +12,19 @@
#include <string.h> #include <string.h>
#include <cstdint>
#include <memory> #include <memory>
#include <optional>
#include <utility> #include <utility>
#include "api/units/time_delta.h"
#include "api/units/timestamp.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/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/thread.h"
#include "rtc_base/time_utils.h" #include "rtc_base/time_utils.h"
@ -79,7 +86,7 @@ std::unique_ptr<TestClient::Packet> TestClient::NextPacket(int timeout_ms) {
while (TimeUntil(end) > 0) { while (TimeUntil(end) > 0) {
{ {
webrtc::MutexLock lock(&mutex_); webrtc::MutexLock lock(&mutex_);
if (packets_.size() != 0) { if (!packets_.empty()) {
break; break;
} }
} }
@ -89,7 +96,7 @@ std::unique_ptr<TestClient::Packet> TestClient::NextPacket(int timeout_ms) {
// Return the first packet placed in the queue. // Return the first packet placed in the queue.
std::unique_ptr<Packet> packet; std::unique_ptr<Packet> packet;
webrtc::MutexLock lock(&mutex_); webrtc::MutexLock lock(&mutex_);
if (packets_.size() > 0) { if (!packets_.empty()) {
packet = std::move(packets_.front()); packet = std::move(packets_.front());
packets_.erase(packets_.begin()); 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 // If the test is using a fake clock, we must advance the fake clock to
// advance time. Otherwise, ProcessMessages will work. // advance time. Otherwise, ProcessMessages will work.
if (fake_clock_) { 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 { } else {
Thread::Current()->ProcessMessages(1); Thread::Current()->ProcessMessages(1);
} }

26
rtc_base/thread_unittest.cc
View File

@ -10,27 +10,39 @@
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <memory> #include <memory>
#include <utility>
#include <vector>
#include "absl/strings/string_view.h"
#include "api/field_trials_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_factory.h"
#include "api/task_queue/task_queue_test.h" #include "api/task_queue/task_queue_test.h"
#include "api/test/rtc_error_matchers.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_udp_socket.h" #include "rtc_base/async_udp_socket.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/fake_clock.h" #include "rtc_base/fake_clock.h"
#include "rtc_base/gunit.h"
#include "rtc_base/internal/default_socket_server.h" #include "rtc_base/internal/default_socket_server.h"
#include "rtc_base/network/received_packet.h" #include "rtc_base/network/received_packet.h"
#include "rtc_base/null_socket_server.h" #include "rtc_base/null_socket_server.h"
#include "rtc_base/physical_socket_server.h" #include "rtc_base/socket.h"
#include "rtc_base/ref_counted_object.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
#include "rtc_base/socket_server.h"
#include "rtc_base/synchronization/mutex.h" #include "rtc_base/synchronization/mutex.h"
#include "rtc_base/third_party/sigslot/sigslot.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/gmock.h"
#include "test/gtest.h"
#include "test/testsupport/rtc_expect_death.h" #include "test/testsupport/rtc_expect_death.h"
#include "test/wait_until.h"
#if defined(WEBRTC_WIN) #if defined(WEBRTC_WIN)
#include <comdef.h> // NOLINT #include <comdef.h> // NOLINT
@ -457,7 +469,9 @@ TEST(ThreadTest, ThreeThreadsBlockingCall) {
SetAndInvokeSet(&async_invoked, thread2, out); 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_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( static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(