Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_processing/audio_processing_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 214 matching lines @@
   msg->set_instant(output.instant);
   msg->set_average(output.average);
   msg->set_maximum(output.maximum);
   msg->set_minimum(output.minimum);
 }
 #endif
 
 void OpenFileAndWriteMessage(const std::string filename,
                              const ::google::protobuf::MessageLite& msg) {
   FILE* file = fopen(filename.c_str(), "wb");
-  ASSERT_TRUE(file != NULL);
+  ASSERT_TRUE(file != nullptr);
 
   int32_t size = msg.ByteSize();
   ASSERT_GT(size, 0);
   std::unique_ptr<uint8_t[]> array(new uint8_t[size]);
   ASSERT_TRUE(msg.SerializeToArray(array.get(), size));
 
   ASSERT_EQ(1u, fwrite(&size, sizeof(size), 1, file));
   ASSERT_EQ(static_cast<size_t>(size),
       fwrite(array.get(), sizeof(array[0]), size, file));
   fclose(file);
@@ skipping 49 matching lines @@
 }
 
 void ClearTempFiles() {
   for (auto& kv : temp_filenames)
     remove(kv.second.c_str());
 }
 
 void OpenFileAndReadMessage(std::string filename,
                             ::google::protobuf::MessageLite* msg) {
   FILE* file = fopen(filename.c_str(), "rb");
-  ASSERT_TRUE(file != NULL);
+  ASSERT_TRUE(file != nullptr);
   ReadMessageFromFile(file, msg);
   fclose(file);
 }
 
 // Reads a 10 ms chunk of int16 interleaved audio from the given (assumed
 // stereo) file, converts to deinterleaved float (optionally downmixing) and
 // returns the result in |cb|. Returns false if the file ended (or on error) and
 // true otherwise.
 //
 // |int_data| and |float_data| are just temporary space that must be
@@ skipping 87 matching lines @@
   int output_sample_rate_hz_;
   size_t num_output_channels_;
   FILE* far_file_;
   FILE* near_file_;
   FILE* out_file_;
 };
 
 ApmTest::ApmTest()
     : output_path_(test::OutputPath()),
 #if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)
-      ref_filename_(test::ResourcePath("audio_processing/output_data_fixed",
-                                       "pb")),
+      ref_filename_(
+          test::ResourcePath("audio_processing/output_data_fixed", "pb")),
 #elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
 #if defined(WEBRTC_MAC)
       // A different file for Mac is needed because on this platform the AEC
       // constant |kFixedDelayMs| value is 20 and not 50 as it is on the rest.
-      ref_filename_(test::ResourcePath("audio_processing/output_data_mac",
-                                       "pb")),
+      ref_filename_(
+          test::ResourcePath("audio_processing/output_data_mac", "pb")),
 #else
-      ref_filename_(test::ResourcePath("audio_processing/output_data_float",
-                                       "pb")),
+      ref_filename_(
+          test::ResourcePath("audio_processing/output_data_float", "pb")),
 #endif
 #endif
-      frame_(NULL),
-      revframe_(NULL),
+      frame_(nullptr),
+      revframe_(nullptr),
       output_sample_rate_hz_(0),
       num_output_channels_(0),
-      far_file_(NULL),
-      near_file_(NULL),
-      out_file_(NULL) {
+      far_file_(nullptr),
+      near_file_(nullptr),
+      out_file_(nullptr) {
   Config config;
   config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
   apm_.reset(AudioProcessing::Create(config));
 }
 
 void ApmTest::SetUp() {
-  ASSERT_TRUE(apm_.get() != NULL);
+  ASSERT_TRUE(apm_.get() != nullptr);
 
   frame_ = new AudioFrame();
   revframe_ = new AudioFrame();
 
   Init(32000, 32000, 32000, 2, 2, 2, false);
 }
 
 void ApmTest::TearDown() {
   if (frame_) {
     delete frame_;
   }
-  frame_ = NULL;
+  frame_ = nullptr;
 
   if (revframe_) {
     delete revframe_;
   }
-  revframe_ = NULL;
+  revframe_ = nullptr;
 
   if (far_file_) {
     ASSERT_EQ(0, fclose(far_file_));
   }
-  far_file_ = NULL;
+  far_file_ = nullptr;
 
   if (near_file_) {
     ASSERT_EQ(0, fclose(near_file_));
   }
-  near_file_ = NULL;
+  near_file_ = nullptr;
 
   if (out_file_) {
     ASSERT_EQ(0, fclose(out_file_));
   }
-  out_file_ = NULL;
+  out_file_ = nullptr;
 }
 
 void ApmTest::Init(AudioProcessing* ap) {
   ASSERT_EQ(kNoErr,
             ap->Initialize(
                 {{{frame_->sample_rate_hz_, frame_->num_channels_},
                   {output_sample_rate_hz_, num_output_channels_},
                   {revframe_->sample_rate_hz_, revframe_->num_channels_},
                   {revframe_->sample_rate_hz_, revframe_->num_channels_}}}));
 }
@@ skipping 11 matching lines @@
 
   SetContainerFormat(reverse_sample_rate_hz, num_reverse_channels, revframe_,
                      &revfloat_cb_);
   Init(apm_.get());
 
   if (far_file_) {
     ASSERT_EQ(0, fclose(far_file_));
   }
   std::string filename = ResourceFilePath("far", sample_rate_hz);
   far_file_ = fopen(filename.c_str(), "rb");
-  ASSERT_TRUE(far_file_ != NULL) << "Could not open file " <<
-      filename << "\n";
+  ASSERT_TRUE(far_file_ != nullptr) << "Could not open file " << filename
+                                    << "\n";
 
   if (near_file_) {
     ASSERT_EQ(0, fclose(near_file_));
   }
   filename = ResourceFilePath("near", sample_rate_hz);
   near_file_ = fopen(filename.c_str(), "rb");
-  ASSERT_TRUE(near_file_ != NULL) << "Could not open file " <<
-        filename << "\n";
+  ASSERT_TRUE(near_file_ != nullptr) << "Could not open file " << filename
+                                     << "\n";
 
   if (open_output_file) {
     if (out_file_) {
       ASSERT_EQ(0, fclose(out_file_));
     }
     filename = OutputFilePath(
         "out", sample_rate_hz, output_sample_rate_hz, reverse_sample_rate_hz,
         reverse_sample_rate_hz, num_input_channels, num_output_channels,
         num_reverse_channels, num_reverse_channels, kForward);
     out_file_ = fopen(filename.c_str(), "wb");
-    ASSERT_TRUE(out_file_ != NULL) << "Could not open file " <<
-          filename << "\n";
+    ASSERT_TRUE(out_file_ != nullptr) << "Could not open file " << filename
+                                      << "\n";
   }
 }
 
 void ApmTest::EnableAllComponents() {
   EnableAllAPComponents(apm_.get());
 }
 
 bool ApmTest::ReadFrame(FILE* file, AudioFrame* frame,
                         ChannelBuffer<float>* cb) {
   // The files always contain stereo audio.
@@ skipping 13 matching lines @@
                     frame->samples_per_channel_);
   }
 
   if (cb) {
     ConvertToFloat(*frame, cb);
   }
   return true;
 }
 
 bool ApmTest::ReadFrame(FILE* file, AudioFrame* frame) {
-  return ReadFrame(file, frame, NULL);
+  return ReadFrame(file, frame, nullptr);
 }
 
 // If the end of the file has been reached, rewind it and attempt to read the
 // frame again.
 void ApmTest::ReadFrameWithRewind(FILE* file, AudioFrame* frame,
                                   ChannelBuffer<float>* cb) {
   if (!ReadFrame(near_file_, frame_, cb)) {
     rewind(near_file_);
     ASSERT_TRUE(ReadFrame(near_file_, frame_, cb));
   }
 }
 
 void ApmTest::ReadFrameWithRewind(FILE* file, AudioFrame* frame) {
-  ReadFrameWithRewind(file, frame, NULL);
+  ReadFrameWithRewind(file, frame, nullptr);
 }
 
 void ApmTest::ProcessWithDefaultStreamParameters(AudioFrame* frame) {
   EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0));
   apm_->echo_cancellation()->set_stream_drift_samples(0);
   EXPECT_EQ(apm_->kNoError,
       apm_->gain_control()->set_stream_analog_level(127));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame));
 }
 
@@ skipping 371 matching lines @@
   EXPECT_EQ(apm_->kNotEnabledError, apm_->echo_cancellation()->GetDelayMetrics(
                                         &median, &std, &poor_fraction));
 
   EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));
   EXPECT_TRUE(apm_->echo_cancellation()->is_enabled());
   EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(false));
   EXPECT_FALSE(apm_->echo_cancellation()->is_enabled());
 
   EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));
   EXPECT_TRUE(apm_->echo_cancellation()->is_enabled());
-  EXPECT_TRUE(apm_->echo_cancellation()->aec_core() != NULL);
+  EXPECT_TRUE(apm_->echo_cancellation()->aec_core() != nullptr);
   EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(false));
   EXPECT_FALSE(apm_->echo_cancellation()->is_enabled());
-  EXPECT_FALSE(apm_->echo_cancellation()->aec_core() != NULL);
+  EXPECT_FALSE(apm_->echo_cancellation()->aec_core() != nullptr);
 }
 
 TEST_F(ApmTest, DISABLED_EchoCancellationReportsCorrectDelays) {
   // TODO(bjornv): Fix this test to work with DA-AEC.
   // Enable AEC only.
   EXPECT_EQ(apm_->kNoError,
             apm_->echo_cancellation()->enable_drift_compensation(false));
   EXPECT_EQ(apm_->kNoError,
             apm_->echo_cancellation()->enable_metrics(false));
   EXPECT_EQ(apm_->kNoError,
@@ skipping 93 matching lines @@
   EXPECT_FALSE(apm_->echo_control_mobile()->is_comfort_noise_enabled());
   EXPECT_EQ(apm_->kNoError,
       apm_->echo_control_mobile()->enable_comfort_noise(true));
   EXPECT_TRUE(apm_->echo_control_mobile()->is_comfort_noise_enabled());
   // Set and get echo path
   const size_t echo_path_size =
       apm_->echo_control_mobile()->echo_path_size_bytes();
   std::unique_ptr<char[]> echo_path_in(new char[echo_path_size]);
   std::unique_ptr<char[]> echo_path_out(new char[echo_path_size]);
   EXPECT_EQ(apm_->kNullPointerError,
-            apm_->echo_control_mobile()->SetEchoPath(NULL, echo_path_size));
+            apm_->echo_control_mobile()->SetEchoPath(nullptr, echo_path_size));
   EXPECT_EQ(apm_->kNullPointerError,
-            apm_->echo_control_mobile()->GetEchoPath(NULL, echo_path_size));
+            apm_->echo_control_mobile()->GetEchoPath(nullptr, echo_path_size));
   EXPECT_EQ(apm_->kBadParameterError,
             apm_->echo_control_mobile()->GetEchoPath(echo_path_out.get(), 1));
   EXPECT_EQ(apm_->kNoError,
             apm_->echo_control_mobile()->GetEchoPath(echo_path_out.get(),
                                                      echo_path_size));
   for (size_t i = 0; i < echo_path_size; i++) {
     echo_path_in[i] = echo_path_out[i] + 1;
   }
   EXPECT_EQ(apm_->kBadParameterError,
             apm_->echo_control_mobile()->SetEchoPath(echo_path_in.get(), 1));
@@ skipping 211 matching lines @@
       AudioProcessing::Create(config, beamformer));
   EXPECT_EQ(kNoErr, apm->gain_control()->Enable(true));
   ChannelBuffer<float> src_buf(kSamplesPerChannel, kNumInputChannels);
   ChannelBuffer<float> dest_buf(kSamplesPerChannel, kNumOutputChannels);
   const size_t max_length = kSamplesPerChannel * std::max(kNumInputChannels,
                                                           kNumOutputChannels);
   std::unique_ptr<int16_t[]> int_data(new int16_t[max_length]);
   std::unique_ptr<float[]> float_data(new float[max_length]);
   std::string filename = ResourceFilePath("far", kSampleRateHz);
   FILE* far_file = fopen(filename.c_str(), "rb");
-  ASSERT_TRUE(far_file != NULL) << "Could not open file " << filename << "\n";
+  ASSERT_TRUE(far_file != nullptr) << "Could not open file " << filename
+                                   << "\n";
   const int kDefaultVolume = apm->gain_control()->stream_analog_level();
   const int kDefaultCompressionGain =
       apm->gain_control()->compression_gain_db();
   bool is_target = false;
   EXPECT_CALL(*beamformer, is_target_present())
       .WillRepeatedly(testing::ReturnPointee(&is_target));
   for (size_t i = 0; i < kNumChunks; ++i) {
     ASSERT_TRUE(ReadChunk(far_file,
                           int_data.get(),
                           float_data.get(),
@@ skipping 374 matching lines @@
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_FALSE(FrameDataAreEqual(*frame_, frame_copy));
 }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 void ApmTest::ProcessDebugDump(const std::string& in_filename,
                                const std::string& out_filename,
                                Format format,
                                int max_size_bytes) {
   FILE* in_file = fopen(in_filename.c_str(), "rb");
-  ASSERT_TRUE(in_file != NULL);
+  ASSERT_TRUE(in_file != nullptr);
   audioproc::Event event_msg;
   bool first_init = true;
 
   while (ReadMessageFromFile(in_file, &event_msg)) {
     if (event_msg.type() == audioproc::Event::INIT) {
       const audioproc::Init msg = event_msg.init();
       int reverse_sample_rate = msg.sample_rate();
       if (msg.has_reverse_sample_rate()) {
         reverse_sample_rate = msg.reverse_sample_rate();
       }
@@ skipping 94 matching lines @@
   // We expect at least this many bytes in the created logfile.
   const size_t logging_expected_bytes = 95000;
   EnableAllComponents();
   ProcessDebugDump(in_filename, ref_filename, format, -1);
   ProcessDebugDump(ref_filename, out_filename, format, -1);
   ProcessDebugDump(ref_filename, limited_filename, format, logging_limit_bytes);
 
   FILE* ref_file = fopen(ref_filename.c_str(), "rb");
   FILE* out_file = fopen(out_filename.c_str(), "rb");
   FILE* limited_file = fopen(limited_filename.c_str(), "rb");
-  ASSERT_TRUE(ref_file != NULL);
-  ASSERT_TRUE(out_file != NULL);
-  ASSERT_TRUE(limited_file != NULL);
+  ASSERT_TRUE(ref_file != nullptr);
+  ASSERT_TRUE(out_file != nullptr);
+  ASSERT_TRUE(limited_file != nullptr);
   std::unique_ptr<uint8_t[]> ref_bytes;
   std::unique_ptr<uint8_t[]> out_bytes;
   std::unique_ptr<uint8_t[]> limited_bytes;
 
   size_t ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes);
   size_t out_size = ReadMessageBytesFromFile(out_file, &out_bytes);
   size_t limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes);
   size_t bytes_read = 0;
   size_t bytes_read_limited = 0;
   while (ref_size > 0 && out_size > 0) {
@@ skipping 28 matching lines @@
 TEST_F(ApmTest, VerifyDebugDumpFloat) {
   VerifyDebugDumpTest(kFloatFormat);
 }
 #endif
 
 // TODO(andrew): expand test to verify output.
 TEST_F(ApmTest, DebugDump) {
   const std::string filename =
       test::TempFilename(test::OutputPath(), "debug_aec");
   EXPECT_EQ(apm_->kNullPointerError,
-            apm_->StartDebugRecording(static_cast<const char*>(NULL), -1));
+            apm_->StartDebugRecording(static_cast<const char*>(nullptr), -1));
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(filename.c_str(), -1));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   // Verify the file has been written.
   FILE* fid = fopen(filename.c_str(), "r");
-  ASSERT_TRUE(fid != NULL);
+  ASSERT_TRUE(fid != nullptr);
 
   // Clean it up.
   ASSERT_EQ(0, fclose(fid));
   ASSERT_EQ(0, remove(filename.c_str()));
 #else
   EXPECT_EQ(apm_->kUnsupportedFunctionError,
             apm_->StartDebugRecording(filename.c_str(), -1));
   EXPECT_EQ(apm_->kUnsupportedFunctionError, apm_->StopDebugRecording());
 
   // Verify the file has NOT been written.
-  ASSERT_TRUE(fopen(filename.c_str(), "r") == NULL);
+  ASSERT_TRUE(fopen(filename.c_str(), "r") == nullptr);
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 // TODO(andrew): expand test to verify output.
 TEST_F(ApmTest, DebugDumpFromFileHandle) {
-  FILE* fid = NULL;
+  FILE* fid = nullptr;
   EXPECT_EQ(apm_->kNullPointerError, apm_->StartDebugRecording(fid, -1));
   const std::string filename =
       test::TempFilename(test::OutputPath(), "debug_aec");
   fid = fopen(filename.c_str(), "w");
   ASSERT_TRUE(fid);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stopping without having started should be OK.
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   EXPECT_EQ(apm_->kNoError, apm_->StartDebugRecording(fid, -1));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(revframe_));
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_EQ(apm_->kNoError, apm_->StopDebugRecording());
 
   // Verify the file has been written.
   fid = fopen(filename.c_str(), "r");
-  ASSERT_TRUE(fid != NULL);
+  ASSERT_TRUE(fid != nullptr);
 
   // Clean it up.
   ASSERT_EQ(0, fclose(fid));
   ASSERT_EQ(0, remove(filename.c_str()));
 #else
   EXPECT_EQ(apm_->kUnsupportedFunctionError,
             apm_->StartDebugRecording(fid, -1));
   EXPECT_EQ(apm_->kUnsupportedFunctionError, apm_->StopDebugRecording());
 
   ASSERT_EQ(0, fclose(fid));
@@ skipping 518 matching lines @@
                              num_reverse_input_channels,
                              num_reverse_output_channels, kForward).c_str(),
               "wb");
     FILE* rev_out_file =
         fopen(OutputFilePath(output_file_prefix, input_rate, output_rate,
                              reverse_input_rate, reverse_output_rate,
                              num_input_channels, num_output_channels,
                              num_reverse_input_channels,
                              num_reverse_output_channels, kReverse).c_str(),
               "wb");
-    ASSERT_TRUE(far_file != NULL);
-    ASSERT_TRUE(near_file != NULL);
-    ASSERT_TRUE(out_file != NULL);
-    ASSERT_TRUE(rev_out_file != NULL);
+    ASSERT_TRUE(far_file != nullptr);
+    ASSERT_TRUE(near_file != nullptr);
+    ASSERT_TRUE(out_file != nullptr);
+    ASSERT_TRUE(rev_out_file != nullptr);
 
     ChannelBuffer<float> fwd_cb(SamplesFromRate(input_rate),
                                 num_input_channels);
     ChannelBuffer<float> rev_cb(SamplesFromRate(reverse_input_rate),
                                 num_reverse_input_channels);
     ChannelBuffer<float> out_cb(SamplesFromRate(output_rate),
                                 num_output_channels);
     ChannelBuffer<float> rev_out_cb(SamplesFromRate(reverse_output_rate),
                                     num_reverse_output_channels);
 
@@ skipping 116 matching lines @@
                          cf[i].num_output, cf[i].num_reverse_input,
                          cf[i].num_reverse_output, file_direction).c_str(),
           "rb");
       // The reference files always have matching input and output channels.
       FILE* ref_file = fopen(
           OutputFilePath("ref", ref_rate, ref_rate, ref_rate, ref_rate,
                          cf[i].num_output, cf[i].num_output,
                          cf[i].num_reverse_output, cf[i].num_reverse_output,
                          file_direction).c_str(),
           "rb");
-      ASSERT_TRUE(out_file != NULL);
-      ASSERT_TRUE(ref_file != NULL);
+      ASSERT_TRUE(out_file != nullptr);
+      ASSERT_TRUE(ref_file != nullptr);
 
       const size_t ref_length = SamplesFromRate(ref_rate) * out_num;
       const size_t out_length = SamplesFromRate(out_rate) * out_num;
       // Data from the reference file.
       std::unique_ptr<float[]> ref_data(new float[ref_length]);
       // Data from the output file.
       std::unique_ptr<float[]> out_data(new float[out_length]);
       // Data from the resampled output, in case the reference and output rates
       // don't match.
       std::unique_ptr<float[]> cmp_data(new float[ref_length]);
@@ skipping 262 matching lines @@
   // TODO(peah): Remove the testing for
   // apm->capture_nonlocked_.level_controller_enabled once the value in config_
   // is instead used to activate the level controller.
   EXPECT_FALSE(apm->capture_nonlocked_.level_controller_enabled);
   EXPECT_NEAR(kTargetLcPeakLeveldBFS,
               apm->config_.level_controller.initial_peak_level_dbfs,
               std::numeric_limits<float>::epsilon());
 }
 
 }  // namespace webrtc