[rtp_rtcp] Lint errors cleared from rtp_rtcp/test

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

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 382 matching lines @@
     int num_media_packets = code_params_[code_index].num_media_packets;
     int num_fec_packets = code_params_[code_index].num_fec_packets;
     int tot_num_packets = num_media_packets + num_fec_packets;
     rtc::scoped_ptr<uint8_t[]> state(new uint8_t[tot_num_packets]);
     memset(state.get() , 0, tot_num_packets);
 
     int num_loss_configurations = static_cast<int>(pow(2.0f, tot_num_packets));
     // Loop over all loss configurations for the symbol sequence of length
     // |tot_num_packets|. In this version we process up to (k=12, m=12) codes,
     // and get exact expressions for the residual loss.
-    // TODO (marpan): For larger codes, loop over some random sample of loss
+    // TODO(marpan): For larger codes, loop over some random sample of loss
     // configurations, sampling driven by the underlying statistical loss model
     // (importance sampling).
 
     // The symbols/packets are arranged as a sequence of source/media packets
     // followed by FEC packets. This is the sequence ordering used in the RTP.
     // A configuration refers to a sequence of received/lost (0/1 bit) states
     // for the string of packets/symbols. For example, for a (k=4,m=3) code
     // (4 media packets, 3 FEC packets), with 2 losses (one media and one FEC),
     // the loss configurations is:
     // Media1   Media2   Media3   Media4   FEC1   FEC2   FEC3
     //   0         0        1       0        0      1     0
     for (int i = 1; i < num_loss_configurations; i++) {
       // Counter for number of packets lost.
       int num_packets_lost = 0;
       // Counters for the number of media packets lost.
       int num_media_packets_lost = 0;
 
       // Map configuration number to a loss state.
       for (int j = 0; j < tot_num_packets; j++) {
-        state[j]=0;  // Received state.
+        state[j] = 0;  // Received state.
         int bit_value = i >> (tot_num_packets - j - 1) & 1;
         if (bit_value == 1) {
           state[j] = 1;  // Lost state.
           num_packets_lost++;
            if (j < num_media_packets) {
              num_media_packets_lost++;
            }
         }
       }  // Done with loop over total number of packets.
       assert(num_media_packets_lost <= num_media_packets);
@@ skipping 412 matching lines @@
       float loss_rate = loss_model_[k].average_loss_rate;
       float protection_level = code_params_[code_index].protection_level;
       // Under these conditions we expect XOR to not be better than RS.
        if (loss_model_[k].loss_type == kRandomLossModel &&
            loss_rate <= protection_level) {
         EXPECT_GE(kMetricsXorRandom[code_index].average_residual_loss[k],
                   kMetricsReedSolomon[code_index].average_residual_loss[k]);
         EXPECT_GE(kMetricsXorBursty[code_index].average_residual_loss[k],
                   kMetricsReedSolomon[code_index].average_residual_loss[k]);
        }
-      // TODO (marpan): There are some cases (for high loss rates and/or
-      // burst loss models) where XOR is better than RS. Is there some pattern
-      // we can identify and enforce as a constraint?
+       // TODO(marpan): There are some cases (for high loss rates and/or
+       // burst loss models) where XOR is better than RS. Is there some pattern
+       // we can identify and enforce as a constraint?
     }
   }
 }
 
 // Verify the trend (change) in the average residual loss, as a function of
 // loss rate, of the XOR code relative to the RS code.
 // The difference between XOR and RS should not get worse as we increase
 // the average loss rate.
 TEST_F(FecPacketMaskMetricsTest, FecTrendXorVsRsLossRate) {
   SetLossModels();
   SetCodeParams();
-  // TODO (marpan): Examine this further to see if the condition can be strictly
+  // TODO(marpan): Examine this further to see if the condition can be strictly
   // satisfied (i.e., scale = 1.0) for all codes with different/better masks.
   double scale = 0.90;
   int num_loss_rates = sizeof(kAverageLossRate) /
       sizeof(*kAverageLossRate);
   int num_burst_lengths = sizeof(kAverageBurstLength) /
       sizeof(*kAverageBurstLength);
   for (int code_index = 0; code_index < max_num_codes_; code_index++) {
     for (int i = 0; i < num_burst_lengths; i++) {
       for (int j = 0; j < num_loss_rates - 1; j++) {
         int k = num_loss_rates * i + j;
         // For XOR random.
         if (kMetricsXorRandom[code_index].average_residual_loss[k] >
         kMetricsReedSolomon[code_index].average_residual_loss[k]) {
           double diff_rs_xor_random_loss1 =
               (kMetricsXorRandom[code_index].average_residual_loss[k] -
                kMetricsReedSolomon[code_index].average_residual_loss[k]) /
                kMetricsXorRandom[code_index].average_residual_loss[k];
           double diff_rs_xor_random_loss2 =
               (kMetricsXorRandom[code_index].average_residual_loss[k+1] -
                kMetricsReedSolomon[code_index].average_residual_loss[k+1]) /
                kMetricsXorRandom[code_index].average_residual_loss[k+1];
           EXPECT_GE(diff_rs_xor_random_loss1, scale * diff_rs_xor_random_loss2);
         }
-        // TODO (marpan): Investigate the cases for the bursty mask where
+        // TODO(marpan): Investigate the cases for the bursty mask where
         // this trend is not strictly satisfied.
       }
     }
   }
 }
 
 // Verify the average residual loss behavior via the protection level and
 // the code length. The average residual loss for a given (k1,m1) code
 // should generally be higher than that of another code (k2,m2), which has
 // either of the two conditions satisfied:
@@ skipping 18 matching lines @@
       // models, this condition may be violated for some codes with equal or
       // very close protection levels. High loss rate case is excluded below.
       if ((protection_level2 > protection_level1 && length2 >= length1) ||
           (protection_level2 == protection_level1 && length2 > length1)) {
         for (int k = 0; k < kNumLossModels; k++) {
           float loss_rate = loss_model_[k].average_loss_rate;
           if (loss_rate < loss_rate_upper_threshold) {
             EXPECT_LT(
                 kMetricsReedSolomon[code_index2].average_residual_loss[k],
                 kMetricsReedSolomon[code_index1].average_residual_loss[k]);
-            // TODO (marpan): There are some corner cases where this is not
+            // TODO(marpan): There are some corner cases where this is not
             // satisfied with the current packet masks. Look into updating
             // these cases to see if this behavior should/can be satisfied,
             // with overall lower residual loss for those XOR codes.
             // EXPECT_LT(
             //    kMetricsXorBursty[code_index2].average_residual_loss[k],
             //    kMetricsXorBursty[code_index1].average_residual_loss[k]);
             // EXPECT_LT(
             //   kMetricsXorRandom[code_index2].average_residual_loss[k],
             //   kMetricsXorRandom[code_index1].average_residual_loss[k]);
           }
         }
       }
     }
   }
 }
 
 // Verify the beheavior of the variance of the XOR codes.
 // The partial recovery of the XOR versus the all or nothing behavior of the RS
 // code means that the variance of the residual loss for XOR should generally
 // not be worse than RS.
 TEST_F(FecPacketMaskMetricsTest, FecVarianceBehaviorXorVsRs) {
   SetLossModels();
   SetCodeParams();
   // The condition is not strictly satisfied with the current masks,
   // i.e., for some codes, the variance of XOR may be slightly higher than RS.
-  // TODO (marpan): Examine this further to see if the condition can be strictly
+  // TODO(marpan): Examine this further to see if the condition can be strictly
   // satisfied (i.e., scale = 1.0) for all codes with different/better masks.
   double scale = 0.95;
   for (int code_index = 0; code_index < max_num_codes_; code_index++) {
     for (int k = 0; k < kNumLossModels; k++) {
       EXPECT_LE(scale *
                 kMetricsXorRandom[code_index].variance_residual_loss[k],
                 kMetricsReedSolomon[code_index].variance_residual_loss[k]);
       EXPECT_LE(scale *
                 kMetricsXorBursty[code_index].variance_residual_loss[k],
                 kMetricsReedSolomon[code_index].variance_residual_loss[k]);
@@ skipping 14 matching lines @@
       EXPECT_EQ(kMetricsXorBursty[code_index].
                 residual_loss_per_loss_gap[index], 0.0);
     }
   }
 }
 
 // The XOR codes with random mask type are generally better than the ones with
 // bursty mask type, for random loss models at low loss rates.
 // The XOR codes with bursty mask types are generally better than the one with
 // random mask type, for bursty loss models and/or high loss rates.
-// TODO (marpan): Enable this test when some of the packet masks are updated.
+// TODO(marpan): Enable this test when some of the packet masks are updated.
 // Some isolated cases of the codes don't pass this currently.
 /*
 TEST_F(FecPacketMaskMetricsTest, FecXorRandomVsBursty) {
   SetLossModels();
   SetCodeParams();
   for (int code_index = 0; code_index < max_num_codes_; code_index++) {
     double sum_residual_loss_random_mask_random_loss = 0.0;
     double sum_residual_loss_bursty_mask_random_loss = 0.0;
     double sum_residual_loss_random_mask_bursty_loss = 0.0;
     double sum_residual_loss_bursty_mask_bursty_loss = 0.0;
@@ skipping 67 matching lines @@
                 recovery_rate_per_loss[loss_number],
                 kRecoveryRateXorRandom[2]);
       EXPECT_GE(kMetricsXorBursty[code_index].
                 recovery_rate_per_loss[loss_number],
                 kRecoveryRateXorBursty[2]);
     }
   }
 }
 
 }  // namespace webrtc