From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- third_party/libwebrtc/rtc_base/sigslot_tester.h | 245 ++++++++++++++++++++++++ 1 file changed, 245 insertions(+) create mode 100644 third_party/libwebrtc/rtc_base/sigslot_tester.h (limited to 'third_party/libwebrtc/rtc_base/sigslot_tester.h') diff --git a/third_party/libwebrtc/rtc_base/sigslot_tester.h b/third_party/libwebrtc/rtc_base/sigslot_tester.h new file mode 100644 index 0000000000..92483c0b8d --- /dev/null +++ b/third_party/libwebrtc/rtc_base/sigslot_tester.h @@ -0,0 +1,245 @@ +// This file was GENERATED by command: +// pump.py sigslottester.h.pump +// DO NOT EDIT BY HAND!!! + +/* + * Copyright 2014 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_SIGSLOT_TESTER_H_ +#define RTC_BASE_SIGSLOT_TESTER_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 "rtc_base/third_party/sigslot/sigslot.h" + +namespace rtc { + +// Base version for testing signals that passes no arguments. +class SigslotTester0 : public sigslot::has_slots<> { + public: + explicit SigslotTester0(sigslot::signal0<>* signal) : callback_count_(0) { + signal->connect(this, &SigslotTester0::OnSignalCallback); + } + + SigslotTester0(const SigslotTester0&) = delete; + SigslotTester0& operator=(const SigslotTester0&) = delete; + + int callback_count() const { return callback_count_; } + + private: + void OnSignalCallback() { callback_count_++; } + int callback_count_; +}; + +// Versions below are for testing signals that pass arguments. 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); + } + + SigslotTester1(const SigslotTester1&) = delete; + SigslotTester1& operator=(const SigslotTester1&) = delete; + + int callback_count() const { return callback_count_; } + + private: + void OnSignalCallback(A1 arg1) { + callback_count_++; + *capture1_ = arg1; + } + + int callback_count_; + C1* capture1_; +}; + +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); + } + + SigslotTester2(const SigslotTester2&) = delete; + SigslotTester2& operator=(const SigslotTester2&) = delete; + + 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_; +}; + +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); + } + + SigslotTester3(const SigslotTester3&) = delete; + SigslotTester3& operator=(const SigslotTester3&) = delete; + + 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_; +}; + +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); + } + + SigslotTester4(const SigslotTester4&) = delete; + SigslotTester4& operator=(const SigslotTester4&) = delete; + + 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_; +}; + +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); + } + + SigslotTester5(const SigslotTester5&) = delete; + SigslotTester5& operator=(const SigslotTester5&) = delete; + + 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_; +}; +} // namespace rtc + +#endif // RTC_BASE_SIGSLOT_TESTER_H_ -- cgit v1.2.3