src/third_party/webrtc/base/network_unittest.cc

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