base/message_loop_proxy_impl_unittest.cc

   1 // Copyright (c) 2011 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/message_loop_proxy_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop.h"
  10 #include "base/message_loop_proxy.h"
  11 #include "base/threading/thread.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "testing/platform_test.h"
  14
  15
  16 class MessageLoopProxyImplTest : public testing::Test {
  17  public:
  18   void Release() const {
  19     AssertOnIOThread();
  20     Quit();
  21   }
  22
  23   void Quit() const {
  24     loop_.PostTask(FROM_HERE, new MessageLoop::QuitTask);
  25   }
  26
  27   void AssertOnIOThread() const {
  28     ASSERT_TRUE(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
  29     ASSERT_EQ(io_thread_->message_loop_proxy(),
  30               base::MessageLoopProxy::current());
  31   }
  32
  33   void AssertOnFileThread() const {
  34     ASSERT_TRUE(file_thread_->message_loop_proxy()->BelongsToCurrentThread());
  35     ASSERT_EQ(file_thread_->message_loop_proxy(),
  36               base::MessageLoopProxy::current());
  37   }
  38
  39  protected:
  40   virtual void SetUp() {
  41     io_thread_.reset(new base::Thread("MessageLoopProxyImplTest_IO"));
  42     file_thread_.reset(new base::Thread("MessageLoopProxyImplTest_File"));
  43     io_thread_->Start();
  44     file_thread_->Start();
  45   }
  46
  47   virtual void TearDown() {
  48     io_thread_->Stop();
  49     file_thread_->Stop();
  50   }
  51
  52   static void BasicFunction(MessageLoopProxyImplTest* test) {
  53     test->AssertOnFileThread();
  54     test->Quit();
  55   }
  56
  57   static void AssertNotRun() {
  58     FAIL() << "Callback Should not get executed.";
  59   }
  60
  61   class DummyTask : public Task {
  62    public:
  63     explicit DummyTask(bool* deleted) : deleted_(deleted) { }
  64     ~DummyTask() {
  65       *deleted_ = true;
  66     }
  67
  68     void Run() {
  69       FAIL();
  70     }
  71
  72    private:
  73     bool* deleted_;
  74   };
  75
  76   class DeletedOnFile {
  77    public:
  78     explicit DeletedOnFile(MessageLoopProxyImplTest* test) : test_(test) {}
  79
  80     ~DeletedOnFile() {
  81       test_->AssertOnFileThread();
  82       test_->Quit();
  83     }
  84
  85    private:
  86     MessageLoopProxyImplTest* test_;
  87   };
  88
  89   scoped_ptr<base::Thread> io_thread_;
  90   scoped_ptr<base::Thread> file_thread_;
  91
  92  private:
  93   mutable MessageLoop loop_;
  94 };
  95
  96
  97 TEST_F(MessageLoopProxyImplTest, LegacyPostTask) {
  98   EXPECT_TRUE(file_thread_->message_loop_proxy()->PostTask(
  99       FROM_HERE, NewRunnableFunction(&BasicFunction, this)));
 100   MessageLoop::current()->Run();
 101 }
 102
 103 TEST_F(MessageLoopProxyImplTest, Release) {
 104   EXPECT_TRUE(io_thread_->message_loop_proxy()->ReleaseSoon(FROM_HERE, this));
 105   MessageLoop::current()->Run();
 106 }
 107
 108 TEST_F(MessageLoopProxyImplTest, Delete) {
 109   DeletedOnFile* deleted_on_file = new DeletedOnFile(this);
 110   EXPECT_TRUE(file_thread_->message_loop_proxy()->DeleteSoon(
 111       FROM_HERE, deleted_on_file));
 112   MessageLoop::current()->Run();
 113 }
 114
 115 TEST_F(MessageLoopProxyImplTest, LegacyPostTaskAfterThreadExits) {
 116   scoped_ptr<base::Thread> test_thread(
 117       new base::Thread("MessageLoopProxyImplTest_Dummy"));
 118   test_thread->Start();
 119   scoped_refptr<base::MessageLoopProxy> message_loop_proxy =
 120       test_thread->message_loop_proxy();
 121   test_thread->Stop();
 122
 123   bool deleted = false;
 124   bool ret = message_loop_proxy->PostTask(
 125       FROM_HERE, new DummyTask(&deleted));
 126   EXPECT_FALSE(ret);
 127   EXPECT_TRUE(deleted);
 128 }
 129
 130 TEST_F(MessageLoopProxyImplTest, LegacyPostTaskAfterThreadIsDeleted) {
 131   scoped_refptr<base::MessageLoopProxy> message_loop_proxy;
 132   {
 133     scoped_ptr<base::Thread> test_thread(
 134         new base::Thread("MessageLoopProxyImplTest_Dummy"));
 135     test_thread->Start();
 136     message_loop_proxy = test_thread->message_loop_proxy();
 137   }
 138   bool deleted = false;
 139   bool ret = message_loop_proxy->PostTask(FROM_HERE, new DummyTask(&deleted));
 140   EXPECT_FALSE(ret);
 141   EXPECT_TRUE(deleted);
 142 }
 143
 144 TEST_F(MessageLoopProxyImplTest, PostTask) {
 145   EXPECT_TRUE(file_thread_->message_loop_proxy()->PostTask(
 146       FROM_HERE, base::Bind(&MessageLoopProxyImplTest::BasicFunction,
 147                             base::Unretained(this))));
 148   MessageLoop::current()->Run();
 149 }
 150
 151 TEST_F(MessageLoopProxyImplTest, PostTaskAfterThreadExits) {
 152   scoped_ptr<base::Thread> test_thread(
 153       new base::Thread("MessageLoopProxyImplTest_Dummy"));
 154   test_thread->Start();
 155   scoped_refptr<base::MessageLoopProxy> message_loop_proxy =
 156       test_thread->message_loop_proxy();
 157   test_thread->Stop();
 158
 159   bool ret = message_loop_proxy->PostTask(
 160       FROM_HERE,
 161       base::Bind(&MessageLoopProxyImplTest::AssertNotRun));
 162   EXPECT_FALSE(ret);
 163 }
 164
 165 TEST_F(MessageLoopProxyImplTest, PostTaskAfterThreadIsDeleted) {
 166   scoped_refptr<base::MessageLoopProxy> message_loop_proxy;
 167   {
 168     scoped_ptr<base::Thread> test_thread(
 169         new base::Thread("MessageLoopProxyImplTest_Dummy"));
 170     test_thread->Start();
 171     message_loop_proxy = test_thread->message_loop_proxy();
 172   }
 173   bool ret = message_loop_proxy->PostTask(
 174       FROM_HERE,
 175       base::Bind(&MessageLoopProxyImplTest::AssertNotRun));
 176   EXPECT_FALSE(ret);
 177 }