diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /third_party/libwebrtc/pc/proxy_unittest.cc | |
parent | Initial commit. (diff) | |
download | thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/pc/proxy_unittest.cc')
-rw-r--r-- | third_party/libwebrtc/pc/proxy_unittest.cc | 260 |
1 files changed, 260 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/proxy_unittest.cc b/third_party/libwebrtc/pc/proxy_unittest.cc new file mode 100644 index 0000000000..ebfde9fecf --- /dev/null +++ b/third_party/libwebrtc/pc/proxy_unittest.cc @@ -0,0 +1,260 @@ +/* + * Copyright 2013 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. + */ + +#include "pc/proxy.h" + +#include <memory> +#include <string> + +#include "api/make_ref_counted.h" +#include "rtc_base/gunit.h" +#include "rtc_base/ref_count.h" +#include "test/gmock.h" + +using ::testing::_; +using ::testing::DoAll; +using ::testing::Exactly; +using ::testing::InvokeWithoutArgs; +using ::testing::Return; + +namespace webrtc { + +// Interface used for testing here. +class FakeInterface : public rtc::RefCountInterface { + public: + virtual void VoidMethod0() = 0; + virtual std::string Method0() = 0; + virtual std::string ConstMethod0() const = 0; + virtual std::string Method1(std::string s) = 0; + virtual std::string ConstMethod1(std::string s) const = 0; + virtual std::string Method2(std::string s1, std::string s2) = 0; + + protected: + virtual ~FakeInterface() {} +}; + +// Implementation of the test interface. +class Fake : public FakeInterface { + public: + static rtc::scoped_refptr<Fake> Create() { + return rtc::make_ref_counted<Fake>(); + } + // Used to verify destructor is called on the correct thread. + MOCK_METHOD(void, Destroy, ()); + + MOCK_METHOD(void, VoidMethod0, (), (override)); + MOCK_METHOD(std::string, Method0, (), (override)); + MOCK_METHOD(std::string, ConstMethod0, (), (const, override)); + + MOCK_METHOD(std::string, Method1, (std::string), (override)); + MOCK_METHOD(std::string, ConstMethod1, (std::string), (const, override)); + + MOCK_METHOD(std::string, Method2, (std::string, std::string), (override)); + + protected: + Fake() {} + ~Fake() { Destroy(); } +}; + +// Proxies for the test interface. +BEGIN_PROXY_MAP(Fake) +PROXY_SECONDARY_THREAD_DESTRUCTOR() +PROXY_METHOD0(void, VoidMethod0) +PROXY_METHOD0(std::string, Method0) +PROXY_CONSTMETHOD0(std::string, ConstMethod0) +PROXY_SECONDARY_METHOD1(std::string, Method1, std::string) +PROXY_CONSTMETHOD1(std::string, ConstMethod1, std::string) +PROXY_SECONDARY_METHOD2(std::string, Method2, std::string, std::string) +END_PROXY_MAP(Fake) + +// Preprocessor hack to get a proxy class a name different than FakeProxy. +#define FakeProxy FakeSignalingProxy +#define FakeProxyWithInternal FakeSignalingProxyWithInternal +BEGIN_PRIMARY_PROXY_MAP(Fake) +PROXY_PRIMARY_THREAD_DESTRUCTOR() +PROXY_METHOD0(void, VoidMethod0) +PROXY_METHOD0(std::string, Method0) +PROXY_CONSTMETHOD0(std::string, ConstMethod0) +PROXY_METHOD1(std::string, Method1, std::string) +PROXY_CONSTMETHOD1(std::string, ConstMethod1, std::string) +PROXY_METHOD2(std::string, Method2, std::string, std::string) +END_PROXY_MAP(Fake) +#undef FakeProxy + +class SignalingProxyTest : public ::testing::Test { + public: + // Checks that the functions are called on the right thread. + void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); } + + protected: + void SetUp() override { + signaling_thread_ = rtc::Thread::Create(); + ASSERT_TRUE(signaling_thread_->Start()); + fake_ = Fake::Create(); + fake_signaling_proxy_ = + FakeSignalingProxy::Create(signaling_thread_.get(), fake_); + } + + protected: + std::unique_ptr<rtc::Thread> signaling_thread_; + rtc::scoped_refptr<FakeInterface> fake_signaling_proxy_; + rtc::scoped_refptr<Fake> fake_; +}; + +TEST_F(SignalingProxyTest, SignalingThreadDestructor) { + EXPECT_CALL(*fake_, Destroy()) + .Times(Exactly(1)) + .WillOnce( + InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread)); + fake_ = nullptr; + fake_signaling_proxy_ = nullptr; +} + +TEST_F(SignalingProxyTest, VoidMethod0) { + EXPECT_CALL(*fake_, VoidMethod0()) + .Times(Exactly(1)) + .WillOnce( + InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread)); + fake_signaling_proxy_->VoidMethod0(); +} + +TEST_F(SignalingProxyTest, Method0) { + EXPECT_CALL(*fake_, Method0()) + .Times(Exactly(1)) + .WillOnce(DoAll( + InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread), + Return("Method0"))); + EXPECT_EQ("Method0", fake_signaling_proxy_->Method0()); +} + +TEST_F(SignalingProxyTest, ConstMethod0) { + EXPECT_CALL(*fake_, ConstMethod0()) + .Times(Exactly(1)) + .WillOnce(DoAll( + InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread), + Return("ConstMethod0"))); + EXPECT_EQ("ConstMethod0", fake_signaling_proxy_->ConstMethod0()); +} + +TEST_F(SignalingProxyTest, Method1) { + const std::string arg1 = "arg1"; + EXPECT_CALL(*fake_, Method1(arg1)) + .Times(Exactly(1)) + .WillOnce(DoAll( + InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread), + Return("Method1"))); + EXPECT_EQ("Method1", fake_signaling_proxy_->Method1(arg1)); +} + +TEST_F(SignalingProxyTest, ConstMethod1) { + const std::string arg1 = "arg1"; + EXPECT_CALL(*fake_, ConstMethod1(arg1)) + .Times(Exactly(1)) + .WillOnce(DoAll( + InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread), + Return("ConstMethod1"))); + EXPECT_EQ("ConstMethod1", fake_signaling_proxy_->ConstMethod1(arg1)); +} + +TEST_F(SignalingProxyTest, Method2) { + const std::string arg1 = "arg1"; + const std::string arg2 = "arg2"; + EXPECT_CALL(*fake_, Method2(arg1, arg2)) + .Times(Exactly(1)) + .WillOnce(DoAll( + InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread), + Return("Method2"))); + EXPECT_EQ("Method2", fake_signaling_proxy_->Method2(arg1, arg2)); +} + +class ProxyTest : public ::testing::Test { + public: + // Checks that the functions are called on the right thread. + void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); } + void CheckWorkerThread() { EXPECT_TRUE(worker_thread_->IsCurrent()); } + + protected: + void SetUp() override { + signaling_thread_ = rtc::Thread::Create(); + worker_thread_ = rtc::Thread::Create(); + ASSERT_TRUE(signaling_thread_->Start()); + ASSERT_TRUE(worker_thread_->Start()); + fake_ = Fake::Create(); + fake_proxy_ = + FakeProxy::Create(signaling_thread_.get(), worker_thread_.get(), fake_); + } + + protected: + std::unique_ptr<rtc::Thread> signaling_thread_; + std::unique_ptr<rtc::Thread> worker_thread_; + rtc::scoped_refptr<FakeInterface> fake_proxy_; + rtc::scoped_refptr<Fake> fake_; +}; + +TEST_F(ProxyTest, WorkerThreadDestructor) { + EXPECT_CALL(*fake_, Destroy()) + .Times(Exactly(1)) + .WillOnce(InvokeWithoutArgs(this, &ProxyTest::CheckWorkerThread)); + fake_ = nullptr; + fake_proxy_ = nullptr; +} + +TEST_F(ProxyTest, VoidMethod0) { + EXPECT_CALL(*fake_, VoidMethod0()) + .Times(Exactly(1)) + .WillOnce(InvokeWithoutArgs(this, &ProxyTest::CheckSignalingThread)); + fake_proxy_->VoidMethod0(); +} + +TEST_F(ProxyTest, Method0) { + EXPECT_CALL(*fake_, Method0()) + .Times(Exactly(1)) + .WillOnce(DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckSignalingThread), + Return("Method0"))); + EXPECT_EQ("Method0", fake_proxy_->Method0()); +} + +TEST_F(ProxyTest, ConstMethod0) { + EXPECT_CALL(*fake_, ConstMethod0()) + .Times(Exactly(1)) + .WillOnce(DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckSignalingThread), + Return("ConstMethod0"))); + EXPECT_EQ("ConstMethod0", fake_proxy_->ConstMethod0()); +} + +TEST_F(ProxyTest, WorkerMethod1) { + const std::string arg1 = "arg1"; + EXPECT_CALL(*fake_, Method1(arg1)) + .Times(Exactly(1)) + .WillOnce(DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckWorkerThread), + Return("Method1"))); + EXPECT_EQ("Method1", fake_proxy_->Method1(arg1)); +} + +TEST_F(ProxyTest, ConstMethod1) { + const std::string arg1 = "arg1"; + EXPECT_CALL(*fake_, ConstMethod1(arg1)) + .Times(Exactly(1)) + .WillOnce(DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckSignalingThread), + Return("ConstMethod1"))); + EXPECT_EQ("ConstMethod1", fake_proxy_->ConstMethod1(arg1)); +} + +TEST_F(ProxyTest, WorkerMethod2) { + const std::string arg1 = "arg1"; + const std::string arg2 = "arg2"; + EXPECT_CALL(*fake_, Method2(arg1, arg2)) + .Times(Exactly(1)) + .WillOnce(DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckWorkerThread), + Return("Method2"))); + EXPECT_EQ("Method2", fake_proxy_->Method2(arg1, arg2)); +} + +} // namespace webrtc |