1/*
2 * libjingle
3 * Copyright 2013, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include "talk/app/webrtc/proxy.h"
29
30#include <string>
31
32#include "testing/base/public/gmock.h"
33#include "webrtc/base/gunit.h"
34#include "webrtc/base/refcount.h"
35#include "webrtc/base/scoped_ptr.h"
36#include "webrtc/base/thread.h"
37
38using ::testing::_;
39using ::testing::DoAll;
40using ::testing::Exactly;
41using ::testing::InvokeWithoutArgs;
42using ::testing::Return;
43
44namespace webrtc {
45
46// Interface used for testing here.
47class FakeInterface : public rtc::RefCountInterface {
48 public:
49  virtual void VoidMethod0() = 0;
50  virtual std::string Method0() = 0;
51  virtual std::string ConstMethod0() const = 0;
52  virtual std::string Method1(std::string s) = 0;
53  virtual std::string ConstMethod1(std::string s) const = 0;
54  virtual std::string Method2(std::string s1, std::string s2) = 0;
55
56 protected:
57  ~FakeInterface() {}
58};
59
60// Proxy for the test interface.
61BEGIN_PROXY_MAP(Fake)
62  PROXY_METHOD0(void, VoidMethod0)
63  PROXY_METHOD0(std::string, Method0)
64  PROXY_CONSTMETHOD0(std::string, ConstMethod0)
65  PROXY_METHOD1(std::string, Method1, std::string)
66  PROXY_CONSTMETHOD1(std::string, ConstMethod1, std::string)
67  PROXY_METHOD2(std::string, Method2, std::string, std::string)
68END_PROXY()
69
70// Implementation of the test interface.
71class Fake : public FakeInterface {
72 public:
73  static rtc::scoped_refptr<Fake> Create() {
74    return new rtc::RefCountedObject<Fake>();
75  }
76
77  MOCK_METHOD0(VoidMethod0, void());
78  MOCK_METHOD0(Method0, std::string());
79  MOCK_CONST_METHOD0(ConstMethod0, std::string());
80
81  MOCK_METHOD1(Method1, std::string(std::string));
82  MOCK_CONST_METHOD1(ConstMethod1, std::string(std::string));
83
84  MOCK_METHOD2(Method2, std::string(std::string, std::string));
85
86 protected:
87  Fake() {}
88  ~Fake() {}
89};
90
91class ProxyTest: public testing::Test {
92 public:
93  // Checks that the functions is called on the |signaling_thread_|.
94  void CheckThread() {
95    EXPECT_EQ(rtc::Thread::Current(), signaling_thread_.get());
96  }
97
98 protected:
99  virtual void SetUp() {
100    signaling_thread_.reset(new rtc::Thread());
101    ASSERT_TRUE(signaling_thread_->Start());
102    fake_ = Fake::Create();
103    fake_proxy_ = FakeProxy::Create(signaling_thread_.get(), fake_.get());
104  }
105
106 protected:
107  rtc::scoped_ptr<rtc::Thread> signaling_thread_;
108  rtc::scoped_refptr<FakeInterface> fake_proxy_;
109  rtc::scoped_refptr<Fake> fake_;
110};
111
112TEST_F(ProxyTest, VoidMethod0) {
113  EXPECT_CALL(*fake_, VoidMethod0())
114            .Times(Exactly(1))
115            .WillOnce(InvokeWithoutArgs(this, &ProxyTest::CheckThread));
116  fake_proxy_->VoidMethod0();
117}
118
119TEST_F(ProxyTest, Method0) {
120  EXPECT_CALL(*fake_, Method0())
121            .Times(Exactly(1))
122            .WillOnce(
123                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
124                      Return("Method0")));
125  EXPECT_EQ("Method0",
126            fake_proxy_->Method0());
127}
128
129TEST_F(ProxyTest, ConstMethod0) {
130  EXPECT_CALL(*fake_, ConstMethod0())
131            .Times(Exactly(1))
132            .WillOnce(
133                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
134                      Return("ConstMethod0")));
135  EXPECT_EQ("ConstMethod0",
136            fake_proxy_->ConstMethod0());
137}
138
139TEST_F(ProxyTest, Method1) {
140  const std::string arg1 = "arg1";
141  EXPECT_CALL(*fake_, Method1(arg1))
142            .Times(Exactly(1))
143            .WillOnce(
144                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
145                      Return("Method1")));
146  EXPECT_EQ("Method1", fake_proxy_->Method1(arg1));
147}
148
149TEST_F(ProxyTest, ConstMethod1) {
150  const std::string arg1 = "arg1";
151  EXPECT_CALL(*fake_, ConstMethod1(arg1))
152            .Times(Exactly(1))
153            .WillOnce(
154                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
155                      Return("ConstMethod1")));
156  EXPECT_EQ("ConstMethod1", fake_proxy_->ConstMethod1(arg1));
157}
158
159TEST_F(ProxyTest, Method2) {
160  const std::string arg1 = "arg1";
161  const std::string arg2 = "arg2";
162  EXPECT_CALL(*fake_, Method2(arg1, arg2))
163            .Times(Exactly(1))
164            .WillOnce(
165                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
166                      Return("Method2")));
167  EXPECT_EQ("Method2", fake_proxy_->Method2(arg1, arg2));
168}
169
170}  // namespace webrtc
171