From f1adbeedb4b4a56cfeb3e0789c2bb900762ec977 Mon Sep 17 00:00:00 2001 From: "buildbot@webrtc.org" Date: Wed, 4 Jun 2014 21:57:16 +0000 Subject: [PATCH] (Auto)update libjingle 68562943-> 68571194 git-svn-id: http://webrtc.googlecode.com/svn/trunk@6333 4adac7df-926f-26a2-2b94-8c16560cd09d --- talk/base/genericslot.h | 258 ---------------------------- talk/base/genericslot.h.pump | 101 ----------- talk/base/genericslot_unittest.cc | 28 --- talk/base/sigslottester.h | 216 +++++++++++++++++++++++ talk/base/sigslottester.h.pump | 102 +++++++++++ talk/base/sigslottester_unittest.cc | 74 ++++++++ 6 files changed, 392 insertions(+), 387 deletions(-) delete mode 100755 talk/base/genericslot.h delete mode 100755 talk/base/genericslot.h.pump delete mode 100755 talk/base/genericslot_unittest.cc create mode 100755 talk/base/sigslottester.h create mode 100755 talk/base/sigslottester.h.pump create mode 100755 talk/base/sigslottester_unittest.cc diff --git a/talk/base/genericslot.h b/talk/base/genericslot.h deleted file mode 100755 index 112bb88ac..000000000 --- a/talk/base/genericslot.h +++ /dev/null @@ -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 foo; -// -// /* We want to monitor foo in some test */ -// talk_base::GenericSlot1 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 GenericSlot1 : public sigslot::has_slots<> { - public: - GenericSlot1(sigslot::signal1* 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 GenericSlot2 : public sigslot::has_slots<> { - public: - GenericSlot2(sigslot::signal2* 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 GenericSlot3 : public sigslot::has_slots<> { - public: - GenericSlot3(sigslot::signal3* 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 GenericSlot4 : public sigslot::has_slots<> { - public: - GenericSlot4(sigslot::signal4* 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 GenericSlot5 : public sigslot::has_slots<> { - public: - GenericSlot5(sigslot::signal5* 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_ diff --git a/talk/base/genericslot.h.pump b/talk/base/genericslot.h.pump deleted file mode 100755 index 9f3f181a3..000000000 --- a/talk/base/genericslot.h.pump +++ /dev/null @@ -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 foo; -// -// /* We want to monitor foo in some test */ -// talk_base::GenericSlot1 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_ diff --git a/talk/base/genericslot_unittest.cc b/talk/base/genericslot_unittest.cc deleted file mode 100755 index ea3025fa5..000000000 --- a/talk/base/genericslot_unittest.cc +++ /dev/null @@ -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 source1; - GenericSlot1 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 source2; - GenericSlot2 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 diff --git a/talk/base/sigslottester.h b/talk/base/sigslottester.h new file mode 100755 index 000000000..9422318e2 --- /dev/null +++ b/talk/base/sigslottester.h @@ -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 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 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 SigslotTester1 : public sigslot::has_slots<> { + public: + SigslotTester1(sigslot::signal1* 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 SigslotTester2 : public sigslot::has_slots<> { + public: + SigslotTester2(sigslot::signal2* 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 SigslotTester3 : public sigslot::has_slots<> { + public: + SigslotTester3(sigslot::signal3* 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 SigslotTester4 : public sigslot::has_slots<> { + public: + SigslotTester4(sigslot::signal4* 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 SigslotTester5 : public sigslot::has_slots<> { + public: + SigslotTester5(sigslot::signal5* 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_ diff --git a/talk/base/sigslottester.h.pump b/talk/base/sigslottester.h.pump new file mode 100755 index 000000000..dce1c7b26 --- /dev/null +++ b/talk/base/sigslottester.h.pump @@ -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 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 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_ diff --git a/talk/base/sigslottester_unittest.cc b/talk/base/sigslottester_unittest.cc new file mode 100755 index 000000000..b427ef67c --- /dev/null +++ b/talk/base/sigslottester_unittest.cc @@ -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 source1; + int capture1; + SigslotTester1 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 source2; + int capture1; + char capture2; + SigslotTester2 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 source1; + std::string capture1; + SigslotTester1 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 source1; + const std::string* capture1; + SigslotTester1 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 source1; + std::string* capture1; + SigslotTester1 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