Fix the turn and udp port type.

webrtc/p2p/base/stunport_unittest.cc

 /*
  *  Copyright 2009 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.
  */
 
@@ skipping 74 matching lines @@
     // choose its lifetime from the network type.
     if (stun_keepalive_lifetime_ >= 0) {
       stun_port_->set_stun_keepalive_lifetime(stun_keepalive_lifetime_);
     }
     stun_port_->SignalPortComplete.connect(this,
         &StunPortTest::OnPortComplete);
     stun_port_->SignalPortError.connect(this,
         &StunPortTest::OnPortError);
   }
 
-  void CreateSharedStunPort(const rtc::SocketAddress& server_addr) {
+  void CreateSharedUdpPort(const rtc::SocketAddress& server_addr) {
     socket_.reset(socket_factory_.CreateUdpSocket(
         rtc::SocketAddress(kLocalAddr.ipaddr(), 0), 0, 0));
     ASSERT_TRUE(socket_ != NULL);
     socket_->SignalReadPacket.connect(this, &StunPortTest::OnReadPacket);
     stun_port_.reset(cricket::UDPPort::Create(
         rtc::Thread::Current(), &socket_factory_,
         &network_, socket_.get(),
         rtc::CreateRandomString(16), rtc::CreateRandomString(22),
         std::string(), false));
     ASSERT_TRUE(stun_port_ != NULL);
@@ skipping 63 matching lines @@
   std::unique_ptr<cricket::UDPPort> stun_port_;
   std::unique_ptr<cricket::TestStunServer> stun_server_1_;
   std::unique_ptr<cricket::TestStunServer> stun_server_2_;
   std::unique_ptr<rtc::AsyncPacketSocket> socket_;
   bool done_;
   bool error_;
   int stun_keepalive_delay_;
   int stun_keepalive_lifetime_;
 };
 
-// Test that we can create a STUN port
-TEST_F(StunPortTest, TestBasic) {
+// Test that we can create a STUN port.
+TEST_F(StunPortTest, TestCreateStunPort) {
   CreateStunPort(kStunAddr1);
   EXPECT_EQ("stun", port()->Type());
   EXPECT_EQ(0U, port()->Candidates().size());
 }
 
+// Test that we can create a UDP port.
+TEST_F(StunPortTest, TestCreateUdpPort) {
+  CreateSharedUdpPort(kStunAddr1);
+  EXPECT_EQ("local", port()->Type());
+  EXPECT_EQ(0U, port()->Candidates().size());
+}
+
 // Test that we can get an address from a STUN server.
 TEST_F(StunPortTest, TestPrepareAddress) {
   CreateStunPort(kStunAddr1);
   PrepareAddress();
   EXPECT_TRUE_WAIT(done(), kTimeoutMs);
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
 
   // TODO: Add IPv6 tests here, once either physicalsocketserver supports
   // IPv6, or this test is changed to use VirtualSocketServer.
@@ skipping 37 matching lines @@
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
   // Waiting for 1 seond, which will allow us to process
   // response for keepalive binding request. 500 ms is the keepalive delay.
   rtc::Thread::Current()->ProcessMessages(1000);
   ASSERT_EQ(1U, port()->Candidates().size());
 }
 
 // Test that a local candidate can be generated using a shared socket.
 TEST_F(StunPortTest, TestSharedSocketPrepareAddress) {
-  CreateSharedStunPort(kStunAddr1);
+  CreateSharedUdpPort(kStunAddr1);
   PrepareAddress();
   EXPECT_TRUE_WAIT(done(), kTimeoutMs);
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
 }
 
 // Test that we still a get a local candidate with invalid stun server hostname.
 // Also verifing that UDPPort can receive packets when stun address can't be
 // resolved.
 TEST_F(StunPortTest, TestSharedSocketPrepareAddressInvalidHostname) {
-  CreateSharedStunPort(kBadHostnameAddr);
+  CreateSharedUdpPort(kBadHostnameAddr);
   PrepareAddress();
   EXPECT_TRUE_WAIT(done(), kTimeoutMs);
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
 
   // Send data to port after it's ready. This is to make sure, UDP port can
   // handle data with unresolved stun server address.
   std::string data = "some random data, sending to cricket::Port.";
   SendData(data.c_str(), data.length());
   // No crash is success.
@@ skipping 61 matching lines @@
   SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
   CreateStunPort(kStunAddr2);
   EXPECT_EQ(kInfiniteLifetime, port()->stun_keepalive_lifetime());
 }
 
 // Test that the stun_keepalive_lifetime is set correctly based on the network
 // type on a shared STUN port (UDPPort). Also test that it will be updated
 // if the network type changes.
 TEST_F(StunPortTest, TestUdpPortGetStunKeepaliveLifetime) {
   // Lifetime for the default (unknown) network type is |kInfiniteLifetime|.
-  CreateSharedStunPort(kStunAddr1);
+  CreateSharedUdpPort(kStunAddr1);
   EXPECT_EQ(kInfiniteLifetime, port()->stun_keepalive_lifetime());
   // Lifetime for the cellular network is |kHighCostPortKeepaliveLifetimeMs|.
   SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   EXPECT_EQ(kHighCostPortKeepaliveLifetimeMs,
             port()->stun_keepalive_lifetime());
 
   // Lifetime for the wifi network type is |kInfiniteLifetime|.
   SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
-  CreateSharedStunPort(kStunAddr2);
+  CreateSharedUdpPort(kStunAddr2);
   EXPECT_EQ(kInfiniteLifetime, port()->stun_keepalive_lifetime());
 }
 
 // Test that STUN binding requests will be stopped shortly if the keep-alive
 // lifetime is short.
 TEST_F(StunPortTest, TestStunBindingRequestShortLifetime) {
   SetKeepaliveDelay(101);
   SetKeepaliveLifetime(100);
   CreateStunPort(kStunAddr1);
   PrepareAddress();
   EXPECT_TRUE_WAIT(done(), kTimeoutMs);
   EXPECT_TRUE_WAIT(!port()->HasPendingRequest(cricket::STUN_BINDING_REQUEST),
                    2000);
 }
 
 // Test that by default, the STUN binding requests will last for a long time.
 TEST_F(StunPortTest, TestStunBindingRequestLongLifetime) {
   SetKeepaliveDelay(101);
   CreateStunPort(kStunAddr1);
   PrepareAddress();
   EXPECT_TRUE_WAIT(done(), kTimeoutMs);
   rtc::Thread::Current()->ProcessMessages(1000);
   EXPECT_TRUE(port()->HasPendingRequest(cricket::STUN_BINDING_REQUEST));
 }