base/sequence_checker_unittest.cc

   1 // Copyright 2013 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/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/bind_helpers.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/sequence_checker.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/test/sequenced_worker_pool_owner.h"
  15 #include "base/threading/thread.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 // Duplicated from base/sequence_checker.h so that we can be good citizens
  19 // there and undef the macro.
  20 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
  21 #define ENABLE_SEQUENCE_CHECKER 1
  22 #else
  23 #define ENABLE_SEQUENCE_CHECKER 0
  24 #endif
  25
  26 namespace base {
  27
  28 namespace {
  29
  30 const size_t kNumWorkerThreads = 3;
  31
  32 // Simple class to exercise the basics of SequenceChecker.
  33 // DoStuff should verify that it's called on a valid sequenced thread.
  34 // SequenceCheckedObject can be destroyed on any thread (like WeakPtr).
  35 class SequenceCheckedObject {
  36  public:
  37   SequenceCheckedObject() {}
  38   ~SequenceCheckedObject() {}
  39
  40   // Verifies that it was called on the same thread as the constructor.
  41   void DoStuff() {
  42     DCHECK(sequence_checker_.CalledOnValidSequencedThread());
  43   }
  44
  45   void DetachFromSequence() {
  46     sequence_checker_.DetachFromSequence();
  47   }
  48
  49  private:
  50   SequenceChecker sequence_checker_;
  51
  52   DISALLOW_COPY_AND_ASSIGN(SequenceCheckedObject);
  53 };
  54
  55 class SequenceCheckerTest : public testing::Test {
  56  public:
  57   SequenceCheckerTest() : other_thread_("sequence_checker_test_other_thread") {}
  58
  59   void SetUp() override {
  60     other_thread_.Start();
  61     ResetPool();
  62   }
  63
  64   void TearDown() override {
  65     other_thread_.Stop();
  66     pool()->Shutdown();
  67   }
  68
  69  protected:
  70   base::Thread* other_thread() { return &other_thread_; }
  71
  72   const scoped_refptr<SequencedWorkerPool>& pool() {
  73     return pool_owner_->pool();
  74   }
  75
  76   void PostDoStuffToWorkerPool(SequenceCheckedObject* sequence_checked_object,
  77                                const std::string& token_name) {
  78     pool()->PostNamedSequencedWorkerTask(
  79         token_name,
  80         FROM_HERE,
  81         base::Bind(&SequenceCheckedObject::DoStuff,
  82                    base::Unretained(sequence_checked_object)));
  83   }
  84
  85   void PostDoStuffToOtherThread(
  86       SequenceCheckedObject* sequence_checked_object) {
  87     other_thread()->task_runner()->PostTask(
  88         FROM_HERE, base::Bind(&SequenceCheckedObject::DoStuff,
  89                               base::Unretained(sequence_checked_object)));
  90   }
  91
  92   void PostDeleteToOtherThread(
  93       scoped_ptr<SequenceCheckedObject> sequence_checked_object) {
  94     other_thread()->message_loop()->DeleteSoon(
  95         FROM_HERE,
  96         sequence_checked_object.release());
  97   }
  98
  99   // Destroys the SequencedWorkerPool instance, blocking until it is fully shut
 100   // down, and creates a new instance.
 101   void ResetPool() {
 102     pool_owner_.reset(new SequencedWorkerPoolOwner(kNumWorkerThreads, "test"));
 103   }
 104
 105   void MethodOnDifferentThreadDeathTest();
 106   void DetachThenCallFromDifferentThreadDeathTest();
 107   void DifferentSequenceTokensDeathTest();
 108   void WorkerPoolAndSimpleThreadDeathTest();
 109   void TwoDifferentWorkerPoolsDeathTest();
 110
 111  private:
 112   MessageLoop message_loop_;  // Needed by SequencedWorkerPool to function.
 113   base::Thread other_thread_;
 114   scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
 115 };
 116
 117 TEST_F(SequenceCheckerTest, CallsAllowedOnSameThread) {
 118   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 119       new SequenceCheckedObject);
 120
 121   // Verify that DoStuff doesn't assert.
 122   sequence_checked_object->DoStuff();
 123
 124   // Verify that the destructor doesn't assert.
 125   sequence_checked_object.reset();
 126 }
 127
 128 TEST_F(SequenceCheckerTest, DestructorAllowedOnDifferentThread) {
 129   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 130       new SequenceCheckedObject);
 131
 132   // Verify the destructor doesn't assert when called on a different thread.
 133   PostDeleteToOtherThread(sequence_checked_object.Pass());
 134   other_thread()->Stop();
 135 }
 136
 137 TEST_F(SequenceCheckerTest, DetachFromSequence) {
 138   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 139       new SequenceCheckedObject);
 140
 141   // Verify that DoStuff doesn't assert when called on a different thread after
 142   // a call to DetachFromSequence.
 143   sequence_checked_object->DetachFromSequence();
 144
 145   PostDoStuffToOtherThread(sequence_checked_object.get());
 146   other_thread()->Stop();
 147 }
 148
 149 TEST_F(SequenceCheckerTest, SameSequenceTokenValid) {
 150   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 151       new SequenceCheckedObject);
 152
 153   sequence_checked_object->DetachFromSequence();
 154   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 155   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 156   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 157   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 158   pool()->FlushForTesting();
 159
 160   PostDeleteToOtherThread(sequence_checked_object.Pass());
 161   other_thread()->Stop();
 162 }
 163
 164 TEST_F(SequenceCheckerTest, DetachSequenceTokenValid) {
 165   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 166       new SequenceCheckedObject);
 167
 168   sequence_checked_object->DetachFromSequence();
 169   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 170   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 171   pool()->FlushForTesting();
 172
 173   sequence_checked_object->DetachFromSequence();
 174   PostDoStuffToWorkerPool(sequence_checked_object.get(), "B");
 175   PostDoStuffToWorkerPool(sequence_checked_object.get(), "B");
 176   pool()->FlushForTesting();
 177
 178   PostDeleteToOtherThread(sequence_checked_object.Pass());
 179   other_thread()->Stop();
 180 }
 181
 182 #if GTEST_HAS_DEATH_TEST || !ENABLE_SEQUENCE_CHECKER
 183
 184 void SequenceCheckerTest::MethodOnDifferentThreadDeathTest() {
 185   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 186       new SequenceCheckedObject);
 187
 188   // DoStuff should assert in debug builds only when called on a
 189   // different thread.
 190   PostDoStuffToOtherThread(sequence_checked_object.get());
 191   other_thread()->Stop();
 192 }
 193
 194 #if ENABLE_SEQUENCE_CHECKER
 195 TEST_F(SequenceCheckerTest, MethodNotAllowedOnDifferentThreadDeathTestInDebug) {
 196   // The default style "fast" does not support multi-threaded tests.
 197   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 198   ASSERT_DEATH({
 199     MethodOnDifferentThreadDeathTest();
 200   }, "");
 201 }
 202 #else
 203 TEST_F(SequenceCheckerTest, MethodAllowedOnDifferentThreadDeathTestInRelease) {
 204   MethodOnDifferentThreadDeathTest();
 205 }
 206 #endif  // ENABLE_SEQUENCE_CHECKER
 207
 208 void SequenceCheckerTest::DetachThenCallFromDifferentThreadDeathTest() {
 209   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 210       new SequenceCheckedObject);
 211
 212   // DoStuff doesn't assert when called on a different thread
 213   // after a call to DetachFromSequence.
 214   sequence_checked_object->DetachFromSequence();
 215   PostDoStuffToOtherThread(sequence_checked_object.get());
 216   other_thread()->Stop();
 217
 218   // DoStuff should assert in debug builds only after moving to
 219   // another thread.
 220   sequence_checked_object->DoStuff();
 221 }
 222
 223 #if ENABLE_SEQUENCE_CHECKER
 224 TEST_F(SequenceCheckerTest, DetachFromSequenceDeathTestInDebug) {
 225   // The default style "fast" does not support multi-threaded tests.
 226   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 227   ASSERT_DEATH({
 228     DetachThenCallFromDifferentThreadDeathTest();
 229   }, "");
 230 }
 231 #else
 232 TEST_F(SequenceCheckerTest, DetachFromThreadDeathTestInRelease) {
 233   DetachThenCallFromDifferentThreadDeathTest();
 234 }
 235 #endif  // ENABLE_SEQUENCE_CHECKER
 236
 237 void SequenceCheckerTest::DifferentSequenceTokensDeathTest() {
 238   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 239       new SequenceCheckedObject);
 240
 241   sequence_checked_object->DetachFromSequence();
 242   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 243   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 244   PostDoStuffToWorkerPool(sequence_checked_object.get(), "B");
 245   PostDoStuffToWorkerPool(sequence_checked_object.get(), "B");
 246   pool()->FlushForTesting();
 247
 248   PostDeleteToOtherThread(sequence_checked_object.Pass());
 249   other_thread()->Stop();
 250 }
 251
 252 #if ENABLE_SEQUENCE_CHECKER
 253 TEST_F(SequenceCheckerTest, DifferentSequenceTokensDeathTestInDebug) {
 254   // The default style "fast" does not support multi-threaded tests.
 255   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 256   ASSERT_DEATH({
 257     DifferentSequenceTokensDeathTest();
 258   }, "");
 259 }
 260 #else
 261 TEST_F(SequenceCheckerTest, DifferentSequenceTokensDeathTestInRelease) {
 262   DifferentSequenceTokensDeathTest();
 263 }
 264 #endif  // ENABLE_SEQUENCE_CHECKER
 265
 266 void SequenceCheckerTest::WorkerPoolAndSimpleThreadDeathTest() {
 267   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 268       new SequenceCheckedObject);
 269
 270   sequence_checked_object->DetachFromSequence();
 271   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 272   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 273   pool()->FlushForTesting();
 274
 275   PostDoStuffToOtherThread(sequence_checked_object.get());
 276   other_thread()->Stop();
 277 }
 278
 279 #if ENABLE_SEQUENCE_CHECKER
 280 TEST_F(SequenceCheckerTest, WorkerPoolAndSimpleThreadDeathTestInDebug) {
 281   // The default style "fast" does not support multi-threaded tests.
 282   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 283   ASSERT_DEATH({
 284     WorkerPoolAndSimpleThreadDeathTest();
 285   }, "");
 286 }
 287 #else
 288 TEST_F(SequenceCheckerTest, WorkerPoolAndSimpleThreadDeathTestInRelease) {
 289   WorkerPoolAndSimpleThreadDeathTest();
 290 }
 291 #endif  // ENABLE_SEQUENCE_CHECKER
 292
 293 void SequenceCheckerTest::TwoDifferentWorkerPoolsDeathTest() {
 294   scoped_ptr<SequenceCheckedObject> sequence_checked_object(
 295       new SequenceCheckedObject);
 296
 297   sequence_checked_object->DetachFromSequence();
 298   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 299   PostDoStuffToWorkerPool(sequence_checked_object.get(), "A");
 300   pool()->FlushForTesting();
 301
 302   SequencedWorkerPoolOwner second_pool_owner(kNumWorkerThreads, "test2");
 303   second_pool_owner.pool()->PostNamedSequencedWorkerTask(
 304       "A",
 305       FROM_HERE,
 306       base::Bind(&SequenceCheckedObject::DoStuff,
 307                  base::Unretained(sequence_checked_object.get())));
 308   second_pool_owner.pool()->FlushForTesting();
 309   second_pool_owner.pool()->Shutdown();
 310 }
 311
 312 #if ENABLE_SEQUENCE_CHECKER
 313 TEST_F(SequenceCheckerTest, TwoDifferentWorkerPoolsDeathTestInDebug) {
 314   // The default style "fast" does not support multi-threaded tests.
 315   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 316   ASSERT_DEATH({
 317     TwoDifferentWorkerPoolsDeathTest();
 318   }, "");
 319 }
 320 #else
 321 TEST_F(SequenceCheckerTest, TwoDifferentWorkerPoolsDeathTestInRelease) {
 322   TwoDifferentWorkerPoolsDeathTest();
 323 }
 324 #endif  // ENABLE_SEQUENCE_CHECKER
 325
 326 #endif  // GTEST_HAS_DEATH_TEST || !ENABLE_SEQUENCE_CHECKER
 327
 328 }  // namespace
 329
 330 }  // namespace base
 331
 332 // Just in case we ever get lumped together with other compilation units.
 333 #undef ENABLE_SEQUENCE_CHECKER