src/net/quic/quic_received_packet_manager_test.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/quic_received_packet_manager.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "net/quic/quic_connection_stats.h"
  11 #include "net/quic/test_tools/quic_received_packet_manager_peer.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using std::make_pair;
  16 using std::pair;
  17 using std::vector;
  18
  19 namespace net {
  20 namespace test {
  21 namespace {
  22
  23 class QuicReceivedPacketManagerTest : public ::testing::Test {
  24  protected:
  25   QuicReceivedPacketManagerTest() : received_manager_(kTCP, &stats_) { }
  26
  27   void RecordPacketReceipt(QuicPacketSequenceNumber sequence_number,
  28                            QuicPacketEntropyHash entropy_hash) {
  29     RecordPacketReceipt(sequence_number, entropy_hash, QuicTime::Zero());
  30   }
  31
  32   void RecordPacketReceipt(QuicPacketSequenceNumber sequence_number,
  33                            QuicPacketEntropyHash entropy_hash,
  34                            QuicTime receipt_time) {
  35     QuicPacketHeader header;
  36     header.packet_sequence_number = sequence_number;
  37     header.entropy_hash = entropy_hash;
  38     received_manager_.RecordPacketReceived(0u, header, receipt_time);
  39   }
  40
  41   QuicConnectionStats stats_;
  42   QuicReceivedPacketManager received_manager_;
  43 };
  44
  45 TEST_F(QuicReceivedPacketManagerTest, ReceivedPacketEntropyHash) {
  46   vector<pair<QuicPacketSequenceNumber, QuicPacketEntropyHash> > entropies;
  47   entropies.push_back(make_pair(1, 12));
  48   entropies.push_back(make_pair(7, 1));
  49   entropies.push_back(make_pair(2, 33));
  50   entropies.push_back(make_pair(5, 3));
  51   entropies.push_back(make_pair(8, 34));
  52
  53   for (size_t i = 0; i < entropies.size(); ++i) {
  54     RecordPacketReceipt(entropies[i].first, entropies[i].second);
  55   }
  56
  57   sort(entropies.begin(), entropies.end());
  58
  59   QuicPacketEntropyHash hash = 0;
  60   size_t index = 0;
  61   for (size_t i = 1; i <= (*entropies.rbegin()).first; ++i) {
  62     if (entropies[index].first == i) {
  63       hash ^= entropies[index].second;
  64       ++index;
  65     }
  66     EXPECT_EQ(hash, received_manager_.EntropyHash(i));
  67   }
  68   // Reorder by 5 when 2 is received after 7.
  69   EXPECT_EQ(5u, stats_.max_sequence_reordering);
  70   EXPECT_EQ(0u, stats_.max_time_reordering_us);
  71   EXPECT_EQ(2u, stats_.packets_reordered);
  72 }
  73
  74 TEST_F(QuicReceivedPacketManagerTest, EntropyHashBelowLeastObserved) {
  75   EXPECT_EQ(0, received_manager_.EntropyHash(0));
  76   RecordPacketReceipt(4, 5);
  77   EXPECT_EQ(0, received_manager_.EntropyHash(3));
  78 }
  79
  80 TEST_F(QuicReceivedPacketManagerTest, EntropyHashAboveLargestObserved) {
  81   EXPECT_EQ(0, received_manager_.EntropyHash(0));
  82   RecordPacketReceipt(4, 5);
  83   EXPECT_EQ(0, received_manager_.EntropyHash(3));
  84 }
  85
  86 TEST_F(QuicReceivedPacketManagerTest, RecalculateEntropyHash) {
  87   vector<pair<QuicPacketSequenceNumber, QuicPacketEntropyHash> > entropies;
  88   entropies.push_back(make_pair(1, 12));
  89   entropies.push_back(make_pair(2, 1));
  90   entropies.push_back(make_pair(3, 33));
  91   entropies.push_back(make_pair(4, 3));
  92   entropies.push_back(make_pair(5, 34));
  93   entropies.push_back(make_pair(6, 29));
  94
  95   QuicPacketEntropyHash entropy_hash = 0;
  96   for (size_t i = 0; i < entropies.size(); ++i) {
  97     RecordPacketReceipt(entropies[i].first, entropies[i].second);
  98     entropy_hash ^= entropies[i].second;
  99   }
 100   EXPECT_EQ(entropy_hash, received_manager_.EntropyHash(6));
 101
 102   // Now set the entropy hash up to 4 to be 100.
 103   entropy_hash ^= 100;
 104   for (size_t i = 0; i < 3; ++i) {
 105     entropy_hash ^= entropies[i].second;
 106   }
 107   QuicReceivedPacketManagerPeer::RecalculateEntropyHash(
 108       &received_manager_, 4, 100);
 109   EXPECT_EQ(entropy_hash, received_manager_.EntropyHash(6));
 110
 111   QuicReceivedPacketManagerPeer::RecalculateEntropyHash(
 112       &received_manager_, 1, 50);
 113   EXPECT_EQ(entropy_hash, received_manager_.EntropyHash(6));
 114
 115   // No reordering.
 116   EXPECT_EQ(0u, stats_.max_sequence_reordering);
 117   EXPECT_EQ(0u, stats_.max_time_reordering_us);
 118   EXPECT_EQ(0u, stats_.packets_reordered);
 119 }
 120
 121 TEST_F(QuicReceivedPacketManagerTest, DontWaitForPacketsBefore) {
 122   QuicPacketHeader header;
 123   header.packet_sequence_number = 2u;
 124   received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero());
 125   header.packet_sequence_number = 7u;
 126   received_manager_.RecordPacketReceived(0u, header, QuicTime::Zero());
 127   EXPECT_TRUE(received_manager_.IsAwaitingPacket(3u));
 128   EXPECT_TRUE(received_manager_.IsAwaitingPacket(6u));
 129   EXPECT_TRUE(QuicReceivedPacketManagerPeer::DontWaitForPacketsBefore(
 130       &received_manager_, 4));
 131   EXPECT_FALSE(received_manager_.IsAwaitingPacket(3u));
 132   EXPECT_TRUE(received_manager_.IsAwaitingPacket(6u));
 133 }
 134
 135 TEST_F(QuicReceivedPacketManagerTest, UpdateReceivedPacketInfo) {
 136   QuicPacketHeader header;
 137   header.packet_sequence_number = 2u;
 138   QuicTime two_ms = QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(2));
 139   received_manager_.RecordPacketReceived(0u, header, two_ms);
 140
 141   ReceivedPacketInfo info;
 142   received_manager_.UpdateReceivedPacketInfo(&info, QuicTime::Zero());
 143   // When UpdateReceivedPacketInfo with a time earlier than the time of the
 144   // largest observed packet, make sure that the delta is 0, not negative.
 145   EXPECT_EQ(QuicTime::Delta::Zero(), info.delta_time_largest_observed);
 146
 147   QuicTime four_ms = QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(4));
 148   received_manager_.UpdateReceivedPacketInfo(&info, four_ms);
 149   // When UpdateReceivedPacketInfo after not having received a new packet,
 150   // the delta should still be accurate.
 151   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(2),
 152             info.delta_time_largest_observed);
 153 }
 154
 155 TEST_F(QuicReceivedPacketManagerTest, UpdateReceivedConnectionStats) {
 156   RecordPacketReceipt(1, 0);
 157   RecordPacketReceipt(6, 0);
 158   RecordPacketReceipt(
 159       2, 0, QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(1)));
 160
 161   EXPECT_EQ(4u, stats_.max_sequence_reordering);
 162   EXPECT_EQ(1000u, stats_.max_time_reordering_us);
 163   EXPECT_EQ(1u, stats_.packets_reordered);
 164 }
 165
 166 }  // namespace
 167 }  // namespace test
 168 }  // namespace net