base/threading/platform_thread_unittest.cc - bauxite - Git at Google

 // 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
	// 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