Consistently suggest ephemeral port for QUIC client

net/quic/port_suggester_unittest.cc

+// Copyright (c) 2012 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 "net/quic/port_suggester.h"
+
+#include <climits>

[wtc, 2013/12/06 23:36:44]

Nit: what is <climits> for?

[jar (doing other things), 2013/12/07 00:47:58]

<oops>  I was using MAX_INT, but switched to using the shared max/min ephemeral_
variables.

Removed include (thanks!!).

+#include <set>
+
+#include "base/basictypes.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace test {
+
+class PortSuggesterTest : public ::testing::Test {
+ protected:
+  PortSuggesterTest()
+      : entropy_(34567),
+        min_ephemeral_port_(1025),
+        max_ephemeral_port_(65535) {
+  }
+
+  uint64 entropy_;
+  int min_ephemeral_port_;
+  int max_ephemeral_port_;
+};
+
+TEST_F(PortSuggesterTest, SmallRangeTest) {
+  // When the range is small (one wide), we always get that as our answer.
+  scoped_refptr<PortSuggester> port_suggester =
+      new PortSuggester(HostPortPair("www.com", 443), entropy_);

[wtc, 2013/12/06 23:36:44]

Nit: I suggest "www.example.com".

[jar (doing other things), 2013/12/07 00:47:58]

Done.

+  // Test this for a few different (small) ranges.
+  for (int port = 2000; port < 2010; ++port) {
+    // Use a min an max for the range of |port|.

[wtc, 2013/12/06 23:36:44]

an => and?

[jar (doing other things), 2013/12/07 00:47:58]

Improved comment.

+    EXPECT_EQ(port, port_suggester->SuggestPort(port, port));
+  }
+}
+
+TEST_F(PortSuggesterTest, SuggestAllPorts) {
+  // We should eventually fill out any range, but we'll just ensure that we
+  // fill out a small range of ports.
+  scoped_refptr<PortSuggester> port_suggester =
+      new PortSuggester(HostPortPair("www.com", 443), entropy_);
+  std::set<int> ports;
+  const int port_range = 20;
+  int insertion_limit = 200;  // We should be done by then.
+  for (int i = 0; i < insertion_limit; ++i) {
+    ports.insert(port_suggester->SuggestPort(min_ephemeral_port_,
+        min_ephemeral_port_ + port_range - 1));
+    if (ports.size() == static_cast<size_t>(port_range)) {
+      break;
+    }
+  }
+  EXPECT_EQ(static_cast<size_t>(port_range), ports.size());
+}
+
+TEST_F(PortSuggesterTest, AvoidDuplication) {
+  // When the range is large, duplicates are rare, but we'll ask for a few
+  // suggestions and make sure they are unique.
+  scoped_refptr<PortSuggester> port_suggester =
+      new PortSuggester(HostPortPair("www.com", 443), entropy_);
+  std::set<int> ports;
+  const int port_count = 200;
+  for (int i = 0; i < port_count; ++i) {
+    ports.insert(port_suggester->SuggestPort(min_ephemeral_port_,
+                                             max_ephemeral_port_));
+  }
+  EXPECT_EQ(static_cast<size_t>(port_count), ports.size());
+}
+
+TEST_F(PortSuggesterTest, ConsistentPorts) {
+  // For given hostname, port, and entropy, we should always get the same
+  // suggestions.
+  scoped_refptr<PortSuggester> port_suggester1 =
+      new PortSuggester(HostPortPair("www.com", 443), entropy_);
+  scoped_refptr<PortSuggester> port_suggester2 =
+      new PortSuggester(HostPortPair("www.com", 443), entropy_);
+  for (int test_count = 20; test_count > 0; --test_count) {
+    EXPECT_EQ(port_suggester1->SuggestPort(min_ephemeral_port_,
+                                           min_ephemeral_port_),
+              port_suggester2->SuggestPort(min_ephemeral_port_,
+                                           min_ephemeral_port_));
+  }
+}
+
+TEST_F(PortSuggesterTest, DifferentHostPorts) {
+  // When we have different hosts, port, or entropy, we probably won't collide.
+  scoped_refptr<PortSuggester> port_suggester[] = {
+      new PortSuggester(HostPortPair("www.com", 80), entropy_),
+      new PortSuggester(HostPortPair("www.gov", 80), entropy_),
+      new PortSuggester(HostPortPair("www.com", 81), entropy_),
+      new PortSuggester(HostPortPair("www.com", 80), entropy_ + 1),
+  };
+
+  std::set<int> ports;
+  const int port_count = 40;
+  size_t insertion_count = 0;
+  for (size_t j = 0; j < arraysize(port_suggester); ++j) {
+    for (int i = 0; i < port_count; ++i) {
+     ports.insert(port_suggester[j]->SuggestPort(min_ephemeral_port_,
+                                                 max_ephemeral_port_));
+     ++insertion_count;
+    }
+  }
+  EXPECT_EQ(insertion_count, ports.size());
+}
+
+}  // namespace test
+}  // namespace net