Add an explicit way of forcing the MDnsClient to listen on the network

net/dns/mdns_client_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <queue>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "net/base/rand_callback.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 283 matching lines @@
   bool set_;
   std::string name_;
   std::string ptrdomain_;
   int ttl_;
 };
 
 class MDnsTest : public ::testing::Test {
  public:
   MDnsTest();
   virtual ~MDnsTest();
+  virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
   void DeleteTransaction();
   void DeleteBothListeners();
   void RunFor(base::TimeDelta time_period);
   void Stop();
 
   MOCK_METHOD2(MockableRecordCallback, void(MDnsTransaction::Result result,
                                             const RecordParsed* record));
 
   MOCK_METHOD2(MockableRecordCallback2, void(MDnsTransaction::Result result,
@@ skipping 26 matching lines @@
 
 MDnsTest::MDnsTest() {
   socket_factory_ = new StrictMock<MockMDnsSocketFactory>();
   test_client_.reset(new MDnsClientImpl(
       scoped_ptr<MDnsConnection::SocketFactory>(socket_factory_)));
 }
 
 MDnsTest::~MDnsTest() {
 }
 
+void MDnsTest::SetUp() {
+  test_client_->StartListening();
+}
+
 void MDnsTest::TearDown() {
-  base::MessageLoop::current()->RunUntilIdle();
-
-  ASSERT_FALSE(test_client_->IsListeningForTests());
-
-  base::MessageLoop::current()->AssertIdle();
 }
 
 void MDnsTest::SimulatePacketReceive(const char* packet, unsigned size) {
   socket_factory_->SimulateReceive(packet, size);
 }
 
 void MDnsTest::ExpectPacket(
     const char* packet,
     unsigned size) {
   EXPECT_CALL(*socket_factory_, OnSendTo(std::string(packet, size)))
@@ skipping 35 matching lines @@
       dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet);
   scoped_ptr<MDnsListener> listener_printer = test_client_->CreateListener(
       dns_protocol::kTypePTR, "_printer._tcp.local", &delegate_printer);
   scoped_ptr<MDnsListener> listener_ptr = test_client_->CreateListener(
       dns_protocol::kTypePTR, "", &delegate_ptr);
 
   ASSERT_TRUE(listener_privet->Start());
   ASSERT_TRUE(listener_printer->Start());
   ASSERT_TRUE(listener_ptr->Start());
 
-  ASSERT_TRUE(test_client_->IsListeningForTests());
-
   // Send the same packet twice to ensure no records are double-counted.
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_privet,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   EXPECT_CALL(delegate_printer, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_printer,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   EXPECT_CALL(delegate_ptr, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(2));
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
                                          "hello._privet._tcp.local"));
 
   EXPECT_TRUE(record_printer.IsRecordWith("_printer._tcp.local",
                                           "hello._printer._tcp.local"));
 
   listener_privet.reset();
   listener_printer.reset();
 
-  ASSERT_TRUE(test_client_->IsListeningForTests());
-
   EXPECT_CALL(delegate_ptr, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(2));
 
   SimulatePacketReceive(kSamplePacket2, sizeof(kSamplePacket2));
 }
 
 TEST_F(MDnsTest, PassiveListenersCacheCleanup) {
   StrictMock<MockListenerDelegate> delegate_privet;
 
   PtrRecordCopyContainer record_privet;
   PtrRecordCopyContainer record_privet2;
 
   scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
       dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet);
 
   ASSERT_TRUE(listener_privet->Start());
 
-  ASSERT_TRUE(test_client_->IsListeningForTests());
-
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_privet,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
                                          "hello._privet._tcp.local"));
@@ skipping 14 matching lines @@
 TEST_F(MDnsTest, MalformedPacket) {
   StrictMock<MockListenerDelegate> delegate_printer;
 
   PtrRecordCopyContainer record_printer;
 
   scoped_ptr<MDnsListener> listener_printer = test_client_->CreateListener(
       dns_protocol::kTypePTR, "_printer._tcp.local", &delegate_printer);
 
   ASSERT_TRUE(listener_printer->Start());
 
-  ASSERT_TRUE(test_client_->IsListeningForTests());
-
   EXPECT_CALL(delegate_printer, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_printer,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   // First, send unsalvagable packet to ensure we can deal with it.
   SimulatePacketReceive(kCorruptedPacketUnsalvagable,
                         sizeof(kCorruptedPacketUnsalvagable));
 
@@ skipping 16 matching lines @@
       test_client_->CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet->Start());
 
-  EXPECT_TRUE(test_client_->IsListeningForTests());
-
   PtrRecordCopyContainer record_privet;
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(&record_privet,
                        &PtrRecordCopyContainer::SaveWithDummyArg));
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
                                          "hello._privet._tcp.local"));
 }
 
 TEST_F(MDnsTest, TransactionCacheOnlyNoResult) {
   scoped_ptr<MDnsTransaction> transaction_privet =
       test_client_->CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   EXPECT_CALL(*this,
               MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS, _))
       .Times(Exactly(1));
 
   ASSERT_TRUE(transaction_privet->Start());
-
-  EXPECT_FALSE(test_client_->IsListeningForTests());
 }
 
 TEST_F(MDnsTest, TransactionWithCache) {
   // Listener to force the client to listen
   StrictMock<MockListenerDelegate> delegate_irrelevant;
   scoped_ptr<MDnsListener> listener_irrelevant = test_client_->CreateListener(
       dns_protocol::kTypeA, "codereview.chromium.local",
       &delegate_irrelevant);
 
   ASSERT_TRUE(listener_irrelevant->Start());
 
-  EXPECT_TRUE(test_client_->IsListeningForTests());
-
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
 
   PtrRecordCopyContainer record_privet;
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
       .WillOnce(Invoke(&record_privet,
                        &PtrRecordCopyContainer::SaveWithDummyArg));
 
   scoped_ptr<MDnsTransaction> transaction_privet =
@@ skipping 15 matching lines @@
   StrictMock<MockListenerDelegate> delegate_privet;
 
   PtrRecordCopyContainer record_privet;
 
   scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
       dns_protocol::kTypePTR, "_privet._tcp.local",
       &delegate_privet);
 
   ASSERT_TRUE(listener_privet->Start());
 
-  ASSERT_TRUE(test_client_->IsListeningForTests());
-
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_privet,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   SimulatePacketReceive(kSamplePacketAdditionalOnly, sizeof(kSamplePacket1));
 
   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
                                          "hello._privet._tcp.local"));
 }
 
 TEST_F(MDnsTest, TransactionTimeout) {
   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 
   scoped_ptr<MDnsTransaction> transaction_privet =
       test_client_->CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet->Start());
 
-  EXPECT_TRUE(test_client_->IsListeningForTests());
-
   EXPECT_CALL(*this,
               MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS, NULL))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::Stop));
 
   RunFor(base::TimeDelta::FromSeconds(4));
 }
 
 TEST_F(MDnsTest, TransactionMultipleRecords) {
   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 
   scoped_ptr<MDnsTransaction> transaction_privet =
       test_client_->CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE ,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet->Start());
 
-  EXPECT_TRUE(test_client_->IsListeningForTests());
-
   PtrRecordCopyContainer record_privet;
   PtrRecordCopyContainer record_privet2;
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
       .Times(Exactly(2))
       .WillOnce(Invoke(&record_privet,
                        &PtrRecordCopyContainer::SaveWithDummyArg))
       .WillOnce(Invoke(&record_privet2,
                        &PtrRecordCopyContainer::SaveWithDummyArg));
 
@@ skipping 18 matching lines @@
   transaction_ = test_client_->CreateTransaction(
       dns_protocol::kTypePTR, "_privet._tcp.local",
       MDnsTransaction::QUERY_NETWORK |
       MDnsTransaction::QUERY_CACHE |
       MDnsTransaction::SINGLE_RESULT,
       base::Bind(&MDnsTest::MockableRecordCallback,
                  base::Unretained(this)));
 
   ASSERT_TRUE(transaction_->Start());
 
-  EXPECT_TRUE(test_client_->IsListeningForTests());
-
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS,
                                             NULL))
       .Times(Exactly(1))
       .WillOnce(DoAll(InvokeWithoutArgs(this, &MDnsTest::DeleteTransaction),
                       InvokeWithoutArgs(this, &MDnsTest::Stop)));
 
   RunFor(base::TimeDelta::FromSeconds(4));
 
   EXPECT_EQ(NULL, transaction_.get());
 }
 
 TEST_F(MDnsTest, TransactionReentrantDeleteFromCache) {
   StrictMock<MockListenerDelegate> delegate_irrelevant;
   scoped_ptr<MDnsListener> listener_irrelevant = test_client_->CreateListener(
       dns_protocol::kTypeA, "codereview.chromium.local",
       &delegate_irrelevant);
   ASSERT_TRUE(listener_irrelevant->Start());
 
-  ASSERT_TRUE(test_client_->IsListeningForTests());
-
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
   transaction_ = test_client_->CreateTransaction(
       dns_protocol::kTypePTR, "_privet._tcp.local",
       MDnsTransaction::QUERY_NETWORK |
       MDnsTransaction::QUERY_CACHE,
       base::Bind(&MDnsTest::MockableRecordCallback,
                  base::Unretained(this)));
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
@@ skipping 28 matching lines @@
       .Times(Exactly(1));
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD,
                                             _))
       .Times(Exactly(1))
       .WillOnce(IgnoreResult(InvokeWithoutArgs(transaction2.get(),
                                                &MDnsTransaction::Start)));
 
   ASSERT_TRUE(transaction1->Start());
 
-  EXPECT_TRUE(test_client_->IsListeningForTests());
-
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 }
 
 // In order to reliably test reentrant listener deletes, we create two listeners
 // and have each of them delete both, so we're guaranteed to try and deliver a
 // callback to at least one deleted listener.
 
 TEST_F(MDnsTest, ListenerReentrantDelete) {
   StrictMock<MockListenerDelegate> delegate_privet;
 
   listener1_ = test_client_->CreateListener(
       dns_protocol::kTypePTR, "_privet._tcp.local",
       &delegate_privet);
 
   listener2_ = test_client_->CreateListener(
       dns_protocol::kTypePTR, "_privet._tcp.local",
       &delegate_privet);
 
   ASSERT_TRUE(listener1_->Start());
 
   ASSERT_TRUE(listener2_->Start());
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::DeleteBothListeners));
 
-  EXPECT_TRUE(test_client_->IsListeningForTests());
-
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_EQ(NULL, listener1_.get());
   EXPECT_EQ(NULL, listener2_.get());
 }
 
 ACTION_P(SaveIPAddress, ip_container) {
   ::testing::StaticAssertTypeEq<const RecordParsed*, arg1_type>();
   ::testing::StaticAssertTypeEq<IPAddressNumber*, ip_container_type>();
 
@@ skipping 174 matching lines @@
 
   ASSERT_TRUE(InitConnection());
 
   EXPECT_CALL(delegate_, OnConnectionError(ERR_SOCKET_NOT_CONNECTED));
   callback.Run(ERR_SOCKET_NOT_CONNECTED);
 }
 
 }  // namespace
 
 }  // namespace net