generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

(Auto)update libjingle 68562943-> 68571194

Browse Source 
git-svn-id: http://webrtc.googlecode.com/svn/trunk@6333 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
buildbot@webrtc.org 2014-06-04 21:57:16 +00:00
parent e6e139159f
commit f1adbeedb4
6 changed files with 392 additions and 387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
talk/base/genericslot.h
View File

@ -1,258 +0,0 @@
// This file was GENERATED by command:
// pump.py genericslot.h.pump
// DO NOT EDIT BY HAND!!!
/*
* libjingle
* Copyright 2014 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TALK_BASE_GENERICSLOT_H_
#define TALK_BASE_GENERICSLOT_H_
// To generate genericslot.h from genericslot.h.pump, execute:
// /home/build/google3/third_party/gtest/scripts/pump.py genericslot.h.pump
// Generic-slots are pure slots that can be hooked up to signals. They're
// mainly intended to be used in tests where we want to check if a signal
// was invoked and what arguments were passed. NOTE: They do not do any
// lifetime management of the arguments received via callbacks.
//
// Example:
// /* Some signal */
// sigslot::signal1<int> foo;
//
// /* We want to monitor foo in some test */
// talk_base::GenericSlot1<int> slot(&foo, 0);
// foo.emit(5);
// EXPECT_TRUE(slot.callback_received());
// EXPECT_EQ(5, *(slot.arg1()));
//
#include "talk/base/constructormagic.h"
#include "talk/base/sigslot.h"
namespace talk_base {
template <class A1>
class GenericSlot1 : public sigslot::has_slots<> {
public:
GenericSlot1(sigslot::signal1<A1>* signal,
const A1& arg1_initial)
: arg1_initial_(arg1_initial) {
Reset();
signal->connect(this, &GenericSlot1::OnSignalCallback);
}
void Reset() {
callback_received_ = false;
arg1_ = arg1_initial_;
}
bool callback_received() const { return callback_received_; }
const A1& arg1() const { return arg1_; }
private:
void OnSignalCallback(A1 arg1) {
callback_received_ = true;
arg1_ = arg1;
}
bool callback_received_;
A1 arg1_initial_, arg1_;
DISALLOW_COPY_AND_ASSIGN(GenericSlot1);
};
template <class A1, class A2>
class GenericSlot2 : public sigslot::has_slots<> {
public:
GenericSlot2(sigslot::signal2<A1, A2>* signal,
const A1& arg1_initial, const A2& arg2_initial)
: arg1_initial_(arg1_initial), arg2_initial_(arg2_initial) {
Reset();
signal->connect(this, &GenericSlot2::OnSignalCallback);
}
void Reset() {
callback_received_ = false;
arg1_ = arg1_initial_;
arg2_ = arg2_initial_;
}
bool callback_received() const { return callback_received_; }
const A1& arg1() const { return arg1_; }
const A2& arg2() const { return arg2_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2) {
callback_received_ = true;
arg1_ = arg1;
arg2_ = arg2;
}
bool callback_received_;
A1 arg1_initial_, arg1_;
A2 arg2_initial_, arg2_;
DISALLOW_COPY_AND_ASSIGN(GenericSlot2);
};
template <class A1, class A2, class A3>
class GenericSlot3 : public sigslot::has_slots<> {
public:
GenericSlot3(sigslot::signal3<A1, A2, A3>* signal,
const A1& arg1_initial, const A2& arg2_initial,
const A3& arg3_initial)
: arg1_initial_(arg1_initial), arg2_initial_(arg2_initial),
arg3_initial_(arg3_initial) {
Reset();
signal->connect(this, &GenericSlot3::OnSignalCallback);
}
void Reset() {
callback_received_ = false;
arg1_ = arg1_initial_;
arg2_ = arg2_initial_;
arg3_ = arg3_initial_;
}
bool callback_received() const { return callback_received_; }
const A1& arg1() const { return arg1_; }
const A2& arg2() const { return arg2_; }
const A3& arg3() const { return arg3_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3) {
callback_received_ = true;
arg1_ = arg1;
arg2_ = arg2;
arg3_ = arg3;
}
bool callback_received_;
A1 arg1_initial_, arg1_;
A2 arg2_initial_, arg2_;
A3 arg3_initial_, arg3_;
DISALLOW_COPY_AND_ASSIGN(GenericSlot3);
};
template <class A1, class A2, class A3, class A4>
class GenericSlot4 : public sigslot::has_slots<> {
public:
GenericSlot4(sigslot::signal4<A1, A2, A3, A4>* signal,
const A1& arg1_initial, const A2& arg2_initial,
const A3& arg3_initial, const A4& arg4_initial)
: arg1_initial_(arg1_initial), arg2_initial_(arg2_initial),
arg3_initial_(arg3_initial), arg4_initial_(arg4_initial) {
Reset();
signal->connect(this, &GenericSlot4::OnSignalCallback);
}
void Reset() {
callback_received_ = false;
arg1_ = arg1_initial_;
arg2_ = arg2_initial_;
arg3_ = arg3_initial_;
arg4_ = arg4_initial_;
}
bool callback_received() const { return callback_received_; }
const A1& arg1() const { return arg1_; }
const A2& arg2() const { return arg2_; }
const A3& arg3() const { return arg3_; }
const A4& arg4() const { return arg4_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3, A4 arg4) {
callback_received_ = true;
arg1_ = arg1;
arg2_ = arg2;
arg3_ = arg3;
arg4_ = arg4;
}
bool callback_received_;
A1 arg1_initial_, arg1_;
A2 arg2_initial_, arg2_;
A3 arg3_initial_, arg3_;
A4 arg4_initial_, arg4_;
DISALLOW_COPY_AND_ASSIGN(GenericSlot4);
};
template <class A1, class A2, class A3, class A4, class A5>
class GenericSlot5 : public sigslot::has_slots<> {
public:
GenericSlot5(sigslot::signal5<A1, A2, A3, A4, A5>* signal,
const A1& arg1_initial, const A2& arg2_initial,
const A3& arg3_initial, const A4& arg4_initial,
const A5& arg5_initial)
: arg1_initial_(arg1_initial), arg2_initial_(arg2_initial),
arg3_initial_(arg3_initial), arg4_initial_(arg4_initial),
arg5_initial_(arg5_initial) {
Reset();
signal->connect(this, &GenericSlot5::OnSignalCallback);
}
void Reset() {
callback_received_ = false;
arg1_ = arg1_initial_;
arg2_ = arg2_initial_;
arg3_ = arg3_initial_;
arg4_ = arg4_initial_;
arg5_ = arg5_initial_;
}
bool callback_received() const { return callback_received_; }
const A1& arg1() const { return arg1_; }
const A2& arg2() const { return arg2_; }
const A3& arg3() const { return arg3_; }
const A4& arg4() const { return arg4_; }
const A5& arg5() const { return arg5_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5) {
callback_received_ = true;
arg1_ = arg1;
arg2_ = arg2;
arg3_ = arg3;
arg4_ = arg4;
arg5_ = arg5;
}
bool callback_received_;
A1 arg1_initial_, arg1_;
A2 arg2_initial_, arg2_;
A3 arg3_initial_, arg3_;
A4 arg4_initial_, arg4_;
A5 arg5_initial_, arg5_;
DISALLOW_COPY_AND_ASSIGN(GenericSlot5);
};
} // namespace talk_base
#endif // TALK_BASE_GENERICSLOT_H_

101
talk/base/genericslot.h.pump
View File

@ -1,101 +0,0 @@
/*
* libjingle
* Copyright 2014 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TALK_BASE_GENERICSLOT_H_
#define TALK_BASE_GENERICSLOT_H_
// To generate genericslot.h from genericslot.h.pump, execute:
// /home/build/google3/third_party/gtest/scripts/pump.py genericslot.h.pump
// Generic-slots are pure slots that can be hooked up to signals. They're
// mainly intended to be used in tests where we want to check if a signal
// was invoked and what arguments were passed. NOTE: They do not do any
// lifetime management of the arguments received via callbacks.
//
// Example:
// /* Some signal */
// sigslot::signal1<int> foo;
//
// /* We want to monitor foo in some test */
// talk_base::GenericSlot1<int> slot(&foo, 0);
// foo.emit(5);
// EXPECT_TRUE(slot.callback_received());
// EXPECT_EQ(5, *(slot.arg1()));
//
#include "talk/base/constructormagic.h"
#include "talk/base/sigslot.h"
namespace talk_base {
$var n = 5
$range i 1..n
$for i [[
$range j 1..i
template <$for j , [[class A$j]]>
class GenericSlot$i : public sigslot::has_slots<> {
public:
GenericSlot$i(sigslot::signal$i<$for j , [[A$j]]>* signal,
$for j , [[const A$j& arg$j[[]]_initial]])
: $for j , [[arg$j[[]]_initial_(arg$j[[]]_initial)]] {
Reset();
signal->connect(this, &GenericSlot$i::OnSignalCallback);
}
void Reset() {
callback_received_ = false;$for j [[
arg$j[[]]_ = arg$j[[]]_initial_; ]]
}
bool callback_received() const { return callback_received_; }$for j [[
const A$j& arg$j() const { return arg$j[[]]_; }]]
private:
void OnSignalCallback($for j , [[A$j arg$j]]) {
callback_received_ = true;$for j [[
arg$j[[]]_ = arg$j;]]
}
bool callback_received_;$for j [[
A$j arg$j[[]]_initial_, arg$j[[]]_;]]
DISALLOW_COPY_AND_ASSIGN(GenericSlot$i);
};
]]
} // namespace talk_base
#endif // TALK_BASE_GENERICSLOT_H_

28
talk/base/genericslot_unittest.cc
View File

@ -1,28 +0,0 @@
#include "talk/base/genericslot.h"
#include "talk/base/gunit.h"
#include "talk/base/sigslot.h"
namespace talk_base {
TEST(GenericSlotTest, TestSlot1) {
sigslot::signal1<int> source1;
GenericSlot1<int> slot1(&source1, 1);
EXPECT_FALSE(slot1.callback_received());
source1.emit(10);
EXPECT_TRUE(slot1.callback_received());
EXPECT_EQ(10, slot1.arg1());
}
TEST(GenericSlotTest, TestSlot2) {
sigslot::signal2<int, char> source2;
GenericSlot2<int, char> slot2(&source2, 1, '0');
EXPECT_FALSE(slot2.callback_received());
source2.emit(10, 'x');
EXPECT_TRUE(slot2.callback_received());
EXPECT_EQ(10, slot2.arg1());
EXPECT_EQ('x', slot2.arg2());
}
// By induction we assume the rest work too...
} // namespace talk_base

216
talk/base/sigslottester.h Executable file
View File

@ -0,0 +1,216 @@
// This file was GENERATED by command:
// pump.py sigslottester.h.pump
// DO NOT EDIT BY HAND!!!
/*
* libjingle
* Copyright 2014 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TALK_BASE_SIGSLOTTESTER_H_
#define TALK_BASE_SIGSLOTTESTER_H_
// To generate sigslottester.h from sigslottester.h.pump, execute:
// /home/build/google3/third_party/gtest/scripts/pump.py sigslottester.h.pump
// SigslotTester(s) are utility classes to check if signals owned by an
// object are being invoked at the right time and with the right arguments.
// They are meant to be used in tests. Tests must provide "capture" pointers
// (i.e. address of variables) where the arguments from the signal callback
// can be stored.
//
// Example:
// /* Some signal */
// sigslot::signal1<const std::string&> foo;
//
// /* We want to monitor foo in some test. Note how signal argument is
// const std::string&, but capture-type is std::string. Capture type
// must be type that can be assigned to. */
// std::string capture;
// SigslotTester1<const std::string&, std::string> slot(&foo, &capture);
// foo.emit("hello");
// EXPECT_EQ(1, slot.callback_count());
// EXPECT_EQ("hello", capture);
// /* See unit-tests for more examples */
#include "talk/base/constructormagic.h"
#include "talk/base/sigslot.h"
namespace talk_base {
// For all the templates below:
// - A1-A5 is the type of the argument i in the callback. Signals may and often
// do use const-references here for efficiency.
// - C1-C5 is the type of the variable to capture argument i. These should be
// non-const value types suitable for use as lvalues.
template <class A1, class C1>
class SigslotTester1 : public sigslot::has_slots<> {
public:
SigslotTester1(sigslot::signal1<A1>* signal,
C1* capture1)
: callback_count_(0),
capture1_(capture1) {
signal->connect(this, &SigslotTester1::OnSignalCallback);
}
int callback_count() const { return callback_count_; }
private:
void OnSignalCallback(A1 arg1) {
callback_count_++;
*capture1_ = arg1;
}
int callback_count_;
C1* capture1_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester1);
};
template <class A1, class A2, class C1, class C2>
class SigslotTester2 : public sigslot::has_slots<> {
public:
SigslotTester2(sigslot::signal2<A1, A2>* signal,
C1* capture1, C2* capture2)
: callback_count_(0),
capture1_(capture1), capture2_(capture2) {
signal->connect(this, &SigslotTester2::OnSignalCallback);
}
int callback_count() const { return callback_count_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2) {
callback_count_++;
*capture1_ = arg1;
*capture2_ = arg2;
}
int callback_count_;
C1* capture1_;
C2* capture2_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester2);
};
template <class A1, class A2, class A3, class C1, class C2, class C3>
class SigslotTester3 : public sigslot::has_slots<> {
public:
SigslotTester3(sigslot::signal3<A1, A2, A3>* signal,
C1* capture1, C2* capture2, C3* capture3)
: callback_count_(0),
capture1_(capture1), capture2_(capture2), capture3_(capture3) {
signal->connect(this, &SigslotTester3::OnSignalCallback);
}
int callback_count() const { return callback_count_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3) {
callback_count_++;
*capture1_ = arg1;
*capture2_ = arg2;
*capture3_ = arg3;
}
int callback_count_;
C1* capture1_;
C2* capture2_;
C3* capture3_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester3);
};
template <class A1, class A2, class A3, class A4, class C1, class C2, class C3,
class C4>
class SigslotTester4 : public sigslot::has_slots<> {
public:
SigslotTester4(sigslot::signal4<A1, A2, A3, A4>* signal,
C1* capture1, C2* capture2, C3* capture3, C4* capture4)
: callback_count_(0),
capture1_(capture1), capture2_(capture2), capture3_(capture3),
capture4_(capture4) {
signal->connect(this, &SigslotTester4::OnSignalCallback);
}
int callback_count() const { return callback_count_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3, A4 arg4) {
callback_count_++;
*capture1_ = arg1;
*capture2_ = arg2;
*capture3_ = arg3;
*capture4_ = arg4;
}
int callback_count_;
C1* capture1_;
C2* capture2_;
C3* capture3_;
C4* capture4_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester4);
};
template <class A1, class A2, class A3, class A4, class A5, class C1, class C2,
class C3, class C4, class C5>
class SigslotTester5 : public sigslot::has_slots<> {
public:
SigslotTester5(sigslot::signal5<A1, A2, A3, A4, A5>* signal,
C1* capture1, C2* capture2, C3* capture3, C4* capture4,
C5* capture5)
: callback_count_(0),
capture1_(capture1), capture2_(capture2), capture3_(capture3),
capture4_(capture4), capture5_(capture5) {
signal->connect(this, &SigslotTester5::OnSignalCallback);
}
int callback_count() const { return callback_count_; }
private:
void OnSignalCallback(A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5) {
callback_count_++;
*capture1_ = arg1;
*capture2_ = arg2;
*capture3_ = arg3;
*capture4_ = arg4;
*capture5_ = arg5;
}
int callback_count_;
C1* capture1_;
C2* capture2_;
C3* capture3_;
C4* capture4_;
C5* capture5_;
DISALLOW_COPY_AND_ASSIGN(SigslotTester5);
};
} // namespace talk_base
#endif // TALK_BASE_SIGSLOTTESTER_H_

102
talk/base/sigslottester.h.pump Executable file
View File

@ -0,0 +1,102 @@
/*
* libjingle
* Copyright 2014 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TALK_BASE_SIGSLOTTESTER_H_
#define TALK_BASE_SIGSLOTTESTER_H_
// To generate sigslottester.h from sigslottester.h.pump, execute:
// /home/build/google3/third_party/gtest/scripts/pump.py sigslottester.h.pump
// SigslotTester(s) are utility classes to check if signals owned by an
// object are being invoked at the right time and with the right arguments.
// They are meant to be used in tests. Tests must provide "capture" pointers
// (i.e. address of variables) where the arguments from the signal callback
// can be stored.
//
// Example:
// /* Some signal */
// sigslot::signal1<const std::string&> foo;
//
// /* We want to monitor foo in some test. Note how signal argument is
// const std::string&, but capture-type is std::string. Capture type
// must be type that can be assigned to. */
// std::string capture;
// SigslotTester1<const std::string&, std::string> slot(&foo, &capture);
// foo.emit("hello");
// EXPECT_EQ(1, slot.callback_count());
// EXPECT_EQ("hello", capture);
// /* See unit-tests for more examples */
#include "talk/base/constructormagic.h"
#include "talk/base/sigslot.h"
namespace talk_base {
// For all the templates below:
// - A1-A5 is the type of the argument i in the callback. Signals may and often
// do use const-references here for efficiency.
// - C1-C5 is the type of the variable to capture argument i. These should be
// non-const value types suitable for use as lvalues.
$var n = 5
$range i 1..n
$for i [[
$range j 1..i
template <$for j , [[class A$j]], $for j , [[class C$j]]>
class SigslotTester$i : public sigslot::has_slots<> {
public:
SigslotTester$i(sigslot::signal$i<$for j , [[A$j]]>* signal,
$for j , [[C$j* capture$j]])
: callback_count_(0),
$for j , [[capture$j[[]]_(capture$j)]] {
signal->connect(this, &SigslotTester$i::OnSignalCallback);
}
int callback_count() const { return callback_count_; }
private:
void OnSignalCallback($for j , [[A$j arg$j]]) {
callback_count_++;$for j [[
*capture$j[[]]_ = arg$j;]]
}
int callback_count_;$for j [[
C$j* capture$j[[]]_;]]
DISALLOW_COPY_AND_ASSIGN(SigslotTester$i);
};
]]
} // namespace talk_base
#endif // TALK_BASE_SIGSLOTTESTER_H_

74
talk/base/sigslottester_unittest.cc Executable file
View File

@ -0,0 +1,74 @@
#include "talk/base/sigslottester.h"
#include "talk/base/gunit.h"
#include "talk/base/sigslot.h"
namespace talk_base {
TEST(SigslotTester, TestSignal1Arg) {
sigslot::signal1<int> source1;
int capture1;
SigslotTester1<int, int> slot1(&source1, &capture1);
EXPECT_EQ(0, slot1.callback_count());
source1.emit(10);
EXPECT_EQ(1, slot1.callback_count());
EXPECT_EQ(10, capture1);
source1.emit(20);
EXPECT_EQ(2, slot1.callback_count());
EXPECT_EQ(20, capture1);
}
TEST(SigslotTester, TestSignal2Args) {
sigslot::signal2<int, char> source2;
int capture1;
char capture2;
SigslotTester2<int, char, int, char> slot2(&source2, &capture1, &capture2);
EXPECT_EQ(0, slot2.callback_count());
source2.emit(10, 'x');
EXPECT_EQ(1, slot2.callback_count());
EXPECT_EQ(10, capture1);
EXPECT_EQ('x', capture2);
source2.emit(20, 'y');
EXPECT_EQ(2, slot2.callback_count());
EXPECT_EQ(20, capture1);
EXPECT_EQ('y', capture2);
}
// Since it applies for 1 and 2 args, we assume it will work for up to 5 args.
TEST(SigslotTester, TestSignalWithConstReferenceArgs) {
sigslot::signal1<const std::string&> source1;
std::string capture1;
SigslotTester1<const std::string&, std::string> slot1(&source1, &capture1);
EXPECT_EQ(0, slot1.callback_count());
source1.emit("hello");
EXPECT_EQ(1, slot1.callback_count());
EXPECT_EQ("hello", capture1);
}
TEST(SigslotTester, TestSignalWithPointerToConstArgs) {
sigslot::signal1<const std::string*> source1;
const std::string* capture1;
SigslotTester1<const std::string*, const std::string*> slot1(&source1,
&capture1);
EXPECT_EQ(0, slot1.callback_count());
source1.emit(NULL);
EXPECT_EQ(1, slot1.callback_count());
EXPECT_EQ(NULL, capture1);
}
TEST(SigslotTester, TestSignalWithConstPointerArgs) {
sigslot::signal1<std::string* const> source1;
std::string* capture1;
SigslotTester1<std::string* const, std::string*> slot1(&source1, &capture1);
EXPECT_EQ(0, slot1.callback_count());
source1.emit(NULL);
EXPECT_EQ(1, slot1.callback_count());
EXPECT_EQ(NULL, capture1);
}
} // namespace talk_base