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