net/quic/quic_ack_notifier_manager_test.cc

   1 // Copyright (c) 2015 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_ack_notifier_manager.h"
   6
   7 #include "net/quic/quic_ack_notifier.h"
   8 #include "net/quic/quic_protocol.h"
   9 #include "net/quic/test_tools/quic_ack_notifier_manager_peer.h"
  10 #include "net/quic/test_tools/quic_test_utils.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace net {
  14 namespace test {
  15 namespace {
  16
  17 // Test fixture for testing AckNotifierManager.  Instantiates a manager and
  18 // provides shared code for adding notifiers and verifying the contents of the
  19 // manager.
  20 class QuicAckNotifierManagerTest : public ::testing::Test {
  21  protected:
  22   AckNotifierManager manager_;
  23   scoped_refptr<MockAckNotifierDelegate> delegate_;
  24   QuicTime::Delta zero_;
  25
  26   QuicAckNotifierManagerTest() : zero_(QuicTime::Delta::Zero()) {
  27     delegate_ = new MockAckNotifierDelegate;
  28   }
  29
  30   ~QuicAckNotifierManagerTest() override {}
  31
  32   size_t CountPackets() const {
  33     return AckNotifierManagerPeer::GetNumberOfRegisteredPackets(&manager_);
  34   }
  35
  36   // Add a mock packet with specified parameters.  The packet with given
  37   // sequence number must not exist in the map before.
  38   void AddPacket(QuicPacketSequenceNumber sequence_number,
  39                  bool retransmittable) {
  40     // Create a mock packet.
  41     RetransmittableFrames frames(ENCRYPTION_NONE);
  42     SerializedPacket packet(sequence_number, PACKET_4BYTE_SEQUENCE_NUMBER,
  43                             /*packet=*/nullptr,
  44                             /*entropy_hash=*/0,
  45                             retransmittable ? &frames : nullptr,
  46                             /*has_ack=*/false,
  47                             /*has_stop_waiting=*/false);
  48
  49     // Create and register a notifier.  Normally, this would be created by
  50     // QuicPacketGenerator.
  51     QuicAckNotifier* notifier = new QuicAckNotifier(delegate_.get());
  52     packet.notifiers.push_back(notifier);
  53
  54     // Ensure that exactly one packet is added.
  55     const size_t old_packet_count = CountPackets();
  56
  57     // Actually add the packet.
  58     manager_.OnSerializedPacket(packet);
  59
  60     // Ensure the change in the number of packets.
  61     EXPECT_EQ(old_packet_count + 1, CountPackets());
  62   }
  63 };
  64
  65 // This test verifies that QuicAckNotifierManager can handle the trivial case of
  66 // received packet notification.
  67 TEST_F(QuicAckNotifierManagerTest, SimpleAck) {
  68   AddPacket(1, false);
  69   AddPacket(2, true);
  70
  71   EXPECT_CALL(*delegate_, OnAckNotification(0, 0, zero_)).Times(2);
  72   manager_.OnPacketAcked(1, zero_);
  73   EXPECT_EQ(1u, CountPackets());
  74   manager_.OnPacketAcked(2, zero_);
  75   EXPECT_EQ(0u, CountPackets());
  76
  77   manager_.OnPacketRemoved(1);
  78   manager_.OnPacketRemoved(2);
  79   EXPECT_EQ(0u, CountPackets());
  80 }
  81
  82 // This test verifies that QuicAckNotifierManager can correctly handle the case
  83 // when some of the packets are lost, which causes retransmission and removal
  84 // from the unacked packet map.
  85 TEST_F(QuicAckNotifierManagerTest, AckWithLosses) {
  86   const size_t retransmitted_packet_size = kDefaultMaxPacketSize;
  87
  88   // Here, we simulate the following scenario:
  89   // 1. We send packets 1 to 5, where only odd-numbered packets are
  90   //    retransmittable.
  91   // 2. The peer acks 1, 2 and 5, but not 3 and 4.
  92   // 3. We retransmit 3 as 6.
  93   // 4. We remove 1 and 2, since we no longer care about them.
  94   // 4. The peer acks 6.
  95   // 5. We remove packets 3 to 6.
  96
  97   // Step 1: send five packets.
  98   AddPacket(1, true);
  99   AddPacket(2, false);
 100   AddPacket(3, true);
 101   AddPacket(4, false);
 102   AddPacket(5, true);
 103
 104   // Step 2: handle acks from peer.
 105   EXPECT_CALL(*delegate_, OnAckNotification(0, 0, zero_)).Times(3);
 106   manager_.OnPacketAcked(1, zero_);
 107   EXPECT_EQ(4u, CountPackets());
 108   manager_.OnPacketAcked(2, zero_);
 109   EXPECT_EQ(3u, CountPackets());
 110   manager_.OnPacketAcked(5, zero_);
 111   EXPECT_EQ(2u, CountPackets());
 112
 113   // Step 3: retransmit 3 as 6.
 114   manager_.OnPacketRetransmitted(3, 6, retransmitted_packet_size);
 115   EXPECT_EQ(2u, CountPackets());
 116
 117   // Step 4: remove 1 and 2.
 118   manager_.OnPacketRemoved(1);
 119   manager_.OnPacketRemoved(2);
 120   EXPECT_EQ(2u, CountPackets());
 121
 122   // Step 4: ack packet 6.
 123   EXPECT_CALL(*delegate_,
 124               OnAckNotification(1, retransmitted_packet_size, zero_)).Times(1);
 125   manager_.OnPacketAcked(6, zero_);
 126   EXPECT_EQ(1u, CountPackets());
 127
 128   // Step 5: remove all packets.  This causes packet 4 to be dropped from the
 129   // map.
 130   manager_.OnPacketRemoved(3);
 131   manager_.OnPacketRemoved(4);
 132   manager_.OnPacketRemoved(5);
 133   manager_.OnPacketRemoved(6);
 134   EXPECT_EQ(0u, CountPackets());
 135 }
 136
 137 // This test verifies that the QuicAckNotifierManager behaves correctly when
 138 // there are many retransmissions.
 139 TEST_F(QuicAckNotifierManagerTest, RepeatedRetransmission) {
 140   AddPacket(1, true);
 141
 142   const size_t packet_size = kDefaultMaxPacketSize;
 143   const size_t times_lost = 100;
 144   const size_t total_size_lost = packet_size * times_lost;
 145   const QuicPacketSequenceNumber last_packet = times_lost + 1;
 146
 147   // Retransmit the packet many times.
 148   for (size_t sequence_number = 1; sequence_number < last_packet;
 149        sequence_number++) {
 150     manager_.OnPacketRetransmitted(sequence_number, sequence_number + 1,
 151                                    packet_size);
 152     EXPECT_EQ(1u, CountPackets());
 153   }
 154
 155   // Remove all lost packets.
 156   for (QuicPacketSequenceNumber packet = 1; packet < last_packet; packet++) {
 157     manager_.OnPacketRemoved(packet);
 158   }
 159   EXPECT_EQ(1u, CountPackets());
 160
 161   // Finally get the packet acknowledged.
 162   EXPECT_CALL(*delegate_, OnAckNotification(times_lost, total_size_lost, zero_))
 163       .Times(1);
 164   manager_.OnPacketAcked(last_packet, zero_);
 165   EXPECT_EQ(0u, CountPackets());
 166
 167   // Remove the last packet.
 168   manager_.OnPacketRemoved(last_packet);
 169   EXPECT_EQ(0u, CountPackets());
 170 }
 171
 172 }  // namespace
 173 }  // namespace test
 174 }  // namespace net