Adding debug dump tests.

webrtc/modules/audio_processing/test/debug_dump_test.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.
+ */
+
+#include <stddef.h>  // size_t
+#include <string>
+#include <vector>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/audio_processing/debug.pb.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/common_audio/channel_buffer.h"
+#include "webrtc/modules/audio_coding/neteq/tools/resample_input_audio_file.h"
+#include "webrtc/modules/audio_processing/include/audio_processing.h"
+#include "webrtc/modules/audio_processing/test/protobuf_utils.h"
+#include "webrtc/modules/audio_processing/test/test_utils.h"
+#include "webrtc/test/testsupport/fileutils.h"
+
+namespace webrtc {

[Andrew MacDonald, 2015/10/30 16:26:06]

Why did you remove this namespace? It's fine to put test tools in the webrtc
namespace.

[minyue-webrtc, 2015/10/30 16:32:25]

Per mentioned that DebugDumpGenerator is used only in this test (he said
"function", which I do not fully understand) and suggested to place it in an
anonymous namespace. I don't quite know pros and cons.

[Andrew MacDonald, 2015/10/30 16:39:42]

You have an anonymous namespace starting on line 26, and it's still fine to wrap
that in the webrtc namespace.

[minyue-webrtc, 2015/10/30 17:13:29]

ah, I see that you mean a wrapped anonymous namespace. 

+namespace test {
+
+namespace {
+
+void MaybeResetBuffer(rtc::scoped_ptr<ChannelBuffer<float>>& buffer,

[peah-webrtc, 2015/10/29 22:25:02]

Since this is only used inside the DebugDumpGenerator, would it make sense to
have it as a static method in that class?

[minyue-webrtc, 2015/10/30 11:07:08]

It is used in other test, see line 318

+                      const StreamConfig& config) {
+  if (!buffer.get() || buffer->num_frames() != config.num_frames() ||
+      buffer->num_channels() != config.num_channels()) {
+    buffer.reset(new ChannelBuffer<float>(config.num_frames(),
+                                          config.num_channels()));
+  }
+}
+
+}  // namespace
+
+class DebugDumpGenerator {

[peah-webrtc, 2015/10/29 22:25:02]

Since this class is only used inside this function, there should be no need to
put it in the webrtc namespace, right? It should be possible to have it in the
anonymous namespace I think.

[minyue-webrtc, 2015/10/30 11:07:07]

Ok. I made a change. I needed to move some blocks. See the new patch.

+ public:
+  DebugDumpGenerator(const std::string& input_file_name,
+                     int input_file_rate_hz,
+                     int input_channels,
+                     const std::string& reverse_file_name,
+                     int reverse_file_rate_hz,
+                     int reverse_channels,
+                     const Config& config,
+                     const std::string& dump_file_name);
+
+  // Constructor that uses default input files.
+  explicit DebugDumpGenerator(const Config& config);
+
+  ~DebugDumpGenerator();
+
+  // Changes the sample rate of the input audio to the APM.
+  void SetInputRate(int rate_hz);
+
+  // Sets if converts stereo input signal to mono by discarding other channels.
+  void ForceInputMono(bool mono);
+
+  // Changes the sample rate of the reverse audio to the APM.
+  void SetReverseRate(int rate_hz);
+
+  // Sets if converts stereo reverse signal to mono by discarding other
+  // channels.
+  void ForceReverseMono(bool mono);
+
+  // Sets the required sample rate of the APM output.
+  void SetOutputRate(int rate_hz);
+
+  // Sets the required channels of the APM output.
+  void SetOutputChannels(int channels);
+
+  std::string dump_file_name() const { return dump_file_name_; }
+
+  void StartRecording();
+  void Process(size_t num_blocks);
+  void StopRecording();
+  AudioProcessing* apm() const { return apm_.get(); }
+
+ private:
+  void ReadAndDeinterleave(ResampleInputAudioFile* audio, int channels,

[peah-webrtc, 2015/10/29 22:25:02]

This does not at all depend on the state apart from the vector signal_. Would it
make sense to instead create the vector signal_ a local variable inside this
method and make the method static? 
Otherwise I think the method should be declared const and the signal_ vector be
declared mutable, as it is only accessed by this method.

[minyue-webrtc, 2015/10/30 11:07:07]

agree!

+                           const StreamConfig& config, float* const* buffer);
+
+  void MonoToStereo(float* const* buffer, size_t num_frames);

[peah-webrtc, 2015/10/29 22:25:02]

I cannot find the implementation of this method. It should be in this file,
right?

[minyue-webrtc, 2015/10/30 11:07:07]

Oh, good catch? why is it still there. I thought I needed it to make fake
stereo, but it turned out that, with the default file, which is stereo, I need
StereoToMono instead. I just forgot to remove this from the class definition.

+
+  // APM input/output settings

[peah-webrtc, 2015/10/29 22:25:02]

Should end with a "."

[minyue-webrtc, 2015/10/30 11:07:07]

Done.

+  StreamConfig input_config_;
+  StreamConfig reverse_config_;
+  StreamConfig output_config_;
+
+  // Input file format.
+  const std::string input_file_name_;
+  ResampleInputAudioFile input_audio_;
+  const int input_file_channels_;
+
+  // Reverse file format.
+  const std::string reverse_file_name_;
+  ResampleInputAudioFile reverse_audio_;
+  const int reverse_file_channels_;
+
+  // Buffer for APM input/output.
+  rtc::scoped_ptr<ChannelBuffer<float>> input_;
+  rtc::scoped_ptr<ChannelBuffer<float>> reverse_;
+  rtc::scoped_ptr<ChannelBuffer<float>> output_;
+
+  rtc::scoped_ptr<AudioProcessing> apm_;
+
+  const std::string dump_file_name_;
+
+  // Buffer for reading audio files.
+  std::vector<int16_t> signal_;
+};
+
+class DebugDumpTest : public ::testing::Test {
+ public:
+  DebugDumpTest();
+
+  // VerifyDebugDump replays a debug dump using APM and verifies that the result
+  // is bit-exact-identical to the output channel in the dump. This is only
+  // guaranteed if the debug dump is started on the first frame.
+  void VerifyDebugDump(const std::string& dump_file_name);
+
+ private:
+  // Following functions are facilities for replaying debug dumps.
+  void OnInitEvent(const audioproc::Init& msg);
+  void OnStreamEvent(const audioproc::Stream& msg);
+  void OnReverseStreamEvent(const audioproc::ReverseStream& msg);
+  void OnConfigEvent(const audioproc::Config& msg);
+
+  void MaybeRecreateApm(const audioproc::Config& msg);
+  void ConfigureApm(const audioproc::Config& msg);
+
+  // Buffer for APM input/output.
+  rtc::scoped_ptr<ChannelBuffer<float>> input_;
+  rtc::scoped_ptr<ChannelBuffer<float>> reverse_;
+  rtc::scoped_ptr<ChannelBuffer<float>> output_;
+
+  rtc::scoped_ptr<AudioProcessing> apm_;
+
+  StreamConfig input_config_;
+  StreamConfig reverse_config_;
+  StreamConfig output_config_;
+};
+
+DebugDumpGenerator::DebugDumpGenerator(const std::string& input_file_name,
+                                       int input_rate_hz,
+                                       int input_channels,
+                                       const std::string& reverse_file_name,
+                                       int reverse_rate_hz,
+                                       int reverse_channels,
+                                       const Config& config,
+                                       const std::string& dump_file_name)
+    : input_config_(input_rate_hz, input_channels),
+      reverse_config_(reverse_rate_hz, reverse_channels),
+      output_config_(input_rate_hz, input_channels),
+      input_audio_(input_file_name, input_rate_hz, input_rate_hz),
+      input_file_channels_(input_channels),
+      reverse_audio_(reverse_file_name, reverse_rate_hz, reverse_rate_hz),
+      reverse_file_channels_(reverse_channels),
+      input_(new ChannelBuffer<float>(input_config_.num_frames(),
+                                      input_config_.num_channels())),
+      reverse_(new ChannelBuffer<float>(reverse_config_.num_frames(),
+                                        reverse_config_.num_channels())),
+      output_(new ChannelBuffer<float>(output_config_.num_frames(),
+                                       output_config_.num_channels())),
+      apm_(AudioProcessing::Create(config)),
+      dump_file_name_(dump_file_name) {
+}
+
+DebugDumpGenerator::DebugDumpGenerator(const Config& config)
+  : DebugDumpGenerator(test::ResourcePath("near32_stereo", "pcm"), 32000, 2,
+                       test::ResourcePath("far32_stereo", "pcm"), 32000, 2,
+                       config,
+                       test::TempFilename(test::OutputPath(), "debug_aec")) {
+}
+
+DebugDumpGenerator::~DebugDumpGenerator() {
+  remove(dump_file_name_.c_str());
+}
+
+void DebugDumpGenerator::SetInputRate(int rate_hz) {
+  input_audio_.set_output_rate_hz(rate_hz);
+  input_config_.set_sample_rate_hz(rate_hz);
+  MaybeResetBuffer(input_, input_config_);
+}
+
+void DebugDumpGenerator::ForceInputMono(bool mono) {
+  const int channels = mono ? 1 : input_file_channels_;
+  input_config_.set_num_channels(channels);
+  MaybeResetBuffer(input_, input_config_);
+}
+
+void DebugDumpGenerator::SetReverseRate(int rate_hz) {
+  reverse_audio_.set_output_rate_hz(rate_hz);
+  reverse_config_.set_sample_rate_hz(rate_hz);
+  MaybeResetBuffer(reverse_, reverse_config_);
+}
+
+void DebugDumpGenerator::ForceReverseMono(bool mono) {
+  const int channels = mono ? 1 : reverse_file_channels_;
+  reverse_config_.set_num_channels(channels);
+  MaybeResetBuffer(reverse_, reverse_config_);
+}
+
+void DebugDumpGenerator::SetOutputRate(int rate_hz) {
+  output_config_.set_sample_rate_hz(rate_hz);
+  MaybeResetBuffer(output_, output_config_);
+}
+
+void DebugDumpGenerator::SetOutputChannels(int channels) {
+  output_config_.set_num_channels(channels);
+  MaybeResetBuffer(output_, output_config_);
+}
+
+void DebugDumpGenerator::StartRecording() {
+  apm_->StartDebugRecording(dump_file_name_.c_str());
+}
+
+void DebugDumpGenerator::Process(size_t num_blocks) {
+  for (size_t i = 0; i < num_blocks; ++i) {
+    ReadAndDeinterleave(&reverse_audio_, reverse_file_channels_,
+                        reverse_config_, reverse_->channels());
+    ReadAndDeinterleave(&input_audio_, input_file_channels_, input_config_,
+                        input_->channels());
+    RTC_CHECK_EQ(AudioProcessing::kNoError, apm_->set_stream_delay_ms(100));
+    apm_->set_stream_key_pressed(i % 10 == 9);
+    RTC_CHECK_EQ(AudioProcessing::kNoError,
+                 apm_->ProcessStream(input_->channels(), input_config_,
+                                     output_config_, output_->channels()));
+
+    RTC_CHECK_EQ(AudioProcessing::kNoError,
+                 apm_->ProcessReverseStream(reverse_->channels(),
+                                            reverse_config_,
+                                            reverse_config_,
+                                            reverse_->channels()));
+  }
+}
+
+void DebugDumpGenerator::StopRecording() {
+  apm_->StopDebugRecording();
+}
+
+void DebugDumpGenerator::ReadAndDeinterleave(ResampleInputAudioFile* audio,
+                                             int channels,
+                                             const StreamConfig& config,
+                                             float* const* buffer) {
+  const size_t num_frames = config.num_frames();
+  const int out_channels = config.num_channels();
+
+  // Make sure the buffer for reading the file is large enough.
+  if (channels * num_frames > signal_.size()) {
+    signal_.resize(num_frames * channels);
+  }
+
+  audio->Read(num_frames * channels, &signal_[0]);
+
+  // We only allow reducing number of channels by discarding some channels.
+  RTC_CHECK_LE(out_channels, channels);
+  for (int channel = 0; channel < out_channels; ++channel) {
+    for (size_t i = 0; i < num_frames; ++i) {
+      buffer[channel][i] = S16ToFloat(signal_[i * channels + channel]);
+    }
+  }
+}
+
+DebugDumpTest::DebugDumpTest()
+    : input_(nullptr),  // will be created upon usage.
+      reverse_(nullptr),
+      output_(nullptr),
+      apm_(nullptr) {
+}
+
+void DebugDumpTest::VerifyDebugDump(const std::string& in_filename) {
+  FILE* in_file = fopen(in_filename.c_str(), "rb");
+  ASSERT_TRUE(in_file);
+  audioproc::Event event_msg;
+
+  while (ReadMessageFromFile(in_file, &event_msg)) {
+    switch (event_msg.type()) {
+      case audioproc::Event::INIT:
+        OnInitEvent(event_msg.init());
+        break;
+      case audioproc::Event::STREAM:
+        OnStreamEvent(event_msg.stream());
+        break;
+      case audioproc::Event::REVERSE_STREAM:
+        OnReverseStreamEvent(event_msg.reverse_stream());
+        break;
+      case audioproc::Event::CONFIG:
+        OnConfigEvent(event_msg.config());
+        break;
+      case audioproc::Event::UNKNOWN_EVENT:
+        // We do not expect receive UNKNOWN event currently.
+        ASSERT_TRUE(false);

[peah-webrtc, 2015/10/29 22:25:02]

Should use FAIL() instead.

[minyue-webrtc, 2015/10/30 11:07:07]

Done.

+    }
+  }
+  fclose(in_file);
+}
+
+// OnInitEvent reset the input/output/reserve channel format.
+void DebugDumpTest::OnInitEvent(const audioproc::Init& msg) {
+  ASSERT_TRUE(msg.has_num_input_channels());
+  ASSERT_TRUE(msg.has_output_sample_rate());
+  ASSERT_TRUE(msg.has_num_output_channels());
+  ASSERT_TRUE(msg.has_reverse_sample_rate());
+  ASSERT_TRUE(msg.has_num_reverse_channels());
+
+  input_config_ = StreamConfig(msg.sample_rate(), msg.num_input_channels());
+  output_config_ =
+      StreamConfig(msg.output_sample_rate(), msg.num_output_channels());
+  reverse_config_ =
+      StreamConfig(msg.reverse_sample_rate(), msg.num_reverse_channels());
+
+  MaybeResetBuffer(input_, input_config_);
+  MaybeResetBuffer(output_, output_config_);
+  MaybeResetBuffer(reverse_, reverse_config_);
+}
+
+// OnStreamEvent replays an input signal and verifies the output.
+void DebugDumpTest::OnStreamEvent(const audioproc::Stream& msg) {
+  // APM should have been created.
+  ASSERT_TRUE(apm_.get());
+
+  EXPECT_NOERR(apm_->gain_control()->set_stream_analog_level(msg.level()));
+  EXPECT_NOERR(apm_->set_stream_delay_ms(msg.delay()));
+  apm_->echo_cancellation()->set_stream_drift_samples(msg.drift());
+  if (msg.has_keypress())
+    apm_->set_stream_key_pressed(msg.keypress());
+  else
+    apm_->set_stream_key_pressed(true);
+
+  ASSERT_EQ(input_config_.num_channels(), msg.input_channel_size());
+  ASSERT_EQ(input_config_.num_frames() * sizeof(float),
+            msg.input_channel(0).size());
+
+  for (int i = 0; i < msg.input_channel_size(); ++i) {
+     memcpy(input_->channels()[i], msg.input_channel(i).data(),
+            msg.input_channel(i).size());
+  }
+
+  ASSERT_EQ(AudioProcessing::kNoError,
+            apm_->ProcessStream(input_->channels(), input_config_,
+                                output_config_, output_->channels()));
+
+  // Check that output of APM is bit-exact to the output in the dump.
+  ASSERT_EQ(output_config_.num_channels(), msg.output_channel_size());
+  ASSERT_EQ(output_config_.num_frames() * sizeof(float),
+            msg.output_channel(0).size());
+  for (int i = 0; i < msg.output_channel_size(); ++i) {
+    ASSERT_EQ(0, memcmp(output_->channels()[i], msg.output_channel(i).data(),
+                        msg.output_channel(i).size()));
+  }
+}
+
+void DebugDumpTest::OnReverseStreamEvent(const audioproc::ReverseStream& msg) {
+  // APM should have been created.
+  ASSERT_TRUE(apm_.get());
+
+  ASSERT_GT(msg.channel_size(), 0);
+  ASSERT_EQ(reverse_config_.num_channels(), msg.channel_size());
+  ASSERT_EQ(reverse_config_.num_frames() * sizeof(float),
+            msg.channel(0).size());
+
+  for (int i = 0; i < msg.channel_size(); ++i) {
+     memcpy(reverse_->channels()[i], msg.channel(i).data(),
+            msg.channel(i).size());
+  }
+
+  ASSERT_EQ(AudioProcessing::kNoError,
+            apm_->ProcessReverseStream(reverse_->channels(),
+                                       reverse_config_,
+                                       reverse_config_,
+                                       reverse_->channels()));
+}
+
+void DebugDumpTest::OnConfigEvent(const audioproc::Config& msg) {
+  MaybeRecreateApm(msg);
+  ConfigureApm(msg);
+}
+
+void DebugDumpTest::MaybeRecreateApm(const audioproc::Config& msg) {
+  // These configurations cannot be changed on the fly.
+  Config config;
+  ASSERT_TRUE(msg.has_aec_delay_agnostic_enabled());
+  config.Set<DelayAgnostic>(
+      new DelayAgnostic(msg.aec_delay_agnostic_enabled()));
+
+  ASSERT_TRUE(msg.has_noise_robust_agc_enabled());
+  config.Set<ExperimentalAgc>(
+       new ExperimentalAgc(msg.noise_robust_agc_enabled()));
+
+  ASSERT_TRUE(msg.has_transient_suppression_enabled());
+  config.Set<ExperimentalNs>(
+      new ExperimentalNs(msg.transient_suppression_enabled()));
+
+  ASSERT_TRUE(msg.has_aec_extended_filter_enabled());
+  config.Set<ExtendedFilter>(new ExtendedFilter(
+      msg.aec_extended_filter_enabled()));
+
+  // We only create APM once, since changes on these fields should not
+  // happen in current implementation.
+  if (!apm_.get()) {
+    apm_.reset(AudioProcessing::Create(config));
+  }
+}
+
+void DebugDumpTest::ConfigureApm(const audioproc::Config& msg) {
+  // AEC configs.
+  ASSERT_TRUE(msg.has_aec_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->echo_cancellation()->Enable(msg.aec_enabled()));
+
+  ASSERT_TRUE(msg.has_aec_drift_compensation_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->echo_cancellation()->enable_drift_compensation(
+                msg.aec_drift_compensation_enabled()));
+
+  ASSERT_TRUE(msg.has_aec_suppression_level());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->echo_cancellation()->set_suppression_level(
+                static_cast<webrtc::EchoCancellation::SuppressionLevel>(
+                    msg.aec_suppression_level())));
+
+  // AECM configs.
+  ASSERT_TRUE(msg.has_aecm_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->echo_control_mobile()->Enable(msg.aecm_enabled()));
+
+  ASSERT_TRUE(msg.has_aecm_comfort_noise_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->echo_control_mobile()->enable_comfort_noise(
+                msg.aecm_comfort_noise_enabled()));
+
+  ASSERT_TRUE(msg.has_aecm_routing_mode());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->echo_control_mobile()->set_routing_mode(
+                static_cast<webrtc::EchoControlMobile::RoutingMode>(
+                    msg.aecm_routing_mode())));
+
+  // AGC configs.
+  ASSERT_TRUE(msg.has_agc_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->gain_control()->Enable(msg.agc_enabled()));
+
+  ASSERT_TRUE(msg.has_agc_mode());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->gain_control()->set_mode(
+                static_cast<webrtc::GainControl::Mode>(msg.agc_mode())));
+
+  ASSERT_TRUE(msg.has_agc_limiter_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->gain_control()->enable_limiter(msg.agc_limiter_enabled()));
+
+  // HPF configs.
+  ASSERT_TRUE(msg.has_hpf_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->high_pass_filter()->Enable(msg.hpf_enabled()));
+
+  // NS configs.
+  ASSERT_TRUE(msg.has_ns_enabled());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->noise_suppression()->Enable(msg.ns_enabled()));
+
+  ASSERT_TRUE(msg.has_ns_level());
+  EXPECT_EQ(AudioProcessing::kNoError,
+            apm_->noise_suppression()->set_level(
+                static_cast<webrtc::NoiseSuppression::Level>(msg.ns_level())));
+}
+
+TEST_F(DebugDumpTest, SimpleCase) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ChangeInputFormat) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+  generator.SetInputRate(48000);
+
+  generator.ForceInputMono(true);
+  // #channel of out put should not be larger than that of input. APM will fail

[peah-webrtc, 2015/10/29 22:25:02]

Number of output channels should....

[minyue-webrtc, 2015/10/30 11:07:08]

Done.

+  // otherwise.
+  generator.SetOutputChannels(1);
+
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ChangeReverseFormat) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+  generator.SetReverseRate(48000);
+  generator.ForceReverseMono(true);
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ChangeOutputFormat) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+  generator.SetOutputRate(48000);
+  generator.SetOutputChannels(1);
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ToggleAec) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+
+  EchoCancellation* aec = generator.apm()->echo_cancellation();
+  EXPECT_EQ(AudioProcessing::kNoError, aec->Enable(!aec->is_enabled()));
+
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ToggleDelayAgnosticAec) {
+  Config config;
+  config.Set<DelayAgnostic>(new DelayAgnostic(true));
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+
+  EchoCancellation* aec = generator.apm()->echo_cancellation();
+  EXPECT_EQ(AudioProcessing::kNoError, aec->Enable(!aec->is_enabled()));
+
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ToggleAecLevel) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  EchoCancellation* aec = generator.apm()->echo_cancellation();
+  EXPECT_EQ(AudioProcessing::kNoError, aec->Enable(true));
+  EXPECT_EQ(AudioProcessing::kNoError,
+            aec->set_suppression_level(EchoCancellation::kLowSuppression));
+  generator.StartRecording();
+  generator.Process(100);
+
+  EXPECT_EQ(AudioProcessing::kNoError,
+            aec->set_suppression_level(EchoCancellation::kHighSuppression));
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ToggleAgc) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+
+  GainControl* agc = generator.apm()->gain_control();
+  EXPECT_EQ(AudioProcessing::kNoError, agc->Enable(!agc->is_enabled()));
+
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, ToggleNs) {
+  Config config;
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+
+  NoiseSuppression* ns = generator.apm()->noise_suppression();
+  EXPECT_EQ(AudioProcessing::kNoError, ns->Enable(!ns->is_enabled()));
+
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+TEST_F(DebugDumpTest, TransientSuppressionOn) {
+  Config config;
+  config.Set<ExperimentalNs>(new ExperimentalNs(true));
+  DebugDumpGenerator generator(config);
+  generator.StartRecording();
+  generator.Process(100);
+  generator.StopRecording();
+  VerifyDebugDump(generator.dump_file_name());
+}
+
+}  // namespace test
+}  // namespace webrtc