commit 130bdcea7e69368cae66e10a99c5e86dc4e5770a
author Philipp Hancke <phancke@meta.com> Mon Oct 28 17:01:38 2024
committer WebRTC LUCI CQ <webrtc-scoped@luci-project-accounts.iam.gserviceaccount.com> Wed Oct 30 14:04:14 2024
tree 126b2dba178b86b25683d9923a6254c89297a47e
parent dd493e56a472ab7b3faa84743c1a481c4c67ee6c

Use fake clock for SSLStreamAdapter unit tests

BUG=webrtc:375552698

Change-Id: I2859b6220194ff747637a9a3870c5b8979c83ca8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/366940
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Christoffer Dewerin <jansson@webrtc.org>
Commit-Queue: Philipp Hancke <phancke@meta.com>
Cr-Commit-Position: refs/heads/main@{#43333}

rtc_base/ssl_stream_adapter_unittest.cc

diff --git a/rtc_base/ssl_stream_adapter_unittest.cc b/rtc_base/ssl_stream_adapter_unittest.cc
index 3534b1c..01c3529 100644
--- a/rtc_base/ssl_stream_adapter_unittest.cc
+++ b/rtc_base/ssl_stream_adapter_unittest.cc
@@ -583,20 +583,19 @@
 
     // Now run the handshake
     if (expect_success) {
-      EXPECT_TRUE_WAIT((client_ssl_->GetState() == rtc::SS_OPEN) &&
-                           (server_ssl_->GetState() == rtc::SS_OPEN),
-                       handshake_wait_);
+      EXPECT_TRUE_SIMULATED_WAIT((client_ssl_->GetState() == rtc::SS_OPEN) &&
+                                     (server_ssl_->GetState() == rtc::SS_OPEN),
+                                 handshake_wait_, clock_);
     } else {
-      EXPECT_TRUE_WAIT(client_ssl_->GetState() == rtc::SS_CLOSED,
-                       handshake_wait_);
+      EXPECT_TRUE_SIMULATED_WAIT(client_ssl_->GetState() == rtc::SS_CLOSED,
+                                 handshake_wait_, clock_);
     }
   }
 
   // This tests that we give up after 12 DTLS resends.
   // Only works for BoringSSL which allows advancing the fake clock.
   void TestHandshakeTimeout() {
-    rtc::ScopedFakeClock clock;
-    int64_t time_start = clock.TimeNanos();
+    int64_t time_start = clock_.TimeNanos();
     webrtc::TimeDelta time_increment = webrtc::TimeDelta::Millis(1000);
 
     if (!dtls_) {
@@ -624,12 +623,12 @@
     // Now wait for the handshake to timeout (or fail after an hour of simulated
     // time).
     while (client_ssl_->GetState() == rtc::SS_OPENING &&
-           (rtc::TimeDiff(clock.TimeNanos(), time_start) <
+           (rtc::TimeDiff(clock_.TimeNanos(), time_start) <
             3600 * rtc::kNumNanosecsPerSec)) {
-      EXPECT_TRUE_WAIT(!((client_ssl_->GetState() == rtc::SS_OPEN) &&
-                         (server_ssl_->GetState() == rtc::SS_OPEN)),
-                       1000);
-      clock.AdvanceTime(time_increment);
+      EXPECT_TRUE_SIMULATED_WAIT(!((client_ssl_->GetState() == rtc::SS_OPEN) &&
+                                   (server_ssl_->GetState() == rtc::SS_OPEN)),
+                                 1000, clock_);
+      clock_.AdvanceTime(time_increment);
     }
     EXPECT_EQ(client_ssl_->GetState(), rtc::SS_CLOSED);
   }
@@ -653,9 +652,9 @@
     ASSERT_EQ(0, client_ssl_->StartSSL());
 
     // Now run the handshake.
-    EXPECT_TRUE_WAIT(
+    EXPECT_TRUE_SIMULATED_WAIT(
         client_ssl_->IsTlsConnected() && server_ssl_->IsTlsConnected(),
-        handshake_wait_);
+        handshake_wait_, clock_);
 
     // Until the identity has been verified, the state should still be
     // SS_OPENING and writes should return SR_BLOCK.
@@ -856,6 +855,7 @@
   }
 
   rtc::AutoThread main_thread_;
+  rtc::ScopedFakeClock clock_;
   std::string client_cert_pem_;
   std::string client_private_key_pem_;
   rtc::KeyParams client_key_type_;
@@ -973,14 +973,15 @@
 
     WriteData();
 
-    EXPECT_TRUE_WAIT(sent_ == count_, 10000);
+    EXPECT_TRUE_SIMULATED_WAIT(sent_ == count_, 10000, clock_);
     RTC_LOG(LS_INFO) << "sent_ == " << sent_;
 
     if (damage_) {
-      WAIT(false, 2000);
+      SIMULATED_WAIT(false, 2000, clock_);
       EXPECT_EQ(0U, received_.size());
     } else if (loss_ == 0) {
-      EXPECT_EQ_WAIT(static_cast<size_t>(sent_), received_.size(), 1000);
+      EXPECT_EQ_SIMULATED_WAIT(static_cast<size_t>(sent_), received_.size(),
+                               1000, clock_);
     } else {
       RTC_LOG(LS_INFO) << "Sent " << sent_ << " packets; received "
                        << received_.size();