| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
