diff options
Diffstat (limited to 'chromium/base/task/post_task_unittest.cc')
-rw-r--r-- | chromium/base/task/post_task_unittest.cc | 157 |
1 files changed, 157 insertions, 0 deletions
diff --git a/chromium/base/task/post_task_unittest.cc b/chromium/base/task/post_task_unittest.cc index ed7fb3db3bb..798eba8e580 100644 --- a/chromium/base/task/post_task_unittest.cc +++ b/chromium/base/task/post_task_unittest.cc @@ -5,9 +5,11 @@ #include "base/task/post_task.h" #include "base/bind_helpers.h" +#include "base/run_loop.h" #include "base/task/scoped_set_task_priority_for_current_thread.h" #include "base/task/task_executor.h" #include "base/task/test_task_traits_extension.h" +#include "base/test/bind_test_util.h" #include "base/test/gtest_util.h" #include "base/test/task_environment.h" #include "base/test/test_simple_task_runner.h" @@ -17,6 +19,8 @@ using ::testing::_; using ::testing::Invoke; +using ::testing::IsNull; +using ::testing::NotNull; using ::testing::Return; namespace base { @@ -177,6 +181,159 @@ TEST_F(PostTaskTestWithExecutor, PostTaskToTaskExecutor) { } } +TEST_F(PostTaskTestWithExecutor, + ThreadPoolTaskRunnerGetTaskExecutorForCurrentThread) { + auto task_runner = CreateTaskRunner({ThreadPool()}); + RunLoop run_loop; + + EXPECT_TRUE(task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + // We don't have an executor for a ThreadPool task runner becuse they + // are for one shot tasks. + EXPECT_THAT(GetTaskExecutorForCurrentThread(), IsNull()); + run_loop.Quit(); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, + ThreadPoolSequencedTaskRunnerGetTaskExecutorForCurrentThread) { + auto sequenced_task_runner = CreateSequencedTaskRunner({ThreadPool()}); + RunLoop run_loop; + + EXPECT_TRUE(sequenced_task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + EXPECT_THAT(GetTaskExecutorForCurrentThread(), NotNull()); + run_loop.Quit(); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, + ThreadPoolSingleThreadTaskRunnerGetTaskExecutorForCurrentThread) { + auto single_thread_task_runner = CreateSingleThreadTaskRunner({ThreadPool()}); + RunLoop run_loop; + + EXPECT_TRUE(single_thread_task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + EXPECT_THAT(GetTaskExecutorForCurrentThread(), NotNull()); + run_loop.Quit(); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, ThreadPoolTaskRunnerCurrentThreadTrait) { + auto task_runner = CreateTaskRunner({ThreadPool()}); + RunLoop run_loop; + + EXPECT_TRUE(task_runner->PostTask(FROM_HERE, BindLambdaForTesting([&]() { + // CurrentThread is meaningless in this + // context. + EXPECT_DCHECK_DEATH( + PostTask(FROM_HERE, {CurrentThread()}, + DoNothing())); + run_loop.Quit(); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, + ThreadPoolSequencedTaskRunnerCurrentThreadTrait) { + auto sequenced_task_runner = CreateSequencedTaskRunner({ThreadPool()}); + RunLoop run_loop; + + auto current_thread_task = BindLambdaForTesting([&]() { + EXPECT_TRUE(sequenced_task_runner->RunsTasksInCurrentSequence()); + run_loop.Quit(); + }); + + EXPECT_TRUE(sequenced_task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + EXPECT_TRUE( + PostTask(FROM_HERE, {CurrentThread()}, current_thread_task)); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, + ThreadPoolSingleThreadTaskRunnerCurrentThreadTrait) { + auto single_thread_task_runner = CreateSingleThreadTaskRunner({ThreadPool()}); + RunLoop run_loop; + + auto current_thread_task = BindLambdaForTesting([&]() { + EXPECT_TRUE(single_thread_task_runner->RunsTasksInCurrentSequence()); + run_loop.Quit(); + }); + + EXPECT_TRUE(single_thread_task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + EXPECT_TRUE( + PostTask(FROM_HERE, {CurrentThread()}, current_thread_task)); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, ThreadPoolCurrentThreadChangePriority) { + auto single_thread_task_runner = + CreateSingleThreadTaskRunner({ThreadPool(), TaskPriority::USER_BLOCKING}); + RunLoop run_loop; + + auto current_thread_task = BindLambdaForTesting([&]() { + EXPECT_TRUE(single_thread_task_runner->RunsTasksInCurrentSequence()); + run_loop.Quit(); + }); + + EXPECT_TRUE(single_thread_task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + // We should be able to request a priority change, although it may be + // ignored. + EXPECT_TRUE(PostTask(FROM_HERE, + {CurrentThread(), TaskPriority::USER_VISIBLE}, + current_thread_task)); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, + ThreadPoolCurrentThreadCantChangeShutdownBehavior) { + auto single_thread_task_runner = CreateSingleThreadTaskRunner( + {ThreadPool(), TaskShutdownBehavior::SKIP_ON_SHUTDOWN}); + RunLoop run_loop; + + EXPECT_TRUE(single_thread_task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + EXPECT_DCHECK_DEATH(PostTask( + FROM_HERE, {CurrentThread(), TaskShutdownBehavior::BLOCK_SHUTDOWN}, + DoNothing())); + run_loop.Quit(); + }))); + + run_loop.Run(); +} + +TEST_F(PostTaskTestWithExecutor, + ThreadPoolCurrentThreadCantSetSyncPrimitivesInNonSyncTaskRunner) { + auto single_thread_task_runner = CreateSingleThreadTaskRunner({ThreadPool()}); + RunLoop run_loop; + + EXPECT_TRUE(single_thread_task_runner->PostTask( + FROM_HERE, BindLambdaForTesting([&]() { + EXPECT_DCHECK_DEATH( + PostTask(FROM_HERE, {CurrentThread(), WithBaseSyncPrimitives()}, + DoNothing())); + run_loop.Quit(); + }))); + + run_loop.Run(); +} + TEST_F(PostTaskTestWithExecutor, RegisterExecutorTwice) { testing::FLAGS_gtest_death_test_style = "threadsafe"; EXPECT_DCHECK_DEATH( |