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 int g_foo_destruct_count = 0;
  24 int g_foo_free_count = 0;
  25
  26 struct Foo {
  27   ~Foo() {
  28     ++g_foo_destruct_count;
  29   }
  30 };
  31
  32 scoped_ptr<Foo> CreateFoo() {
  33   return scoped_ptr<Foo>(new Foo);
  34 }
  35
  36 void ExpectFoo(scoped_ptr<Foo> foo) {
  37   EXPECT_TRUE(foo.get());
  38   scoped_ptr<Foo> local_foo(foo.Pass());
  39   EXPECT_TRUE(local_foo.get());
  40   EXPECT_FALSE(foo.get());
  41 }
  42
  43 struct FreeFooFunctor {
  44   void operator()(Foo* foo) const {
  45     ++g_foo_free_count;
  46     delete foo;
  47   };
  48 };
  49
  50 scoped_ptr_malloc<Foo, FreeFooFunctor> CreateScopedFoo() {
  51   return scoped_ptr_malloc<Foo, FreeFooFunctor>(new Foo);
  52 }
  53
  54 void ExpectScopedFoo(scoped_ptr_malloc<Foo, FreeFooFunctor> foo) {
  55   EXPECT_TRUE(foo.get());
  56   scoped_ptr_malloc<Foo, FreeFooFunctor> local_foo(foo.Pass());
  57   EXPECT_TRUE(local_foo.get());
  58   EXPECT_FALSE(foo.get());
  59 }
  60
  61 }  // namespace
  62
  63 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResult) {
  64   MessageLoop message_loop;
  65   int result = 0;
  66
  67   PostTaskAndReplyWithResult(
  68       message_loop.message_loop_proxy(),
  69       FROM_HERE,
  70       Bind(&ReturnFourtyTwo),
  71       Bind(&StoreValue, &result));
  72
  73   message_loop.RunAllPending();
  74
  75   EXPECT_EQ(42, result);
  76 }
  77
  78 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassed) {
  79   g_foo_destruct_count = 0;
  80   g_foo_free_count = 0;
  81
  82   MessageLoop message_loop;
  83
  84   PostTaskAndReplyWithResult(
  85       message_loop.message_loop_proxy(),
  86       FROM_HERE,
  87       Bind(&CreateFoo),
  88       Bind(&ExpectFoo));
  89
  90   message_loop.RunAllPending();
  91
  92   EXPECT_EQ(1, g_foo_destruct_count);
  93   EXPECT_EQ(0, g_foo_free_count);
  94 }
  95
  96 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassedFreeProc) {
  97   g_foo_destruct_count = 0;
  98   g_foo_free_count = 0;
  99
 100   MessageLoop message_loop;
 101
 102   PostTaskAndReplyWithResult(
 103       message_loop.message_loop_proxy(),
 104       FROM_HERE,
 105       Bind(&CreateScopedFoo),
 106       Bind(&ExpectScopedFoo));
 107
 108   message_loop.RunAllPending();
 109
 110   EXPECT_EQ(1, g_foo_destruct_count);
 111   EXPECT_EQ(1, g_foo_free_count);
 112 }
 113
 114 }  // namespace base