message_loop_proxy_impl_unittest.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d 
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/message_loop/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/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
15namespace base {
16
17class MessageLoopProxyImplTest : public testing::Test {
18 public:
19  void Release() const {
20    AssertOnIOThread();
21    Quit();
22  }
23
24  void Quit() const {
25    loop_.PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
26  }
27
28  void AssertOnIOThread() const {
29    ASSERT_TRUE(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
30    ASSERT_EQ(io_thread_->message_loop_proxy(),
31              MessageLoopProxy::current());
32  }
33
34  void AssertOnFileThread() const {
35    ASSERT_TRUE(file_thread_->message_loop_proxy()->BelongsToCurrentThread());
36    ASSERT_EQ(file_thread_->message_loop_proxy(),
37              MessageLoopProxy::current());
38  }
39
40 protected:
41  virtual void SetUp() OVERRIDE {
42    io_thread_.reset(new Thread("MessageLoopProxyImplTest_IO"));
43    file_thread_.reset(new Thread("MessageLoopProxyImplTest_File"));
44    io_thread_->Start();
45    file_thread_->Start();
46  }
47
48  virtual void TearDown() OVERRIDE {
49    io_thread_->Stop();
50    file_thread_->Stop();
51  }
52
53  static void BasicFunction(MessageLoopProxyImplTest* test) {
54    test->AssertOnFileThread();
55    test->Quit();
56  }
57
58  static void AssertNotRun() {
59    FAIL() << "Callback Should not get executed.";
60  }
61
62  class DeletedOnFile {
63   public:
64    explicit DeletedOnFile(MessageLoopProxyImplTest* test) : test_(test) {}
65
66    ~DeletedOnFile() {
67      test_->AssertOnFileThread();
68      test_->Quit();
69    }
70
71   private:
72    MessageLoopProxyImplTest* test_;
73  };
74
75  scoped_ptr<Thread> io_thread_;
76  scoped_ptr<Thread> file_thread_;
77
78 private:
79  mutable MessageLoop loop_;
80};
81
82TEST_F(MessageLoopProxyImplTest, Release) {
83  EXPECT_TRUE(io_thread_->message_loop_proxy()->ReleaseSoon(FROM_HERE, this));
84  MessageLoop::current()->Run();
85}
86
87TEST_F(MessageLoopProxyImplTest, Delete) {
88  DeletedOnFile* deleted_on_file = new DeletedOnFile(this);
89  EXPECT_TRUE(file_thread_->message_loop_proxy()->DeleteSoon(
90      FROM_HERE, deleted_on_file));
91  MessageLoop::current()->Run();
92}
93
94TEST_F(MessageLoopProxyImplTest, PostTask) {
95  EXPECT_TRUE(file_thread_->message_loop_proxy()->PostTask(
96      FROM_HERE, Bind(&MessageLoopProxyImplTest::BasicFunction,
97                            Unretained(this))));
98  MessageLoop::current()->Run();
99}
100
101TEST_F(MessageLoopProxyImplTest, PostTaskAfterThreadExits) {
102  scoped_ptr<Thread> test_thread(
103      new Thread("MessageLoopProxyImplTest_Dummy"));
104  test_thread->Start();
105  scoped_refptr<MessageLoopProxy> message_loop_proxy =
106      test_thread->message_loop_proxy();
107  test_thread->Stop();
108
109  bool ret = message_loop_proxy->PostTask(
110      FROM_HERE,
111      Bind(&MessageLoopProxyImplTest::AssertNotRun));
112  EXPECT_FALSE(ret);
113}
114
115TEST_F(MessageLoopProxyImplTest, PostTaskAfterThreadIsDeleted) {
116  scoped_refptr<MessageLoopProxy> message_loop_proxy;
117  {
118    scoped_ptr<Thread> test_thread(
119        new Thread("MessageLoopProxyImplTest_Dummy"));
120    test_thread->Start();
121    message_loop_proxy = test_thread->message_loop_proxy();
122  }
123  bool ret = message_loop_proxy->PostTask(
124      FROM_HERE,
125      Bind(&MessageLoopProxyImplTest::AssertNotRun));
126  EXPECT_FALSE(ret);
127}
128
129}  // namespace base
130