base/task_runner_util_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 "base/bind.h"
   8 #include "base/message_loop.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace base {
  12
  13 namespace {
  14
  15 int ReturnFourtyTwo() {
  16   return 42;
  17 }
  18
  19 void StoreValue(int* destination, int value) {
  20   *destination = value;
  21 }
  22
  23 void StoreDoubleValue(double* destination, double value) {
  24   *destination = value;
  25 }
  26
  27 int g_foo_destruct_count = 0;
  28 int g_foo_free_count = 0;
  29
  30 struct Foo {
  31   ~Foo() {
  32     ++g_foo_destruct_count;
  33   }
  34 };
  35
  36 scoped_ptr<Foo> CreateFoo() {
  37   return scoped_ptr<Foo>(new Foo);
  38 }
  39
  40 void ExpectFoo(scoped_ptr<Foo> foo) {
  41   EXPECT_TRUE(foo.get());
  42   scoped_ptr<Foo> local_foo(foo.Pass());
  43   EXPECT_TRUE(local_foo.get());
  44   EXPECT_FALSE(foo.get());
  45 }
  46
  47 struct FreeFooFunctor {
  48   void operator()(Foo* foo) const {
  49     ++g_foo_free_count;
  50     delete foo;
  51   };
  52 };
  53
  54 scoped_ptr_malloc<Foo, FreeFooFunctor> CreateScopedFoo() {
  55   return scoped_ptr_malloc<Foo, FreeFooFunctor>(new Foo);
  56 }
  57
  58 void ExpectScopedFoo(scoped_ptr_malloc<Foo, FreeFooFunctor> foo) {
  59   EXPECT_TRUE(foo.get());
  60   scoped_ptr_malloc<Foo, FreeFooFunctor> local_foo(foo.Pass());
  61   EXPECT_TRUE(local_foo.get());
  62   EXPECT_FALSE(foo.get());
  63 }
  64
  65 }  // namespace
  66
  67 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResult) {
  68   MessageLoop message_loop;
  69   int result = 0;
  70
  71   PostTaskAndReplyWithResult(
  72       message_loop.message_loop_proxy(),
  73       FROM_HERE,
  74       Bind(&ReturnFourtyTwo),
  75       Bind(&StoreValue, &result));
  76
  77   message_loop.RunUntilIdle();
  78
  79   EXPECT_EQ(42, result);
  80 }
  81
  82 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultImplicitConvert) {
  83   MessageLoop message_loop;
  84   double result = 0;
  85
  86   PostTaskAndReplyWithResult(
  87       message_loop.message_loop_proxy(),
  88       FROM_HERE,
  89       Bind(&ReturnFourtyTwo),
  90       Bind(&StoreDoubleValue, &result));
  91
  92   message_loop.RunUntilIdle();
  93
  94   EXPECT_DOUBLE_EQ(42.0, result);
  95 }
  96
  97 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassed) {
  98   g_foo_destruct_count = 0;
  99   g_foo_free_count = 0;
 100
 101   MessageLoop message_loop;
 102
 103   PostTaskAndReplyWithResult(
 104       message_loop.message_loop_proxy(),
 105       FROM_HERE,
 106       Bind(&CreateFoo),
 107       Bind(&ExpectFoo));
 108
 109   message_loop.RunUntilIdle();
 110
 111   EXPECT_EQ(1, g_foo_destruct_count);
 112   EXPECT_EQ(0, g_foo_free_count);
 113 }
 114
 115 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassedFreeProc) {
 116   g_foo_destruct_count = 0;
 117   g_foo_free_count = 0;
 118
 119   MessageLoop message_loop;
 120
 121   PostTaskAndReplyWithResult(
 122       message_loop.message_loop_proxy(),
 123       FROM_HERE,
 124       Bind(&CreateScopedFoo),
 125       Bind(&ExpectScopedFoo));
 126
 127   message_loop.RunUntilIdle();
 128
 129   EXPECT_EQ(1, g_foo_destruct_count);
 130   EXPECT_EQ(1, g_foo_free_count);
 131 }
 132
 133 }  // namespace base