task_runner_unittest.cc 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170
  1. // Copyright (c) 2012 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. #include "base/task/task_runner_util.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/location.h"
  9. #include "base/run_loop.h"
  10. #include "base/test/task_environment.h"
  11. #include "base/threading/thread_task_runner_handle.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace base {
  14. namespace {
  15. int ReturnFourtyTwo() {
  16. return 42;
  17. }
  18. void StoreValue(int* destination, int value) {
  19. *destination = value;
  20. }
  21. void StoreDoubleValue(double* destination, double value) {
  22. *destination = value;
  23. }
  24. int g_foo_destruct_count = 0;
  25. int g_foo_free_count = 0;
  26. struct Foo {
  27. ~Foo() { ++g_foo_destruct_count; }
  28. };
  29. std::unique_ptr<Foo> CreateFoo() {
  30. return std::make_unique<Foo>();
  31. }
  32. void ExpectFoo(std::unique_ptr<Foo> foo) {
  33. EXPECT_TRUE(foo.get());
  34. std::unique_ptr<Foo> local_foo(std::move(foo));
  35. EXPECT_TRUE(local_foo.get());
  36. EXPECT_FALSE(foo.get());
  37. }
  38. struct FooDeleter {
  39. void operator()(Foo* foo) const {
  40. ++g_foo_free_count;
  41. delete foo;
  42. }
  43. };
  44. std::unique_ptr<Foo, FooDeleter> CreateScopedFoo() {
  45. return std::unique_ptr<Foo, FooDeleter>(new Foo);
  46. }
  47. void ExpectScopedFoo(std::unique_ptr<Foo, FooDeleter> foo) {
  48. EXPECT_TRUE(foo.get());
  49. std::unique_ptr<Foo, FooDeleter> local_foo(std::move(foo));
  50. EXPECT_TRUE(local_foo.get());
  51. EXPECT_FALSE(foo.get());
  52. }
  53. struct FooWithoutDefaultConstructor {
  54. explicit FooWithoutDefaultConstructor(int value) : value(value) {}
  55. int value;
  56. };
  57. FooWithoutDefaultConstructor CreateFooWithoutDefaultConstructor(int value) {
  58. return FooWithoutDefaultConstructor(value);
  59. }
  60. void SaveFooWithoutDefaultConstructor(int* output_value,
  61. FooWithoutDefaultConstructor input) {
  62. *output_value = input.value;
  63. }
  64. class TaskRunnerTest : public testing::Test {
  65. public:
  66. TaskRunnerTest() = default;
  67. void SetUp() override {
  68. g_foo_destruct_count = 0;
  69. g_foo_free_count = 0;
  70. }
  71. };
  72. } // namespace
  73. TEST_F(TaskRunnerTest, PostTaskAndReplyWithResult) {
  74. int result = 0;
  75. test::SingleThreadTaskEnvironment task_environment;
  76. ThreadTaskRunnerHandle::Get()->PostTaskAndReplyWithResult(
  77. FROM_HERE, BindOnce(&ReturnFourtyTwo), BindOnce(&StoreValue, &result));
  78. RunLoop().RunUntilIdle();
  79. EXPECT_EQ(42, result);
  80. }
  81. TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultRepeatingCallbacks) {
  82. int result = 0;
  83. test::SingleThreadTaskEnvironment task_environment;
  84. ThreadTaskRunnerHandle::Get()->PostTaskAndReplyWithResult(
  85. FROM_HERE, BindRepeating(&ReturnFourtyTwo),
  86. BindRepeating(&StoreValue, &result));
  87. RunLoop().RunUntilIdle();
  88. EXPECT_EQ(42, result);
  89. }
  90. TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultImplicitConvert) {
  91. double result = 0;
  92. test::SingleThreadTaskEnvironment task_environment;
  93. ThreadTaskRunnerHandle::Get()->PostTaskAndReplyWithResult(
  94. FROM_HERE, BindOnce(&ReturnFourtyTwo),
  95. BindOnce(&StoreDoubleValue, &result));
  96. RunLoop().RunUntilIdle();
  97. EXPECT_DOUBLE_EQ(42.0, result);
  98. }
  99. TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultPassed) {
  100. test::SingleThreadTaskEnvironment task_environment;
  101. ThreadTaskRunnerHandle::Get()->PostTaskAndReplyWithResult(
  102. FROM_HERE, BindOnce(&CreateFoo), BindOnce(&ExpectFoo));
  103. RunLoop().RunUntilIdle();
  104. EXPECT_EQ(1, g_foo_destruct_count);
  105. EXPECT_EQ(0, g_foo_free_count);
  106. }
  107. TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultPassedFreeProc) {
  108. test::SingleThreadTaskEnvironment task_environment;
  109. ThreadTaskRunnerHandle::Get()->PostTaskAndReplyWithResult(
  110. FROM_HERE, BindOnce(&CreateScopedFoo), BindOnce(&ExpectScopedFoo));
  111. RunLoop().RunUntilIdle();
  112. EXPECT_EQ(1, g_foo_destruct_count);
  113. EXPECT_EQ(1, g_foo_free_count);
  114. }
  115. TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultWithoutDefaultConstructor) {
  116. const int kSomeVal = 17;
  117. test::SingleThreadTaskEnvironment task_environment;
  118. int actual = 0;
  119. ThreadTaskRunnerHandle::Get()->PostTaskAndReplyWithResult(
  120. FROM_HERE, BindOnce(&CreateFooWithoutDefaultConstructor, kSomeVal),
  121. BindOnce(&SaveFooWithoutDefaultConstructor, &actual));
  122. RunLoop().RunUntilIdle();
  123. EXPECT_EQ(kSomeVal, actual);
  124. }
  125. } // namespace base