Updated mixer unittests and fixed a related bug in the new mixer.

webrtc/modules/audio_mixer/test/audio_mixer_unittest.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.
  */
 
 #include <memory>
 #include <utility>
 
 #include "testing/gmock/include/gmock/gmock.h"
-
-#include "webrtc/modules/audio_conference_mixer/include/audio_conference_mixer.h"
-#include "webrtc/modules/audio_conference_mixer/include/audio_conference_mixer_defines.h"
-#include "webrtc/modules/audio_conference_mixer/source/audio_frame_manipulator.h"
 #include "webrtc/modules/audio_mixer/audio_mixer.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_defines.h"
 #include "webrtc/modules/audio_mixer/new_audio_conference_mixer.h"
-#include "webrtc/modules/audio_mixer/new_audio_conference_mixer_impl.h"
 
 using testing::_;
 using testing::Exactly;
 using testing::Invoke;
 using testing::Return;
 
 using webrtc::voe::AudioMixer;
 
 namespace webrtc {
-class MockAudioMixerParticipant : public MixerParticipant {
- public:
-  MockAudioMixerParticipant()
-      : fake_audio_frame_info_(MixerParticipant::AudioFrameInfo::kNormal) {
-    ON_CALL(*this, GetAudioFrameWithMuted(_, _))
-        .WillByDefault(
-            Invoke(this, &MockAudioMixerParticipant::FakeAudioFrameWithMuted));
-  }
 
-  MOCK_METHOD2(GetAudioFrameWithMuted,
-               AudioFrameInfo(const int32_t id, AudioFrame* audio_frame));
-  MOCK_CONST_METHOD1(NeededFrequency, int32_t(const int32_t id));
+namespace {
 
-  AudioFrame* fake_frame() { return &fake_frame_; }
-  AudioFrameInfo fake_info() { return this->fake_audio_frame_info_; }
-  void set_fake_info(const AudioFrameInfo audio_frame_info) {
-    fake_audio_frame_info_ = audio_frame_info;
-  }
+constexpr int kDefaultSampleRateHz = 48000;
+constexpr int kId = 1;
 
- private:
-  AudioFrame fake_frame_;
-  AudioFrameInfo fake_audio_frame_info_;
-  AudioFrameInfo FakeAudioFrameWithMuted(const int32_t id,
-                                         AudioFrame* audio_frame) {
-    audio_frame->CopyFrom(*fake_frame());
-    return fake_info();
-  }
-};

[aleloi, 2016/08/18 09:21:14]

This class was used for testing against the old AudioConferenceMixer.

+// Utility function that resets the frame member variables with
+// sensible defaults.
+void ResetFrame(AudioFrame* frame) {
+  frame->id_ = kId;
+  frame->sample_rate_hz_ = kDefaultSampleRateHz;
+  frame->num_channels_ = 1;
+
+  // Frame duration 10ms.
+  frame->samples_per_channel_ = kDefaultSampleRateHz / 100;
+  frame->vad_activity_ = AudioFrame::kVadActive;
+  frame->speech_type_ = AudioFrame::kNormalSpeech;
+}
+
+AudioFrame frame_for_mixing;
+
+}  // namespace
 
 class MockMixerAudioSource : public MixerAudioSource {
  public:
   MockMixerAudioSource()
       : fake_audio_frame_info_(MixerAudioSource::AudioFrameInfo::kNormal) {
     ON_CALL(*this, GetAudioFrameWithMuted(_, _))
         .WillByDefault(
             Invoke(this, &MockMixerAudioSource::FakeAudioFrameWithMuted));
   }
 
   MOCK_METHOD2(GetAudioFrameWithMuted,
                AudioFrameWithMuted(const int32_t id, int sample_rate_hz));
 
   AudioFrame* fake_frame() { return &fake_frame_; }
   AudioFrameInfo fake_info() { return fake_audio_frame_info_; }
   void set_fake_info(const AudioFrameInfo audio_frame_info) {
     fake_audio_frame_info_ = audio_frame_info;
   }
 
  private:
-  AudioFrame fake_frame_, output_frame_;
+  AudioFrame fake_frame_, fake_output_frame_;
   AudioFrameInfo fake_audio_frame_info_;
   AudioFrameWithMuted FakeAudioFrameWithMuted(const int32_t id,
                                               int sample_rate_hz) {
-    output_frame_.CopyFrom(fake_frame_);
+    fake_output_frame_.CopyFrom(fake_frame_);
     return {
-        &output_frame_,  // audio_frame_pointer
-        fake_info(),     // audio_frame_info
+        &fake_output_frame_,  // audio_frame_pointer
+        fake_info(),          // audio_frame_info

[aleloi, 2016/08/18 09:21:14]

Instead of returning the fake frame, now returns a copy of the fake frame. This
was a bug in the tests, because the mixer modifies the incoming frame by
dividing the samples by 2 every iteration.

     };
   }
 };
 
-// Keeps two identical sets of participants and two mixers to test
-// that the same participants are chosen for mixing.
-class CompareWithOldMixerTest : public testing::Test, AudioMixerOutputReceiver {
- protected:
-  constexpr static int kId = 1;
-  constexpr static int kSampleRateHz = 32000;
+// Creates participants from |frames| and |frame_info| and adds them
+// to the mixer. Compares mixed status with |expected_status|
+void MixAndCompare(
+    const std::vector<AudioFrame>& frames,
+    const std::vector<MixerAudioSource::AudioFrameInfo>& frame_info,
+    const std::vector<bool>& expected_status) {
+  size_t num_audio_sources = frames.size();
+  RTC_DCHECK(frames.size() == frame_info.size() &&
+             frame_info.size() == expected_status.size());
 
-  CompareWithOldMixerTest()
-      : old_mixer_(AudioConferenceMixer::Create(kId)),
-        new_mixer_(NewAudioConferenceMixer::Create(kId)) {}
+  std::unique_ptr<NewAudioConferenceMixer> mixer(
+      NewAudioConferenceMixer::Create(kId));
+  std::vector<MockMixerAudioSource> participants(num_audio_sources);
 
-  ~CompareWithOldMixerTest() { Reset(); }
-
-  // Mixes with both mixers and compares results: resulting frames and
-  // mix statuses.
-  void MixAndCompare() {
-    old_mixer_->Process();
-    new_mixer_->Mix(kSampleRateHz,
-                    1,  // number of channels
-                    &new_mixer_frame_);
-    EXPECT_EQ(0, memcmp(old_mixer_frame_.data_, new_mixer_frame_.data_,
-                        sizeof(old_mixer_frame_.data_)));
-
-    for (auto& participant_pair : participants_) {
-      EXPECT_EQ(participant_pair.first->IsMixed(),
-                participant_pair.second->IsMixed());
-    }
+  for (size_t i = 0; i < num_audio_sources; i++) {
+    participants[i].fake_frame()->CopyFrom(frames[i]);
+    participants[i].set_fake_info(frame_info[i]);
   }
 
-  std::unique_ptr<AudioFrame> last_mixed_audio_old() {
-    std::unique_ptr<AudioFrame> result(new AudioFrame);
-    result->CopyFrom(old_mixer_frame_);
-    return result;
+  for (size_t i = 0; i < num_audio_sources; i++) {
+    EXPECT_EQ(0, mixer->SetMixabilityStatus(&participants[i], true));
+    EXPECT_CALL(participants[i],
+                GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
+        .Times(Exactly(1));
   }
 
-  void Reset() {
-    old_mixer_.reset(AudioConferenceMixer::Create(kId));
-    new_mixer_.reset(NewAudioConferenceMixer::Create(kId));
-    for (auto& participant_pair : participants_) {
-      delete participant_pair.first;
-      delete participant_pair.second;
-    }
-    participants_.clear();
+  mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
+
+  for (size_t i = 0; i < num_audio_sources; i++) {
+    EXPECT_EQ(participants[i].IsMixed(), expected_status[i])
+        << "Mixed status of AudioSource #" << i << " wrong.";
   }
-
-  void ResetFrame(AudioFrame* audio_frame) {
-    audio_frame->sample_rate_hz_ = kSampleRateHz;
-    audio_frame->speech_type_ = AudioFrame::kNormalSpeech;
-    audio_frame->vad_activity_ = AudioFrame::kVadActive;
-    audio_frame->num_channels_ = 1;
-  }
-
-  void AddParticipant(AudioFrame* audio_frame,
-                      MixerParticipant::AudioFrameInfo audio_frame_info) {
-    auto old_participant = new MockAudioMixerParticipant;
-    auto new_participant = new MockMixerAudioSource;
-    old_participant->fake_frame()->CopyFrom(*audio_frame);
-    new_participant->fake_frame()->CopyFrom(*audio_frame);
-    old_participant->set_fake_info(audio_frame_info);
-    MixerAudioSource::AudioFrameInfo new_audio_frame_info;
-    switch (audio_frame_info) {
-      case MixerParticipant::AudioFrameInfo::kNormal:
-        new_audio_frame_info = MixerAudioSource::AudioFrameInfo::kNormal;
-        break;
-      case MixerParticipant::AudioFrameInfo::kMuted:
-        new_audio_frame_info = MixerAudioSource::AudioFrameInfo::kMuted;
-        break;
-      default:
-        new_audio_frame_info = MixerAudioSource::AudioFrameInfo::kError;
-    }
-    new_participant->set_fake_info(new_audio_frame_info);
-    participants_.emplace_back(old_participant, new_participant);
-  }
-
-  void NewMixedAudio(const int32_t id,
-                     const AudioFrame& generalAudioFrame,
-                     const AudioFrame** uniqueAudioFrames,
-                     const uint32_t size) override {
-    old_mixer_frame_.CopyFrom(generalAudioFrame);
-  }
-
-  AudioFrame old_mixer_frame_;
-  AudioFrame new_mixer_frame_;
-
-  std::vector<std::pair<MockAudioMixerParticipant*, MockMixerAudioSource*>>
-      participants_;
-  std::unique_ptr<AudioConferenceMixer> old_mixer_;
-  std::unique_ptr<NewAudioConferenceMixer> new_mixer_;
-};

[aleloi, 2016/08/18 09:21:14]

Removed test class that compared mixing decisions made by the old and new mixer.
It was incorrect since it didn't add the participants to the mixer. The mixing
decisions made by the old mixer turned out to be very hard to copy with a
sorting function. (It depended on input order and could mix muted zero-frames
before un-muted loud passive frames.)

-
-class BothMixersTest : public testing::Test {
- protected:
-  BothMixersTest() {
-    // Create an OutputMixer.
-    AudioMixer::Create(audio_mixer_, kId);
-
-    // Create one mixer participant and add it to the mixer.
-    EXPECT_EQ(0, audio_mixer_->SetMixabilityStatus(participant_, true));
-
-    // Each iteration, the participant will return a frame with this content:
-    participant_.fake_frame()->id_ = 1;
-    participant_.fake_frame()->sample_rate_hz_ = kSampleRateHz;
-    participant_.fake_frame()->speech_type_ = AudioFrame::kNormalSpeech;
-    participant_.fake_frame()->vad_activity_ = AudioFrame::kVadActive;
-    participant_.fake_frame()->num_channels_ = 1;
-
-    // We modify one sample within the RampIn window and one sample
-    // outside of it.
-    participant_.fake_frame()->data_[10] = 100;
-    participant_.fake_frame()->data_[20] = -200;
-    participant_.fake_frame()->data_[30] = 300;
-    participant_.fake_frame()->data_[90] = -400;
-
-    // Frame duration 10ms.
-    participant_.fake_frame()->samples_per_channel_ = kSampleRateHz / 100;
-  }
-
-  ~BothMixersTest() { AudioMixer::Destroy(audio_mixer_); }
-
-  // Mark the participant as 'unmixed' last round.
-  void ResetAudioSource() { participant_._mixHistory->SetIsMixed(false); }
-
-  AudioMixer* audio_mixer_;
-  MockMixerAudioSource participant_;
-  AudioFrame mixing_round_frame, mixed_results_frame_;
-
-  constexpr static int kSampleRateHz = 48000;
-  constexpr static int kId = 1;
-};

[aleloi, 2016/08/18 09:21:14]

Removed the former OutputMixer (now AudioMixer) tests, since most AudioMixing
functionality is added to NewAudioConferenceMixer and AudioMixer is soon going
to be removed.

+}

[aleloi, 2016/08/18 09:21:14]

Utility function for testing mixing priority order.

Writing functions and classes interleaved doesn't feel right. I couldn't find
anything about class and function order in the style guide, though. Do you think
it's worth it to put the test class in its own header?

 
 TEST(AudioMixer, AnonymousAndNamed) {
-  constexpr int kId = 1;
   // Should not matter even if partipants are more than
   // kMaximumAmountOfMixedAudioSources.
   constexpr int kNamed =
       NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
   constexpr int kAnonymous =
       NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
 
   std::unique_ptr<NewAudioConferenceMixer> mixer(
       NewAudioConferenceMixer::Create(kId));
 
@@ skipping 34 matching lines @@
   }
 
   // SetMixabilityStatus(anonymous, false) will remove anonymous from both
   // anonymous and named groups.
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&anonymous[kAnonymous - 1], false));
   EXPECT_FALSE(mixer->AnonymousMixabilityStatus(anonymous[kAnonymous - 1]));
   EXPECT_FALSE(mixer->MixabilityStatus(anonymous[kAnonymous - 1]));
 }
 
 TEST(AudioMixer, LargestEnergyVadActiveMixed) {
-  const int kId = 1;
   const int kAudioSources =
       NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 3;
-  const int kSampleRateHz = 32000;
 
   std::unique_ptr<NewAudioConferenceMixer> mixer(
       NewAudioConferenceMixer::Create(kId));
 
   MockMixerAudioSource participants[kAudioSources];
 
   for (int i = 0; i < kAudioSources; ++i) {
-    participants[i].fake_frame()->id_ = i;
-    participants[i].fake_frame()->sample_rate_hz_ = kSampleRateHz;
-    participants[i].fake_frame()->speech_type_ = AudioFrame::kNormalSpeech;
-    participants[i].fake_frame()->vad_activity_ = AudioFrame::kVadActive;
-    participants[i].fake_frame()->num_channels_ = 1;
-
-    // Frame duration 10ms.
-    participants[i].fake_frame()->samples_per_channel_ = kSampleRateHz / 100;
+    ResetFrame(participants[i].fake_frame());
 
     // We set the 80-th sample value since the first 80 samples may be
     // modified by a ramped-in window.
     participants[i].fake_frame()->data_[80] = i;
 
     EXPECT_EQ(0, mixer->SetMixabilityStatus(&participants[i], true));
     EXPECT_CALL(participants[i], GetAudioFrameWithMuted(_, _))
         .Times(Exactly(1));
   }
 
   // Last participant gives audio frame with passive VAD, although it has the
   // largest energy.
   participants[kAudioSources - 1].fake_frame()->vad_activity_ =
       AudioFrame::kVadPassive;
 
   AudioFrame audio_frame;
-  mixer->Mix(kSampleRateHz,
+  mixer->Mix(kDefaultSampleRateHz,
              1,  // number of channels
              &audio_frame);
 
   for (int i = 0; i < kAudioSources; ++i) {
     bool is_mixed = participants[i].IsMixed();
     if (i == kAudioSources - 1 ||
         i < kAudioSources - 1 -
                 NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources) {
       EXPECT_FALSE(is_mixed) << "Mixing status of AudioSource #" << i
                              << " wrong.";
     } else {
       EXPECT_TRUE(is_mixed) << "Mixing status of AudioSource #" << i
                             << " wrong.";
     }
   }
 }
 
 TEST(AudioMixer, ParticipantSampleRate) {
-  const int kId = 1;
   std::unique_ptr<NewAudioConferenceMixer> mixer(
       NewAudioConferenceMixer::Create(kId));
-  AudioFrame frame_for_mixing;
 
   MockMixerAudioSource participant;
-  participant.fake_frame()->sample_rate_hz_ = 8000;
-  participant.fake_frame()->num_channels_ = 1;
-
-  // Frame duration 10ms.
-  participant.fake_frame()->samples_per_channel_ = 8000 / 100;
+  ResetFrame(participant.fake_frame());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (auto frequency : {8000, 16000, 32000, 48000}) {
     EXPECT_CALL(participant, GetAudioFrameWithMuted(_, frequency))
         .Times(Exactly(1));
     mixer->Mix(frequency, 1, &frame_for_mixing);
     EXPECT_EQ(frequency, frame_for_mixing.sample_rate_hz_);
   }
 }
 
 TEST(AudioMixer, ParticipantNumberOfChannels) {
-  const int kId = 1;
   std::unique_ptr<NewAudioConferenceMixer> mixer(
       NewAudioConferenceMixer::Create(kId));
-  AudioFrame frame_for_mixing;
 
   MockMixerAudioSource participant;
-  participant.fake_frame()->sample_rate_hz_ = 8000;
-  participant.fake_frame()->num_channels_ = 1;
-
-  // Frame duration 10ms.
-  participant.fake_frame()->samples_per_channel_ = 8000 / 100;
+  ResetFrame(participant.fake_frame());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (size_t number_of_channels : {1, 2}) {
-    EXPECT_CALL(participant, GetAudioFrameWithMuted(_, 8000)).Times(Exactly(1));
-    mixer->Mix(8000, number_of_channels, &frame_for_mixing);
+    EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
+        .Times(Exactly(1));
+    mixer->Mix(kDefaultSampleRateHz, number_of_channels, &frame_for_mixing);
     EXPECT_EQ(number_of_channels, frame_for_mixing.num_channels_);
   }
 }
 
 // Test that the volume is reported as zero when the mixer input
 // comprises only zero values.
 TEST(AudioMixer, LevelIsZeroWhenMixingZeroes) {
-  const int kId = 1;
-  const int kSampleRateHz = 8000;
   std::unique_ptr<NewAudioConferenceMixer> mixer(
       NewAudioConferenceMixer::Create(kId));
-  AudioFrame frame_for_mixing;
 
   MockMixerAudioSource participant;
-  participant.fake_frame()->sample_rate_hz_ = kSampleRateHz;
-  participant.fake_frame()->num_channels_ = 1;
-
-  // Frame duration 10ms.
-  participant.fake_frame()->samples_per_channel_ = kSampleRateHz / 100;
+  ResetFrame(participant.fake_frame());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (size_t i = 0; i < 11; i++) {
-    EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kSampleRateHz))
+    EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
-    mixer->Mix(8000, 1, &frame_for_mixing);
+    mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
   }
 
   EXPECT_EQ(static_cast<uint32_t>(0), mixer->GetOutputAudioLevel());
   EXPECT_EQ(static_cast<uint32_t>(0), mixer->GetOutputAudioLevelFullRange());
 }
 
 // Test that the reported volume is maximal as full when the mixer
 // input comprises frames with maximal values.
 TEST(AudioMixer, LevelIsMaximalWhenMixingMaximalValues) {
-  const int kId = 1;
-  const int kSampleRateHz = 8000;
   std::unique_ptr<NewAudioConferenceMixer> mixer(
       NewAudioConferenceMixer::Create(kId));
-  AudioFrame frame_for_mixing;
 
   MockMixerAudioSource participant;
-  participant.fake_frame()->sample_rate_hz_ = kSampleRateHz;
-  participant.fake_frame()->num_channels_ = 1;
-
-  // Frame duration 10ms.
-  participant.fake_frame()->samples_per_channel_ = kSampleRateHz / 100;
+  ResetFrame(participant.fake_frame());
 
   // Fill participant frame data with maximal sound.
   std::fill(participant.fake_frame()->data_,
-            participant.fake_frame()->data_ + kSampleRateHz / 100,
+            participant.fake_frame()->data_ + kDefaultSampleRateHz / 100,
             std::numeric_limits<int16_t>::max());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (size_t i = 0; i < 11; i++) {
-    EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kSampleRateHz))
+    EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
-    mixer->Mix(8000, 1, &frame_for_mixing);
+    mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
   }
 
   // 9 is the highest possible audio level
   EXPECT_EQ(static_cast<uint32_t>(9), mixer->GetOutputAudioLevel());
 
   // 0x7fff = 32767 is the highest full range audio level.
   EXPECT_EQ(static_cast<uint32_t>(std::numeric_limits<int16_t>::max()),
             mixer->GetOutputAudioLevelFullRange());
 }
 
-TEST_F(BothMixersTest, CompareInitialFrameAudio) {
-  EXPECT_CALL(participant_, GetAudioFrameWithMuted(_, _)).Times(Exactly(1));
+// Test that the reported volume is maximal as full when the mixer
+// input comprises frames with maximal values.
+TEST(AudioMixer, VolumeTwoParticipants) {
+  std::unique_ptr<NewAudioConferenceMixer> mixer(
+      NewAudioConferenceMixer::Create(kId));
 
-  // Make sure the participant is marked as 'non-mixed' so that it is
-  // ramped in next round.
-  ResetAudioSource();
+  MockMixerAudioSource participant1, participant2;
+  ResetFrame(participant1.fake_frame());
+  ResetFrame(participant2.fake_frame());
 
-  // Construct the expected sound for the first mixing round.
-  mixing_round_frame.CopyFrom(*participant_.fake_frame());
-  RampIn(mixing_round_frame);
+  // Fill participant1 frame data with maximal sound.
+  std::fill(participant1.fake_frame()->data_,
+            participant1.fake_frame()->data_ + kDefaultSampleRateHz / 100, 0);
+  std::fill(participant2.fake_frame()->data_,
+            participant2.fake_frame()->data_ + kDefaultSampleRateHz / 100,
+            std::numeric_limits<int16_t>::max());
 
-  // Mix frames and put the result into a frame.
-  audio_mixer_->GetMixedAudio(kSampleRateHz, 1, &mixed_results_frame_);
-
-  // Compare the received frame with the expected.
-  EXPECT_EQ(mixing_round_frame.sample_rate_hz_,
-            mixed_results_frame_.sample_rate_hz_);
-  EXPECT_EQ(mixing_round_frame.num_channels_,
-            mixed_results_frame_.num_channels_);
-  EXPECT_EQ(mixing_round_frame.samples_per_channel_,
-            mixed_results_frame_.samples_per_channel_);
-  EXPECT_EQ(0, memcmp(mixing_round_frame.data_, mixed_results_frame_.data_,
-                      sizeof(mixing_round_frame.data_)));
-}
-
-TEST_F(BothMixersTest, CompareSecondFrameAudio) {
-  EXPECT_CALL(participant_, GetAudioFrameWithMuted(_, _)).Times(Exactly(2));
-
-  // Make sure the participant is marked as 'non-mixed' so that it is
-  // ramped in next round.
-  ResetAudioSource();
-
-  // Do one mixing iteration.
-  audio_mixer_->GetMixedAudio(kSampleRateHz, 1, &mixed_results_frame_);
-
-  // Mix frames a second time and compare with the expected frame
-  // (which is the participant's frame).
-  audio_mixer_->GetMixedAudio(kSampleRateHz, 1, &mixed_results_frame_);
-  EXPECT_EQ(0,
-            memcmp(participant_.fake_frame()->data_, mixed_results_frame_.data_,
-                   sizeof(mixing_round_frame.data_)));
-}
-
-TEST_F(CompareWithOldMixerTest, TwoParticipantsNormalFrames) {
-  Reset();
-  AudioFrame first_frame, second_frame;
-
-  ResetFrame(&first_frame);
-  ResetFrame(&second_frame);
-
-  first_frame.id_ = 1;
-  second_frame.id_ = 2;
-
-  AddParticipant(&first_frame, MixerParticipant::AudioFrameInfo::kNormal);
-  AddParticipant(&second_frame, MixerParticipant::AudioFrameInfo::kNormal);
-
-  for (int i = 0; i < 3; ++i) {
-    MixAndCompare();
+  EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant1, true));
+  EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant2, true));
+  for (size_t i = 0; i < 11; i++) {
+    EXPECT_CALL(participant1, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
+        .Times(Exactly(1));
+    EXPECT_CALL(participant2, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
+        .Times(Exactly(1));
+    mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
   }
 }
 
-TEST_F(CompareWithOldMixerTest, ThreeParticipantsDifferentFrames) {
-  Reset();
-  AudioFrame first_frame, second_frame, third_frame;
+// Maximal amount of participants are mixed one iteration, then
+// another participant with higher energy is added.
+TEST(AudioMixer, RampedOutSourcesShouldNotBeMarkedMixed) {
+  const int kAudioSources =
+      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
 
-  ResetFrame(&first_frame);
-  ResetFrame(&second_frame);
-  ResetFrame(&third_frame);
+  std::unique_ptr<NewAudioConferenceMixer> mixer(
+      NewAudioConferenceMixer::Create(kId));
+  MockMixerAudioSource participants[kAudioSources];
 
-  first_frame.id_ = 1;
-  second_frame.id_ = 2;
-  third_frame.id_ = 3;
-  second_frame.vad_activity_ = AudioFrame::kVadPassive;
+  for (size_t i = 0; i < kAudioSources; i++) {
+    ResetFrame(participants[i].fake_frame());
+    participants[i].fake_frame()->data_[0] = 100 * i;
+  }
 
-  AddParticipant(&first_frame, MixerParticipant::AudioFrameInfo::kNormal);
-  AddParticipant(&second_frame, MixerParticipant::AudioFrameInfo::kMuted);
-  AddParticipant(&third_frame, MixerParticipant::AudioFrameInfo::kMuted);
+  for (size_t i = 0; i < kAudioSources - 1; i++) {
+    EXPECT_EQ(0, mixer->SetMixabilityStatus(&participants[i], true));
+    EXPECT_CALL(participants[i],
+                GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
+        .Times(Exactly(1));
+  }
 
-  for (int i = 0; i < 3; ++i) {
-    MixAndCompare();
+  // First mixer iteration
+  mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
+
+  // All participants should have been mixed.
+  for (size_t i = 0; i < kAudioSources - 1; i++) {
+    EXPECT_TRUE(participants[i].IsMixed()) << "Mixed status of AudioSource #"
+                                           << i << " wrong.";
+  }
+
+  // Add new participant with higher energy.
+  EXPECT_EQ(0,
+            mixer->SetMixabilityStatus(&participants[kAudioSources - 1], true));
+  for (size_t i = 0; i < kAudioSources; i++) {
+    EXPECT_CALL(participants[i],
+                GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
+        .Times(Exactly(1));
+  }
+
+  mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
+  EXPECT_FALSE(participants[0].IsMixed())
+      << "Mixed status of AudioSource #0 wrong.";
+
+  for (size_t i = 1; i < kAudioSources; i++) {
+    EXPECT_EQ(participants[i].IsMixed(), true)
+        << "Mixed status of AudioSource #" << i << " wrong.";
   }
 }
 
-TEST_F(CompareWithOldMixerTest, ManyParticipantsDifferentFrames) {
-  Reset();
-  constexpr int kNumParticipants = 20;
-  AudioFrame audio_frames[kNumParticipants];
+TEST(AudioMixer, MutedShouldMixAfterUnmuted) {
+  const int kAudioSources =
+      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
 
-  for (int i = 0; i < kNumParticipants; ++i) {
-    ResetFrame(&audio_frames[i]);
-    audio_frames[i].id_ = 1;
-    audio_frames[i].data_[10] = 100 * (i % 5);
-    audio_frames[i].data_[100] = 100 * (i % 5);
-    if (i % 2 == 0) {
-      audio_frames[i].vad_activity_ = AudioFrame::kVadPassive;
-    }
+  std::vector<AudioFrame> frames(kAudioSources);
+  for (auto& frame : frames) {
+    ResetFrame(&frame);
   }
 
-  for (int i = 0; i < kNumParticipants; ++i) {
-    if (i % 2 == 0) {
-      AddParticipant(&audio_frames[i],
-                     MixerParticipant::AudioFrameInfo::kMuted);
-    } else {
-      AddParticipant(&audio_frames[i],
-                     MixerParticipant::AudioFrameInfo::kNormal);
-    }
-    MixAndCompare();
-  }
+  std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
+      kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
+  frame_info[0] = MixerAudioSource::AudioFrameInfo::kMuted;
+  std::vector<bool> expected_status(kAudioSources, true);
+  expected_status[0] = false;
+
+  MixAndCompare(frames, frame_info, expected_status);
 }
 
+TEST(AudioMixer, PassiveShouldMixAfterNormal) {
+  const int kAudioSources =
+      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+
+  std::vector<AudioFrame> frames(kAudioSources);
+  for (auto& frame : frames) {
+    ResetFrame(&frame);
+  }
+
+  std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
+      kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
+  frames[0].vad_activity_ = AudioFrame::kVadPassive;
+  std::vector<bool> expected_status(kAudioSources, true);
+  expected_status[0] = false;
+
+  MixAndCompare(frames, frame_info, expected_status);
+}
+
+TEST(AudioMixer, ActiveShouldMixBeforeLoud) {
+  const int kAudioSources =
+      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+
+  std::vector<AudioFrame> frames(kAudioSources);
+  for (auto& frame : frames) {
+    ResetFrame(&frame);
+  }
+
+  std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
+      kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
+  frames[0].vad_activity_ = AudioFrame::kVadPassive;
+  std::fill(frames[0].data_, frames[0].data_ + kDefaultSampleRateHz / 100,
+            std::numeric_limits<int16_t>::max());
+  std::vector<bool> expected_status(kAudioSources, true);
+  expected_status[0] = false;
+
+  MixAndCompare(frames, frame_info, expected_status);
+}
+
+TEST(AudioMixer, UnmutedShouldMixBeforeLoud) {
+  const int kAudioSources =
+      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+
+  std::vector<AudioFrame> frames(kAudioSources);
+  for (auto& frame : frames) {
+    ResetFrame(&frame);
+  }
+
+  std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
+      kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
+  frame_info[0] = MixerAudioSource::AudioFrameInfo::kMuted;
+  std::fill(frames[0].data_, frames[0].data_ + kDefaultSampleRateHz / 100,
+            std::numeric_limits<int16_t>::max());
+  std::vector<bool> expected_status(kAudioSources, true);
+  expected_status[0] = false;
+
+  MixAndCompare(frames, frame_info, expected_status);
+}
 }  // namespace webrtc