/*
 * Copyright 2012 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "media/audio/shell_audio_sink.h"

#include <algorithm>

#include "media/audio/mock_shell_audio_streamer.h"
#include "media/base/mock_filters.h"
#include "media/mp4/aac.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

typedef media::ShellAudioStreamer::Config Config;

// TODO: Add 32 bits per sample tests.

namespace {

using namespace testing;

const uint32 kMaxHardwareChannelsStereo = 2;
const size_t kFramesPerAccessUnit = media::mp4::AAC::kFramesPerAccessUnit;

bool operator==(const media::AudioParameters& params1,
                const media::AudioParameters& params2) {
  return params1.channels() == params2.channels() &&
         params1.bits_per_sample() == params2.bits_per_sample() &&
         params1.sample_rate() == params2.sample_rate();
}

void InterleavedFill(size_t frames_per_channel,
                     int channels,
                     int bytes_per_sample,
                     uint8* data,
                     uint8* fill_byte) {
  while (frames_per_channel) {
    for (int i = 0; i < channels; ++i) {
      for (int j = 0; j < bytes_per_sample; ++j) {
        *data = *fill_byte + j;
        ++data;
      }
    }
    *fill_byte += bytes_per_sample;
    --frames_per_channel;
  }
}

void InterleavedVerify(size_t frames_per_channel,
                       int channels,
                       int bytes_per_sample,
                       const uint8* data,
                       uint8* fill_byte) {
  while (frames_per_channel) {
    for (int i = 0; i < channels; ++i) {
      for (int j = 0; j < bytes_per_sample; ++j) {
        ASSERT_EQ(*data, static_cast<uint8>(*fill_byte + j));
        ++data;
      }
    }
    *fill_byte += bytes_per_sample;
    --frames_per_channel;
  }
}

class MockRenderCallback : public media::AudioRendererSink::RenderCallback {
 public:
  MockRenderCallback() {}

  MOCK_METHOD2(Render, int(media::AudioBus*, int));
  MOCK_METHOD3(RenderIO, void(media::AudioBus*, media::AudioBus*, int));
  MOCK_METHOD0(OnRenderError, void());
  MOCK_METHOD0(SinkFull, void());

  MOCK_METHOD0(SinkUnderflow, void());

  DISALLOW_COPY_AND_ASSIGN(MockRenderCallback);
};

class ShellAudioSinkTest : public testing::Test {
 public:
  ShellAudioSinkTest() { media::ShellBufferFactory::Initialize(); }

  virtual ~ShellAudioSinkTest() { media::ShellBufferFactory::Terminate(); }

  void Configure(const Config& config) {
    render_byte_ = 0;
    consumption_byte_ = 0;
    render_bytes_num_ = 0;
    consumption_bytes_num_ = 0;
    render_frames_per_channel_ = 0;
    consumption_frames_per_channel_ = 0;

    sink_ = media::ShellAudioSink::Create(&streamer_);
    EXPECT_CALL(streamer_, GetConfig()).WillRepeatedly(Return(config));
    EXPECT_CALL(streamer_, HasStream(sink_.get()))
        .WillRepeatedly(Return(false));
    EXPECT_CALL(render_callback_, Render(_, _)).WillRepeatedly(Return(0));
    EXPECT_CALL(render_callback_, SinkFull()).Times(AnyNumber());
    EXPECT_CALL(render_callback_, SinkUnderflow()).Times(AnyNumber());
  }

  void FillAudioBus(int frames_per_channel, media::AudioBus* audio_bus) {
    Config config = streamer_.GetConfig();
    media::AudioParameters params = sink_->GetAudioParameters();
    int bytes_per_channel = frames_per_channel * params.bits_per_sample() / 8;
    int channels = params.channels();
    if (config.interleaved()) {
      bytes_per_channel *= channels;
    }
    ASSERT_LE(bytes_per_channel, audio_bus->frames() * sizeof(float));

    if (config.interleaved()) {
      ASSERT_EQ(audio_bus->channels(), 1);
      InterleavedFill(
          frames_per_channel, channels, params.bits_per_sample() / 8,
          reinterpret_cast<uint8*>(audio_bus->channel(0)), &render_byte_);
    } else {
      ASSERT_EQ(audio_bus->channels(), channels);
      uint8 render_byte;
      for (int i = 0; i < channels; ++i) {
        render_byte = render_byte_;
        InterleavedFill(frames_per_channel, 1, params.bits_per_sample() / 8,
                        reinterpret_cast<uint8*>(audio_bus->channel(i)),
                        &render_byte);
      }
      render_byte_ = render_byte;
    }

    render_bytes_num_ += channels * bytes_per_channel;
    render_frames_per_channel_ += frames_per_channel;
  }

  void Consume(int frames_per_channel) {
    Config config = streamer_.GetConfig();
    media::AudioParameters params = sink_->GetAudioParameters();
    media::AudioSinkSettings settings;
    media::AudioBus* audio_bus = sink_->GetAudioBus();
    int bytes_per_channel = frames_per_channel * params.bits_per_sample() / 8;

    settings.Reset(config, params);
    if (config.interleaved()) {
      bytes_per_channel *= settings.channels();
    }
    ASSERT_LE(bytes_per_channel, audio_bus->frames() * sizeof(float));

    uint32_t offset_in_frame, total_frames;
    EXPECT_CALL(render_callback_, Render(_, _)).WillOnce(Return(0));
    sink_->PullFrames(&offset_in_frame, &total_frames);

    EXPECT_LE(frames_per_channel, total_frames);

    int frames_to_request =
        std::min<int>(frames_per_channel,
                      settings.per_channel_frames(audio_bus) - offset_in_frame);
    if (config.interleaved()) {
      ASSERT_EQ(audio_bus->channels(), 1);
      uint8* data =
          reinterpret_cast<uint8*>(audio_bus->channel(0)) +
          offset_in_frame * params.bits_per_sample() / 8 * settings.channels();
      InterleavedVerify(frames_to_request, settings.channels(),
                        params.bits_per_sample() / 8, data, &consumption_byte_);
    } else {
      ASSERT_EQ(audio_bus->channels(), settings.channels());
      uint8 consumption_byte;
      for (int i = 0; i < settings.channels(); ++i) {
        consumption_byte = consumption_byte_;
        uint8* data = reinterpret_cast<uint8*>(audio_bus->channel(i)) +
                      offset_in_frame * params.bits_per_sample() / 8;
        InterleavedVerify(frames_to_request, 1, params.bits_per_sample() / 8,
                          data, &consumption_byte);
      }
      consumption_byte_ = consumption_byte;
    }

    frames_to_request = frames_per_channel - frames_to_request;
    if (frames_to_request != 0) {
      if (config.interleaved()) {
        ASSERT_EQ(audio_bus->channels(), 1);
        uint8* data = reinterpret_cast<uint8*>(audio_bus->channel(0));
        InterleavedVerify(frames_to_request, settings.channels(),
                          params.bits_per_sample() / 8, data,
                          &consumption_byte_);
      } else {
        ASSERT_EQ(audio_bus->channels(), settings.channels());
        uint8 consumption_byte;
        for (int i = 0; i < settings.channels(); ++i) {
          consumption_byte = consumption_byte_;
          uint8* data = reinterpret_cast<uint8*>(audio_bus->channel(i));
          InterleavedVerify(frames_to_request, 1, params.bits_per_sample() / 8,
                            data, &consumption_byte);
        }
        consumption_byte_ = consumption_byte;
      }
    }

    sink_->ConsumeFrames(frames_per_channel);

    consumption_bytes_num_ += settings.channels() * bytes_per_channel;
    consumption_frames_per_channel_ += frames_per_channel;
  }

  bool AllConsumed() {
    uint32_t offset_in_frame, total_frames;
    EXPECT_CALL(render_callback_, Render(_, _))
        .Times(AtLeast(0))
        .WillRepeatedly(Return(0));
    sink_->PullFrames(&offset_in_frame, &total_frames);

    return total_frames == 0 && render_byte_ == consumption_byte_ &&
           render_bytes_num_ == consumption_bytes_num_ &&
           render_frames_per_channel_ == consumption_frames_per_channel_;
  }

  // ==== Test Fixture Members
  media::MockShellAudioStreamer streamer_;
  MockRenderCallback render_callback_;
  scoped_refptr<media::ShellAudioSink> sink_;

  uint8 render_byte_;
  uint8 consumption_byte_;
  int render_bytes_num_;
  int consumption_bytes_num_;
  int render_frames_per_channel_;
  int consumption_frames_per_channel_;
};

// Verify the frame count of audio_bus
ACTION_P3(VerifyAudioBusFrameCount, config, init_params, frames_per_channel) {
  media::AudioBus* audio_bus = arg0;
  int bytes_per_channel =
      frames_per_channel * init_params.bits_per_sample() / 8;
  if (config.interleaved()) {
    int channels = init_params.channels();
    bytes_per_channel *= channels;
  }
  EXPECT_EQ(bytes_per_channel, audio_bus->frames() * sizeof(float));
  return 0;
}

// Verify the frame count of audio_bus
ACTION_P2(RenderAudioBus, frames_per_channel, sink_test) {
  media::AudioBus* audio_bus = arg0;
  sink_test->FillAudioBus(frames_per_channel, audio_bus);
  return frames_per_channel;
}

TEST_F(ShellAudioSinkTest, Prerequisites) {
  uint8 data[48000] = {0};
  uint8 render_byte = 0, consume_byte = 0;
  uint8 verify_data[] = {0x00, 0x01, 0x02, 0x00, 0x01, 0x02, 0x00, 0x01, 0x02,
                         0x03, 0x04, 0x05, 0x03, 0x04, 0x05, 0x03, 0x04, 0x05};
  InterleavedFill(2, 3, 3, data, &render_byte);
  EXPECT_EQ(memcmp(verify_data, data, 9), 0);
  EXPECT_EQ(memcmp(data + 18, data + 19, 1024), 0);

  for (size_t frames_per_channel = 1; frames_per_channel < 301;
       frames_per_channel += 3) {
    for (int channels = 1; channels < 5; ++channels) {
      for (int bytes_per_sample = 1; bytes_per_sample < 5; ++bytes_per_sample) {
        render_byte = consume_byte = 0;
        InterleavedFill(frames_per_channel, channels, bytes_per_sample, data,
                        &render_byte);
        InterleavedVerify(frames_per_channel, channels, bytes_per_sample, data,
                          &consume_byte);
        ASSERT_EQ(render_byte, consume_byte);
      }
    }
  }
}

TEST_F(ShellAudioSinkTest, Initialize) {
  const uint32 initial_rebuffering_frames_per_channel = 2048;
  const uint32 sink_buffer_size_in_frames_per_channel = 8192;

  // 2 configurations with different interleaved
  for (int i = 0; i < 2; ++i) {
    for (media::ChannelLayout layout = media::CHANNEL_LAYOUT_MONO;
         layout != media::CHANNEL_LAYOUT_MAX;
         layout = static_cast<media::ChannelLayout>(layout + 1)) {
      for (int bytes_per_sample = 2; bytes_per_sample < 5;
           bytes_per_sample *= 2) {
        Config config(i == 0 ? Config::INTERLEAVED : Config::PLANAR,
                      initial_rebuffering_frames_per_channel,
                      sink_buffer_size_in_frames_per_channel,
                      kMaxHardwareChannelsStereo, bytes_per_sample,
                      48000 /* output_sample_rate */);

        Configure(config);
        EXPECT_TRUE(!sink_->GetAudioBus());
        media::AudioParameters init_params = media::AudioParameters(
            media::AudioParameters::AUDIO_PCM_LOW_LATENCY, layout, 48000,
            bytes_per_sample * 8, 1024);
        sink_->Initialize(init_params, &render_callback_);

        EXPECT_TRUE(sink_->PauseRequested());
        EXPECT_TRUE(sink_->GetAudioBus());

        media::AudioBus* audio_bus = sink_->GetAudioBus();
        media::AudioParameters params = sink_->GetAudioParameters();
        int expected_channels = init_params.channels();
        if (config.interleaved()) {
          EXPECT_EQ(audio_bus->channels(), 1);
          EXPECT_EQ(audio_bus->frames(),
                    config.sink_buffer_size_in_frames_per_channel() *
                        expected_channels * bytes_per_sample / sizeof(float));
          EXPECT_EQ(params.channels(), init_params.channels());
        } else {
          EXPECT_EQ(audio_bus->channels(), expected_channels);
          EXPECT_EQ(audio_bus->frames(),
                    config.sink_buffer_size_in_frames_per_channel() *
                        bytes_per_sample / sizeof(float));
          EXPECT_EQ(params.channels(), init_params.channels());
        }

        EXPECT_EQ(params.bits_per_sample(), init_params.bits_per_sample());
        EXPECT_EQ(params.sample_rate(), init_params.sample_rate());
      }
    }
  }
}

TEST_F(ShellAudioSinkTest, StartAndStop) {
  const uint32 initial_rebuffering_frames_per_channel = 2048;
  const uint32 sink_buffer_size_in_frames_per_channel = 8192;

  Config config(
      Config::INTERLEAVED, initial_rebuffering_frames_per_channel,
      sink_buffer_size_in_frames_per_channel, kMaxHardwareChannelsStereo,
      sizeof(int16_t) /* bytes_per_sample */, 48000 /* output_sample_rate */);

  media::AudioParameters init_params =
      media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                             media::CHANNEL_LAYOUT_MONO, 48000, 16, 1024);

  Configure(config);

  sink_->Initialize(init_params, &render_callback_);

  InSequence seq;
  EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(false));
  EXPECT_CALL(streamer_, AddStream(sink_.get())).WillOnce(Return(true));
  EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
  sink_->Start();
  EXPECT_TRUE(sink_->PauseRequested());
  EXPECT_CALL(streamer_, RemoveStream(sink_.get())).WillOnce(Return());
  EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(false));
  sink_->Stop();
  EXPECT_TRUE(sink_->PauseRequested());
}

TEST_F(ShellAudioSinkTest, RenderNoFrames) {
  const uint32 initial_rebuffering_frames_per_channel = 2048;
  const uint32 sink_buffer_size_in_frames_per_channel = 8192;

  Config config(
      Config::INTERLEAVED, initial_rebuffering_frames_per_channel,
      sink_buffer_size_in_frames_per_channel, kMaxHardwareChannelsStereo,
      sizeof(int16_t) /* bytes_per_sample */, 48000 /* output_sample_rate */);

  Configure(config);

  media::AudioParameters init_params =
      media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                             media::CHANNEL_LAYOUT_MONO, 48000, 16, 1024);

  sink_->Initialize(init_params, &render_callback_);

  InSequence seq;
  EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(false));
  EXPECT_CALL(streamer_, AddStream(sink_.get())).WillOnce(Return(true));
  EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
  sink_->Start();

  EXPECT_FALSE(sink_->PullFrames(NULL, NULL));
  uint32_t offset_in_frame, total_frames;
  EXPECT_FALSE(sink_->PullFrames(&offset_in_frame, &total_frames));

  EXPECT_CALL(streamer_, RemoveStream(sink_.get())).WillOnce(Return());
  EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(false));
  sink_->Stop();
}

TEST_F(ShellAudioSinkTest, RenderFrames) {
  const uint32 initial_rebuffering_frames_per_channel = 2048;
  const uint32 sink_buffer_size_in_frames_per_channel = 8192;

  for (int i = 0; i < 2; ++i) {
    Config config(
        i == 0 ? Config::INTERLEAVED : Config::PLANAR,
        initial_rebuffering_frames_per_channel,
        sink_buffer_size_in_frames_per_channel, kMaxHardwareChannelsStereo,
        sizeof(int16_t) /* bytes_per_sample */, 48000 /* output_sample_rate */);

    Configure(config);

    media::AudioParameters init_params =
        media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                               media::CHANNEL_LAYOUT_MONO, 48000, 16, 1024);

    sink_->Initialize(init_params, &render_callback_);

    InSequence seq;
    EXPECT_CALL(streamer_, HasStream(sink_.get()))
        .WillRepeatedly(Return(false));
    EXPECT_CALL(streamer_, AddStream(sink_.get())).WillOnce(Return(true));
    EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
    sink_->Start();

    EXPECT_CALL(render_callback_, Render(_, _))
        .WillOnce(RenderAudioBus(16, this));
    EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

    uint32_t offset_in_frame, total_frames;
    EXPECT_CALL(render_callback_, Render(_, _)).WillOnce(Return(0));
    EXPECT_FALSE(sink_->PullFrames(&offset_in_frame, &total_frames));
    EXPECT_EQ(offset_in_frame, 0);
    EXPECT_EQ(total_frames, 16);

    EXPECT_CALL(render_callback_, Render(_, _))
        .WillOnce(RenderAudioBus(8, this));
    EXPECT_FALSE(sink_->PullFrames(&offset_in_frame, &total_frames));
    EXPECT_EQ(offset_in_frame, 0);
    EXPECT_EQ(total_frames, 24);

    Consume(8);

    EXPECT_CALL(render_callback_, Render(_, _)).WillOnce(Return(0));
    EXPECT_FALSE(sink_->PullFrames(&offset_in_frame, &total_frames));
    EXPECT_EQ(offset_in_frame, 8);
    EXPECT_EQ(total_frames, 16);

    Consume(16);

    EXPECT_TRUE(AllConsumed());

    EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
    EXPECT_CALL(streamer_, RemoveStream(sink_.get())).WillOnce(Return());
    EXPECT_CALL(streamer_, HasStream(sink_.get()))
        .WillRepeatedly(Return(false));
    sink_->Stop();
  }
}

TEST_F(ShellAudioSinkTest, RenderRequestSizeAkaAudioBusFrames) {
  const uint32 initial_rebuffering_frames_per_channel = 2048;
  const uint32 sink_buffer_size_in_frames_per_channel = 2048;

  for (int i = 0; i < 2; ++i) {
    Config config(
        i == 0 ? Config::INTERLEAVED : Config::PLANAR,
        initial_rebuffering_frames_per_channel,
        sink_buffer_size_in_frames_per_channel, kMaxHardwareChannelsStereo,
        sizeof(int16_t) /* bytes_per_sample */, 48000 /* output_sample_rate */);
    Configure(config);

    media::AudioParameters init_params =
        media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                               media::CHANNEL_LAYOUT_MONO, 48000, 16, 1024);

    sink_->Initialize(init_params, &render_callback_);

    InSequence seq;
    EXPECT_CALL(streamer_, HasStream(sink_.get()))
        .WillRepeatedly(Return(false));
    EXPECT_CALL(streamer_, AddStream(sink_.get())).WillOnce(Return(true));
    EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
    sink_->Start();

    for (int i = 0; i < 10; ++i) {
      // Try to get 1024 frames but don't give it any data
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(VerifyAudioBusFrameCount(config, init_params,
                                             kFramesPerAccessUnit));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Ok, now give it 1024 frames
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(RenderAudioBus(1024, this));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Try to get another 1024 frames but don't give it any data
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(VerifyAudioBusFrameCount(config, init_params,
                                             kFramesPerAccessUnit));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Ok, now give it 480 frames
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(RenderAudioBus(480, this));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Consume 1024 frames, leave 1568 frames space but only 544 are
      // continuous
      Consume(1024);

      // It still only has room for 544 continuous frames, don't give it any
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(VerifyAudioBusFrameCount(config, init_params, 544));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Ok, now give it 544 frames
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(RenderAudioBus(544, this));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Now it has room for another 1024 frames, don't give it
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(VerifyAudioBusFrameCount(config, init_params, 1024));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Ok, now give it 1024 frames
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(RenderAudioBus(1024, this));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

      // Consume 2048 frames
      Consume(2048);

      // Give it another 64 and then consume 64 to ensure we can get into the
      // next iteration of the loop with empty buffer
      EXPECT_CALL(render_callback_, Render(_, _))
          .WillOnce(RenderAudioBus(1024, this));
      EXPECT_FALSE(sink_->PullFrames(NULL, NULL));
      Consume(1024);

      EXPECT_TRUE(AllConsumed());
    }

    EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
    EXPECT_CALL(streamer_, RemoveStream(sink_.get())).WillOnce(Return());
    EXPECT_CALL(streamer_, HasStream(sink_.get()))
        .WillRepeatedly(Return(false));
    sink_->Stop();
  }
}

TEST_F(ShellAudioSinkTest, ResumeAfterUnderflow) {
  const uint32 initial_rebuffering_frames_per_channel = 1024;
  const uint32 sink_buffer_size_in_frames_per_channel = 2048;

  for (int i = 0; i < 2; ++i) {
    Config config(
        i == 0 ? Config::INTERLEAVED : Config::PLANAR,
        initial_rebuffering_frames_per_channel,
        sink_buffer_size_in_frames_per_channel, kMaxHardwareChannelsStereo,
        sizeof(int16_t) /* bytes_per_sample */, 48000 /* output_sample_rate */);
    Configure(config);

    media::AudioParameters init_params =
        media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                               media::CHANNEL_LAYOUT_MONO, 48000, 16, 1024);

    sink_->Initialize(init_params, &render_callback_);

    InSequence seq;
    EXPECT_CALL(streamer_, HasStream(sink_.get()))
        .WillRepeatedly(Return(false));
    EXPECT_CALL(streamer_, AddStream(sink_.get())).WillOnce(Return(true));
    EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
    sink_->Start();

    // Render 64 frames
    EXPECT_CALL(render_callback_, Render(_, _))
        .WillOnce(RenderAudioBus(64, this));
    EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

    // Render another 64 frames
    EXPECT_CALL(render_callback_, Render(_, _))
        .WillOnce(RenderAudioBus(64, this));
    EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

    // Consume 112 frames, leave 16 frames left
    Consume(112);

    // Render another 16 frames
    EXPECT_CALL(render_callback_, Render(_, _))
        .WillOnce(RenderAudioBus(16, this));
    EXPECT_FALSE(sink_->PullFrames(NULL, NULL));

    Consume(32);

    EXPECT_TRUE(AllConsumed());

    EXPECT_CALL(streamer_, HasStream(sink_.get())).WillRepeatedly(Return(true));
    EXPECT_CALL(streamer_, RemoveStream(sink_.get())).WillOnce(Return());
    EXPECT_CALL(streamer_, HasStream(sink_.get()))
        .WillRepeatedly(Return(false));
    sink_->Stop();
  }
}

}  // namespace