src/third_party/libjingle/source/talk/base/network_unittest.cc

   1 /*
   2  * libjingle
   3  * Copyright 2004 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "talk/base/network.h"
  29
  30 #include <vector>
  31 #if defined(POSIX)
  32 #include <sys/types.h>
  33 #ifndef ANDROID
  34 #include <ifaddrs.h>
  35 #else
  36 #include "talk/base/ifaddrs-android.h"
  37 #endif
  38 #endif
  39 #include "talk/base/gunit.h"
  40 #ifdef WIN32
  41 #include "talk/base/logging.h"  // For LOG_GLE
  42 #endif
  43
  44 namespace talk_base {
  45
  46 class NetworkTest : public testing::Test, public sigslot::has_slots<>  {
  47  public:
  48   NetworkTest() : callback_called_(false) {}
  49
  50   void OnNetworksChanged() {
  51     callback_called_ = true;
  52   }
  53
  54   void MergeNetworkList(BasicNetworkManager& network_manager,
  55                         const NetworkManager::NetworkList& list,
  56                         bool* changed ) {
  57     network_manager.MergeNetworkList(list, changed);
  58   }
  59
  60   bool IsIgnoredNetwork(BasicNetworkManager& network_manager,
  61                         const Network& network) {
  62     return network_manager.IsIgnoredNetwork(network);
  63   }
  64
  65   NetworkManager::NetworkList GetNetworks(
  66       const BasicNetworkManager& network_manager, bool include_ignored) {
  67     NetworkManager::NetworkList list;
  68     network_manager.CreateNetworks(include_ignored, &list);
  69     return list;
  70   }
  71
  72 #if defined(POSIX)
  73   // Separated from CreateNetworks for tests.
  74   static void CallConvertIfAddrs(const BasicNetworkManager& network_manager,
  75                                  struct ifaddrs* interfaces,
  76                                  bool include_ignored,
  77                                  NetworkManager::NetworkList* networks) {
  78     network_manager.ConvertIfAddrs(interfaces, include_ignored, networks);
  79   }
  80 #endif  // defined(POSIX)
  81
  82  protected:
  83   bool callback_called_;
  84 };
  85
  86 // Test that the Network ctor works properly.
  87 TEST_F(NetworkTest, TestNetworkConstruct) {
  88   Network ipv4_network1("test_eth0", "Test Network Adapter 1",
  89                         IPAddress(0x12345600U), 24);
  90   EXPECT_EQ("test_eth0", ipv4_network1.name());
  91   EXPECT_EQ("Test Network Adapter 1", ipv4_network1.description());
  92   EXPECT_EQ(IPAddress(0x12345600U), ipv4_network1.prefix());
  93   EXPECT_EQ(24, ipv4_network1.prefix_length());
  94   EXPECT_FALSE(ipv4_network1.ignored());
  95 }
  96
  97 // Tests that our ignore function works properly.
  98 TEST_F(NetworkTest, TestNetworkIgnore) {
  99   Network ipv4_network1("test_eth0", "Test Network Adapter 1",
 100                         IPAddress(0x12345600U), 24);
 101   Network ipv4_network2("test_eth1", "Test Network Adapter 2",
 102                         IPAddress(0x00010000U), 16);
 103   BasicNetworkManager network_manager;
 104   EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1));
 105   EXPECT_TRUE(IsIgnoredNetwork(network_manager, ipv4_network2));
 106 }
 107
 108 TEST_F(NetworkTest, TestIgnoreList) {
 109   Network ignore_me("ignore_me", "Ignore me please!",
 110                     IPAddress(0x12345600U), 24);
 111   Network include_me("include_me", "Include me please!",
 112                      IPAddress(0x12345600U), 24);
 113   BasicNetworkManager network_manager;
 114   EXPECT_FALSE(IsIgnoredNetwork(network_manager, ignore_me));
 115   EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me));
 116   std::vector<std::string> ignore_list;
 117   ignore_list.push_back("ignore_me");
 118   network_manager.set_network_ignore_list(ignore_list);
 119   EXPECT_TRUE(IsIgnoredNetwork(network_manager, ignore_me));
 120   EXPECT_FALSE(IsIgnoredNetwork(network_manager, include_me));
 121 }
 122
 123 // Test is failing on Windows opt: b/11288214
 124 TEST_F(NetworkTest, DISABLED_TestCreateNetworks) {
 125   BasicNetworkManager manager;
 126   NetworkManager::NetworkList result = GetNetworks(manager, true);
 127   // We should be able to bind to any addresses we find.
 128   NetworkManager::NetworkList::iterator it;
 129   for (it = result.begin();
 130        it != result.end();
 131        ++it) {
 132     sockaddr_storage storage;
 133     memset(&storage, 0, sizeof(storage));
 134     IPAddress ip = (*it)->ip();
 135     SocketAddress bindaddress(ip, 0);
 136     bindaddress.SetScopeID((*it)->scope_id());
 137     // TODO(thaloun): Use talk_base::AsyncSocket once it supports IPv6.
 138     int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
 139     if (fd > 0) {
 140       size_t ipsize = bindaddress.ToSockAddrStorage(&storage);
 141       EXPECT_GE(ipsize, 0U);
 142       int success = ::bind(fd,
 143                            reinterpret_cast<sockaddr*>(&storage),
 144                            static_cast<int>(ipsize));
 145 #ifdef WIN32
 146       if (success) LOG_GLE(LS_ERROR) << "Socket bind failed.";
 147 #endif
 148       EXPECT_EQ(0, success);
 149 #ifdef WIN32
 150       closesocket(fd);
 151 #else
 152       close(fd);
 153 #endif
 154     }
 155     delete (*it);
 156   }
 157 }
 158
 159 // Test that UpdateNetworks succeeds.
 160 TEST_F(NetworkTest, TestUpdateNetworks) {
 161   BasicNetworkManager manager;
 162   manager.SignalNetworksChanged.connect(
 163       static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
 164   manager.StartUpdating();
 165   Thread::Current()->ProcessMessages(0);
 166   EXPECT_TRUE(callback_called_);
 167   callback_called_ = false;
 168   // Callback should be triggered immediately when StartUpdating
 169   // is called, after network update signal is already sent.
 170   manager.StartUpdating();
 171   EXPECT_TRUE(manager.started());
 172   Thread::Current()->ProcessMessages(0);
 173   EXPECT_TRUE(callback_called_);
 174   manager.StopUpdating();
 175   EXPECT_TRUE(manager.started());
 176   manager.StopUpdating();
 177   EXPECT_FALSE(manager.started());
 178   manager.StopUpdating();
 179   EXPECT_FALSE(manager.started());
 180   callback_called_ = false;
 181   // Callback should be triggered immediately after StartUpdating is called
 182   // when start_count_ is reset to 0.
 183   manager.StartUpdating();
 184   Thread::Current()->ProcessMessages(0);
 185   EXPECT_TRUE(callback_called_);
 186 }
 187
 188 // Verify that MergeNetworkList() merges network lists properly.
 189 TEST_F(NetworkTest, TestBasicMergeNetworkList) {
 190   Network ipv4_network1("test_eth0", "Test Network Adapter 1",
 191                         IPAddress(0x12345600U), 24);
 192   Network ipv4_network2("test_eth1", "Test Network Adapter 2",
 193                         IPAddress(0x00010000U), 16);
 194   ipv4_network1.AddIP(IPAddress(0x12345678));
 195   ipv4_network2.AddIP(IPAddress(0x00010004));
 196   BasicNetworkManager manager;
 197
 198   // Add ipv4_network1 to the list of networks.
 199   NetworkManager::NetworkList list;
 200   list.push_back(new Network(ipv4_network1));
 201   bool changed;
 202   MergeNetworkList(manager, list, &changed);
 203   EXPECT_TRUE(changed);
 204   list.clear();
 205
 206   manager.GetNetworks(&list);
 207   EXPECT_EQ(1U, list.size());
 208   EXPECT_EQ(ipv4_network1.ToString(), list[0]->ToString());
 209   Network* net1 = list[0];
 210   list.clear();
 211
 212   // Replace ipv4_network1 with ipv4_network2.
 213   list.push_back(new Network(ipv4_network2));
 214   MergeNetworkList(manager, list, &changed);
 215   EXPECT_TRUE(changed);
 216   list.clear();
 217
 218   manager.GetNetworks(&list);
 219   EXPECT_EQ(1U, list.size());
 220   EXPECT_EQ(ipv4_network2.ToString(), list[0]->ToString());
 221   Network* net2 = list[0];
 222   list.clear();
 223
 224   // Add Network2 back.
 225   list.push_back(new Network(ipv4_network1));
 226   list.push_back(new Network(ipv4_network2));
 227   MergeNetworkList(manager, list, &changed);
 228   EXPECT_TRUE(changed);
 229   list.clear();
 230
 231   // Verify that we get previous instances of Network objects.
 232   manager.GetNetworks(&list);
 233   EXPECT_EQ(2U, list.size());
 234   EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
 235               (net1 == list[1] && net2 == list[0]));
 236   list.clear();
 237
 238   // Call MergeNetworkList() again and verify that we don't get update
 239   // notification.
 240   list.push_back(new Network(ipv4_network2));
 241   list.push_back(new Network(ipv4_network1));
 242   MergeNetworkList(manager, list, &changed);
 243   EXPECT_FALSE(changed);
 244   list.clear();
 245
 246   // Verify that we get previous instances of Network objects.
 247   manager.GetNetworks(&list);
 248   EXPECT_EQ(2U, list.size());
 249   EXPECT_TRUE((net1 == list[0] && net2 == list[1]) ||
 250               (net1 == list[1] && net2 == list[0]));
 251   list.clear();
 252 }
 253
 254 // Sets up some test IPv6 networks and appends them to list.
 255 // Four networks are added - public and link local, for two interfaces.
 256 void SetupNetworks(NetworkManager::NetworkList* list) {
 257   IPAddress ip;
 258   IPAddress prefix;
 259   EXPECT_TRUE(IPFromString("fe80::1234:5678:abcd:ef12", &ip));
 260   EXPECT_TRUE(IPFromString("fe80::", &prefix));
 261   // First, fake link-locals.
 262   Network ipv6_eth0_linklocalnetwork("test_eth0", "Test NetworkAdapter 1",
 263                                      prefix, 64);
 264   ipv6_eth0_linklocalnetwork.AddIP(ip);
 265   EXPECT_TRUE(IPFromString("fe80::5678:abcd:ef12:3456", &ip));
 266   Network ipv6_eth1_linklocalnetwork("test_eth1", "Test NetworkAdapter 2",
 267                                      prefix, 64);
 268   ipv6_eth1_linklocalnetwork.AddIP(ip);
 269   // Public networks:
 270   EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ip));
 271   prefix = TruncateIP(ip, 64);
 272   Network ipv6_eth0_publicnetwork1_ip1("test_eth0", "Test NetworkAdapter 1",
 273                                        prefix, 64);
 274   ipv6_eth0_publicnetwork1_ip1.AddIP(ip);
 275   EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
 276   prefix = TruncateIP(ip, 64);
 277   Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 1",
 278                                        prefix, 64);
 279   ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
 280   list->push_back(new Network(ipv6_eth0_linklocalnetwork));
 281   list->push_back(new Network(ipv6_eth1_linklocalnetwork));
 282   list->push_back(new Network(ipv6_eth0_publicnetwork1_ip1));
 283   list->push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
 284 }
 285
 286 // Test that the basic network merging case works.
 287 TEST_F(NetworkTest, TestIPv6MergeNetworkList) {
 288   BasicNetworkManager manager;
 289   manager.SignalNetworksChanged.connect(
 290       static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
 291   NetworkManager::NetworkList original_list;
 292   SetupNetworks(&original_list);
 293   bool changed = false;
 294   MergeNetworkList(manager, original_list, &changed);
 295   EXPECT_TRUE(changed);
 296   NetworkManager::NetworkList list;
 297   manager.GetNetworks(&list);
 298   EXPECT_EQ(original_list.size(), list.size());
 299   // Verify that the original members are in the merged list.
 300   for (NetworkManager::NetworkList::iterator it = original_list.begin();
 301        it != original_list.end(); ++it) {
 302     EXPECT_NE(list.end(), std::find(list.begin(), list.end(), *it));
 303   }
 304 }
 305
 306 // Tests that when two network lists that describe the same set of networks are
 307 // merged, that the changed callback is not called, and that the original
 308 // objects remain in the result list.
 309 TEST_F(NetworkTest, TestNoChangeMerge) {
 310   BasicNetworkManager manager;
 311   manager.SignalNetworksChanged.connect(
 312       static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
 313   NetworkManager::NetworkList original_list;
 314   SetupNetworks(&original_list);
 315   bool changed = false;
 316   MergeNetworkList(manager, original_list, &changed);
 317   EXPECT_TRUE(changed);
 318   // Second list that describes the same networks but with new objects.
 319   NetworkManager::NetworkList second_list;
 320   SetupNetworks(&second_list);
 321   changed = false;
 322   MergeNetworkList(manager, second_list, &changed);
 323   EXPECT_FALSE(changed);
 324   NetworkManager::NetworkList resulting_list;
 325   manager.GetNetworks(&resulting_list);
 326   EXPECT_EQ(original_list.size(), resulting_list.size());
 327   // Verify that the original members are in the merged list.
 328   for (NetworkManager::NetworkList::iterator it = original_list.begin();
 329        it != original_list.end(); ++it) {
 330     EXPECT_NE(resulting_list.end(),
 331               std::find(resulting_list.begin(), resulting_list.end(), *it));
 332   }
 333   // Doublecheck that the new networks aren't in the list.
 334   for (NetworkManager::NetworkList::iterator it = second_list.begin();
 335        it != second_list.end(); ++it) {
 336     EXPECT_EQ(resulting_list.end(),
 337               std::find(resulting_list.begin(), resulting_list.end(), *it));
 338   }
 339 }
 340
 341 // Test that we can merge a network that is the same as another network but with
 342 // a different IP. The original network should remain in the list, but have its
 343 // IP changed.
 344 TEST_F(NetworkTest, MergeWithChangedIP) {
 345   BasicNetworkManager manager;
 346   manager.SignalNetworksChanged.connect(
 347       static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
 348   NetworkManager::NetworkList original_list;
 349   SetupNetworks(&original_list);
 350   // Make a network that we're going to change.
 351   IPAddress ip;
 352   EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:faa:fee:faa", &ip));
 353   IPAddress prefix = TruncateIP(ip, 64);
 354   Network* network_to_change = new Network("test_eth0",
 355                                           "Test Network Adapter 1",
 356                                           prefix, 64);
 357   Network* changed_network = new Network(*network_to_change);
 358   network_to_change->AddIP(ip);
 359   IPAddress changed_ip;
 360   EXPECT_TRUE(IPFromString("2401:fa01:4:1000:be30:f00:f00:f00", &changed_ip));
 361   changed_network->AddIP(changed_ip);
 362   original_list.push_back(network_to_change);
 363   bool changed = false;
 364   MergeNetworkList(manager, original_list, &changed);
 365   NetworkManager::NetworkList second_list;
 366   SetupNetworks(&second_list);
 367   second_list.push_back(changed_network);
 368   changed = false;
 369   MergeNetworkList(manager, second_list, &changed);
 370   EXPECT_TRUE(changed);
 371   NetworkManager::NetworkList list;
 372   manager.GetNetworks(&list);
 373   EXPECT_EQ(original_list.size(), list.size());
 374   // Make sure the original network is still in the merged list.
 375   EXPECT_NE(list.end(),
 376             std::find(list.begin(), list.end(), network_to_change));
 377   EXPECT_EQ(changed_ip, network_to_change->GetIPs().at(0));
 378 }
 379
 380 // Testing a similar case to above, but checking that a network can be updated
 381 // with additional IPs (not just a replacement).
 382 TEST_F(NetworkTest, TestMultipleIPMergeNetworkList) {
 383   BasicNetworkManager manager;
 384   manager.SignalNetworksChanged.connect(
 385       static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
 386   NetworkManager::NetworkList original_list;
 387   SetupNetworks(&original_list);
 388   bool changed = false;
 389   MergeNetworkList(manager, original_list, &changed);
 390   EXPECT_TRUE(changed);
 391   IPAddress ip;
 392   IPAddress check_ip;
 393   IPAddress prefix;
 394   // Add a second IP to the public network on eth0 (2401:fa00:4:1000/64).
 395   EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c6", &ip));
 396   prefix = TruncateIP(ip, 64);
 397   Network ipv6_eth0_publicnetwork1_ip2("test_eth0", "Test NetworkAdapter 1",
 398                                        prefix, 64);
 399   // This is the IP that already existed in the public network on eth0.
 400   EXPECT_TRUE(IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &check_ip));
 401   ipv6_eth0_publicnetwork1_ip2.AddIP(ip);
 402   original_list.push_back(new Network(ipv6_eth0_publicnetwork1_ip2));
 403   changed = false;
 404   MergeNetworkList(manager, original_list, &changed);
 405   EXPECT_TRUE(changed);
 406   // There should still be four networks.
 407   NetworkManager::NetworkList list;
 408   manager.GetNetworks(&list);
 409   EXPECT_EQ(4U, list.size());
 410   // Check the gathered IPs.
 411   int matchcount = 0;
 412   for (NetworkManager::NetworkList::iterator it = list.begin();
 413        it != list.end(); ++it) {
 414     if ((*it)->ToString() == original_list[2]->ToString()) {
 415       ++matchcount;
 416       EXPECT_EQ(1, matchcount);
 417       // This should be the same network object as before.
 418       EXPECT_EQ((*it), original_list[2]);
 419       // But with two addresses now.
 420       EXPECT_EQ(2U, (*it)->GetIPs().size());
 421       EXPECT_NE((*it)->GetIPs().end(),
 422                 std::find((*it)->GetIPs().begin(),
 423                           (*it)->GetIPs().end(),
 424                           check_ip));
 425       EXPECT_NE((*it)->GetIPs().end(),
 426                 std::find((*it)->GetIPs().begin(),
 427                           (*it)->GetIPs().end(),
 428                           ip));
 429     } else {
 430       // Check the IP didn't get added anywhere it wasn't supposed to.
 431       EXPECT_EQ((*it)->GetIPs().end(),
 432                 std::find((*it)->GetIPs().begin(),
 433                           (*it)->GetIPs().end(),
 434                           ip));
 435     }
 436   }
 437 }
 438
 439 // Test that merge correctly distinguishes multiple networks on an interface.
 440 TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) {
 441   BasicNetworkManager manager;
 442   manager.SignalNetworksChanged.connect(
 443       static_cast<NetworkTest*>(this), &NetworkTest::OnNetworksChanged);
 444   NetworkManager::NetworkList original_list;
 445   SetupNetworks(&original_list);
 446   bool changed = false;
 447   MergeNetworkList(manager, original_list, &changed);
 448   EXPECT_TRUE(changed);
 449   IPAddress ip;
 450   IPAddress prefix;
 451   // A second network for eth0.
 452   EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:5bff:fee5:c3", &ip));
 453   prefix = TruncateIP(ip, 64);
 454   Network ipv6_eth0_publicnetwork2_ip1("test_eth0", "Test NetworkAdapter 1",
 455                                        prefix, 64);
 456   ipv6_eth0_publicnetwork2_ip1.AddIP(ip);
 457   original_list.push_back(new Network(ipv6_eth0_publicnetwork2_ip1));
 458   changed = false;
 459   MergeNetworkList(manager, original_list, &changed);
 460   EXPECT_TRUE(changed);
 461   // There should be five networks now.
 462   NetworkManager::NetworkList list;
 463   manager.GetNetworks(&list);
 464   EXPECT_EQ(5U, list.size());
 465   // Check the resulting addresses.
 466   for (NetworkManager::NetworkList::iterator it = list.begin();
 467        it != list.end(); ++it) {
 468     if ((*it)->prefix() == ipv6_eth0_publicnetwork2_ip1.prefix() &&
 469         (*it)->name() == ipv6_eth0_publicnetwork2_ip1.name()) {
 470       // Check the new network has 1 IP and that it's the correct one.
 471       EXPECT_EQ(1U, (*it)->GetIPs().size());
 472       EXPECT_EQ(ip, (*it)->GetIPs().at(0));
 473     } else {
 474       // Check the IP didn't get added anywhere it wasn't supposed to.
 475       EXPECT_EQ((*it)->GetIPs().end(),
 476                 std::find((*it)->GetIPs().begin(),
 477                           (*it)->GetIPs().end(),
 478                           ip));
 479     }
 480   }
 481 }
 482
 483 // Test that DumpNetworks works.
 484 TEST_F(NetworkTest, TestDumpNetworks) {
 485   BasicNetworkManager manager;
 486   manager.DumpNetworks(true);
 487 }
 488
 489 // Test that we can toggle IPv6 on and off.
 490 TEST_F(NetworkTest, TestIPv6Toggle) {
 491   BasicNetworkManager manager;
 492   bool ipv6_found = false;
 493   NetworkManager::NetworkList list;
 494 #ifndef WIN32
 495   // There should be at least one IPv6 network (fe80::/64 should be in there).
 496   // TODO(thaloun): Disabling this test on windows for the moment as the test
 497   // machines don't seem to have IPv6 installed on them at all.
 498   manager.set_ipv6_enabled(true);
 499   list = GetNetworks(manager, true);
 500   for (NetworkManager::NetworkList::iterator it = list.begin();
 501        it != list.end(); ++it) {
 502     if ((*it)->prefix().family() == AF_INET6) {
 503       ipv6_found = true;
 504       break;
 505     }
 506   }
 507   EXPECT_TRUE(ipv6_found);
 508   for (NetworkManager::NetworkList::iterator it = list.begin();
 509        it != list.end(); ++it) {
 510     delete (*it);
 511   }
 512 #endif
 513   ipv6_found = false;
 514   manager.set_ipv6_enabled(false);
 515   list = GetNetworks(manager, true);
 516   for (NetworkManager::NetworkList::iterator it = list.begin();
 517        it != list.end(); ++it) {
 518     if ((*it)->prefix().family() == AF_INET6) {
 519       ipv6_found = true;
 520       break;
 521     }
 522   }
 523   EXPECT_FALSE(ipv6_found);
 524   for (NetworkManager::NetworkList::iterator it = list.begin();
 525        it != list.end(); ++it) {
 526     delete (*it);
 527   }
 528 }
 529
 530 TEST_F(NetworkTest, TestNetworkListSorting) {
 531   BasicNetworkManager manager;
 532   Network ipv4_network1("test_eth0", "Test Network Adapter 1",
 533                         IPAddress(0x12345600U), 24);
 534   ipv4_network1.AddIP(IPAddress(0x12345600U));
 535
 536   IPAddress ip;
 537   IPAddress prefix;
 538   EXPECT_TRUE(IPFromString("2400:4030:1:2c00:be30:abcd:efab:cdef", &ip));
 539   prefix = TruncateIP(ip, 64);
 540   Network ipv6_eth1_publicnetwork1_ip1("test_eth1", "Test NetworkAdapter 2",
 541                                        prefix, 64);
 542   ipv6_eth1_publicnetwork1_ip1.AddIP(ip);
 543
 544   NetworkManager::NetworkList list;
 545   list.push_back(new Network(ipv4_network1));
 546   list.push_back(new Network(ipv6_eth1_publicnetwork1_ip1));
 547   Network* net1 = list[0];
 548   Network* net2 = list[1];
 549
 550   bool changed = false;
 551   MergeNetworkList(manager, list, &changed);
 552   ASSERT_TRUE(changed);
 553   // After sorting IPv6 network should be higher order than IPv4 networks.
 554   EXPECT_TRUE(net1->preference() < net2->preference());
 555 }
 556
 557 TEST_F(NetworkTest, TestNetworkAdapterTypes) {
 558   Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24,
 559                ADAPTER_TYPE_WIFI);
 560   EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type());
 561   Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24,
 562                    ADAPTER_TYPE_ETHERNET);
 563   EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type());
 564   Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24,
 565                    ADAPTER_TYPE_CELLULAR);
 566   EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type());
 567   Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24,
 568               ADAPTER_TYPE_VPN);
 569   EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type());
 570   Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24,
 571                   ADAPTER_TYPE_UNKNOWN);
 572   EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type());
 573 }
 574
 575 #if defined(POSIX)
 576 // Verify that we correctly handle interfaces with no address.
 577 TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) {
 578   ifaddrs list;
 579   memset(&list, 0, sizeof(list));
 580   list.ifa_name = const_cast<char*>("test_iface");
 581
 582   NetworkManager::NetworkList result;
 583   BasicNetworkManager manager;
 584   CallConvertIfAddrs(manager, &list, true, &result);
 585   EXPECT_TRUE(result.empty());
 586 }
 587 #endif  // defined(POSIX)
 588
 589 #if defined(LINUX)
 590 // If you want to test non-default routes, you can do the following on a linux
 591 // machine:
 592 // 1) Load the dummy network driver:
 593 // sudo modprobe dummy
 594 // sudo ifconfig dummy0 127.0.0.1
 595 // 2) Run this test and confirm the output says it found a dummy route (and
 596 // passes).
 597 // 3) When done:
 598 // sudo rmmmod dummy
 599 TEST_F(NetworkTest, TestIgnoreNonDefaultRoutes) {
 600   BasicNetworkManager manager;
 601   NetworkManager::NetworkList list;
 602   list = GetNetworks(manager, false);
 603   bool found_dummy = false;
 604   LOG(LS_INFO) << "Looking for dummy network: ";
 605   for (NetworkManager::NetworkList::iterator it = list.begin();
 606        it != list.end(); ++it) {
 607     LOG(LS_INFO) << "  Network name: " << (*it)->name();
 608     found_dummy |= (*it)->name().find("dummy0") != std::string::npos;
 609   }
 610   for (NetworkManager::NetworkList::iterator it = list.begin();
 611        it != list.end(); ++it) {
 612     delete (*it);
 613   }
 614   if (!found_dummy) {
 615     LOG(LS_INFO) << "No dummy found, quitting.";
 616     return;
 617   }
 618   LOG(LS_INFO) << "Found dummy, running again while ignoring non-default "
 619                << "routes.";
 620   manager.set_ignore_non_default_routes(true);
 621   list = GetNetworks(manager, false);
 622   for (NetworkManager::NetworkList::iterator it = list.begin();
 623        it != list.end(); ++it) {
 624     LOG(LS_INFO) << "  Network name: " << (*it)->name();
 625     EXPECT_TRUE((*it)->name().find("dummy0") == std::string::npos);
 626   }
 627   for (NetworkManager::NetworkList::iterator it = list.begin();
 628        it != list.end(); ++it) {
 629     delete (*it);
 630   }
 631 }
 632 #endif
 633
 634 }  // namespace talk_base