task_runner_util_unittest.cc 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158
  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() {
  28. ++g_foo_destruct_count;
  29. }
  30. };
  31. std::unique_ptr<Foo> CreateFoo() {
  32. return std::make_unique<Foo>();
  33. }
  34. void ExpectFoo(std::unique_ptr<Foo> foo) {
  35. EXPECT_TRUE(foo.get());
  36. std::unique_ptr<Foo> local_foo(std::move(foo));
  37. EXPECT_TRUE(local_foo.get());
  38. EXPECT_FALSE(foo.get());
  39. }
  40. struct FooDeleter {
  41. void operator()(Foo* foo) const {
  42. ++g_foo_free_count;
  43. delete foo;
  44. }
  45. };
  46. std::unique_ptr<Foo, FooDeleter> CreateScopedFoo() {
  47. return std::unique_ptr<Foo, FooDeleter>(new Foo);
  48. }
  49. void ExpectScopedFoo(std::unique_ptr<Foo, FooDeleter> foo) {
  50. EXPECT_TRUE(foo.get());
  51. std::unique_ptr<Foo, FooDeleter> local_foo(std::move(foo));
  52. EXPECT_TRUE(local_foo.get());
  53. EXPECT_FALSE(foo.get());
  54. }
  55. struct FooWithoutDefaultConstructor {
  56. explicit FooWithoutDefaultConstructor(int value) : value(value) {}
  57. int value;
  58. };
  59. FooWithoutDefaultConstructor CreateFooWithoutDefaultConstructor(int value) {
  60. return FooWithoutDefaultConstructor(value);
  61. }
  62. void SaveFooWithoutDefaultConstructor(int* output_value,
  63. FooWithoutDefaultConstructor input) {
  64. *output_value = input.value;
  65. }
  66. } // namespace
  67. TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResult) {
  68. int result = 0;
  69. test::TaskEnvironment task_environment;
  70. PostTaskAndReplyWithResult(ThreadTaskRunnerHandle::Get().get(), FROM_HERE,
  71. BindOnce(&ReturnFourtyTwo),
  72. BindOnce(&StoreValue, &result));
  73. RunLoop().RunUntilIdle();
  74. EXPECT_EQ(42, result);
  75. }
  76. TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultImplicitConvert) {
  77. double result = 0;
  78. test::TaskEnvironment task_environment;
  79. PostTaskAndReplyWithResult(ThreadTaskRunnerHandle::Get().get(), FROM_HERE,
  80. BindOnce(&ReturnFourtyTwo),
  81. BindOnce(&StoreDoubleValue, &result));
  82. RunLoop().RunUntilIdle();
  83. EXPECT_DOUBLE_EQ(42.0, result);
  84. }
  85. TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassed) {
  86. g_foo_destruct_count = 0;
  87. g_foo_free_count = 0;
  88. test::TaskEnvironment task_environment;
  89. PostTaskAndReplyWithResult(ThreadTaskRunnerHandle::Get().get(), FROM_HERE,
  90. BindOnce(&CreateFoo), BindOnce(&ExpectFoo));
  91. RunLoop().RunUntilIdle();
  92. EXPECT_EQ(1, g_foo_destruct_count);
  93. EXPECT_EQ(0, g_foo_free_count);
  94. }
  95. TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassedFreeProc) {
  96. g_foo_destruct_count = 0;
  97. g_foo_free_count = 0;
  98. test::TaskEnvironment task_environment;
  99. PostTaskAndReplyWithResult(ThreadTaskRunnerHandle::Get().get(), FROM_HERE,
  100. BindOnce(&CreateScopedFoo),
  101. BindOnce(&ExpectScopedFoo));
  102. RunLoop().RunUntilIdle();
  103. EXPECT_EQ(1, g_foo_destruct_count);
  104. EXPECT_EQ(1, g_foo_free_count);
  105. }
  106. TEST(TaskRunnerHelpersTest,
  107. PostTaskAndReplyWithResultWithoutDefaultConstructor) {
  108. const int kSomeVal = 17;
  109. test::TaskEnvironment task_environment;
  110. int actual = 0;
  111. PostTaskAndReplyWithResult(
  112. ThreadTaskRunnerHandle::Get().get(), FROM_HERE,
  113. BindOnce(&CreateFooWithoutDefaultConstructor, kSomeVal),
  114. BindOnce(&SaveFooWithoutDefaultConstructor, &actual));
  115. RunLoop().RunUntilIdle();
  116. EXPECT_EQ(kSomeVal, actual);
  117. }
  118. } // namespace base