base/threading/platform_thread_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/compiler_specific.h"
   6 #include "base/threading/platform_thread.h"
   7
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace base {
  11
  12 // Trivial tests that thread runs and doesn't crash on create and join ---------
  13
  14 class TrivialThread : public PlatformThread::Delegate {
  15  public:
  16   TrivialThread() : did_run_(false) {}
  17
  18   void ThreadMain() override { did_run_ = true; }
  19
  20   bool did_run() const { return did_run_; }
  21
  22  private:
  23   bool did_run_;
  24
  25   DISALLOW_COPY_AND_ASSIGN(TrivialThread);
  26 };
  27
  28 TEST(PlatformThreadTest, Trivial) {
  29   TrivialThread thread;
  30   PlatformThreadHandle handle;
  31
  32   ASSERT_FALSE(thread.did_run());
  33   ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
  34   PlatformThread::Join(handle);
  35   ASSERT_TRUE(thread.did_run());
  36 }
  37
  38 TEST(PlatformThreadTest, TrivialTimesTen) {
  39   TrivialThread thread[10];
  40   PlatformThreadHandle handle[arraysize(thread)];
  41
  42   for (size_t n = 0; n < arraysize(thread); n++)
  43     ASSERT_FALSE(thread[n].did_run());
  44   for (size_t n = 0; n < arraysize(thread); n++)
  45     ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
  46   for (size_t n = 0; n < arraysize(thread); n++)
  47     PlatformThread::Join(handle[n]);
  48   for (size_t n = 0; n < arraysize(thread); n++)
  49     ASSERT_TRUE(thread[n].did_run());
  50 }
  51
  52 // Tests of basic thread functions ---------------------------------------------
  53
  54 class FunctionTestThread : public TrivialThread {
  55  public:
  56   FunctionTestThread() : thread_id_(0) {}
  57
  58   void ThreadMain() override {
  59     thread_id_ = PlatformThread::CurrentId();
  60     PlatformThread::YieldCurrentThread();
  61     PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
  62
  63     // Make sure that the thread ID is the same across calls.
  64     EXPECT_EQ(thread_id_, PlatformThread::CurrentId());
  65
  66     TrivialThread::ThreadMain();
  67   }
  68
  69   PlatformThreadId thread_id() const { return thread_id_; }
  70
  71  private:
  72   PlatformThreadId thread_id_;
  73
  74   DISALLOW_COPY_AND_ASSIGN(FunctionTestThread);
  75 };
  76
  77 TEST(PlatformThreadTest, Function) {
  78   PlatformThreadId main_thread_id = PlatformThread::CurrentId();
  79
  80   FunctionTestThread thread;
  81   PlatformThreadHandle handle;
  82
  83   ASSERT_FALSE(thread.did_run());
  84   ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
  85   PlatformThread::Join(handle);
  86   ASSERT_TRUE(thread.did_run());
  87   EXPECT_NE(thread.thread_id(), main_thread_id);
  88
  89   // Make sure that the thread ID is the same across calls.
  90   EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
  91 }
  92
  93 TEST(PlatformThreadTest, FunctionTimesTen) {
  94   PlatformThreadId main_thread_id = PlatformThread::CurrentId();
  95
  96   FunctionTestThread thread[10];
  97   PlatformThreadHandle handle[arraysize(thread)];
  98
  99   for (size_t n = 0; n < arraysize(thread); n++)
 100     ASSERT_FALSE(thread[n].did_run());
 101   for (size_t n = 0; n < arraysize(thread); n++)
 102     ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
 103   for (size_t n = 0; n < arraysize(thread); n++)
 104     PlatformThread::Join(handle[n]);
 105   for (size_t n = 0; n < arraysize(thread); n++) {
 106     ASSERT_TRUE(thread[n].did_run());
 107     EXPECT_NE(thread[n].thread_id(), main_thread_id);
 108
 109     // Make sure no two threads get the same ID.
 110     for (size_t i = 0; i < n; ++i) {
 111       EXPECT_NE(thread[i].thread_id(), thread[n].thread_id());
 112     }
 113   }
 114
 115   // Make sure that the thread ID is the same across calls.
 116   EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
 117 }
 118
 119 }  // namespace base