Fix division by zero in NonlinearBeamformer

webrtc/modules/audio_processing/beamformer/nonlinear_beamformer_unittest.cc

 /*
  *  Copyright (c) 2015 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 231 matching lines @@
                     bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
                     bf.interf_angles_radians_[1]);
     bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
   }
 }
 
-// TODO(peah): Reenable all bitexactness tests once the division-by-zero issue
-// has been resolved.
-
 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in
 // this setup.
 TEST(BeamformerBitExactnessTest,
      DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection1) {
   const float kOutputReference[] = {0.001318f, -0.001091f, 0.000990f,
                                     0.001318f, -0.001091f, 0.000990f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo16kHz_ArrayGeometry1_TargetDirection1) {
+     Stereo16kHz_ArrayGeometry1_TargetDirection1) {
   const float kOutputReference[] = {0.000064f, 0.000211f, 0.000075f,
                                     0.000064f, 0.000211f, 0.000075f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo32kHz_ArrayGeometry1_TargetDirection1) {
+     Stereo32kHz_ArrayGeometry1_TargetDirection1) {
   const float kOutputReference[] = {0.000183f, 0.000183f, 0.000183f,
                                     0.000183f, 0.000183f, 0.000183f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo48kHz_ArrayGeometry1_TargetDirection1) {
+     Stereo48kHz_ArrayGeometry1_TargetDirection1) {
   const float kOutputReference[] = {0.000155f, 0.000152f, 0.000159f,
                                     0.000155f, 0.000152f, 0.000159f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in
 // this setup.
 TEST(BeamformerBitExactnessTest,
      DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection2) {
   const float kOutputReference[] = {0.001144f,  -0.001026f, 0.001074f,
                                     -0.016205f, -0.007324f, -0.015656f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo16kHz_ArrayGeometry1_TargetDirection2) {
+     Stereo16kHz_ArrayGeometry1_TargetDirection2) {
   const float kOutputReference[] = {0.001144f, -0.001026f, 0.001074f,
                                     0.001144f, -0.001026f, 0.001074f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo32kHz_ArrayGeometry1_TargetDirection2) {
+     Stereo32kHz_ArrayGeometry1_TargetDirection2) {
   const float kOutputReference[] = {0.000732f, -0.000397f, 0.000610f,
                                     0.000732f, -0.000397f, 0.000610f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo48kHz_ArrayGeometry1_TargetDirection2) {
+     Stereo48kHz_ArrayGeometry1_TargetDirection2) {
   const float kOutputReference[] = {0.000106f, -0.000464f, 0.000188f,
                                     0.000106f, -0.000464f, 0.000188f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo8kHz_ArrayGeometry2_TargetDirection2) {
+     Stereo8kHz_ArrayGeometry2_TargetDirection2) {
   const float kOutputReference[] = {-0.000649f, 0.000576f, -0.000148f,
                                     -0.000649f, 0.000576f, -0.000148f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo16kHz_ArrayGeometry2_TargetDirection2) {
+     Stereo16kHz_ArrayGeometry2_TargetDirection2) {
   const float kOutputReference[] = {0.000808f, -0.000695f, 0.000739f,
                                     0.000808f, -0.000695f, 0.000739f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo32kHz_ArrayGeometry2_TargetDirection2) {
+     Stereo32kHz_ArrayGeometry2_TargetDirection2) {
   const float kOutputReference[] = {0.000580f, -0.000183f, 0.000458f,
                                     0.000580f, -0.000183f, 0.000458f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
-     DISABLED_Stereo48kHz_ArrayGeometry2_TargetDirection2) {
+     Stereo48kHz_ArrayGeometry2_TargetDirection2) {
   const float kOutputReference[] = {0.000075f, -0.000288f, 0.000156f,
                                     0.000075f, -0.000288f, 0.000156f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in
 // this setup.
 TEST(BeamformerBitExactnessTest,
      DISABLED_Stereo16kHz_ArrayGeometry3_TargetDirection1) {
   const float kOutputReference[] = {-0.000161f, 0.000171f, -0.000096f,
                                     0.001007f,  0.000427f, 0.000977f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(3),
                       TargetDirection1, kOutputReference);
 }
 
 }  // namespace webrtc