re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/synchronization/mutex_test.cc

@@ -23,7 +23,9 @@
 #include <cstdlib>
 #include <functional>
 #include <memory>
+#include <mutex>  // NOLINT(build/c++11)
 #include <random>
+#include <shared_mutex>  // NOLINT(build/c++14)
 #include <string>
 #include <thread>  // NOLINT(build/c++11)
 #include <type_traits>
@@ -36,6 +38,7 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/memory/memory.h"
+#include "absl/random/random.h"
 #include "absl/synchronization/internal/create_thread_identity.h"
 #include "absl/synchronization/internal/thread_pool.h"
 #include "absl/time/clock.h"
@@ -105,7 +108,7 @@ static void CheckSumG0G1(void *v) {
 
 static void TestMu(TestContext *cxt, int c) {
   for (int i = 0; i != cxt->iterations; i++) {
-    absl::MutexLock l(&cxt->mu);
+    absl::MutexLock l(cxt->mu);
     int a = cxt->g0 + 1;
     cxt->g0 = a;
     cxt->g1--;
@@ -116,17 +119,17 @@ static void TestTry(TestContext *cxt, int c) {
   for (int i = 0; i != cxt->iterations; i++) {
     do {
       std::this_thread::yield();
-    } while (!cxt->mu.TryLock());
+    } while (!cxt->mu.try_lock());
     int a = cxt->g0 + 1;
     cxt->g0 = a;
     cxt->g1--;
-    cxt->mu.Unlock();
+    cxt->mu.unlock();
   }
 }
 
 static void TestR20ms(TestContext *cxt, int c) {
   for (int i = 0; i != cxt->iterations; i++) {
-    absl::ReaderMutexLock l(&cxt->mu);
+    absl::ReaderMutexLock l(cxt->mu);
     absl::SleepFor(absl::Milliseconds(20));
     cxt->mu.AssertReaderHeld();
   }
@@ -135,7 +138,7 @@ static void TestR20ms(TestContext *cxt, int c) {
 static void TestRW(TestContext *cxt, int c) {
   if ((c & 1) == 0) {
     for (int i = 0; i != cxt->iterations; i++) {
-      absl::WriterMutexLock l(&cxt->mu);
+      absl::WriterMutexLock l(cxt->mu);
       cxt->g0++;
       cxt->g1--;
       cxt->mu.AssertHeld();
@@ -143,7 +146,7 @@ static void TestRW(TestContext *cxt, int c) {
     }
   } else {
     for (int i = 0; i != cxt->iterations; i++) {
-      absl::ReaderMutexLock l(&cxt->mu);
+      absl::ReaderMutexLock l(cxt->mu);
       CHECK_EQ(cxt->g0, -cxt->g1) << "Error in TestRW";
       cxt->mu.AssertReaderHeld();
     }
@@ -165,7 +168,7 @@ static void TestAwait(TestContext *cxt, int c) {
   MyContext mc;
   mc.target = c;
   mc.cxt = cxt;
-  absl::MutexLock l(&cxt->mu);
+  absl::MutexLock l(cxt->mu);
   cxt->mu.AssertHeld();
   while (cxt->g0 < cxt->iterations) {
     cxt->mu.Await(absl::Condition(&mc, &MyContext::MyTurn));
@@ -181,7 +184,7 @@ static void TestAwait(TestContext *cxt, int c) {
 
 static void TestSignalAll(TestContext *cxt, int c) {
   int target = c;
-  absl::MutexLock l(&cxt->mu);
+  absl::MutexLock l(cxt->mu);
   cxt->mu.AssertHeld();
   while (cxt->g0 < cxt->iterations) {
     while (cxt->g0 != target && cxt->g0 != cxt->iterations) {
@@ -199,7 +202,7 @@ static void TestSignalAll(TestContext *cxt, int c) {
 static void TestSignal(TestContext *cxt, int c) {
   CHECK_EQ(cxt->threads, 2) << "TestSignal should use 2 threads";
   int target = c;
-  absl::MutexLock l(&cxt->mu);
+  absl::MutexLock l(cxt->mu);
   cxt->mu.AssertHeld();
   while (cxt->g0 < cxt->iterations) {
     while (cxt->g0 != target && cxt->g0 != cxt->iterations) {
@@ -216,7 +219,7 @@ static void TestSignal(TestContext *cxt, int c) {
 
 static void TestCVTimeout(TestContext *cxt, int c) {
   int target = c;
-  absl::MutexLock l(&cxt->mu);
+  absl::MutexLock l(cxt->mu);
   cxt->mu.AssertHeld();
   while (cxt->g0 < cxt->iterations) {
     while (cxt->g0 != target && cxt->g0 != cxt->iterations) {
@@ -240,7 +243,7 @@ static void TestTime(TestContext *cxt, int c, bool use_cv) {
   absl::Condition false_cond(&kFalse);
   absl::Condition g0ge2(G0GE2, cxt);
   if (c == 0) {
-    absl::MutexLock l(&cxt->mu);
+    absl::MutexLock l(cxt->mu);
 
     absl::Time start = absl::Now();
     if (use_cv) {
@@ -308,7 +311,7 @@ static void TestTime(TestContext *cxt, int c, bool use_cv) {
     CHECK_EQ(cxt->g0, cxt->threads) << "TestTime failed";
 
   } else if (c == 1) {
-    absl::MutexLock l(&cxt->mu);
+    absl::MutexLock l(cxt->mu);
     const absl::Time start = absl::Now();
     if (use_cv) {
       cxt->cv.WaitWithTimeout(&cxt->mu, absl::Milliseconds(500));
@@ -321,7 +324,7 @@ static void TestTime(TestContext *cxt, int c, bool use_cv) {
         << "TestTime failed";
     cxt->g0++;
   } else if (c == 2) {
-    absl::MutexLock l(&cxt->mu);
+    absl::MutexLock l(cxt->mu);
     if (use_cv) {
       while (cxt->g0 < 2) {
         cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(100));
@@ -332,7 +335,7 @@ static void TestTime(TestContext *cxt, int c, bool use_cv) {
     }
     cxt->g0++;
   } else {
-    absl::MutexLock l(&cxt->mu);
+    absl::MutexLock l(cxt->mu);
     if (use_cv) {
       while (cxt->g0 < 2) {
         cxt->cv.Wait(&cxt->mu);
@@ -350,11 +353,11 @@ static void TestCVTime(TestContext *cxt, int c) { TestTime(cxt, c, true); }
 
 static void EndTest(int *c0, int *c1, absl::Mutex *mu, absl::CondVar *cv,
                     const std::function<void(int)> &cb) {
-  mu->Lock();
+  mu->lock();
   int c = (*c0)++;
-  mu->Unlock();
+  mu->unlock();
   cb(c);
-  absl::MutexLock l(mu);
+  absl::MutexLock l(*mu);
   (*c1)++;
   cv->Signal();
 }
@@ -376,11 +379,11 @@ static int RunTestCommon(TestContext *cxt, void (*test)(TestContext *cxt, int),
         &EndTest, &c0, &c1, &mu2, &cv2,
         std::function<void(int)>(std::bind(test, cxt, std::placeholders::_1))));
   }
-  mu2.Lock();
+  mu2.lock();
   while (c1 != threads) {
     cv2.Wait(&mu2);
   }
-  mu2.Unlock();
+  mu2.unlock();
   return cxt->g0;
 }
 
@@ -421,7 +424,7 @@ struct TimeoutBugStruct {
 static void WaitForA(TimeoutBugStruct *x) {
   x->mu.LockWhen(absl::Condition(&x->a));
   x->a_waiter_count--;
-  x->mu.Unlock();
+  x->mu.unlock();
 }
 
 static bool NoAWaiters(TimeoutBugStruct *x) { return x->a_waiter_count == 0; }
@@ -444,27 +447,27 @@ TEST(Mutex, CondVarWaitSignalsAwait) {
   // Thread A.  Sets barrier, waits for release using Mutex::Await, then
   // signals released_cv.
   pool->Schedule([&state] {
-    state.release_mu.Lock();
+    state.release_mu.lock();
 
-    state.barrier_mu.Lock();
+    state.barrier_mu.lock();
     state.barrier = true;
-    state.barrier_mu.Unlock();
+    state.barrier_mu.unlock();
 
     state.release_mu.Await(absl::Condition(&state.release));
     state.released_cv.Signal();
-    state.release_mu.Unlock();
+    state.release_mu.unlock();
   });
 
   state.barrier_mu.LockWhen(absl::Condition(&state.barrier));
-  state.barrier_mu.Unlock();
-  state.release_mu.Lock();
+  state.barrier_mu.unlock();
+  state.release_mu.lock();
   // Thread A is now blocked on release by way of Mutex::Await().
 
   // Set release.  Calling released_cv.Wait() should un-block thread A,
   // which will signal released_cv.  If not, the test will hang.
   state.release = true;
   state.released_cv.Wait(&state.release_mu);
-  state.release_mu.Unlock();
+  state.release_mu.unlock();
 }
 
 // Test that a CondVar.WaitWithTimeout(&mutex) can un-block a call to
@@ -485,20 +488,20 @@ TEST(Mutex, CondVarWaitWithTimeoutSignalsAwait) {
   // Thread A.  Sets barrier, waits for release using Mutex::Await, then
   // signals released_cv.
   pool->Schedule([&state] {
-    state.release_mu.Lock();
+    state.release_mu.lock();
 
-    state.barrier_mu.Lock();
+    state.barrier_mu.lock();
     state.barrier = true;
-    state.barrier_mu.Unlock();
+    state.barrier_mu.unlock();
 
     state.release_mu.Await(absl::Condition(&state.release));
     state.released_cv.Signal();
-    state.release_mu.Unlock();
+    state.release_mu.unlock();
   });
 
   state.barrier_mu.LockWhen(absl::Condition(&state.barrier));
-  state.barrier_mu.Unlock();
-  state.release_mu.Lock();
+  state.barrier_mu.unlock();
+  state.release_mu.lock();
   // Thread A is now blocked on release by way of Mutex::Await().
 
   // Set release.  Calling released_cv.Wait() should un-block thread A,
@@ -509,7 +512,7 @@ TEST(Mutex, CondVarWaitWithTimeoutSignalsAwait) {
       << "; Unrecoverable test failure: CondVar::WaitWithTimeout did not "
          "unblock the absl::Mutex::Await call in another thread.";
 
-  state.release_mu.Unlock();
+  state.release_mu.unlock();
 }
 
 // Test for regression of a bug in loop of TryRemove()
@@ -535,7 +538,7 @@ TEST(Mutex, MutexTimeoutBug) {
 
   x.a = true;                                    // wakeup the two waiters on A
   x.mu.Await(absl::Condition(&NoAWaiters, &x));  // wait for them to exit
-  x.mu.Unlock();
+  x.mu.unlock();
 }
 
 struct CondVarWaitDeadlock : testing::TestWithParam<int> {
@@ -555,27 +558,27 @@ struct CondVarWaitDeadlock : testing::TestWithParam<int> {
 
   void Waiter1() {
     if (read_lock1) {
-      mu.ReaderLock();
+      mu.lock_shared();
       while (!cond1) {
         cv.Wait(&mu);
       }
-      mu.ReaderUnlock();
+      mu.unlock_shared();
     } else {
-      mu.Lock();
+      mu.lock();
       while (!cond1) {
         cv.Wait(&mu);
       }
-      mu.Unlock();
+      mu.unlock();
     }
   }
 
   void Waiter2() {
     if (read_lock2) {
       mu.ReaderLockWhen(absl::Condition(&cond2));
-      mu.ReaderUnlock();
+      mu.unlock_shared();
     } else {
       mu.LockWhen(absl::Condition(&cond2));
-      mu.Unlock();
+      mu.unlock();
     }
   }
 };
@@ -599,21 +602,21 @@ TEST_P(CondVarWaitDeadlock, Test) {
   absl::SleepFor(absl::Milliseconds(100));
 
   // Wake condwaiter.
-  mu.Lock();
+  mu.lock();
   cond1 = true;
   if (signal_unlocked) {
-    mu.Unlock();
+    mu.unlock();
     cv.Signal();
   } else {
     cv.Signal();
-    mu.Unlock();
+    mu.unlock();
   }
   waiter1.reset();  // "join" waiter1
 
   // Wake waiter.
-  mu.Lock();
+  mu.lock();
   cond2 = true;
-  mu.Unlock();
+  mu.unlock();
   waiter2.reset();  // "join" waiter2
 }
 
@@ -638,19 +641,19 @@ struct DequeueAllWakeableBugStruct {
 
 // Test for regression of a bug in loop of DequeueAllWakeable()
 static void AcquireAsReader(DequeueAllWakeableBugStruct *x) {
-  x->mu.ReaderLock();
-  x->mu2.Lock();
+  x->mu.lock_shared();
+  x->mu2.lock();
   x->unfinished_count--;
   x->done1 = (x->unfinished_count == 0);
-  x->mu2.Unlock();
+  x->mu2.unlock();
   // make sure that both readers acquired mu before we release it.
   absl::SleepFor(absl::Seconds(2));
-  x->mu.ReaderUnlock();
+  x->mu.unlock_shared();
 
-  x->mu2.Lock();
+  x->mu2.lock();
   x->finished_count--;
   x->done2 = (x->finished_count == 0);
-  x->mu2.Unlock();
+  x->mu2.unlock();
 }
 
 // Test for regression of a bug in loop of DequeueAllWakeable()
@@ -662,21 +665,21 @@ TEST(Mutex, MutexReaderWakeupBug) {
   x.done1 = false;
   x.finished_count = 2;
   x.done2 = false;
-  x.mu.Lock();  // acquire mu exclusively
+  x.mu.lock();  // acquire mu exclusively
   // queue two thread that will block on reader locks on x.mu
   tp->Schedule(std::bind(&AcquireAsReader, &x));
   tp->Schedule(std::bind(&AcquireAsReader, &x));
   absl::SleepFor(absl::Seconds(1));  // give time for reader threads to block
-  x.mu.Unlock();                     // wake them up
+  x.mu.unlock();                     // wake them up
 
   // both readers should finish promptly
   EXPECT_TRUE(
       x.mu2.LockWhenWithTimeout(absl::Condition(&x.done1), absl::Seconds(10)));
-  x.mu2.Unlock();
+  x.mu2.unlock();
 
   EXPECT_TRUE(
       x.mu2.LockWhenWithTimeout(absl::Condition(&x.done2), absl::Seconds(10)));
-  x.mu2.Unlock();
+  x.mu2.unlock();
 }
 
 struct LockWhenTestStruct {
@@ -688,15 +691,15 @@ struct LockWhenTestStruct {
 };
 
 static bool LockWhenTestIsCond(LockWhenTestStruct *s) {
-  s->mu2.Lock();
+  s->mu2.lock();
   s->waiting = true;
-  s->mu2.Unlock();
+  s->mu2.unlock();
   return s->cond;
 }
 
 static void LockWhenTestWaitForIsCond(LockWhenTestStruct *s) {
   s->mu1.LockWhen(absl::Condition(&LockWhenTestIsCond, s));
-  s->mu1.Unlock();
+  s->mu1.unlock();
 }
 
 TEST(Mutex, LockWhen) {
@@ -704,11 +707,11 @@ TEST(Mutex, LockWhen) {
 
   std::thread t(LockWhenTestWaitForIsCond, &s);
   s.mu2.LockWhen(absl::Condition(&s.waiting));
-  s.mu2.Unlock();
+  s.mu2.unlock();
 
-  s.mu1.Lock();
+  s.mu1.lock();
   s.cond = true;
-  s.mu1.Unlock();
+  s.mu1.unlock();
 
   t.join();
 }
@@ -723,20 +726,20 @@ TEST(Mutex, LockWhenGuard) {
   bool (*cond_lt_10)(int *) = [](int *p) { return *p < 10; };
 
   std::thread t1([&mu, &n, &done, cond_eq_10]() {
-    absl::ReaderMutexLock lock(&mu, absl::Condition(cond_eq_10, &n));
+    absl::ReaderMutexLock lock(mu, absl::Condition(cond_eq_10, &n));
     done = true;
   });
 
   std::thread t2[10];
   for (std::thread &t : t2) {
     t = std::thread([&mu, &n, cond_lt_10]() {
-      absl::WriterMutexLock lock(&mu, absl::Condition(cond_lt_10, &n));
+      absl::WriterMutexLock lock(mu, absl::Condition(cond_lt_10, &n));
       ++n;
     });
   }
 
   {
-    absl::MutexLock lock(&mu);
+    absl::MutexLock lock(mu);
     n = 0;
   }
 
@@ -748,7 +751,7 @@ TEST(Mutex, LockWhenGuard) {
 }
 
 // --------------------------------------------------------
-// The following test requires Mutex::ReaderLock to be a real shared
+// The following test requires Mutex::lock_shared to be a real shared
 // lock, which is not the case in all builds.
 #if !defined(ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE)
 
@@ -775,9 +778,9 @@ struct ReaderDecrementBugStruct {
 // L >= mu, L < mu_waiting_on_cond
 static bool IsCond(void *v) {
   ReaderDecrementBugStruct *x = reinterpret_cast<ReaderDecrementBugStruct *>(v);
-  x->mu2.Lock();
+  x->mu2.lock();
   x->waiting_on_cond = true;
-  x->mu2.Unlock();
+  x->mu2.unlock();
   return x->cond;
 }
 
@@ -790,23 +793,23 @@ static bool AllDone(void *v) {
 // L={}
 static void WaitForCond(ReaderDecrementBugStruct *x) {
   absl::Mutex dummy;
-  absl::MutexLock l(&dummy);
+  absl::MutexLock l(dummy);
   x->mu.LockWhen(absl::Condition(&IsCond, x));
   x->done--;
-  x->mu.Unlock();
+  x->mu.unlock();
 }
 
 // L={}
 static void GetReadLock(ReaderDecrementBugStruct *x) {
-  x->mu.ReaderLock();
-  x->mu2.Lock();
+  x->mu.lock_shared();
+  x->mu2.lock();
   x->have_reader_lock = true;
   x->mu2.Await(absl::Condition(&x->complete));
-  x->mu2.Unlock();
-  x->mu.ReaderUnlock();
-  x->mu.Lock();
+  x->mu2.unlock();
+  x->mu.unlock_shared();
+  x->mu.lock();
   x->done--;
-  x->mu.Unlock();
+  x->mu.unlock();
 }
 
 // Test for reader counter being decremented incorrectly by waiter
@@ -822,32 +825,32 @@ TEST(Mutex, MutexReaderDecrementBug) ABSL_NO_THREAD_SAFETY_ANALYSIS {
   // Run WaitForCond() and wait for it to sleep
   std::thread thread1(WaitForCond, &x);
   x.mu2.LockWhen(absl::Condition(&x.waiting_on_cond));
-  x.mu2.Unlock();
+  x.mu2.unlock();
 
   // Run GetReadLock(), and wait for it to get the read lock
   std::thread thread2(GetReadLock, &x);
   x.mu2.LockWhen(absl::Condition(&x.have_reader_lock));
-  x.mu2.Unlock();
+  x.mu2.unlock();
 
   // Get the reader lock ourselves, and release it.
-  x.mu.ReaderLock();
-  x.mu.ReaderUnlock();
+  x.mu.lock_shared();
+  x.mu.unlock_shared();
 
   // The lock should be held in read mode by GetReadLock().
   // If we have the bug, the lock will be free.
   x.mu.AssertReaderHeld();
 
   // Wake up all the threads.
-  x.mu2.Lock();
+  x.mu2.lock();
   x.complete = true;
-  x.mu2.Unlock();
+  x.mu2.unlock();
 
   // TODO(delesley): turn on analysis once lock upgrading is supported.
   // (This call upgrades the lock from shared to exclusive.)
-  x.mu.Lock();
+  x.mu.lock();
   x.cond = true;
   x.mu.Await(absl::Condition(&AllDone, &x));
-  x.mu.Unlock();
+  x.mu.unlock();
 
   thread1.join();
   thread2.join();
@@ -868,9 +871,9 @@ TEST(Mutex, LockedMutexDestructionBug) ABSL_NO_THREAD_SAFETY_ANALYSIS {
     auto mu = absl::make_unique<absl::Mutex[]>(kNumLocks);
     for (int j = 0; j != kNumLocks; j++) {
       if ((j % 2) == 0) {
-        mu[j].WriterLock();
+        mu[j].lock();
       } else {
-        mu[j].ReaderLock();
+        mu[j].lock_shared();
       }
     }
   }
@@ -1064,18 +1067,17 @@ TEST(Mutex, ConditionSwap) {
 
 static void ReaderForReaderOnCondVar(absl::Mutex *mu, absl::CondVar *cv,
                                      int *running) {
-  std::random_device dev;
-  std::mt19937 gen(dev());
+  absl::InsecureBitGen gen;
   std::uniform_int_distribution<int> random_millis(0, 15);
-  mu->ReaderLock();
+  mu->lock_shared();
   while (*running == 3) {
     absl::SleepFor(absl::Milliseconds(random_millis(gen)));
     cv->WaitWithTimeout(mu, absl::Milliseconds(random_millis(gen)));
   }
-  mu->ReaderUnlock();
-  mu->Lock();
+  mu->unlock_shared();
+  mu->lock();
   (*running)--;
-  mu->Unlock();
+  mu->unlock();
 }
 
 static bool IntIsZero(int *x) { return *x == 0; }
@@ -1090,10 +1092,10 @@ TEST(Mutex, TestReaderOnCondVar) {
   tp->Schedule(std::bind(&ReaderForReaderOnCondVar, &mu, &cv, &running));
   tp->Schedule(std::bind(&ReaderForReaderOnCondVar, &mu, &cv, &running));
   absl::SleepFor(absl::Seconds(2));
-  mu.Lock();
+  mu.lock();
   running--;
   mu.Await(absl::Condition(&IntIsZero, &running));
-  mu.Unlock();
+  mu.unlock();
 }
 
 // --------------------------------------------------------
@@ -1117,7 +1119,7 @@ static bool ConditionWithAcquire(AcquireFromConditionStruct *x) {
     bool always_false = false;
     x->mu1.LockWhenWithTimeout(absl::Condition(&always_false),
                                absl::Milliseconds(100));
-    x->mu1.Unlock();
+    x->mu1.unlock();
   }
   CHECK_LT(x->value, 4) << "should not be invoked a fourth time";
 
@@ -1129,7 +1131,7 @@ static void WaitForCond2(AcquireFromConditionStruct *x) {
   // wait for cond0 to become true
   x->mu0.LockWhen(absl::Condition(&ConditionWithAcquire, x));
   x->done = true;
-  x->mu0.Unlock();
+  x->mu0.unlock();
 }
 
 // Test for Condition whose function acquires other Mutexes
@@ -1145,12 +1147,12 @@ TEST(Mutex, AcquireFromCondition) {
   // return false.
   absl::SleepFor(absl::Milliseconds(500));  // allow T time to hang
 
-  x.mu0.Lock();
+  x.mu0.lock();
   x.cv.WaitWithTimeout(&x.mu0, absl::Milliseconds(500));  // wake T
   // T will be woken because the Wait() will call ConditionWithAcquire()
   // for the second time, and it will return true.
 
-  x.mu0.Unlock();
+  x.mu0.unlock();
 
   // T will then acquire the lock and recheck its own condition.
   // It will find the condition true, as this is the third invocation,
@@ -1166,7 +1168,7 @@ TEST(Mutex, AcquireFromCondition) {
   // is conceptually waiting both on the condition variable, and on mu2.
 
   x.mu0.LockWhen(absl::Condition(&x.done));
-  x.mu0.Unlock();
+  x.mu0.unlock();
 }
 
 TEST(Mutex, DeadlockDetector) {
@@ -1178,20 +1180,20 @@ TEST(Mutex, DeadlockDetector) {
   absl::Mutex m3;
   absl::Mutex m4;
 
-  m1.Lock();  // m1 gets ID1
-  m2.Lock();  // m2 gets ID2
-  m3.Lock();  // m3 gets ID3
-  m3.Unlock();
-  m2.Unlock();
+  m1.lock();  // m1 gets ID1
+  m2.lock();  // m2 gets ID2
+  m3.lock();  // m3 gets ID3
+  m3.unlock();
+  m2.unlock();
   // m1 still held
   m1.ForgetDeadlockInfo();  // m1 loses ID
-  m2.Lock();                // m2 gets ID2
-  m3.Lock();                // m3 gets ID3
-  m4.Lock();                // m4 gets ID4
-  m3.Unlock();
-  m2.Unlock();
-  m4.Unlock();
-  m1.Unlock();
+  m2.lock();                // m2 gets ID2
+  m3.lock();                // m3 gets ID3
+  m4.lock();                // m4 gets ID4
+  m3.unlock();
+  m2.unlock();
+  m4.unlock();
+  m1.unlock();
 }
 
 // Bazel has a test "warning" file that programs can write to if the
@@ -1246,18 +1248,18 @@ TEST(Mutex, DeadlockDetectorBazelWarning) {
 
   absl::Mutex mu0;
   absl::Mutex mu1;
-  bool got_mu0 = mu0.TryLock();
-  mu1.Lock();  // acquire mu1 while holding mu0
+  bool got_mu0 = mu0.try_lock();
+  mu1.lock();  // acquire mu1 while holding mu0
   if (got_mu0) {
-    mu0.Unlock();
+    mu0.unlock();
   }
-  if (mu0.TryLock()) {  // try lock shouldn't cause deadlock detector to fire
-    mu0.Unlock();
+  if (mu0.try_lock()) {  // try lock shouldn't cause deadlock detector to fire
+    mu0.unlock();
   }
-  mu0.Lock();  // acquire mu0 while holding mu1; should get one deadlock
+  mu0.lock();  // acquire mu0 while holding mu1; should get one deadlock
                // report here
-  mu0.Unlock();
-  mu1.Unlock();
+  mu0.unlock();
+  mu1.unlock();
 
   absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kAbort);
 }
@@ -1272,10 +1274,10 @@ TEST(Mutex, DeadlockDetectorLongCycle) {
   // Check that we survive a deadlock with a lock cycle.
   std::vector<absl::Mutex> mutex(100);
   for (size_t i = 0; i != mutex.size(); i++) {
-    mutex[i].Lock();
-    mutex[(i + 1) % mutex.size()].Lock();
-    mutex[i].Unlock();
-    mutex[(i + 1) % mutex.size()].Unlock();
+    mutex[i].lock();
+    mutex[(i + 1) % mutex.size()].lock();
+    mutex[i].unlock();
+    mutex[(i + 1) % mutex.size()].unlock();
   }
 
   absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kAbort);
@@ -1295,10 +1297,10 @@ TEST(Mutex, DeadlockDetectorStressTest) ABSL_NO_THREAD_SAFETY_ANALYSIS {
     int end = std::min(n_locks, i + 5);
     // acquire and then release locks i, i+1, ..., i+4
     for (int j = i; j < end; j++) {
-      array_of_locks[j].Lock();
+      array_of_locks[j].lock();
     }
     for (int j = i; j < end; j++) {
-      array_of_locks[j].Unlock();
+      array_of_locks[j].unlock();
     }
   }
 }
@@ -1319,11 +1321,11 @@ TEST(Mutex, DeadlockIdBug) ABSL_NO_THREAD_SAFETY_ANALYSIS {
   absl::Mutex b, c;
 
   // Hold mutex.
-  a->Lock();
+  a->lock();
 
   // Force deadlock id assignment by acquiring another lock.
-  b.Lock();
-  b.Unlock();
+  b.lock();
+  b.unlock();
 
   // Delete the mutex. The Mutex destructor tries to remove held locks,
   // but the attempt isn't foolproof.  It can fail if:
@@ -1338,8 +1340,8 @@ TEST(Mutex, DeadlockIdBug) ABSL_NO_THREAD_SAFETY_ANALYSIS {
   // We should end up getting assigned the same deadlock id that was
   // freed up when "a" was deleted, which will cause a spurious deadlock
   // report if the held lock entry for "a" was not invalidated.
-  c.Lock();
-  c.Unlock();
+  c.lock();
+  c.unlock();
 }
 
 // --------------------------------------------------------
@@ -1357,7 +1359,7 @@ static absl::Duration TimeoutTestAllowedSchedulingDelay() {
 
 // Returns true if `actual_delay` is close enough to `expected_delay` to pass
 // the timeouts/deadlines test.  Otherwise, logs warnings and returns false.
-ABSL_MUST_USE_RESULT
+[[nodiscard]]
 static bool DelayIsWithinBounds(absl::Duration expected_delay,
                                 absl::Duration actual_delay) {
   bool pass = true;
@@ -1574,11 +1576,11 @@ TEST_P(TimeoutTest, Await) {
     std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
         CreateDefaultPool();
     RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
-      absl::MutexLock l(&mu);
+      absl::MutexLock l(mu);
       value = true;
     });
 
-    absl::MutexLock lock(&mu);
+    absl::MutexLock lock(mu);
     absl::Time start_time = absl::Now();
     absl::Condition cond(&value);
     bool result =
@@ -1608,7 +1610,7 @@ TEST_P(TimeoutTest, LockWhen) {
     std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
         CreateDefaultPool();
     RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
-      absl::MutexLock l(&mu);
+      absl::MutexLock l(mu);
       value = true;
     });
 
@@ -1618,7 +1620,7 @@ TEST_P(TimeoutTest, LockWhen) {
         params.use_absolute_deadline
             ? mu.LockWhenWithDeadline(cond, start_time + params.wait_timeout)
             : mu.LockWhenWithTimeout(cond, params.wait_timeout);
-    mu.Unlock();
+    mu.unlock();
 
     if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
       EXPECT_EQ(params.expected_result, result);
@@ -1643,7 +1645,7 @@ TEST_P(TimeoutTest, ReaderLockWhen) {
     std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
         CreateDefaultPool();
     RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
-      absl::MutexLock l(&mu);
+      absl::MutexLock l(mu);
       value = true;
     });
 
@@ -1654,7 +1656,7 @@ TEST_P(TimeoutTest, ReaderLockWhen) {
                                             start_time + params.wait_timeout)
             : mu.ReaderLockWhenWithTimeout(absl::Condition(&value),
                                            params.wait_timeout);
-    mu.ReaderUnlock();
+    mu.unlock_shared();
 
     if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
       EXPECT_EQ(params.expected_result, result);
@@ -1680,12 +1682,12 @@ TEST_P(TimeoutTest, Wait) {
     std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
         CreateDefaultPool();
     RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
-      absl::MutexLock l(&mu);
+      absl::MutexLock l(mu);
       value = true;
       cv.Signal();
     });
 
-    absl::MutexLock lock(&mu);
+    absl::MutexLock lock(mu);
     absl::Time start_time = absl::Now();
     absl::Duration timeout = params.wait_timeout;
     absl::Time deadline = start_time + timeout;
@@ -1711,13 +1713,13 @@ TEST(Mutex, Logging) {
   logged_mutex.EnableDebugLog("fido_mutex");
   absl::CondVar logged_cv;
   logged_cv.EnableDebugLog("rover_cv");
-  logged_mutex.Lock();
+  logged_mutex.lock();
   logged_cv.WaitWithTimeout(&logged_mutex, absl::Milliseconds(20));
-  logged_mutex.Unlock();
-  logged_mutex.ReaderLock();
-  logged_mutex.ReaderUnlock();
-  logged_mutex.Lock();
-  logged_mutex.Unlock();
+  logged_mutex.unlock();
+  logged_mutex.lock_shared();
+  logged_mutex.unlock_shared();
+  logged_mutex.lock();
+  logged_mutex.unlock();
   logged_cv.Signal();
   logged_cv.SignalAll();
 }
@@ -1725,7 +1727,7 @@ TEST(Mutex, Logging) {
 TEST(Mutex, LoggingAddressReuse) {
   // Repeatedly re-create a Mutex with debug logging at the same address.
   ScopedInvariantDebugging scoped_debugging;
-  alignas(absl::Mutex) char storage[sizeof(absl::Mutex)];
+  alignas(absl::Mutex) unsigned char storage[sizeof(absl::Mutex)];
   auto invariant =
       +[](void *alive) { EXPECT_TRUE(*static_cast<bool *>(alive)); };
   constexpr size_t kIters = 10;
@@ -1735,8 +1737,8 @@ TEST(Mutex, LoggingAddressReuse) {
     alive[i] = true;
     mu->EnableDebugLog("Mutex");
     mu->EnableInvariantDebugging(invariant, &alive[i]);
-    mu->Lock();
-    mu->Unlock();
+    mu->lock();
+    mu->unlock();
     mu->~Mutex();
     alive[i] = false;
   }
@@ -1762,8 +1764,8 @@ TEST(Mutex, SynchEventRace) {
         {
           absl::Mutex mu;
           mu.EnableInvariantDebugging([](void *) {}, nullptr);
-          mu.Lock();
-          mu.Unlock();
+          mu.lock();
+          mu.unlock();
         }
         {
           absl::Mutex mu;
@@ -1900,7 +1902,7 @@ TEST(Mutex, MuTime) {
 }
 
 TEST(Mutex, SignalExitedThread) {
-  // The test may expose a race when Mutex::Unlock signals a thread
+  // The test may expose a race when Mutex::unlock signals a thread
   // that has already exited.
 #if defined(__wasm__) || defined(__asmjs__)
   constexpr int kThreads = 1;  // OOMs under WASM
@@ -1913,11 +1915,11 @@ TEST(Mutex, SignalExitedThread) {
       for (int i = 0; i < kThreads; i++) {
         absl::Mutex mu;
         std::thread t([&]() {
-          mu.Lock();
-          mu.Unlock();
+          mu.lock();
+          mu.unlock();
         });
-        mu.Lock();
-        mu.Unlock();
+        mu.lock();
+        mu.unlock();
         t.join();
       }
     });
@@ -1931,7 +1933,7 @@ TEST(Mutex, WriterPriority) {
   std::atomic<bool> saw_wrote{false};
   auto readfunc = [&]() {
     for (size_t i = 0; i < 10; ++i) {
-      absl::ReaderMutexLock lock(&mu);
+      absl::ReaderMutexLock lock(mu);
       if (wrote) {
         saw_wrote = true;
         break;
@@ -1946,7 +1948,7 @@ TEST(Mutex, WriterPriority) {
   // PerThreadSynch::priority, so the writer intentionally runs on a new thread.
   std::thread t3([&]() {
     // The writer should be able squeeze between the two alternating readers.
-    absl::MutexLock lock(&mu);
+    absl::MutexLock lock(mu);
     wrote = true;
   });
   t1.join();
@@ -1978,30 +1980,30 @@ TEST(Mutex, CondVarPriority) {
   bool morph = false;
   std::thread th([&]() {
     EXPECT_EQ(0, pthread_setschedparam(pthread_self(), SCHED_FIFO, &param));
-    mu.Lock();
+    mu.lock();
     locked = true;
     mu.Await(absl::Condition(&notified));
-    mu.Unlock();
+    mu.unlock();
     EXPECT_EQ(absl::synchronization_internal::GetOrCreateCurrentThreadIdentity()
                   ->per_thread_synch.priority,
               param.sched_priority);
-    mu.Lock();
+    mu.lock();
     mu.Await(absl::Condition(&waiting));
     morph = true;
     absl::SleepFor(absl::Seconds(1));
     cv.Signal();
-    mu.Unlock();
+    mu.unlock();
   });
-  mu.Lock();
+  mu.lock();
   mu.Await(absl::Condition(&locked));
   notified = true;
-  mu.Unlock();
-  mu.Lock();
+  mu.unlock();
+  mu.lock();
   waiting = true;
   while (!morph) {
     cv.Wait(&mu);
   }
-  mu.Unlock();
+  mu.unlock();
   th.join();
   EXPECT_NE(absl::synchronization_internal::GetOrCreateCurrentThreadIdentity()
                 ->per_thread_synch.priority,
@@ -2016,22 +2018,34 @@ TEST(Mutex, LockWhenWithTimeoutResult) {
   const bool kAlwaysTrue = true, kAlwaysFalse = false;
   const absl::Condition kTrueCond(&kAlwaysTrue), kFalseCond(&kAlwaysFalse);
   EXPECT_TRUE(mu.LockWhenWithTimeout(kTrueCond, absl::Milliseconds(1)));
-  mu.Unlock();
+  mu.unlock();
   EXPECT_FALSE(mu.LockWhenWithTimeout(kFalseCond, absl::Milliseconds(1)));
   EXPECT_TRUE(mu.AwaitWithTimeout(kTrueCond, absl::Milliseconds(1)));
   EXPECT_FALSE(mu.AwaitWithTimeout(kFalseCond, absl::Milliseconds(1)));
   std::thread th1([&]() {
     EXPECT_TRUE(mu.LockWhenWithTimeout(kTrueCond, absl::Milliseconds(1)));
-    mu.Unlock();
+    mu.unlock();
   });
   std::thread th2([&]() {
     EXPECT_FALSE(mu.LockWhenWithTimeout(kFalseCond, absl::Milliseconds(1)));
-    mu.Unlock();
+    mu.unlock();
   });
   absl::SleepFor(absl::Milliseconds(100));
-  mu.Unlock();
+  mu.unlock();
   th1.join();
   th2.join();
 }
 
+TEST(Mutex, ScopedLock) {
+  absl::Mutex mu;
+  {
+    std::scoped_lock l(mu);
+  }
+
+  {
+    std::shared_lock l(mu);
+    EXPECT_TRUE(l.owns_lock());
+  }
+}
+
 }  // namespace