base/task_runner_unittest.cc

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