Convert test_fec to gtest

All tests needs to be gtest tests in order to be executed
with the upcoming isolate/swarm framework.

TEST=trybots passing
BUG=1916
R=andrew@webrtc.org, marpan@google.com

Review URL: https://webrtc-codereview.appspot.com/1647005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4218 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

@@ -20,6 +20,7 @@
 #include <ctime>
 #include <list>
 
+#include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/rtp_rtcp/source/fec_private_tables_bursty.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
@@ -29,14 +30,51 @@
 
 //#define VERBOSE_OUTPUT
 
-using namespace webrtc;
+namespace webrtc {
+namespace test {
 
 void ReceivePackets(
     ForwardErrorCorrection::ReceivedPacketList* toDecodeList,
     ForwardErrorCorrection::ReceivedPacketList* receivedPacketList,
-    uint32_t numPacketsToDecode, float reorderRate, float duplicateRate);
+    uint32_t numPacketsToDecode, float reorderRate, float duplicateRate) {
+  assert(toDecodeList->empty());
+  assert(numPacketsToDecode <= receivedPacketList->size());
 
-int main() {
+  ForwardErrorCorrection::ReceivedPacketList::iterator it;
+  for (uint32_t i = 0; i < numPacketsToDecode; i++) {
+    it = receivedPacketList->begin();
+    // Reorder packets.
+    float randomVariable = static_cast<float>(rand()) / RAND_MAX;
+    while (randomVariable < reorderRate) {
+      ++it;
+      if (it == receivedPacketList->end()) {
+        --it;
+        break;
+      }
+      randomVariable = static_cast<float>(rand()) / RAND_MAX;
+    }
+    ForwardErrorCorrection::ReceivedPacket* receivedPacket = *it;
+    toDecodeList->push_back(receivedPacket);
+
+    // Duplicate packets.
+    randomVariable = static_cast<float>(rand()) / RAND_MAX;
+    while (randomVariable < duplicateRate) {
+      ForwardErrorCorrection::ReceivedPacket* duplicatePacket =
+          new ForwardErrorCorrection::ReceivedPacket;
+      *duplicatePacket = *receivedPacket;
+      duplicatePacket->pkt = new ForwardErrorCorrection::Packet;
+      memcpy(duplicatePacket->pkt->data, receivedPacket->pkt->data,
+             receivedPacket->pkt->length);
+      duplicatePacket->pkt->length = receivedPacket->pkt->length;
+
+      toDecodeList->push_back(duplicatePacket);
+      randomVariable = static_cast<float>(rand()) / RAND_MAX;
+    }
+    receivedPacketList->erase(it);
+  }
+}
+
+TEST(FecTest, FecTest) {
   // TODO(marpan): Split this function into subroutines/helper functions.
   enum {
     kMaxNumberMediaPackets = 48
@@ -63,10 +101,8 @@ int main() {
   const uint16_t kMaxMediaPackets[] = {kMaxNumberMediaPackets,
       sizeof(kPacketMaskBurstyTbl) / sizeof(*kPacketMaskBurstyTbl)};
 
-  if (kMaxMediaPackets[1] != 12) {
+  ASSERT_EQ(12, kMaxMediaPackets[1]) << "Max media packets for bursty mode not "
-    printf("ERROR: max media packets for bursty mode not equal to 12 \n");
+                                     << "equal to 12.";
-    return -1;
-  }
 
   uint32_t id = 0;
   ForwardErrorCorrection fec(id);
@@ -178,20 +214,14 @@ int main() {
               for (uint32_t j = 0; j < rowLimit; ++j) {
                 rowSum += fecPacketMasks[i][j];
               }
-              if (rowSum == 0) {
+              ASSERT_NE(0u, rowSum) << "Row is all zero " << i;
-                printf("ERROR: row is all zero %d \n", i);
-                return -1;
-              }
             }
             for (uint32_t j = 0; j < rowLimit; ++j) {
               uint32_t columnSum = 0;
               for (uint32_t i = 0; i < numFecPackets; ++i) {
                 columnSum += fecPacketMasks[i][j];
               }
-              if (columnSum == 0) {
+              ASSERT_NE(0u, columnSum) << "Column is all zero " << j;
-                printf("ERROR: column is all zero %d \n", j);
-                return -1;
-              }
             }
 
             // Construct media packets.
@@ -239,20 +269,14 @@ int main() {
             }
             mediaPacket->data[1] |= 0x80;
 
-            if (fec.GenerateFEC(mediaPacketList, protectionFactor,
+            ASSERT_EQ(0, fec.GenerateFEC(mediaPacketList, protectionFactor,
-                                numImpPackets, kUseUnequalProtection,
+                                         numImpPackets, kUseUnequalProtection,
-                                fec_mask_type, &fecPacketList) != 0) {
+                                         fec_mask_type, &fecPacketList))
-              printf("Error: GenerateFEC() failed\n");
+                << "GenerateFEC() failed";
-              return -1;
-            }
 
-            if (fecPacketList.size() != numFecPackets) {
+            ASSERT_EQ(numFecPackets, fecPacketList.size())
-              printf("Error: we requested %u FEC packets, "
+                << "We requested " << numFecPackets << " FEC packets, but "
-                     "but GenerateFEC() produced %u\n",
+                << "GenerateFEC() produced " << fecPacketList.size();
-                     numFecPackets,
-                     static_cast<uint32_t>(fecPacketList.size()));
-              return -1;
-            }
             memset(mediaLossMask, 0, sizeof(mediaLossMask));
             ForwardErrorCorrection::PacketList::iterator mediaPacketListItem =
                 mediaPacketList.begin();
@@ -380,14 +404,10 @@ int main() {
                   ++toDecodeIt;
                 }
               }
-              if (fec.DecodeFEC(&toDecodeList, &recoveredPacketList) != 0) {
+              ASSERT_EQ(0, fec.DecodeFEC(&toDecodeList, &recoveredPacketList))
-                printf("Error: DecodeFEC() failed\n");
+                  << "DecodeFEC() failed";
-                return -1;
+              ASSERT_TRUE(toDecodeList.empty())
-              }
+                  << "Received packet list is not empty.";
-              if (!toDecodeList.empty()) {
-                printf("Error: received packet list is not empty\n");
-                return -1;
-              }
             }
             mediaPacketListItem = mediaPacketList.begin();
             mediaPacketIdx = 0;
@@ -397,25 +417,20 @@ int main() {
                 ForwardErrorCorrection::RecoveredPacketList::iterator
                 recoveredPacketListItem = recoveredPacketList.begin();
 
-                if (recoveredPacketListItem == recoveredPacketList.end()) {
+                ASSERT_FALSE(
-                  printf("Error: insufficient number of recovered packets.\n");
+                    recoveredPacketListItem == recoveredPacketList.end())
-                  return -1;
+                  << "Insufficient number of recovered packets.";
-                }
                 mediaPacket = *mediaPacketListItem;
                 ForwardErrorCorrection::RecoveredPacket* recoveredPacket =
                     *recoveredPacketListItem;
 
-                if (recoveredPacket->pkt->length != mediaPacket->length) {
+                ASSERT_EQ(recoveredPacket->pkt->length, mediaPacket->length)
-                  printf("Error: recovered packet length not identical to "
+                    << "Recovered packet length not identical to original "
-                         "original media packet\n");
+                    << "media packet";
-                  return -1;
+                ASSERT_EQ(0, memcmp(recoveredPacket->pkt->data,
-                }
+                                    mediaPacket->data, mediaPacket->length))
-                if (memcmp(recoveredPacket->pkt->data, mediaPacket->data,
+                    << "Recovered packet payload not identical to original "
-                           mediaPacket->length) != 0) {
+                    << "media packet";
-                  printf("Error: recovered packet payload not identical to "
-                         "original media packet\n");
-                  return -1;
-                }
                 delete recoveredPacket;
                 recoveredPacketList.pop_front();
               }
@@ -423,12 +438,9 @@ int main() {
               ++mediaPacketListItem;
             }
             fec.ResetState(&recoveredPacketList);
-            if (!recoveredPacketList.empty()) {
+            ASSERT_TRUE(recoveredPacketList.empty())
-              printf("Error: excessive number of recovered packets.\n");
+                << "Excessive number of recovered packets.\t size is: "
-              printf("\t size is:%u\n",
+                << recoveredPacketList.size();
-                     static_cast<uint32_t>(recoveredPacketList.size()));
-              return -1;
-            }
             // -- Teardown --
             mediaPacketListItem = mediaPacketList.begin();
             while (mediaPacketListItem != mediaPacketList.end()) {
@@ -469,51 +481,9 @@ int main() {
 
   // Have DecodeFEC free allocated memory.
   fec.ResetState(&recoveredPacketList);
-  if (!recoveredPacketList.empty()) {
+  ASSERT_TRUE(recoveredPacketList.empty())
-    printf("Error: recovered packet list is not empty\n");
+      << "Recovered packet list is not empty";
-    return -1;
-  }
-  printf("\nAll tests passed successfully\n");
-  return 0;
 }
 
-void ReceivePackets(
+}  // namespace test
-    ForwardErrorCorrection::ReceivedPacketList* toDecodeList,
+}  // namespace webrtc
-    ForwardErrorCorrection::ReceivedPacketList* receivedPacketList,
-    uint32_t numPacketsToDecode, float reorderRate, float duplicateRate) {
-  assert(toDecodeList->empty());
-  assert(numPacketsToDecode <= receivedPacketList->size());
-
-  ForwardErrorCorrection::ReceivedPacketList::iterator it;
-  for (uint32_t i = 0; i < numPacketsToDecode; i++) {
-    it = receivedPacketList->begin();
-    // Reorder packets.
-    float randomVariable = static_cast<float>(rand()) / RAND_MAX;
-    while (randomVariable < reorderRate) {
-      ++it;
-      if (it == receivedPacketList->end()) {
-        --it;
-        break;
-      }
-      randomVariable = static_cast<float>(rand()) / RAND_MAX;
-    }
-    ForwardErrorCorrection::ReceivedPacket* receivedPacket = *it;
-    toDecodeList->push_back(receivedPacket);
-
-    // Duplicate packets.
-    randomVariable = static_cast<float>(rand()) / RAND_MAX;
-    while (randomVariable < duplicateRate) {
-      ForwardErrorCorrection::ReceivedPacket* duplicatePacket =
-          new ForwardErrorCorrection::ReceivedPacket;
-      *duplicatePacket = *receivedPacket;
-      duplicatePacket->pkt = new ForwardErrorCorrection::Packet;
-      memcpy(duplicatePacket->pkt->data, receivedPacket->pkt->data,
-             receivedPacket->pkt->length);
-      duplicatePacket->pkt->length = receivedPacket->pkt->length;
-
-      toDecodeList->push_back(duplicatePacket);
-      randomVariable = static_cast<float>(rand()) / RAND_MAX;
-    }
-    receivedPacketList->erase(it);
-  }
-}