1 /*
2 * Copyright 2018 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "p2p/base/basic_async_resolver_factory.h"
12
13 #include "api/test/mock_async_dns_resolver.h"
14 #include "p2p/base/mock_async_resolver.h"
15 #include "rtc_base/async_resolver.h"
16 #include "rtc_base/gunit.h"
17 #include "rtc_base/socket_address.h"
18 #include "rtc_base/third_party/sigslot/sigslot.h"
19 #include "test/gmock.h"
20 #include "test/gtest.h"
21 #include "test/testsupport/rtc_expect_death.h"
22
23 namespace webrtc {
24
25 class BasicAsyncResolverFactoryTest : public ::testing::Test,
26 public sigslot::has_slots<> {
27 public:
TestCreate()28 void TestCreate() {
29 BasicAsyncResolverFactory factory;
30 rtc::AsyncResolverInterface* resolver = factory.Create();
31 ASSERT_TRUE(resolver);
32 resolver->SignalDone.connect(
33 this, &BasicAsyncResolverFactoryTest::SetAddressResolved);
34
35 rtc::SocketAddress address("", 0);
36 resolver->Start(address);
37 ASSERT_TRUE_WAIT(address_resolved_, 10000 /*ms*/);
38 resolver->Destroy(false);
39 }
40
SetAddressResolved(rtc::AsyncResolverInterface * resolver)41 void SetAddressResolved(rtc::AsyncResolverInterface* resolver) {
42 address_resolved_ = true;
43 }
44
45 private:
46 bool address_resolved_ = false;
47 };
48
49 // This test is primarily intended to let tools check that the created resolver
50 // doesn't leak.
TEST_F(BasicAsyncResolverFactoryTest,TestCreate)51 TEST_F(BasicAsyncResolverFactoryTest, TestCreate) {
52 rtc::AutoThread main_thread;
53 TestCreate();
54 }
55
TEST(WrappingAsyncDnsResolverFactoryTest,TestCreateAndResolve)56 TEST(WrappingAsyncDnsResolverFactoryTest, TestCreateAndResolve) {
57 rtc::AutoThread main_thread;
58 WrappingAsyncDnsResolverFactory factory(
59 std::make_unique<BasicAsyncResolverFactory>());
60
61 std::unique_ptr<AsyncDnsResolverInterface> resolver(factory.Create());
62 ASSERT_TRUE(resolver);
63
64 bool address_resolved = false;
65 rtc::SocketAddress address("", 0);
66 resolver->Start(address, [&address_resolved]() { address_resolved = true; });
67 ASSERT_TRUE_WAIT(address_resolved, 10000 /*ms*/);
68 resolver.reset();
69 }
70
TEST(WrappingAsyncDnsResolverFactoryTest,WrapOtherResolver)71 TEST(WrappingAsyncDnsResolverFactoryTest, WrapOtherResolver) {
72 rtc::AutoThread main_thread;
73 BasicAsyncResolverFactory non_owned_factory;
74 WrappingAsyncDnsResolverFactory factory(&non_owned_factory);
75 std::unique_ptr<AsyncDnsResolverInterface> resolver(factory.Create());
76 ASSERT_TRUE(resolver);
77
78 bool address_resolved = false;
79 rtc::SocketAddress address("", 0);
80 resolver->Start(address, [&address_resolved]() { address_resolved = true; });
81 ASSERT_TRUE_WAIT(address_resolved, 10000 /*ms*/);
82 resolver.reset();
83 }
84
85 #if GTEST_HAS_DEATH_TEST && defined(WEBRTC_LINUX)
86 // Tests that the prohibition against deleting the resolver from the callback
87 // is enforced. This is required by the use of sigslot in the wrapped resolver.
88 // Checking the error message fails on a number of platforms, so run this
89 // test only on the platforms where it works.
CallResolver(WrappingAsyncDnsResolverFactory & factory)90 void CallResolver(WrappingAsyncDnsResolverFactory& factory) {
91 rtc::SocketAddress address("", 0);
92 std::unique_ptr<AsyncDnsResolverInterface> resolver(factory.Create());
93 resolver->Start(address, [&resolver]() { resolver.reset(); });
94 WAIT(!resolver.get(), 10000 /*ms*/);
95 }
96
TEST(WrappingAsyncDnsResolverFactoryDeathTest,DestroyResolverInCallback)97 TEST(WrappingAsyncDnsResolverFactoryDeathTest, DestroyResolverInCallback) {
98 rtc::AutoThread main_thread;
99 // TODO(bugs.webrtc.org/12652): Rewrite as death test in loop style when it
100 // works.
101 WrappingAsyncDnsResolverFactory factory(
102 std::make_unique<BasicAsyncResolverFactory>());
103
104 // Since EXPECT_DEATH is thread sensitive, and the resolver creates a thread,
105 // we wrap the whole creation section in EXPECT_DEATH.
106 RTC_EXPECT_DEATH(CallResolver(factory),
107 "Check failed: !within_resolve_result_");
108 }
109 #endif
110
111 } // namespace webrtc
112