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 = [
":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",

20
rtc_base/async_dns_resolver_unittest.cc
View File

@ -10,13 +10,25 @@
#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/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));

13
rtc_base/nat_unittest.cc
View File

@ -13,16 +13,13 @@
#include <algorithm>
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
#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());

29
rtc_base/network_unittest.cc
View File

@ -12,26 +12,39 @@
#include <stdlib.h>
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#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 <net/if.h>
#include <sys/types.h>
#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<NetworkTest*>(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.

12
rtc_base/null_socket_server_unittest.cc
View File

@ -14,22 +14,30 @@
#include <memory>
#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) {

33
rtc_base/operations_chain_unittest.cc
View File

@ -11,16 +11,21 @@
#include "rtc_base/operations_chain.h"
#include <atomic>
#include <cstddef>
#include <functional>
#include <memory>
#include <utility>
#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/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,

24
rtc_base/physical_socket_server_unittest.cc
View File

@ -10,22 +10,24 @@
#include "rtc_base/physical_socket_server.h"
#include <signal.h>
#include <algorithm>
#include <cstddef>
#include <memory>
#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<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));
// 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<Socket> accepted2(server->Accept(&accept_addr));
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 <cstdint>
#include <memory>
#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/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());
}

198
rtc_base/socket_unittest.cc
View File

@ -17,18 +17,22 @@
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#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<Socket> 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<Socket> 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<Socket> 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<Socket> 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<Socket> 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<Socket> 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<Socket> 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<Socket> 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);
}

8
rtc_base/socket_unittest.h
View File

@ -11,9 +11,12 @@
#ifndef RTC_BASE_SOCKET_UNITTEST_H_
#define RTC_BASE_SOCKET_UNITTEST_H_
#include <cstddef>
#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 {
@ -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;

52
rtc_base/ssl_adapter_unittest.cc
View File

@ -10,37 +10,33 @@
#include "rtc_base/ssl_adapter.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#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<int>(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<int>(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<SSLAdapterTestDummyClient> client_;
std::unique_ptr<rtc::SSLCertificateVerifier> 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<int>(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

63
rtc_base/ssl_stream_adapter_unittest.cc
View File

@ -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<int>& 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<size_t>(sent_), received_.size(),
1000, clock_);
EXPECT_THAT(webrtc::WaitUntil([&] { return received_.size(); },
::testing::Eq(static_cast<size_t>(sent_)),
{.clock = &clock_}),
webrtc::IsRtcOk());
} else {
RTC_LOG(LS_INFO) << "Sent " << sent_ << " packets; received "
<< received_.size();

17
rtc_base/test_client.cc
View File

@ -12,12 +12,19 @@
#include <string.h>
#include <cstdint>
#include <memory>
#include <optional>
#include <utility>
#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::Packet> 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::Packet> TestClient::NextPacket(int timeout_ms) {
// Return the first packet placed in the queue.
std::unique_ptr<Packet> 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);
}

26
rtc_base/thread_unittest.cc
View File

@ -10,27 +10,39 @@
#include "rtc_base/thread.h"
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
#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 <comdef.h> // 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(