| // Copyright (c) 2011 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/synchronization/atomic_flag.h" |
| |
| #include "base/bind.h" |
| #include "base/logging.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/test/gtest_util.h" |
| #include "base/threading/platform_thread.h" |
| #include "base/threading/thread.h" |
| #include "build/build_config.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace base { |
| |
| namespace { |
| |
| void ExpectSetFlagDeath(AtomicFlag* flag) { |
| ASSERT_TRUE(flag); |
| EXPECT_DCHECK_DEATH(flag->Set()); |
| } |
| |
| // Busy waits (to explicitly avoid using synchronization constructs that would |
| // defeat the purpose of testing atomics) until |tested_flag| is set and then |
| // verifies that non-atomic |*expected_after_flag| is true and sets |*done_flag| |
| // before returning if it's non-null. |
| void BusyWaitUntilFlagIsSet(AtomicFlag* tested_flag, bool* expected_after_flag, |
| AtomicFlag* done_flag) { |
| while (!tested_flag->IsSet()) |
| PlatformThread::YieldCurrentThread(); |
| |
| EXPECT_TRUE(*expected_after_flag); |
| if (done_flag) |
| done_flag->Set(); |
| } |
| |
| } // namespace |
| |
| TEST(AtomicFlagTest, SimpleSingleThreadedTest) { |
| AtomicFlag flag; |
| ASSERT_FALSE(flag.IsSet()); |
| flag.Set(); |
| ASSERT_TRUE(flag.IsSet()); |
| } |
| |
| TEST(AtomicFlagTest, DoubleSetTest) { |
| AtomicFlag flag; |
| ASSERT_FALSE(flag.IsSet()); |
| flag.Set(); |
| ASSERT_TRUE(flag.IsSet()); |
| flag.Set(); |
| ASSERT_TRUE(flag.IsSet()); |
| } |
| |
| TEST(AtomicFlagTest, ReadFromDifferentThread) { |
| // |tested_flag| is the one being tested below. |
| AtomicFlag tested_flag; |
| // |expected_after_flag| is used to confirm that sequential consistency is |
| // obtained around |tested_flag|. |
| bool expected_after_flag = false; |
| // |reset_flag| is used to confirm the test flows as intended without using |
| // synchronization constructs which would defeat the purpose of exercising |
| // atomics. |
| AtomicFlag reset_flag; |
| |
| Thread thread("AtomicFlagTest.ReadFromDifferentThread"); |
| ASSERT_TRUE(thread.Start()); |
| thread.task_runner()->PostTask(FROM_HERE, |
| BindOnce(&BusyWaitUntilFlagIsSet, &tested_flag, |
| &expected_after_flag, &reset_flag)); |
| |
| // To verify that IsSet() fetches the flag's value from memory every time it |
| // is called (not just the first time that it is called on a thread), sleep |
| // before setting the flag. |
| PlatformThread::Sleep(TimeDelta::FromMilliseconds(20)); |
| |
| // |expected_after_flag| is used to verify that all memory operations |
| // performed before |tested_flag| is Set() are visible to threads that can see |
| // IsSet(). |
| expected_after_flag = true; |
| tested_flag.Set(); |
| |
| // Sleep again to give the busy loop time to observe the flag and verify |
| // expectations. |
| PlatformThread::Sleep(TimeDelta::FromMilliseconds(20)); |
| |
| // Use |reset_flag| to confirm that the above completed (which the rest of |
| // this test assumes). |
| while (!reset_flag.IsSet()) |
| PlatformThread::YieldCurrentThread(); |
| |
| tested_flag.UnsafeResetForTesting(); |
| EXPECT_FALSE(tested_flag.IsSet()); |
| expected_after_flag = false; |
| |
| // Perform the same test again after the controlled UnsafeResetForTesting(), |
| // |thread| is guaranteed to be synchronized past the |
| // |UnsafeResetForTesting()| call when the task runs per the implicit |
| // synchronization in the post task mechanism. |
| thread.task_runner()->PostTask(FROM_HERE, |
| BindOnce(&BusyWaitUntilFlagIsSet, &tested_flag, |
| &expected_after_flag, nullptr)); |
| |
| PlatformThread::Sleep(TimeDelta::FromMilliseconds(20)); |
| |
| expected_after_flag = true; |
| tested_flag.Set(); |
| |
| // The |thread|'s destructor will block until the posted task completes, so |
| // the test will time out if it fails to see the flag be set. |
| } |
| |
| TEST(AtomicFlagTest, SetOnDifferentSequenceDeathTest) { |
| // Checks that Set() can't be called from another sequence after being called |
| // on this one. AtomicFlag should die on a DCHECK if Set() is called again |
| // from another sequence. |
| |
| // Note: flag must be declared before the Thread so that its destructor runs |
| // later. Otherwise there's a race between destructing flag and running |
| // ExpectSetFlagDeath. |
| AtomicFlag flag; |
| |
| ::testing::FLAGS_gtest_death_test_style = "threadsafe"; |
| Thread t("AtomicFlagTest.SetOnDifferentThreadDeathTest"); |
| ASSERT_TRUE(t.Start()); |
| EXPECT_TRUE(t.WaitUntilThreadStarted()); |
| |
| flag.Set(); |
| t.task_runner()->PostTask(FROM_HERE, BindOnce(&ExpectSetFlagDeath, &flag)); |
| } |
| |
| } // namespace base |