Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_processing/utility/delay_estimator_unittest.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 43 matching lines @@
   int spectrum_size_;
   // Dummy input spectra.
   float far_f_[kSpectrumSize];
   float near_f_[kSpectrumSize];
   uint16_t far_u16_[kSpectrumSize];
   uint16_t near_u16_[kSpectrumSize];
   uint32_t binary_spectrum_[kSequenceLength + kHistorySize];
 };
 
 DelayEstimatorTest::DelayEstimatorTest()
-    : handle_(NULL),
-      self_(NULL),
-      farend_handle_(NULL),
-      farend_self_(NULL),
-      binary_(NULL),
-      binary_farend_(NULL),
+    : handle_(nullptr),
+      self_(nullptr),
+      farend_handle_(nullptr),
+      farend_self_(nullptr),
+      binary_(nullptr),
+      binary_farend_(nullptr),
       spectrum_size_(kSpectrumSize) {
   // Dummy input data are set with more or less arbitrary non-zero values.
   memset(far_f_, 1, sizeof(far_f_));
   memset(near_f_, 2, sizeof(near_f_));
   memset(far_u16_, 1, sizeof(far_u16_));
   memset(near_u16_, 2, sizeof(near_u16_));
   // Construct a sequence of binary spectra used to verify delay estimate. The
   // |kSequenceLength| has to be long enough for the delay estimation to leave
   // the initialized state.
   binary_spectrum_[0] = 1;
   for (int i = 1; i < (kSequenceLength + kHistorySize); i++) {
     binary_spectrum_[i] = 3 * binary_spectrum_[i - 1];
   }
 }
 
 void DelayEstimatorTest::SetUp() {
   farend_handle_ = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize,
                                                      kHistorySize);
-  ASSERT_TRUE(farend_handle_ != NULL);
+  ASSERT_TRUE(farend_handle_ != nullptr);
   farend_self_ = reinterpret_cast<DelayEstimatorFarend*>(farend_handle_);
   handle_ = WebRtc_CreateDelayEstimator(farend_handle_, kLookahead);
-  ASSERT_TRUE(handle_ != NULL);
+  ASSERT_TRUE(handle_ != nullptr);
   self_ = reinterpret_cast<DelayEstimator*>(handle_);
   binary_farend_ = WebRtc_CreateBinaryDelayEstimatorFarend(kHistorySize);
-  ASSERT_TRUE(binary_farend_ != NULL);
+  ASSERT_TRUE(binary_farend_ != nullptr);
   binary_ = WebRtc_CreateBinaryDelayEstimator(binary_farend_, kLookahead);
-  ASSERT_TRUE(binary_ != NULL);
+  ASSERT_TRUE(binary_ != nullptr);
 }
 
 void DelayEstimatorTest::TearDown() {
   WebRtc_FreeDelayEstimator(handle_);
-  handle_ = NULL;
-  self_ = NULL;
+  handle_ = nullptr;
+  self_ = nullptr;
   WebRtc_FreeDelayEstimatorFarend(farend_handle_);
-  farend_handle_ = NULL;
-  farend_self_ = NULL;
+  farend_handle_ = nullptr;
+  farend_self_ = nullptr;
   WebRtc_FreeBinaryDelayEstimator(binary_);
-  binary_ = NULL;
+  binary_ = nullptr;
   WebRtc_FreeBinaryDelayEstimatorFarend(binary_farend_);
-  binary_farend_ = NULL;
+  binary_farend_ = nullptr;
 }
 
 void DelayEstimatorTest::Init() {
   // Initialize Delay Estimator
   EXPECT_EQ(0, WebRtc_InitDelayEstimatorFarend(farend_handle_));
   EXPECT_EQ(0, WebRtc_InitDelayEstimator(handle_));
   // Verify initialization.
   EXPECT_EQ(0, farend_self_->far_spectrum_initialized);
   EXPECT_EQ(0, self_->near_spectrum_initialized);
   EXPECT_EQ(-2, WebRtc_last_delay(handle_));  // Delay in initial state.
@@ skipping 87 matching lines @@
   // For non-causal systems the delay is equivalent with a negative |offset| of
   // the far-end sequence.
   binary_->robust_validation_enabled = ref_robust_validation;
   binary2->robust_validation_enabled = robust_validation;
   for (int offset = -kLookahead;
       offset < kMaxDelay - lookahead_offset - near_offset;
       offset++) {
     RunBinarySpectra(binary_, binary2, near_offset, lookahead_offset, offset);
   }
   WebRtc_FreeBinaryDelayEstimator(binary2);
-  binary2 = NULL;
+  binary2 = nullptr;
   binary_->robust_validation_enabled = 0;  // Reset reference.
 }
 
 TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfWrapper) {
   // In this test we verify correct error returns on invalid API calls.
 
   // WebRtc_CreateDelayEstimatorFarend() and WebRtc_CreateDelayEstimator()
-  // should return a NULL pointer on invalid input values.
-  // Make sure we have a non-NULL value at start, so we can detect NULL after
+  // should return a null pointer on invalid input values.
+  // Make sure we have a non-null value at start, so we can detect null after
   // create failure.
   void* handle = farend_handle_;
   handle = WebRtc_CreateDelayEstimatorFarend(33, kHistorySize);
-  EXPECT_TRUE(handle == NULL);
+  EXPECT_TRUE(handle == nullptr);
   handle = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize, 1);
-  EXPECT_TRUE(handle == NULL);
+  EXPECT_TRUE(handle == nullptr);
 
   handle = handle_;
-  handle = WebRtc_CreateDelayEstimator(NULL, kLookahead);
-  EXPECT_TRUE(handle == NULL);
+  handle = WebRtc_CreateDelayEstimator(nullptr, kLookahead);
+  EXPECT_TRUE(handle == nullptr);
   handle = WebRtc_CreateDelayEstimator(farend_handle_, -1);
-  EXPECT_TRUE(handle == NULL);
+  EXPECT_TRUE(handle == nullptr);
 
   // WebRtc_InitDelayEstimatorFarend() and WebRtc_InitDelayEstimator() should
-  // return -1 if we have a NULL pointer as |handle|.
-  EXPECT_EQ(-1, WebRtc_InitDelayEstimatorFarend(NULL));
-  EXPECT_EQ(-1, WebRtc_InitDelayEstimator(NULL));
+  // return -1 if we have a null pointer as |handle|.
+  EXPECT_EQ(-1, WebRtc_InitDelayEstimatorFarend(nullptr));
+  EXPECT_EQ(-1, WebRtc_InitDelayEstimator(nullptr));
 
   // WebRtc_AddFarSpectrumFloat() should return -1 if we have:
-  // 1) NULL pointer as |handle|.
-  // 2) NULL pointer as far-end spectrum.
+  // 1) null pointer as |handle|.
+  // 2) null pointer as far-end spectrum.
   // 3) Incorrect spectrum size.
-  EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(NULL, far_f_, spectrum_size_));
+  EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(nullptr, far_f_, spectrum_size_));
   // Use |farend_handle_| which is properly created at SetUp().
-  EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(farend_handle_, NULL,
-                                           spectrum_size_));
+  EXPECT_EQ(
+      -1, WebRtc_AddFarSpectrumFloat(farend_handle_, nullptr, spectrum_size_));
   EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(farend_handle_, far_f_,
                                            spectrum_size_ + 1));
 
   // WebRtc_AddFarSpectrumFix() should return -1 if we have:
-  // 1) NULL pointer as |handle|.
-  // 2) NULL pointer as far-end spectrum.
+  // 1) null pointer as |handle|.
+  // 2) null pointer as far-end spectrum.
   // 3) Incorrect spectrum size.
   // 4) Too high precision in far-end spectrum (Q-domain > 15).
-  EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(NULL, far_u16_, spectrum_size_, 0));
-  EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, NULL, spectrum_size_,
-                                         0));
+  EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(nullptr, far_u16_, spectrum_size_, 0));
+  EXPECT_EQ(
+      -1, WebRtc_AddFarSpectrumFix(farend_handle_, nullptr, spectrum_size_, 0));
   EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_,
                                          spectrum_size_ + 1, 0));
   EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_,
                                          spectrum_size_, 16));
 
   // WebRtc_set_history_size() should return -1 if:
-  // 1) |handle| is a NULL.
+  // 1) |handle| is a null.
   // 2) |history_size| <= 1.
-  EXPECT_EQ(-1, WebRtc_set_history_size(NULL, 1));
+  EXPECT_EQ(-1, WebRtc_set_history_size(nullptr, 1));
   EXPECT_EQ(-1, WebRtc_set_history_size(handle_, 1));
   // WebRtc_history_size() should return -1 if:
-  // 1) NULL pointer input.
-  EXPECT_EQ(-1, WebRtc_history_size(NULL));
+  // 1) null pointer input.
+  EXPECT_EQ(-1, WebRtc_history_size(nullptr));
   // 2) there is a mismatch between history size.
   void* tmp_handle = WebRtc_CreateDelayEstimator(farend_handle_, kHistorySize);
   EXPECT_EQ(0, WebRtc_InitDelayEstimator(tmp_handle));
   EXPECT_EQ(kDifferentHistorySize,
             WebRtc_set_history_size(tmp_handle, kDifferentHistorySize));
   EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(tmp_handle));
   EXPECT_EQ(kHistorySize, WebRtc_set_history_size(handle_, kHistorySize));
   EXPECT_EQ(-1, WebRtc_history_size(tmp_handle));
 
   // WebRtc_set_lookahead() should return -1 if we try a value outside the
   /// buffer.
   EXPECT_EQ(-1, WebRtc_set_lookahead(handle_, kLookahead + 1));
   EXPECT_EQ(-1, WebRtc_set_lookahead(handle_, -1));
 
   // WebRtc_set_allowed_offset() should return -1 if we have:
-  // 1) NULL pointer as |handle|.
+  // 1) null pointer as |handle|.
   // 2) |allowed_offset| < 0.
-  EXPECT_EQ(-1, WebRtc_set_allowed_offset(NULL, 0));
+  EXPECT_EQ(-1, WebRtc_set_allowed_offset(nullptr, 0));
   EXPECT_EQ(-1, WebRtc_set_allowed_offset(handle_, -1));
 
-  EXPECT_EQ(-1, WebRtc_get_allowed_offset(NULL));
+  EXPECT_EQ(-1, WebRtc_get_allowed_offset(nullptr));
 
   // WebRtc_enable_robust_validation() should return -1 if we have:
-  // 1) NULL pointer as |handle|.
+  // 1) null pointer as |handle|.
   // 2) Incorrect |enable| value (not 0 or 1).
-  EXPECT_EQ(-1, WebRtc_enable_robust_validation(NULL, kEnable[0]));
+  EXPECT_EQ(-1, WebRtc_enable_robust_validation(nullptr, kEnable[0]));
   EXPECT_EQ(-1, WebRtc_enable_robust_validation(handle_, -1));
   EXPECT_EQ(-1, WebRtc_enable_robust_validation(handle_, 2));
 
-  // WebRtc_is_robust_validation_enabled() should return -1 if we have NULL
+  // WebRtc_is_robust_validation_enabled() should return -1 if we have null
   // pointer as |handle|.
-  EXPECT_EQ(-1, WebRtc_is_robust_validation_enabled(NULL));
+  EXPECT_EQ(-1, WebRtc_is_robust_validation_enabled(nullptr));
 
   // WebRtc_DelayEstimatorProcessFloat() should return -1 if we have:
-  // 1) NULL pointer as |handle|.
-  // 2) NULL pointer as near-end spectrum.
+  // 1) null pointer as |handle|.
+  // 2) null pointer as near-end spectrum.
   // 3) Incorrect spectrum size.
   // 4) Non matching history sizes if multiple delay estimators using the same
   //    far-end reference.
-  EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(NULL, near_f_,
-                                                  spectrum_size_));
+  EXPECT_EQ(
+      -1, WebRtc_DelayEstimatorProcessFloat(nullptr, near_f_, spectrum_size_));
   // Use |handle_| which is properly created at SetUp().
-  EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(handle_, NULL,
-                                                  spectrum_size_));
+  EXPECT_EQ(
+      -1, WebRtc_DelayEstimatorProcessFloat(handle_, nullptr, spectrum_size_));
   EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(handle_, near_f_,
                                                   spectrum_size_ + 1));
   // |tmp_handle| is already in a non-matching state.
   EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(tmp_handle,
                                                   near_f_,
                                                   spectrum_size_));
 
   // WebRtc_DelayEstimatorProcessFix() should return -1 if we have:
-  // 1) NULL pointer as |handle|.
-  // 2) NULL pointer as near-end spectrum.
+  // 1) null pointer as |handle|.
+  // 2) null pointer as near-end spectrum.
   // 3) Incorrect spectrum size.
   // 4) Too high precision in near-end spectrum (Q-domain > 15).
   // 5) Non matching history sizes if multiple delay estimators using the same
   //    far-end reference.
-  EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(NULL, near_u16_, spectrum_size_,
-                                                0));
-  EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, NULL, spectrum_size_,
-                                                0));
+  EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(nullptr, near_u16_,
+                                                spectrum_size_, 0));
+  EXPECT_EQ(
+      -1, WebRtc_DelayEstimatorProcessFix(handle_, nullptr, spectrum_size_, 0));
   EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_,
                                                 spectrum_size_ + 1, 0));
   EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_,
                                                 spectrum_size_, 16));
   // |tmp_handle| is already in a non-matching state.
   EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(tmp_handle,
                                                 near_u16_,
                                                 spectrum_size_,
                                                 0));
   WebRtc_FreeDelayEstimator(tmp_handle);
 
-  // WebRtc_last_delay() should return -1 if we have a NULL pointer as |handle|.
-  EXPECT_EQ(-1, WebRtc_last_delay(NULL));
+  // WebRtc_last_delay() should return -1 if we have a null pointer as |handle|.
+  EXPECT_EQ(-1, WebRtc_last_delay(nullptr));
 
   // Free any local memory if needed.
   WebRtc_FreeDelayEstimator(handle);
 }
 
 TEST_F(DelayEstimatorTest, VerifyAllowedOffset) {
   // Is set to zero by default.
   EXPECT_EQ(0, WebRtc_get_allowed_offset(handle_));
   for (int i = 1; i >= 0; i--) {
     EXPECT_EQ(0, WebRtc_set_allowed_offset(handle_, i));
@@ skipping 106 matching lines @@
 }
 
 TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfBinaryEstimatorFarend) {
   // In this test we verify correct output on invalid API calls to the Binary
   // Delay Estimator (far-end part).
 
   BinaryDelayEstimatorFarend* binary = binary_farend_;
   // WebRtc_CreateBinaryDelayEstimatorFarend() should return -1 if the input
   // history size is less than 2. This is to make sure the buffer shifting
   // applies properly.
-  // Make sure we have a non-NULL value at start, so we can detect NULL after
+  // Make sure we have a non-null value at start, so we can detect null after
   // create failure.
   binary = WebRtc_CreateBinaryDelayEstimatorFarend(1);
-  EXPECT_TRUE(binary == NULL);
+  EXPECT_TRUE(binary == nullptr);
 }
 
 TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfBinaryEstimator) {
   // In this test we verify correct output on invalid API calls to the Binary
   // Delay Estimator.
 
   BinaryDelayEstimator* binary_handle = binary_;
-  // WebRtc_CreateBinaryDelayEstimator() should return -1 if we have a NULL
+  // WebRtc_CreateBinaryDelayEstimator() should return -1 if we have a null
   // pointer as |binary_farend| or invalid input values. Upon failure, the
-  // |binary_handle| should be NULL.
-  // Make sure we have a non-NULL value at start, so we can detect NULL after
+  // |binary_handle| should be null.
+  // Make sure we have a non-null value at start, so we can detect null after
   // create failure.
-  binary_handle = WebRtc_CreateBinaryDelayEstimator(NULL, kLookahead);
-  EXPECT_TRUE(binary_handle == NULL);
+  binary_handle = WebRtc_CreateBinaryDelayEstimator(nullptr, kLookahead);
+  EXPECT_TRUE(binary_handle == nullptr);
   binary_handle = WebRtc_CreateBinaryDelayEstimator(binary_farend_, -1);
-  EXPECT_TRUE(binary_handle == NULL);
+  EXPECT_TRUE(binary_handle == nullptr);
 }
 
 TEST_F(DelayEstimatorTest, MeanEstimatorFix) {
   // In this test we verify that we update the mean value in correct direction
   // only. With "direction" we mean increase or decrease.
 
   int32_t mean_value = 4000;
   int32_t mean_value_before = mean_value;
   int32_t new_mean_value = mean_value * 2;
 
@@ skipping 64 matching lines @@
   // estimator.
 
   binary_->allowed_offset = 10;
   RunBinarySpectraTest(0, 0, 0, 0);
   binary_->allowed_offset = 0;  // Reset reference.
 }
 
 TEST_F(DelayEstimatorTest, VerifyLookaheadAtCreate) {
   void* farend_handle = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize,
                                                           kMaxDelay);
-  ASSERT_TRUE(farend_handle != NULL);
+  ASSERT_TRUE(farend_handle != nullptr);
   void* handle = WebRtc_CreateDelayEstimator(farend_handle, kLookahead);
-  ASSERT_TRUE(handle != NULL);
+  ASSERT_TRUE(handle != nullptr);
   EXPECT_EQ(kLookahead, WebRtc_lookahead(handle));
   WebRtc_FreeDelayEstimator(handle);
   WebRtc_FreeDelayEstimatorFarend(farend_handle);
 }
 
 TEST_F(DelayEstimatorTest, VerifyLookaheadIsSetAndKeptAfterInit) {
   EXPECT_EQ(kLookahead, WebRtc_lookahead(handle_));
   EXPECT_EQ(kDifferentLookahead,
             WebRtc_set_lookahead(handle_, kDifferentLookahead));
   EXPECT_EQ(kDifferentLookahead, WebRtc_lookahead(handle_));
@@ skipping 14 matching lines @@
   EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(handle_));
   EXPECT_EQ(0, WebRtc_InitDelayEstimator(handle_));
   EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(handle_));
   EXPECT_EQ(0, WebRtc_InitDelayEstimatorFarend(farend_handle_));
   EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(handle_));
 }
 
 // TODO(bjornv): Add tests for SoftReset...(...).
 
 }  // namespace