Index: base/task_scheduler/scheduler_lock_unittest.cc |
diff --git a/base/task_scheduler/scheduler_lock_unittest.cc b/base/task_scheduler/scheduler_lock_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..6010b5be1af980bfb8a5789edde883078b62b4ec |
--- /dev/null |
+++ b/base/task_scheduler/scheduler_lock_unittest.cc |
@@ -0,0 +1,184 @@ |
+// Copyright 2016 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "base/task_scheduler/scheduler_lock.h" |
+ |
+#include <stdlib.h> |
+ |
+#include "base/compiler_specific.h" |
+#include "base/macros.h" |
+#include "base/synchronization/waitable_event.h" |
+#include "base/threading/platform_thread.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace base { |
+namespace task_scheduler { |
+ |
+class BasicLockTestThread : public PlatformThread::Delegate { |
+ public: |
+ explicit BasicLockTestThread(SchedulerLock* lock) |
+ : lock_(lock), |
+ acquired_(0) {} |
+ |
+ void ThreadMain() override { |
+ for (int i = 0; i < 10; i++) { |
+ lock_->Acquire(); |
+ acquired_++; |
+ lock_->Release(); |
+ } |
+ for (int i = 0; i < 10; i++) { |
+ lock_->Acquire(); |
+ acquired_++; |
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20)); |
+ lock_->Release(); |
+ } |
+ } |
+ |
+ int acquired() const { return acquired_; } |
+ |
+ private: |
+ SchedulerLock* const lock_; |
+ int acquired_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(BasicLockTestThread); |
+}; |
+ |
+class BasicLockAcquireAndWaitThread : public PlatformThread::Delegate { |
+ public: |
+ explicit BasicLockAcquireAndWaitThread(SchedulerLock* lock) |
+ : lock_(lock), |
+ lock_acquire_event_(false, false), |
+ main_thread_continue_event_(false, false) {} |
+ |
+ void ThreadMain() override { |
+ lock_->Acquire(); |
+ lock_acquire_event_.Signal(); |
+ main_thread_continue_event_.Wait(); |
+ lock_->Release(); |
+ } |
+ |
+ void WaitForLockAcquition() { |
+ lock_acquire_event_.Wait(); |
+ } |
+ |
+ void ContinueMain() { |
+ main_thread_continue_event_.Signal(); |
+ } |
+ |
+ private: |
+ SchedulerLock* const lock_; |
+ WaitableEvent lock_acquire_event_; |
+ WaitableEvent main_thread_continue_event_; |
+}; |
+ |
+TEST(SchedulerLock, Basic) { |
+ SchedulerLock lock; |
+ BasicLockTestThread thread(&lock); |
+ PlatformThreadHandle handle; |
+ |
+ ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
+ |
+ int acquired = 0; |
+ for (int i = 0; i < 5; i++) { |
+ lock.Acquire(); |
+ acquired++; |
+ lock.Release(); |
+ } |
+ for (int i = 0; i < 10; i++) { |
+ lock.Acquire(); |
+ acquired++; |
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20)); |
+ lock.Release(); |
+ } |
+ for (int i = 0; i < 5; i++) { |
+ lock.Acquire(); |
+ acquired++; |
+ PlatformThread::Sleep(TimeDelta::FromMilliseconds(rand() % 20)); |
+ lock.Release(); |
+ } |
+ |
+ PlatformThread::Join(handle); |
+ |
+ EXPECT_GE(acquired, 20); |
+ EXPECT_GE(thread.acquired(), 20); |
+} |
+ |
+TEST(SchedulerLock, AcquirePredecessor) { |
+ SchedulerLock lock_predecessor; |
+ SchedulerLock lock(&lock_predecessor); |
+ lock_predecessor.Acquire(); |
+ lock.Acquire(); |
+ lock.Release(); |
+ lock_predecessor.Release(); |
+} |
+ |
+TEST(SchedulerLock, AcquireNonPredecessor) { |
+ SchedulerLock lock_predecessor; |
+ SchedulerLock lock; |
+ lock_predecessor.Acquire(); |
+ EXPECT_DEATH(lock.Acquire(), ""); |
+ lock_predecessor.Release(); |
+} |
+ |
+TEST(SchedulerLock, AcquireMultipleLocksInOrder) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ SchedulerLock lock3(&lock2); |
+ lock1.Acquire(); |
+ lock2.Acquire(); |
+ lock3.Acquire(); |
+ lock3.Release(); |
+ lock2.Release(); |
+ lock1.Release(); |
+} |
+ |
+TEST(SchedulerLock, AcquireMultipleLocksInTheMiddleOfAChain) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ SchedulerLock lock3(&lock2); |
+ lock2.Acquire(); |
+ lock3.Acquire(); |
+ lock3.Release(); |
+ lock2.Release(); |
+} |
+ |
+TEST(SchedulerLock, AcquireMultipleLocksOutOfOrder) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ SchedulerLock lock3(&lock2); |
+ lock1.Acquire(); |
+ EXPECT_DEATH(lock3.Acquire(), ""); |
+ lock1.Release(); |
+} |
+ |
+TEST(SchedulerLock, AcquireLocksDifferentThreadsSafely) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2; |
+ BasicLockAcquireAndWaitThread thread(&lock1); |
+ PlatformThreadHandle handle; |
+ ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
+ |
+ lock2.Acquire(); |
+ thread.WaitForLockAcquition(); |
+ thread.ContinueMain(); |
+ lock2.Release(); |
+ PlatformThread::Join(handle); |
+} |
+ |
+TEST(SchedulerLock, AcquireLocksWithPredecessorDifferentThreadsSafely) { |
+ SchedulerLock lock1; |
+ SchedulerLock lock2(&lock1); |
+ BasicLockAcquireAndWaitThread thread(&lock1); |
+ PlatformThreadHandle handle; |
+ ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
+ |
+ lock2.Acquire(); |
+ thread.WaitForLockAcquition(); |
+ thread.ContinueMain(); |
+ lock2.Release(); |
+ PlatformThread::Join(handle); |
+} |
+ |
+} // namespace task_scheduler |
+} // base |