Renamed the test::BitExactFrame method to test::VectorDifferenceBounded.

webrtc/modules/audio_processing/test/bitexactness_tools.cc

 /*
  *  Copyright (c) 2016 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 52 matching lines @@
 
   // Convert samples to float and discard any channels not needed.
   for (size_t sample = 0; sample < samples_per_channel; ++sample) {
     for (size_t channel = 0; channel < num_channels; ++channel) {
       data[sample * num_channels + channel] =
           read_samples[sample * 2 + channel] / 32768.0f;
     }
   }
 }
 
-::testing::AssertionResult BitExactFrame(size_t samples_per_channel,
-                                         size_t num_channels,
-                                         rtc::ArrayView<const float> reference,
-                                         rtc::ArrayView<const float> output,
-                                         float tolerance) {
+::testing::AssertionResult StackedFrameDifferenceBounded(
+    size_t samples_per_channel,
+    size_t num_channels,
+    rtc::ArrayView<const float> reference,
+    rtc::ArrayView<const float> output,
+    float element_error_bound) {
   // Form vectors to compare the reference to. Only the first values of the
   // outputs are compared in order not having to specify all preceeding frames
   // as testvectors.
   const size_t reference_frame_length =
       rtc::CheckedDivExact(reference.size(), num_channels);
 
   std::vector<float> output_to_verify;
   for (size_t channel_no = 0; channel_no < num_channels; ++channel_no) {
     output_to_verify.insert(output_to_verify.end(),
                             output.begin() + channel_no * samples_per_channel,
                             output.begin() + channel_no * samples_per_channel +
                                 reference_frame_length);
   }
 
-  return BitExactVector(reference, output_to_verify, tolerance);
+  return VectorDifferenceBounded(reference, output_to_verify,
+                                 element_error_bound);
 }
 
-::testing::AssertionResult BitExactVector(rtc::ArrayView<const float> reference,
-                                          rtc::ArrayView<const float> output,
-                                          float tolerance) {
+::testing::AssertionResult VectorDifferenceBounded(
+    rtc::ArrayView<const float> reference,
+    rtc::ArrayView<const float> output,
+    float element_error_bound) {
   // The vectors are deemed to be bitexact only if
   // a) output have a size at least as long as the reference.
   // b) the samples in the reference are bitexact with the corresponding samples
   //    in the output.
 
   bool equal = true;
   if (output.size() < reference.size()) {
     equal = false;
   } else {
     // Compare the first samples in the vectors.
     for (size_t k = 0; k < reference.size(); ++k) {
-      if (fabs(output[k] - reference[k]) > tolerance) {
+      if (fabs(output[k] - reference[k]) > element_error_bound) {
         equal = false;
         break;
       }
     }
   }
 
   if (equal) {
     return ::testing::AssertionSuccess();
   }
 
@@ skipping 16 matching lines @@
          << "    Actual values : "
          << print_vector_in_c_format(output,
                                      std::min(output.size(), reference.size()))
          << std::endl
          << "    Expected values: "
          << print_vector_in_c_format(reference, reference.size()) << std::endl;
 }
 
 }  // namespace test
 }  // namespace webrtc