| // Copyright (c) 2012 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/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" |
| |
| #if defined(OS_WIN) |
| #include <windows.h> |
| #endif |
| |
| namespace base { |
| |
| // Trivial tests that thread runs and doesn't crash on create and join --------- |
| |
| class TrivialThread : public PlatformThread::Delegate { |
| public: |
| TrivialThread() : did_run_(false) {} |
| |
| void ThreadMain() override { did_run_ = true; } |
| |
| bool did_run() const { return did_run_; } |
| |
| private: |
| bool did_run_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TrivialThread); |
| }; |
| |
| TEST(PlatformThreadTest, Trivial) { |
| TrivialThread thread; |
| PlatformThreadHandle handle; |
| |
| ASSERT_FALSE(thread.did_run()); |
| ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
| PlatformThread::Join(handle); |
| ASSERT_TRUE(thread.did_run()); |
| } |
| |
| TEST(PlatformThreadTest, TrivialTimesTen) { |
| TrivialThread thread[10]; |
| PlatformThreadHandle handle[arraysize(thread)]; |
| |
| for (size_t n = 0; n < arraysize(thread); n++) |
| ASSERT_FALSE(thread[n].did_run()); |
| for (size_t n = 0; n < arraysize(thread); n++) |
| ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n])); |
| for (size_t n = 0; n < arraysize(thread); n++) |
| PlatformThread::Join(handle[n]); |
| for (size_t n = 0; n < arraysize(thread); n++) |
| ASSERT_TRUE(thread[n].did_run()); |
| } |
| |
| // Tests of basic thread functions --------------------------------------------- |
| |
| class FunctionTestThread : public PlatformThread::Delegate { |
| public: |
| FunctionTestThread() |
| : thread_id_(kInvalidThreadId), |
| thread_started_(true, false), |
| terminate_thread_(true, false), |
| done_(false) {} |
| ~FunctionTestThread() override { |
| EXPECT_TRUE(terminate_thread_.IsSignaled()) |
| << "Need to mark thread for termination and join the underlying thread " |
| << "before destroying a FunctionTestThread as it owns the " |
| << "WaitableEvent blocking the underlying thread's main."; |
| } |
| |
| // Grabs |thread_id_|, signals |thread_started_|, and then waits for |
| // |terminate_thread_| to be signaled before exiting. |
| void ThreadMain() override { |
| thread_id_ = PlatformThread::CurrentId(); |
| EXPECT_NE(thread_id_, kInvalidThreadId); |
| |
| // Make sure that the thread ID is the same across calls. |
| EXPECT_EQ(thread_id_, PlatformThread::CurrentId()); |
| |
| thread_started_.Signal(); |
| |
| terminate_thread_.Wait(); |
| |
| done_ = true; |
| } |
| |
| PlatformThreadId thread_id() const { |
| EXPECT_TRUE(thread_started_.IsSignaled()) << "Thread ID still unknown"; |
| return thread_id_; |
| } |
| |
| bool IsRunning() const { |
| return thread_started_.IsSignaled() && !done_; |
| } |
| |
| // Blocks until this thread is started. |
| void WaitForThreadStart() { thread_started_.Wait(); } |
| |
| // Mark this thread for termination (callers must then join this thread to be |
| // guaranteed of termination). |
| void MarkForTermination() { terminate_thread_.Signal(); } |
| |
| private: |
| PlatformThreadId thread_id_; |
| |
| mutable WaitableEvent thread_started_; |
| WaitableEvent terminate_thread_; |
| bool done_; |
| |
| DISALLOW_COPY_AND_ASSIGN(FunctionTestThread); |
| }; |
| |
| TEST(PlatformThreadTest, Function) { |
| PlatformThreadId main_thread_id = PlatformThread::CurrentId(); |
| |
| FunctionTestThread thread; |
| PlatformThreadHandle handle; |
| |
| ASSERT_FALSE(thread.IsRunning()); |
| ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
| thread.WaitForThreadStart(); |
| ASSERT_TRUE(thread.IsRunning()); |
| EXPECT_NE(thread.thread_id(), main_thread_id); |
| |
| thread.MarkForTermination(); |
| PlatformThread::Join(handle); |
| ASSERT_FALSE(thread.IsRunning()); |
| |
| // Make sure that the thread ID is the same across calls. |
| EXPECT_EQ(main_thread_id, PlatformThread::CurrentId()); |
| } |
| |
| TEST(PlatformThreadTest, FunctionTimesTen) { |
| PlatformThreadId main_thread_id = PlatformThread::CurrentId(); |
| |
| FunctionTestThread thread[10]; |
| PlatformThreadHandle handle[arraysize(thread)]; |
| |
| for (size_t n = 0; n < arraysize(thread); n++) |
| ASSERT_FALSE(thread[n].IsRunning()); |
| |
| for (size_t n = 0; n < arraysize(thread); n++) |
| ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n])); |
| for (size_t n = 0; n < arraysize(thread); n++) |
| thread[n].WaitForThreadStart(); |
| |
| for (size_t n = 0; n < arraysize(thread); n++) { |
| ASSERT_TRUE(thread[n].IsRunning()); |
| EXPECT_NE(thread[n].thread_id(), main_thread_id); |
| |
| // Make sure no two threads get the same ID. |
| for (size_t i = 0; i < n; ++i) { |
| EXPECT_NE(thread[i].thread_id(), thread[n].thread_id()); |
| } |
| } |
| |
| for (size_t n = 0; n < arraysize(thread); n++) |
| thread[n].MarkForTermination(); |
| for (size_t n = 0; n < arraysize(thread); n++) |
| PlatformThread::Join(handle[n]); |
| for (size_t n = 0; n < arraysize(thread); n++) |
| ASSERT_FALSE(thread[n].IsRunning()); |
| |
| // Make sure that the thread ID is the same across calls. |
| EXPECT_EQ(main_thread_id, PlatformThread::CurrentId()); |
| } |
| |
| namespace { |
| |
| const ThreadPriority kThreadPriorityTestValues[] = { |
| // Disable non-normal priority toggling on POSIX as it appears to be broken |
| // (http://crbug.com/468793). This is prefered to disabling the tests altogether |
| // on POSIX as it at least provides coverage for running this code under |
| // "normal" priority. |
| #if !defined(OS_POSIX) |
| ThreadPriority::DISPLAY, |
| ThreadPriority::REALTIME_AUDIO, |
| // Keep BACKGROUND second to last to test backgrounding from other |
| // priorities. |
| ThreadPriority::BACKGROUND, |
| #endif // !defined(OS_POSIX) |
| // Keep NORMAL last to test unbackgrounding. |
| ThreadPriority::NORMAL |
| }; |
| |
| } // namespace |
| |
| // Test changing another thread's priority. |
| // NOTE: This test is partially disabled on POSIX, see note above and |
| // http://crbug.com/468793. |
| TEST(PlatformThreadTest, ThreadPriorityOtherThread) { |
| PlatformThreadHandle current_handle(PlatformThread::CurrentHandle()); |
| |
| // Confirm that the current thread's priority is as expected. |
| EXPECT_EQ(ThreadPriority::NORMAL, |
| PlatformThread::GetThreadPriority(current_handle)); |
| |
| // Create a test thread. |
| FunctionTestThread thread; |
| PlatformThreadHandle handle; |
| ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
| thread.WaitForThreadStart(); |
| EXPECT_NE(thread.thread_id(), kInvalidThreadId); |
| EXPECT_NE(thread.thread_id(), PlatformThread::CurrentId()); |
| |
| // New threads should get normal priority by default. |
| EXPECT_EQ(ThreadPriority::NORMAL, PlatformThread::GetThreadPriority(handle)); |
| |
| // Toggle each supported priority on the test thread and confirm it only |
| // affects it (and not the current thread). |
| for (size_t i = 0; i < arraysize(kThreadPriorityTestValues); ++i) { |
| SCOPED_TRACE(i); |
| |
| // Alter and verify the test thread's priority. |
| PlatformThread::SetThreadPriority(handle, kThreadPriorityTestValues[i]); |
| EXPECT_EQ(kThreadPriorityTestValues[i], |
| PlatformThread::GetThreadPriority(handle)); |
| |
| // Make sure the current thread was otherwise unaffected. |
| EXPECT_EQ(ThreadPriority::NORMAL, |
| PlatformThread::GetThreadPriority(current_handle)); |
| } |
| |
| thread.MarkForTermination(); |
| PlatformThread::Join(handle); |
| } |
| |
| // Test changing the current thread's priority (which has different semantics on |
| // some platforms). |
| // NOTE: This test is partially disabled on POSIX, see note above and |
| // http://crbug.com/468793. |
| TEST(PlatformThreadTest, ThreadPriorityCurrentThread) { |
| PlatformThreadHandle current_handle(PlatformThread::CurrentHandle()); |
| |
| // Confirm that the current thread's priority is as expected. |
| EXPECT_EQ(ThreadPriority::NORMAL, |
| PlatformThread::GetThreadPriority(current_handle)); |
| |
| // Create a test thread for verification purposes only. |
| FunctionTestThread thread; |
| PlatformThreadHandle handle; |
| ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle)); |
| thread.WaitForThreadStart(); |
| EXPECT_NE(thread.thread_id(), kInvalidThreadId); |
| EXPECT_NE(thread.thread_id(), PlatformThread::CurrentId()); |
| |
| // Confirm that the new thread's priority is as expected. |
| EXPECT_EQ(ThreadPriority::NORMAL, PlatformThread::GetThreadPriority(handle)); |
| |
| // Toggle each supported priority on the current thread and confirm it only |
| // affects it (and not the test thread). |
| for (size_t i = 0; i < arraysize(kThreadPriorityTestValues); ++i) { |
| SCOPED_TRACE(i); |
| |
| // Alter and verify the current thread's priority. |
| PlatformThread::SetThreadPriority(current_handle, |
| kThreadPriorityTestValues[i]); |
| EXPECT_EQ(kThreadPriorityTestValues[i], |
| PlatformThread::GetThreadPriority(current_handle)); |
| |
| // Make sure the test thread was otherwise unaffected. |
| EXPECT_EQ(ThreadPriority::NORMAL, |
| PlatformThread::GetThreadPriority(handle)); |
| } |
| |
| // Restore current thread priority for follow-up tests. |
| PlatformThread::SetThreadPriority(current_handle, ThreadPriority::NORMAL); |
| |
| thread.MarkForTermination(); |
| PlatformThread::Join(handle); |
| } |
| |
| } // namespace base |