Reenables several NetEq unittests on android.

webrtc/modules/audio_coding/neteq/neteq_stereo_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.
  */
 
@@ skipping 144 matching lines @@
         input_multi_channel_, frame_size_samples_ * num_channels_,
         encoded_multi_channel_);
     if (frame_size_samples_ * 2 * num_channels_ != multi_payload_size_bytes_) {
       return -1;
     }
     rtp_generator_.GetRtpHeader(kPayloadTypeMulti, frame_size_samples_,
                                 &rtp_header_);
     return next_send_time;
   }
 
-  void VerifyOutput(size_t num_samples) {
+  virtual void VerifyOutput(size_t num_samples) {
     for (size_t i = 0; i < num_samples; ++i) {
       for (int j = 0; j < num_channels_; ++j) {
         ASSERT_EQ(output_[i], output_multi_channel_[i * num_channels_ + j]) <<
             "Diff in sample " << i << ", channel " << j << ".";
       }
     }
   }
 
   virtual int GetArrivalTime(int send_time) {
     int arrival_time = last_arrival_time_ + (send_time - last_send_time_);
@@ skipping 93 matching lines @@
  protected:
   NetEqStereoTestNoJitter()
       : NetEqStereoTest() {
     // Start the sender 100 ms before the receiver to pre-fill the buffer.
     // This is to avoid doing preemptive expand early in the test.
     // TODO(hlundin): Mock the decision making instead to control the modes.
     last_arrival_time_ = -100;
   }
 };
 
-TEST_P(NetEqStereoTestNoJitter, DISABLED_ON_ANDROID(RunTest)) {
+TEST_P(NetEqStereoTestNoJitter, RunTest) {
   RunTest(8);
 }
 
 class NetEqStereoTestPositiveDrift : public NetEqStereoTest {
  protected:
   NetEqStereoTestPositiveDrift()
       : NetEqStereoTest(),
         drift_factor(0.9) {
     // Start the sender 100 ms before the receiver to pre-fill the buffer.
     // This is to avoid doing preemptive expand early in the test.
     // TODO(hlundin): Mock the decision making instead to control the modes.
     last_arrival_time_ = -100;
   }
   virtual int GetArrivalTime(int send_time) {
     int arrival_time = last_arrival_time_ +
         drift_factor * (send_time - last_send_time_);
     last_send_time_ = send_time;
     last_arrival_time_ = arrival_time;
     return arrival_time;
   }
 
   double drift_factor;
 };
 
-TEST_P(NetEqStereoTestPositiveDrift, DISABLED_ON_ANDROID(RunTest)) {
+TEST_P(NetEqStereoTestPositiveDrift, RunTest) {
   RunTest(100);
 }
 
 class NetEqStereoTestNegativeDrift : public NetEqStereoTestPositiveDrift {
  protected:
   NetEqStereoTestNegativeDrift()
       : NetEqStereoTestPositiveDrift() {
     drift_factor = 1.1;
     last_arrival_time_ = 0;
   }
 };
 
-TEST_P(NetEqStereoTestNegativeDrift, DISABLED_ON_ANDROID(RunTest)) {
+TEST_P(NetEqStereoTestNegativeDrift, RunTest) {
   RunTest(100);
 }
 
 class NetEqStereoTestDelays : public NetEqStereoTest {
  protected:
   static const int kDelayInterval = 10;
   static const int kDelay = 1000;
   NetEqStereoTestDelays()
       : NetEqStereoTest(),
         frame_index_(0) {
   }
 
   virtual int GetArrivalTime(int send_time) {
     // Deliver immediately, unless we have a back-log.
     int arrival_time = std::min(last_arrival_time_, send_time);
     if (++frame_index_ % kDelayInterval == 0) {
       // Delay this packet.
       arrival_time += kDelay;
     }
     last_send_time_ = send_time;
     last_arrival_time_ = arrival_time;
     return arrival_time;
   }
 
   int frame_index_;
 };
 
-TEST_P(NetEqStereoTestDelays, DISABLED_ON_ANDROID(RunTest)) {
+TEST_P(NetEqStereoTestDelays, RunTest) {
   RunTest(1000);
 }
 
 class NetEqStereoTestLosses : public NetEqStereoTest {
  protected:
   static const int kLossInterval = 10;
   NetEqStereoTestLosses()
       : NetEqStereoTest(),
         frame_index_(0) {
   }
 
   virtual bool Lost() {
     return (++frame_index_) % kLossInterval == 0;
   }
 
+  // TODO(hlundin): NetEq is not giving bitexact results for these cases.
+  virtual void VerifyOutput(size_t num_samples) {
+    for (size_t i = 0; i < num_samples; ++i) {
+      auto first_channel_sample = output_multi_channel_[i * num_channels_];
+      for (int j = 0; j < num_channels_; ++j) {
+        const int error_margin = 200;

[minyue-webrtc, 2015/12/18 15:32:29]

Nit: compiler time constant can name as kErrorMagin

[ivoc, 2016/01/18 15:36:46]

Done.

+        EXPECT_NEAR(output_[i], output_multi_channel_[i * num_channels_ + j],
+                    error_margin)
+            << "Diff in sample " << i << ", channel " << j << ".";
+        EXPECT_EQ(first_channel_sample,
+                  output_multi_channel_[i * num_channels_ + j]);
+      }
+    }
+  }
+
   int frame_index_;
 };
 
-TEST_P(NetEqStereoTestLosses, DISABLED_ON_ANDROID(RunTest)) {
+TEST_P(NetEqStereoTestLosses, RunTest) {
   RunTest(100);
 }
 
 
 // Creates a list of parameter sets.
 std::list<TestParameters> GetTestParameters() {
   std::list<TestParameters> l;
   const int sample_rates[] = {8000, 16000, 32000};
   const int num_rates = sizeof(sample_rates) / sizeof(sample_rates[0]);
   // Loop through sample rates.
@@ skipping 39 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(MultiChannel,
                         NetEqStereoTestDelays,
                         ::testing::ValuesIn(GetTestParameters()));
 
 INSTANTIATE_TEST_CASE_P(MultiChannel,
                         NetEqStereoTestLosses,
                         ::testing::ValuesIn(GetTestParameters()));
 
 }  // namespace webrtc