NetEq: Rename Nack to NackTracker to avoid name collisions in GN

webrtc/modules/audio_coding/neteq/nack_tracker_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "webrtc/modules/audio_coding/neteq/nack.h"
+#include "webrtc/modules/audio_coding/neteq/nack_tracker.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/typedefs.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module_typedefs.h"
 
@@ skipping 25 matching lines @@
       }
     }
     if (!seq_num_matched)
       return false;
   }
   return true;
 }
 
 }  // namespace
 
-TEST(NackTest, EmptyListWhenNoPacketLoss) {
-  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+TEST(NackTrackerTest, EmptyListWhenNoPacketLoss) {
+  std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
 
   int seq_num = 1;
   uint32_t timestamp = 0;
 
   std::vector<uint16_t> nack_list;
   for (int n = 0; n < 100; n++) {
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     seq_num++;
     timestamp += kTimestampIncrement;
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
   }
 }
 
-TEST(NackTest, NoNackIfReorderWithinNackThreshold) {
-  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+TEST(NackTrackerTest, NoNackIfReorderWithinNackThreshold) {
+  std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
 
   int seq_num = 1;
   uint32_t timestamp = 0;
   std::vector<uint16_t> nack_list;
 
   nack->UpdateLastReceivedPacket(seq_num, timestamp);
   nack_list = nack->GetNackList(kShortRoundTripTimeMs);
   EXPECT_TRUE(nack_list.empty());
   int num_late_packets = kNackThreshold + 1;
 
   // Push in reverse order
   while (num_late_packets > 0) {
     nack->UpdateLastReceivedPacket(
         seq_num + num_late_packets,
         timestamp + num_late_packets * kTimestampIncrement);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
     num_late_packets--;
   }
 }
 
-TEST(NackTest, LatePacketsMovedToNackThenNackListDoesNotChange) {
+TEST(NackTrackerTest, LatePacketsMovedToNackThenNackListDoesNotChange) {
   const uint16_t kSequenceNumberLostPackets[] = {2, 3, 4, 5, 6, 7, 8, 9};
   static const int kNumAllLostPackets = sizeof(kSequenceNumberLostPackets) /
                                         sizeof(kSequenceNumberLostPackets[0]);
 
   for (int k = 0; k < 2; k++) {  // Two iteration with/without wrap around.
-    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t sequence_num_lost_packets[kNumAllLostPackets];
     for (int n = 0; n < kNumAllLostPackets; n++) {
       sequence_num_lost_packets[n] =
           kSequenceNumberLostPackets[n] +
           k * 65531;  // Have wrap around in sequence numbers for |k == 1|.
     }
     uint16_t seq_num = sequence_num_lost_packets[0] - 1;
 
@@ skipping 22 matching lines @@
       nack->UpdateLastReceivedPacket(seq_num, timestamp);
       nack_list = nack->GetNackList(kShortRoundTripTimeMs);
       EXPECT_TRUE(IsNackListCorrect(nack_list, sequence_num_lost_packets,
                                     kNumAllLostPackets));
       seq_num++;
       timestamp += kTimestampIncrement;
     }
   }
 }
 
-TEST(NackTest, ArrivedPacketsAreRemovedFromNackList) {
+TEST(NackTrackerTest, ArrivedPacketsAreRemovedFromNackList) {
   const uint16_t kSequenceNumberLostPackets[] = {2, 3, 4, 5, 6, 7, 8, 9};
   static const int kNumAllLostPackets = sizeof(kSequenceNumberLostPackets) /
                                         sizeof(kSequenceNumberLostPackets[0]);
 
   for (int k = 0; k < 2; ++k) {  // Two iteration with/without wrap around.
-    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t sequence_num_lost_packets[kNumAllLostPackets];
     for (int n = 0; n < kNumAllLostPackets; ++n) {
       sequence_num_lost_packets[n] = kSequenceNumberLostPackets[n] +
                                      k * 65531;  // Wrap around for |k == 1|.
     }
 
     uint16_t seq_num = sequence_num_lost_packets[0] - 1;
     uint32_t timestamp = 0;
@@ skipping 34 matching lines @@
       EXPECT_TRUE(IsNackListCorrect(
           nack_list, &sequence_num_lost_packets[index_retransmitted_rtp],
           num_lost_packets - 1));  // One less lost packet in the list.
     }
     ASSERT_TRUE(nack_list.empty());
   }
 }
 
 // Assess if estimation of timestamps and time-to-play is correct. Introduce all
 // combinations that timestamps and sequence numbers might have wrap around.
-TEST(NackTest, EstimateTimestampAndTimeToPlay) {
+TEST(NackTrackerTest, EstimateTimestampAndTimeToPlay) {
   const uint16_t kLostPackets[] = {2, 3,  4,  5,  6,  7,  8,
                                    9, 10, 11, 12, 13, 14, 15};
   static const int kNumAllLostPackets =
       sizeof(kLostPackets) / sizeof(kLostPackets[0]);
 
   for (int k = 0; k < 4; ++k) {
-    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     // Sequence number wrap around if |k| is 2 or 3;
     int seq_num_offset = (k < 2) ? 0 : 65531;
 
     // Timestamp wrap around if |k| is 1 or 3.
     uint32_t timestamp_offset =
         (k & 0x1) ? static_cast<uint32_t>(0xffffffff) - 6 : 0;
 
     uint32_t timestamp_lost_packets[kNumAllLostPackets];
@@ skipping 16 matching lines @@
     seq_num++;
     timestamp += kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     // A packet after the last one which is supposed to be lost.
     seq_num = seq_num_lost_packets[kNumAllLostPackets - 1] + 1;
     timestamp =
         timestamp_lost_packets[kNumAllLostPackets - 1] + kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
-    Nack::NackList nack_list = nack->GetNackList();
+    NackTracker::NackList nack_list = nack->GetNackList();
     EXPECT_EQ(static_cast<size_t>(kNumAllLostPackets), nack_list.size());
 
     // Pretend the first packet is decoded.
     nack->UpdateLastDecodedPacket(first_seq_num, first_timestamp);
     nack_list = nack->GetNackList();
 
-    Nack::NackList::iterator it = nack_list.begin();
+    NackTracker::NackList::iterator it = nack_list.begin();
     while (it != nack_list.end()) {
       seq_num = it->first - seq_num_offset;
       int index = seq_num - kLostPackets[0];
       EXPECT_EQ(timestamp_lost_packets[index], it->second.estimated_timestamp);
       EXPECT_EQ((index + 2) * kPacketSizeMs, it->second.time_to_play_ms);
       ++it;
     }
 
     // Pretend 10 ms is passed, and we had pulled audio from NetEq, it still
     // reports the same sequence number as decoded, time-to-play should be
     // updated by 10 ms.
     nack->UpdateLastDecodedPacket(first_seq_num, first_timestamp);
     nack_list = nack->GetNackList();
     it = nack_list.begin();
     while (it != nack_list.end()) {
       seq_num = it->first - seq_num_offset;
       int index = seq_num - kLostPackets[0];
       EXPECT_EQ((index + 2) * kPacketSizeMs - 10, it->second.time_to_play_ms);
       ++it;
     }
   }
 }
 
-TEST(NackTest, MissingPacketsPriorToLastDecodedRtpShouldNotBeInNackList) {
+TEST(NackTrackerTest,
+     MissingPacketsPriorToLastDecodedRtpShouldNotBeInNackList) {
   for (int m = 0; m < 2; ++m) {
     uint16_t seq_num_offset = (m == 0) ? 0 : 65531;  // Wrap around if |m| is 1.
-    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     // Two consecutive packets to have a correct estimate of timestamp increase.
     uint16_t seq_num = 0;
     nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
                                    seq_num * kTimestampIncrement);
     seq_num++;
     nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
                                    seq_num * kTimestampIncrement);
 
@@ skipping 29 matching lines @@
     for (int n = 0; n < kNackThreshold + 10; ++n) {
       seq_num++;
       nack->UpdateLastReceivedPacket(seq_num_offset + seq_num,
                                      seq_num * kTimestampIncrement);
       nack_list = nack->GetNackList(kShortRoundTripTimeMs);
       EXPECT_TRUE(nack_list.empty());
     }
   }
 }
 
-TEST(NackTest, Reset) {
-  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+TEST(NackTrackerTest, Reset) {
+  std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
 
   // Two consecutive packets to have a correct estimate of timestamp increase.
   uint16_t seq_num = 0;
   nack->UpdateLastReceivedPacket(seq_num, seq_num * kTimestampIncrement);
   seq_num++;
   nack->UpdateLastReceivedPacket(seq_num, seq_num * kTimestampIncrement);
 
   // Skip 10 packets (larger than NACK threshold).
   const int kNumLostPackets = 10;
   seq_num += kNumLostPackets + 1;
   nack->UpdateLastReceivedPacket(seq_num, seq_num * kTimestampIncrement);
 
   const size_t kExpectedListSize = kNumLostPackets - kNackThreshold;
   std::vector<uint16_t> nack_list = nack->GetNackList(kShortRoundTripTimeMs);
   EXPECT_EQ(kExpectedListSize, nack_list.size());
 
   nack->Reset();
   nack_list = nack->GetNackList(kShortRoundTripTimeMs);
   EXPECT_TRUE(nack_list.empty());
 }
 
-TEST(NackTest, ListSizeAppliedFromBeginning) {
+TEST(NackTrackerTest, ListSizeAppliedFromBeginning) {
   const size_t kNackListSize = 10;
   for (int m = 0; m < 2; ++m) {
     uint16_t seq_num_offset = (m == 0) ? 0 : 65525;  // Wrap around if |m| is 1.
-    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
     nack->SetMaxNackListSize(kNackListSize);
 
     uint16_t seq_num = seq_num_offset;
     uint32_t timestamp = 0x12345678;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     // Packet lost more than NACK-list size limit.
     uint16_t num_lost_packets = kNackThreshold + kNackListSize + 5;
 
     seq_num += num_lost_packets + 1;
     timestamp += (num_lost_packets + 1) * kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     std::vector<uint16_t> nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_EQ(kNackListSize - kNackThreshold, nack_list.size());
   }
 }
 
-TEST(NackTest, ChangeOfListSizeAppliedAndOldElementsRemoved) {
+TEST(NackTrackerTest, ChangeOfListSizeAppliedAndOldElementsRemoved) {
   const size_t kNackListSize = 10;
   for (int m = 0; m < 2; ++m) {
     uint16_t seq_num_offset = (m == 0) ? 0 : 65525;  // Wrap around if |m| is 1.
-    std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+    std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
     nack->UpdateSampleRate(kSampleRateHz);
 
     uint16_t seq_num = seq_num_offset;
     uint32_t timestamp = 0x87654321;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
     // Packet lost more than NACK-list size limit.
     uint16_t num_lost_packets = kNackThreshold + kNackListSize + 5;
 
     std::unique_ptr<uint16_t[]> seq_num_lost(new uint16_t[num_lost_packets]);
@@ skipping 43 matching lines @@
 
     // After this packet, NACK list should be empty.
     ++seq_num;
     timestamp += kTimestampIncrement;
     nack->UpdateLastReceivedPacket(seq_num, timestamp);
     nack_list = nack->GetNackList(kShortRoundTripTimeMs);
     EXPECT_TRUE(nack_list.empty());
   }
 }
 
-TEST(NackTest, RoudTripTimeIsApplied) {
+TEST(NackTrackerTest, RoudTripTimeIsApplied) {
   const int kNackListSize = 200;
-  std::unique_ptr<Nack> nack(Nack::Create(kNackThreshold));
+  std::unique_ptr<NackTracker> nack(NackTracker::Create(kNackThreshold));
   nack->UpdateSampleRate(kSampleRateHz);
   nack->SetMaxNackListSize(kNackListSize);
 
   uint16_t seq_num = 0;
   uint32_t timestamp = 0x87654321;
   nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
   // Packet lost more than NACK-list size limit.
   uint16_t kNumLostPackets = kNackThreshold + 5;
 
   seq_num += (1 + kNumLostPackets);
   timestamp += (1 + kNumLostPackets) * kTimestampIncrement;
   nack->UpdateLastReceivedPacket(seq_num, timestamp);
 
   // Expected time-to-play are:
   // kPacketSizeMs - 10, 2*kPacketSizeMs - 10, 3*kPacketSizeMs - 10, ...
   //
   // sequence number:  1,  2,  3,   4,   5
   // time-to-play:    20, 50, 80, 110, 140
   //
   std::vector<uint16_t> nack_list = nack->GetNackList(100);
   ASSERT_EQ(2u, nack_list.size());
   EXPECT_EQ(4, nack_list[0]);
   EXPECT_EQ(5, nack_list[1]);
 }
 
 }  // namespace webrtc