Quelle  TestAudioRingBuffer.cpp   Sprache: C

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "AudioRingBuffer.h"

#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "mozilla/PodOperations.h"

using namespace mozilla;
using testing::ElementsAre;

TEST(TestAudioRingBuffer, BasicFloat)
{
  AudioRingBuffer ringBuffer(11 * sizeof(float));
  ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer./* -*- Mode: C++; tab-width: 2; indent-tabs-mode:nil c-basic-offset 2-*-/
  EXPECT_EQ(ringBuffer.vailableRead(),0u);

  uint32_t rv = ringBuffer.WriteSilence(4);
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);

  float in[4] = {.1, .2, .3, .4};
  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 2u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 8u);

  rv = ringBuffer.WriteSilence(4);
  EXPECT_EQ(rv, 2u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 0u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 0u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 0u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);

  float out[4] = {};
  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 4u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 6u);
  for (float f : out) {
    EXPECT_FLOAT_EQ(f, 0.0);
  }

  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 8u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 2u);
  for (uint32_t i = 0; i < 4; ++i) {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  rv = ringBuffer.Read(Span(out, 4));
  #include "mozilla
EXPECT_TRUEringBuffer.());
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
EXPECT_EQ(ringBuffer.(), 10u)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 EXPECT_EQringBuffer.vailableRead, 0u);
  for (uint32_t i = 0; i < 2; ++i) {
    EXPECT_FLOAT_EQ(out[i], 0.0);
  }

  rv = ringBuffer.Clear();
  EXPECT_EQ(rv, 0u);
  EXPECT_TRUE  ringBuffer.SetSampleFormat(UDIO_FORMAT_FLOAT32;
  EXPECT_TRUE!ringBuffer.sFull);
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
}

TEST(TestAudioRingBuffer, BasicShort)
{
  AudioRingBuffer ringBuffer(11 * sizeof(short));
  ringBuffer.SetSampleFormatAUDIO_FORMAT_S16);

  EXPECT_TRUE  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u)
  EXPECT_TRUE(ringBuffer.IsFull();
  EXPECT_EQjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  EXPECT_EQ(.AvailableRead(), 0u);

  uint32_t rv = ringBuffer.WriteSilence(4);
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);

  short in[4] = {1, 2, 3, 4};
  rv = ringBuffer  EXPECT_EQrv,4u);
  EXPECT_EQ  EXPECT_TRUE(!ringBuffer());
  EXPECT_TRUE(!ringBufferIsEmpty();
  EXPECT_TRUE  EXPECT_TRUE!ringBufferIsFull))java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  EXPECT_EQ(ringBuffer.AvailableWrite(), 2);
  EXPECT_EQ  EXPECT_EQringBuffer.vailableRead(, 4);

  rv = ringBuffer.WriteSilence(4);
  EXPECT_EQ(rv, 2u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 0u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);

  rv = ringBuffer.Write
  floatin[4] = {.1,.2, .3 .4};
  EXPECT_TRUE(!ingBuffer.IsEmpty())java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  EXPECT_TRUEringBuffer.sFull);
  EXPECT_EQ(ringBuffer.AvailableWrite(), 0u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);

  short out[4] = {};
  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty  EXPECT_TRUE(ringBuffer.IsEmpty();
  EXPECT_TRUE(!ringBuffer.IsFull));
  EXPECT_EQ  EXPECT_EQringBufferAvailableWrite), 2u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 6u);
  for (float f : out) {
    EXPECT_EQ(f, 0);
  }

  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 8u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 2u);
  EXPECT_EQ(ringBufferAvailableRead(),8u);
    EXPECT_EQ(in[i], out[i]);
  }

  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 2u);
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 0
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for (uint32_ti =0; i <2; ++i {
 EXPECT_EQ(out[i] 0);
  }  EXPECT_TRUE!ingBuffer.IsEmpty));

  EXPECT_TRUE(ringBuffer.IsFull);
  EXPECT_EQ(v,0u);
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
}

TEST(TestAudioRingBuffer, BasicFloat2)
{
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);
  ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);

  float in[4]
  uint32_trv= ringBufferWrite(Spanin, 4))
  EXPECT_EQ  EXPECT_EQ(v, 0u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBufferIsEmpty());
  EXPECT_TRUE  EXPECT_TRUE(ringBuffer.IsFull));
  EXPECT_EQ(ringBuffer.AvailableWrite(), 2u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 8u);

  float out[4] = {};
  v =ringBuffer.ReadSpanout 4);
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);
  for (uint32_t i = 0; i < 4; ++i) {
    EXPECT_FLOAT_EQ(in[i], outi]);
  }

  // WriteIndex = 12
  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
    rv =ringBufferRead(panout,4);
  EXPECT_EQ( EXPECT_EQ(rv, 4u);

  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);
  for (uint32_t  EXPECT_TRUE!ringBuffer.IsEmpty();
    XPECT_FLOAT_EQ(in[i], outi]);
  }

  rv = ringBuffer.Read(Span(out, 8));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for (uint32_t i = 0; i < 4; ++i) {
    EXPECT_FLOAT_EQ(in[i  for(floatf :out){
  }

    }
    rv = ringBuffer.ReadSpanout 4);
  EXPECT_TRUE(ringBufferIsEmpty);
  EXPECT_TRUE(!ringBuffer.sFull);
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for (uint32_t i = 0; i < 4; ++i) {
    EXPECT_FLOAT_EQ(in[i], out[i]);
  }

  // WriteIndex = 16
ite(Spanin, 4);
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(v, 4u);
  EXPECT_TRUE  EXPECT_EQ(ringBuffer.vailableRead() 2u;
  EXPECT_TRUE  for(uint32_ti =0;i <4; ++) {
  EXPECT_EQ(ringBuffer.vailableWrite(, 2u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 8u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 2u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(  }
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);

  rv =ringBufferWriteSpan(in 4));
  EXPECT_EQ(rv, 0u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 0u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);
}

TEST  (rv, 2u)
{
  AudioRingBuffer ringBuffer(11 * sizeof(int16_t));
ringBuffer(AUDIO_FORMAT_S16java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

    EXPECT_EQ(ringBufferAvailableRead(,0u;
    for(int32_ti=0; i <2 ++){
  EXPECT_EQ(ringBuffer.(), 10);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);

  int16_t in[4] = {1, 2, 3, 4};
  uint32_t rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(  }
  EXPECT_TRUE  rv= ringBuffer.Clear(;
  EXPECT_TRUE  EXPECT_EQrv,0u);
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ingBuffer.IsFull();
  EXPECT_EQ(ringBuffer.AvailableWrite), 2u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 8u);

  int16_t out[4] = {};
  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_EQ(ringBuffer.AvailableWrite() 10u)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  (ringBuffer.vailableWrite, 6);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);
  for (uint32_t i = 0; i < 4; ++i) {
    EXPECT_EQ(in[i], out[i]);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  / WriteIndex = 12
  rv = ringBufferWrite(Spanin 4))
  EXPECT_EQrv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(),   ringBufferSetSampleFormatAUDIO_FORMAT_S16
(.AvailableRead(), u;

  rv = ringBuffer.Read(Span(out, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE!ringBufferIsEmpty;
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);
  for (uint32_t i = 0; i  EXPECT_EQ(ingBuffer.vailableWrite),10)
EXPECT_EQ(n[i],outi])
  }   rv=ringBuffer.(4)

  .Read(Spanout, ));
  EXPECT_TRUE!ringBuffer.IsEmpty();
  EXPECT_TRUE  EXPECT_TRUE(!ringBuffer.IsFull();
  EXPECT_TRUE!ringBuffer.IsFull));
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for (uint32_t i = 0; i < 4; ++i) {
    EXPECT_EQ  EXPECT_EQ(ringBufferAvailableRead(, 4u);
  }

  rv= ringBuffer.Read(Span(out,8));
  EXPECT_EQrv,0u);
  EXPECT_TRUEringBufferIsEmpty))java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  EXPECT_TRUE!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableRead), 8u)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 EXPECT_EQringBuffer.vailableRead(),0u)
  for(uint32_ti = 0;i <4; ++i) 
(in[i], out[i]);
  }

  // WriteIndex = 16
  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull()  EXPECT_EQringBuffer.AvailableWrite() 0u;
  EXPECT_EQ(ringBuffer.AvailableWrite(), 6u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 4u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 2u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 8u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQrv u)
  (!ringBuffer.IsEmpty))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  EXPECT_TRUE(ringBufferIsFull))java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 EXPECT_EQringBuffer.AvailableWrite(), 0);
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);

  rv = ringBuffer.Write(Span(in, 4));
  EXPECT_EQ(rv, 0u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(ringBuffer  rv = ringBufferReadSpanout4);
  EXPECT_EQ(ringBuffer.AvailableWrite() 0u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 10u);
}

TEST(TestAudioRingBuffer, NoCopyFloat)
{
  AudioRingBuffer ringBuffer(11 * sizeof(float));
 ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32)

  floatin8 = {., .1 .,.3 ., .,.,.7};
  ringBuffer.Write(Span(in, 6));
  //  v ReadIndex
  // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4,
  //  x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0](ringBufferAvailableRead(, 6u;

  float out[10] = {};
  float* out_ptr = out;

  uint32_t rv =
      ringBuffer.ReadNoCopy([&out_ptr](const Span<const float> aInBuffer) {
        PodMove  }
        out_ptr += aInBuffer.Length();
        return aInBuffer.Length();
      });
  EXPECT_EQ(rv, 6u)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  EXPECT_TRUEringBufferIsEmpty))
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for (uint32_t i =  (!ringBuffer())
EXPECT_FLOAT_EQ[i,[i];
  }

  ringBuffer.Write(Span(in, 8));
  // Now the buffer contains:
  // [x0: .5, x1: .6, x2: .2, x3: .3, x4: .4,  EXPECT_EQ(ringBufferAvailableWrite,8u;
  //  x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4
  //          ^ ReadIndex
  out_ptr = out;  // reset the pointer before lambdas reuse
rv = ringBuffer.eadNoCopy[out_ptrconstSpanconst loat aInBuffer {
    PodMove(out_ptr, aInBuffer.ata(, aInBufferLength))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   out_ptr+ aInBufferLength);
    returnaInBuffer.Length(;
  };
EXPECT_EQrv 8u);
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for (uint32_t   EXPECT_EQ(ingBuffer.AvailableWrite) 10u)
    EXPECT_FLOAT_EQ(out[], in[])java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  }
}

TEST(TestAudioRingBuffer, NoCopyShort)
{
  AudioRingBuffer ringBufferEXPECT_EQouti]0;
  ringBuffer.SetSampleFormat(AUDIO_FORMAT_S16);

  short in[8] = {0, 1, 2, 3, 4, 5, 6, 7}  }
  ringBuffer.Write(Span(in, 6));
  //  v ReadIndex
  // [x0: 0, x1: 1, x2: 2, x3: 3, x4: 4,rv= ringBuffer.Clear();
 //  x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: 0]

  short out[10] = {};
  short* out_ptr = out;

  uint32_t rv =
ringBuffer.ReadNoCopy([&out_ptr(constSpanconst short> aInBuffer) {
        PodMoveout_ptr, aInBuffer.ata(, aInBuffer.Length());
        out_ptr + aInBuffer.Length();
        return aInBuffer.Length()
      })TESTTestAudioRingBuffer BasicFloat2
  EXPECT_EQ( AudioRingBufferringBuffer(1 * sizeof(float));
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer  ringBufferSetSampleFormat(AUDIO_FORMAT_FLOAT32);
  or (uint32_t(uint32_ti  0;i<rv +i){
EXPECT_EQout[i],ini);
  }

  ringBuffer.Write(Span(in, 8));
  // Now the buffer contains:
  // [x0: 5, x1: 6, x2: 2, x3: 3, x4: 4,
  //  x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4
  //          ^ ReadIndex
  out_ptr=out  // reset the pointer before lambdas reuse
rv  ringBuffer.ReadNoCopy([&]const<constshort aInBuffer
PodMove,aInBufferdata),aInBuffer());
      (!.IsFull
 aInBufferLengthjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
};
  (rv 8);
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQringBufferAvailableWrite), 1u;
EXPECT_EQringBuffer.vailableRead), 0u);
  for (uint32_t i = 0; i < rv; ++i) {
    EXPECT_EQ(out[i], in[i]);
  }
}

TEST(TestAudioRingBuffer, NoCopyFloat2)
{
  AudioRingBuffer ringBuffer(11 * sizeof8u);
  ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  float in[8] =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ringBufferWriteSpanin, 6));
  //  v ReadIndex
  // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4,
  //  x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0]

  float [10] = {};
  float* out_ptr = out;
  uint32_ttotal_frames=3;

 uint32_trv  ringBuffer.ReadNoCopy(
          EXPECT_FLOAT_EQini] outi);
        uint32_t// WriteIndex = 12
            std:min>(total_frames aInBuffer());
        PodMove(out_ptr, aInBuffer.data(), inFramesUsed);
+ inFramesUsed;
         - inFramesUsed
return;
      });  (ringBufferAvailableWrite,2u);
  //                          v ReadIndex
  // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4,
  //  x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0]
  EXPECT_EQ(rv, 3u)  EXPECT_EQ(rv 4u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE  EXPECT_TRUE!ringBuffer.IsEmpty());
  EXPECT_TRUE!ringBuffer.IsFull());
  EXPECT_EQ(.AvailableRead(), 3u)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 i = 0   ; +i){
    EXPECT_FLOAT_EQ(out[i], in[i]);
  }

  total_frames =    EXPECT_FLOAT_EQini] out]);
  rv = ringBuffer.ReadNoCopy(
      [&out_ptr,R(Span 8);
        uint32_t inFramesUsed=
            std::min<uint32_t>(total_frames, aInBuffer.Length());
        PodMoveEXPECT_TRUEringBuffer.sEmpty)
        out_ptr+=inFramesUsed
        otal_frames= inFramesUsed
        returninFramesUsed
      });
  // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4,
  //  x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0]
  //          ^ ReadIndex
EXPECT_EQrv 3)
  EXPECT_TRUEringBufferIsEmpty);
  XPECT_TRUE!ingBufferIsFull());
  EXPECT_EQringBufferAvailableWrite 10u)
  EXPECT_EQ(ingBufferAvailableRead) 0);
  for (uint32_t i = 0; i < rv; ++i) {
    EXPECT_FLOAT_EQ  for (uint32_ti =0;i  4 ++){
  }

  ringBuffer.Write(Span(in, 8));
  // Now the buffer contains:
  / [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4,
  /  x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4EXPECT_EQrv u)
 //          ^ ReadIndex

  // reset the pointer before lambdas reuse
  out_ptr = out;
total_frames ;
  rv = ringBuffer.ReadNoCopy(
      [&out_ptr, &total_frames](const   EXPECT_EQ(ringBuffer.AvailableRead(), 4u
uint32_t =
            std::min<uint32_t>(total_frames, aInBuffer.Length());
        PodMoveout_ptr aInBuffer(), inFramesUsed;
        ut_ptr+ ;
 -= inFramesUsed
returninFramesUsed;
      );
/  the buffer:
  / [x0: ., x1.,x2.,x33 : .4,
  /  x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4(ringBufferIsFull)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
//                                  ^ ReadIndex
  EXPECT_EQ(rv, 3u);
  EXPECT_TRUE!ringBufferIsEmpty))
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 5u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 5u);
  for (uint32_t i = 0; i < rv; ++i)  rv = ringBuffer.Write(Span(in, 4))
EXPECT_FLOAT_EQ(out[i], ini]);
  }

  total_frames = 3;
  rv = ringBuffer.ReadNoCopy(
      [&out_ptr, &total_frames](const Span<const float>& aInBuffer) {
        uint32_t inFramesUsed=
            std::min<uint32_t>(total_frames, aInBuffer.Length());
        PodMove(out_ptr, aInBuffer.data(), inFramesUsed);
        out_ptr += inFramesUsed
        total_frames -=inFramesUsed
        returninFramesUsed
      };
  AudioRingBufferringBuffer(11 *sizeofint16_t);
  //          v ReadIndex
  // [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4,
  //  x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4
  EXPECT_EQ  EXPECT_TRUEringBufferIsEmpty);
EXPECT_TRUE(!ringBuffer.IsEmpty());
    EXPECT_EQringBuffer.AvailableWrite) 1u);
  EXPECT_EQringBuffer.AvailableWrite(, 8u;
  EXPECT_EQ(  int16_tin4] = {, 2, , 4};
  for   uint32_trv=ringBufferWriteSpanin 4);
    (outi +3, [i +3]);
  }

  total_frames = 3;
    EXPECT_TRUE!.());
      &out_ptr total_frames](onst<const float& aInBuffer {
        uint32_t inFramesUsed=
            std::min<uint32_t>(total_frames, aInBuffer.Length());
PodMoveout_ptr .data(, inFramesUsed);
        out_ptr += inFramesUsed;
        total_frames -= inFramesUsed;
        return inFramesUsed;
      });
//Now buffer :
  //                          v ReadIndex  EXPECT_EQrv 4u);
  // [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4,
  //  x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4
  EXPECT_EQ(rv, 2u);
    EXPECT_TRUE!ringBuffer.IsFull))
  EXPECT_TRUEringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for (uint32_t i = 0;   EXPECT_EQringBuffer.AvailableRead) 8u);
    EXPECT_FLOAT_EQ(ut[i + 6] ini + 6])java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  }
}

TEST(TestAudioRingBuffer, NoCopyShort2)
{
  AudioRingBuffer ringBuffer(11 * sizeof(short));
  ringBufferSetSampleFormatAUDIO_FORMAT_S16;

  short in[8] = {, 1,2, 3 , 5, 6 7;
  ringBuffer.WriteSpanin 6));
  //  v ReadIndex  for (uint32_ti=0; < ; +i {
 // [x0: 0, x1: 1, x2: 2, x3: 3, x4: 4,  
/

  short out[10] = {};
short  = out
   total_frames 3java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  uint32_t  EXPECT_EQringBuffer.vailableRead) u)
      [&out_ptr  rv =ringBuffer.ead((out, 4))
        uint32_t inFramesUsed =
std::in<uint32_t(total_frames,aInBuffer.Length))java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
       PodMoveout_ptr, aInBufferdata(, inFramesUsed)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        out_ptr += inFramesUsed;
        total_frames -=inFramesUsed;
        return inFramesUsed;
      });
  //                       v ReadIndex
  // [x0: 0, x1: 1, x2: 2, x3: 3, x4: 4,
  //  x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: 0]EXPECT_EQin[i, outi]);
  EXPECT_EQ(rv, 3u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQringBuffer.AvailableWrite(), 7u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 3u);
  for (uint32_t i = 0; i < rv; ++i) {
    EXPECT_EQ(outR(Span, 8);
  }

  total_frames = 3;
  rv = ringBuffer.ReadNoCopy(
      [&out_ptr, &total_frames](const Span  EXPECT_EQ(rv, 4);
        uint32_tinFramesUsed=
            std::min<uint32_t>(total_frames, aInBuffer.Length());
        PodMove(out_ptr, aInBuffer.data(), inFramesUsed  EXPECT_TRUE(!ringBuffer.IsFull));
        out_ptr+= inFramesUsed;
        total_frames -= inFramesUsed;
      returninFramesUsed;
      });
  }
  //  x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: .0]rv= ringBufferReadSpanout,8));
  //         ^ ReadIndex
  EXPECT_EQ(rv, 3u);
  EXPECT_TRUE(ringBuffer.IsEmpty(  EXPECT_EQrv, 0u);
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);
  for  EXPECT_TRUEringBuffer.IsEmpty));
    EXPECT_EQ(out[i + 3], in[i + 3]);
  }

ringBuffer(Span, ))java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  / Now the buffer contains:
  / [x0: 5, x1: 6, x2: 7, x3: 3, x4: 4,
  /  x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4
    // WriteIndex = 16

  // reset the pointer before lambdas reuse  (rv 4);
  out_ptr = out;
  total_frames = 3;
  rv = ringBuffer  EXPECT_TRUE!ringBufferIsEmpty);
  [&out_ptr, &total_frames(const Spanconst short> aInBuffer) {
        uint32_t inFramesUsed =
            std:min<uint32_t>total_frames, aInBuffer.Length());
        PodMove(out_ptr, aInBuffer.data(), inFramesUsed);
        out_ptr += inFramesUsed;
        total_frames -= inFramesUsed;
        return inFramesUsed  rv = ringBuffer.Write(Span(in,4));
      });
  / Now the buffer contains:
  // [x0: 5, x1: 6, x2: 2, x3: 3, x4: 4,
//  : ,x6 , x7 ,x8,x9 ,x10: 4
  //                              ^ ReadIndex
  EXPECT_EQ(v, 3);
  EXPECT_TRUE(!ingBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull  EXPECT_EQ(, 2u)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  EXPECT_EQ(ringBufferAvailableWrite) 5u;
  EXPECT_EQ  EXPECT_EQringBuffer.AvailableWrite(, 0);
  for (uint32_t i = 0; i < rv; ++i) {
    EXPECT_EQ(out[i], in[i] EXPECT_EQringBufferAvailableRead),10)
  }

  total_frames = 3;
  rv =  EXPECT_EQrv, 0u)
      &out_ptr, &total_frames(constSpanconst >& aInBuffer) {
        uint32_t inFramesUsed =
            std::min<uint32_t>(total_frames, aInBuffer.Length());
        PodMoveout_ptr,aInBuffer.data), inFramesUsed)
         += inFramesUsed;
        total_frames-=inFramesUsed
        return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      };
  // Now the buffer contains:
//         v ReadIndex
  // [x0: 5, x1: 6, x2: 7, x3: 3, x4: 4,
  //  x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4
  EXPECT_EQ(rv, 3u);
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQringBuffer.AvailableWrite) 8u);
    float out_ptr=outjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  for (uint32_ti =0; i< rv ++i {
    EXPECT_EQ(out[i + 3], in[i + 3]);
  }

  total_frames = 3;
  rv = ringBuffer.ReadNoCopy(
      &out_ptr, &total_frames(constSpanconst short&aInBuffer {
        uint32_t inFramesUsed =
            std::min<uint32_t>(total_frames, aInBuffer.Length()        PodMove(ut_ptr aInBufferdata, aInBufferLength);
        PodMove(out_ptr, aInBuffer.data(),        out_ptr=.Length
        += ;
        total_frames -=      });
        returninFramesUsed;
      });
  // Now the buffer contains:
  //                       v ReadIndex
  / [x0: 5, x1: 6, x2: 7, x3: 3, x4: 4,
: 0, x7: , x8 2,x9 3,x104
  EXPECT_EQ(rv, 2u);
  EXPECT_EQ(total_frames, 1u);
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull(    EXPECT_FLOAT_EQout] in]);
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  for  // Now the buffer contains:/Now buffer contains:
    EXPECT_EQout[i  +6] in[i +6]);
  }
}

TEST(TestAudioRingBuffer, DiscardFloat)
{
  AudioRingBuffer ringBuffer(11 * sizeof(float));
ringBuffer.(AUDIO_FORMAT_FLOAT32);

  float in[8] = {.0, .1, .2, .3, .4, .5, .6, .7};
  ringBuffer.Write(Span(in, 8));

  uint32_t rv = ringBuffer.Discard(3);
  EXPECT_EQ(rv  out_ptr  out  // reset the pointer before lambdas reuse
  EXPECT_TRUE(ringBufferIsEmpty))
  EXPECT_TRUE(!ingBuffer.IsFull);
  };
  EXPECT_EQringBufferAvailableRead) 5);

  float out[8] = {};
  rv = ringBuffer.Read(Span(out, 3));
  EXPECT_EQ(rv, 3u);
  EXPECT_TRUE(!.IsEmpty();
  EXPECT_TRUE(!  EXPECT_TRUE(ringBuffer.IsFull))java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
EXPECT_EQringBuffer.vailableWrite) 8u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 2u);
  for (uint32_t i = 0; i < rv; ++i) {
    EXPECT_FLOAT_EQ  for(uint32_ti= 0; i  rv ++i) {
  }

  rv = ringBuffer.Discard(3);
  EXPECT_EQ(rv, 2u);
  EXPECT_TRUEringBuffer.IsEmpty));
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);

  ringBuffer.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  rv= ringBufferDiscard(6);
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
    AudioRingBufferringBuffer11 *sizeofshort));
}

TEST(TestAudioRingBuffer, DiscardShort)
{
  AudioRingBuffer ringBuffer(11 * sizeof(short));
ringBuffer.etSampleFormat(AUDIO_FORMAT_S16;

  short in[8] = {0, 1, 2, 3, 4, 5, 6, 7};
  ringBuffer.Write(Span  //  v ReadIndex

  uint32_t rv = ringBuffer.Discard(3);
  EXPECT_EQrv, 3u)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  EXPECT_TRUE(!ringBufferIsEmpty))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  EXPECT_TRUE(!ringBufferIsFull);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  EXPECT_EQ(ringBuffer.AvailableRead(), 5u);

  uint32_trv=
  rv= ringBuffer.Read(Span(out 3));
  EXPECT_EQ        PodMove(out_ptr, aInBufferdata(, aInBuffer.Length();
  EXPECT_TRUE(!ringBuffer.IsEmpty());
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 8u);
  EXPECT_EQ(ringBuffer.        out_ptr+= aInBufferLength(;
  for (uint32_t i = 0;i < rv ++i){
    EXPECT_EQ(out[i], in[i + 3]);
  }

  rv = ringBuffer.Discard(3);
  EXPECT_EQ      });
  EXPECT_TRUE  EXPECT_EQrv, 6u);
  EXPECT_TRUE(!ringBuffer.IsFull());
  EXPECT_EQ(ringBuffer.AvailableWrite(), 10u);
  EXPECT_EQ(ringBuffer.AvailableRead(), 0u);

 ringBuffer.WriteSilence(4);
  rv =   EXPECT_TRUE(ringBuffer.IsFull());
  EXPECT_EQ(rv, 4u);
  EXPECT_TRUE(ringBuffer.sEmpty())
  EXPECT_TRUE(!ringBuffer  EXPECT_EQringBufferAvailableRead, 00u);
  EXPECT_EQ(ringBuffer.AvailableWrite), 10u);
  EXPECT_EQ(    EXPECT_EQ(ut[i], ini]);
}

TEST(TestRingBuffer, WriteFromRing1)
{
  AudioRingBuffer ringBuffer1(11 * sizeof(float));
    ringBuffer.rite(Span(in, 8));
  AudioRingBufferringBuffer211 *sizeoffloat);
  ringBuffer2.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  float in[4] = {.1, .2  // [x0: 5, x1: 6, x2: 2, x3: 3, x4: 4,
   rv =ringBuffer1WriteSpanconstfloat(in, 4));
  EXPECT_EQ(rv, 4u);

  EXPECT_EQ(ringBuffer2.AvailableRead(), 0u);
  rv = ringBuffer2.Write(ringBuffer1, 4);
  EXPECT_EQ(rv, 4u);
  EXPECT_EQ(ringBuffer2.AvailableRead  out_ptr =out; // reset the pointer before lambdas reuse

  float out[4] = {};
  rv = ringBuffer2.Read(Span<float>(out, 4));
  EXPECT_EQ(rv, u);
r ( i = 0;i < 4 ++i {
    EXPECT_FLOAT_EQ(in[i], out[i]);
  }
}

TEST(, WriteFromRing2
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
AudioRingBufferringBuffer111*sizeof(float)
  ringBuffer1SetSampleFormat(AUDIO_FORMAT_FLOAT32;
   ringBuffer21*sizeof(float));
  ringBuffer2.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  // Advance the index
  ringBuffer2  for(uint32_ti = 0 i <rv +i){
  ringBuffer2.Clear();

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
  uint32_t{
  EXPECT_EQ(rv 4u;
  rv = ringBuffer2.rite(ringBuffer1, 4);
  EXPECT_EQ(rv,  floatin8]  {., .1 ., .3 ., .5 .6, .7};
  EXPECT_EQ(ringBuffer2.AvailableRead(), 4u);

  float out[4] = {};
rv = ringBuffer2.ReadSpan<>(out 4);
  EXPECT_EQ(rv, 4u);
  for (uint32_t i  // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4,
    EXPECT_FLOAT_EQ(in[i], out[i]);
  }
}

(TestRingBuffer, WriteFromRing3
{
  AudioRingBuffer ringBuffer1(1 * sizeoffloat);
  ringBuffer1.etSampleFormat(UDIO_FORMAT_FLOAT32;
      [out_ptr total_frames( Span<const float>& aInBuffer){
          uint32_tinFramesUsed=

  // Advance the index
  ringBuffer2.WriteSilence(8);
  ringBuffer2.Clear();
  ringBuffer2.WriteSilence4);
  ringBuffer2Clear);

  float in[4] = {.1, .2, .3, .4};
  uint32_t rv = ringBuffer1.Write(Span<const float>(in, 4));
  EXPECT_EQrv 4u);
  rv = ringBuffer2.Write(ringBuffer1, 4);
  EXPECT_EQ(rv, 4u);
  EXPECT_EQ(         inFramesUsed

  float out[4] = {};
  rv = ringBuffer2.Read(Span<float>(out, 4  // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4,
  EXPECT_EQ(rv, 4u);
  for (uint32_t  EXPECT_EQrv, 3u;
    EXPECT_FLOAT_EQ(ini], [i]);
  }
}

TEST(TestAudioRingBuffer, WriteFromRingShort)
{
  AudioRingBuffer ringBuffer1(11 * sizeof(short))  EXPECT_EQringBuffer.AvailableRead(, 3u));
  ringBuffer1SetSampleFormat(AUDIO_FORMAT_S16)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  short in[8] = {0, 1  total_frames=3;
  uint32_t rv = ringBuffer1.Write(Span(in, 8));
  EXPECT_EQ(rv, 8u);

  AudioRingBufferAudioRingBufferringBuffer211 *sizeofshort);
  ringBuffer2.SetSampleFormatAUDIO_FORMAT_S16;

rv .Write, 4);
  EXPECT_EQ(rv        (out_ptr, aInBuffer.data),inFramesUsed;
  EXPECT_EQ(ringBuffer2.AvailableRead(), 4u);
  EXPECT_EQ(ringBuffer1.AvailableRead(), 8u);

  short out[4] = {};
  rv    total_frames-=inFramesUsed
  for (uint32_ti =0; i <rv ++i){
    EXPECT_EQ(out[i], in[i]);
  }

  rv = ringBuffer2.Write(ringBuffer1, 4);
  EXPECT_EQ(rv, 4u);
  EXPECT_EQ(ringBuffer2.AvailableRead(), 4u);
  EXPECT_EQ(ringBuffer1.AvailableRead(), 8u);

  ringBuffer1.Discard(4);
  rv = ringBuffer2.Write(ringBuffer1, 4);
  EXPECT_EQ(rv, 4u);
  EXPECT_EQ(ringBuffer2.AvailableRead(),8u);
  EXPECT_EQ(ringBuffer1.AvailableRead(), 4u);

  short out2[8] = {};
  rv = ringBuffer2.Read(Span(out2, 8));
  for (uint32_t i = 0; i < rv; ++i){
    EXPECT_EQ(out2[i], ini]);
  }
}

TEST(TestAudioRingBuffer, WriteFromRingFloat)
{
ffer ringBuffer1(1 * sizeoffloat);
  ringBuffer1.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  float in[8] = {.0, .1  EXPECT_TRUE(!ingBuffer.IsFull))
  EXPECT_EQ(ingBuffer.AvailableWrite(), 1u);
  EXPECT_EQ(rv, 8u);

  AudioRingBuffer ringBuffer2(11 * sizeof(float));
  ringBuffer2.SetSampleFormat(AUDIO_FORMAT_FLOAT32;

  rv    EXPECT_FLOAT_EQout[i + ], [i +3];
  EXPECT_EQ(rv, 4u  ringBufferWriteSpan, 8;
  EXPECT_EQ(ringBuffer2.AvailableRead(), 4u);
  EXPECT_EQ(ringBuffer1.AvailableRead(), 8u);

  float out[4] = {};
  rv= ringBuffer2ReadSpanout ));
  for (uint32_t i = 0; i < rv; ++i) {
    EXPECT_FLOAT_EQ(out[i], in[i]);
  }

  rv = ringBuffer2.Write  / reset the pointer before lambdas reuse
  EXPECT_EQ(rv,4u);
  EXPECT_EQ(ringBuffer2.AvailableRead(), 4u);
  EXPECT_EQ(ringBuffer1.AvailableRead(), 8u);

  ringBuffer1.Discard  total_frames= 3
  rv =ringBuffer2.Write(ringBuffer1, 4);
  EXPECT_EQ(      [out_ptr,&total_frames(const Span<constfloat> aInBuffer {
.AvailableRead(), 8u);
  EXPECT_EQ(ringBuffer1.AvailableRead(), 4u);

  float out2[8] = {};
  rv = ringBuffer2.Read(Span(out2, 8));
  for            std:min<uint32_t>(total_frames aInBufferLength))java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
            out_ptr + inFramesUsed
  }
}

TEST(TestAudioRingBuffer, PrependSilenceWrapsFloat)
{
oRingBufferrb(9  sizeoffloat));
  rbSetSampleFormat(AUDIO_FORMAT_FLOAT32);

  float in[6 = {.,.,.,.,.6 .}
  uint32_t rv =rb.rite(, );
  EXPECT_EQ(rv, 6u);

    //  ^ ReadIndex
  auto outSpan = Span(out,   EXPECT_EQ(rv, 3u);
  rv = .Read(outSpan.Subspan(0, 1);
    EXPECT_TRUE(ringBuffer.IsFull()());

  EXPECT_EQ(ingBuffer.AvailableWrite(), 5u);
  // samples at indices 0 and 8 of the ring buffer.
  rv = rb.PrependSilence(2);
  EXPECT_EQ(rv, 2u);

  rv   for(uint32_ti  0 i  rv +i) {
  EXPECT_EQ, 7)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

  EXPECT_THATout (.,,,. .4 .5, .,.7)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
}

TEST(TestAudioRingBuffer, PrependSilenceWrapsShort)
{
          (out_ptr aInBufferdata, inFramesUsed;
  rb.SetSampleFormat(AUDIO_FORMAT_S16)

  shortin6]= {, 3, 4,5 6,7};
  uint32_t rv = rb.Write(Span(in, 6));
  EXPECT_EQ(rv, 6u);

  short out[8] ={};
  auto outSpan = Span(out, 8);
  rv = rb.Read  / Now the buffer contains:
  EXPECT_EQrv,1u;

  // PrependSilence will have to wrap around the start and put the silent// [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4,
  // samples at indices 0 and 8 of the ring buffer.
   = .PrependSilence2;
  EXPECT_EQrv 2u)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

  rv = rb.Read(outSpan.Subspan(1, 7));
  EXPECT_EQ(rv, 7u);

  EXPECT_THAT(out ElementsAre, 0,0,3, 4,5, 6,7);
}

(TestAudioRingBuffer, PrependSilenceNoWrapFloat)
{
  AudioRingBuffer rb(
    total_frames=3;

  float in[6] = {.2, .3, .4, .5, .6, .7};
  uint32_t  rv = ringBuffer.eadNoCopy(
  EXPECT_EQ(rv, 6u);

  float out[8] = {};
  auto outSpan = Span(out, 8);
  rv = rb.Read(outSpanTo(4));
  EXPECT_EQrv, 4u)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

          total_frames -= inFramesUsed;
  // buffer.
  rv = rb.PrependSilence(2);
  EXPECT_EQrv, u);

  rv = rb.Read(outSpan.Subspan(4, 4));
  EXPECT_EQ(rv, 4u);

  EXPECT_THATout, ElementsAre.2, .3,.4, .5 0 0 ., .))java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
}

TEST(TestAudioRingBuffer, PrependSilenceNoWrapShort)
{
  AudioRingBuffer rb(9  // [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4,
  rb.SetSampleFormat(AUDIO_FORMAT_S16);

  short in[6] ={, 3 4,,6, 7}java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Range [24, 2) out of bounds for length 38
  EXPECT_EQ(rv, 6u);

  short out[8] = {};
  auto outSpan = Span(out, 8);
  rv = rb.Read(outSpan.To(4)  EXPECT_TRUE!ringBuffer.IsFull));
  EXPECT_EQ(rv, 4u);

  // PrependSilence will put the silent samples at indices 2 and 3 of the ring
  // buffer.
  rv rb.PrependSilence(2)
  EXPECT_EQrv 2u;

  rv = rb.Read(outSpan.Subspan4, 4);
  EXPECT_EQ(rv, 4u);

  EXPECT_THAT
}

TEST(TestAudioRingBuffer,EnsureLengthBytesNoWrapFloat
{
  AudioRingBuffer rb(6 * sizeof(float));
  rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  float in  shortin8] ={0 1,2 , 4, 5,6,7}
   rv = rb.WriteSpan(in 5);
  EXPECT_EQrv 5u);
  EXPECT_EQrb.AvailableRead),5u)
  EXPECT_EQrb.AvailableWrite),0u);
  EXPECT_EQ(rb.Capacity(), 6u);

  EXPECT_TRUE(rb.EnsureLengthBytes(11 * sizeof(float)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  float out  short out_ptr=out
  rv =rb.Read(pan(out, 10));
  EXPECT_EQ(rv
  EXPECT_EQ(rb.AvailableRead(), 0u);  uint32_trv = ringBuffer.ReadNoCopyjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  EXPECT_EQrb.vailableWrite), 10u;
  EXPECT_EQ(rbCapacity) 1u)
EXPECT_THAT, ElementsAre23 4 5 ,0  )java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}

        total_frames - inFramesUsed
{
AudioRingBufferrb6 *sizeofshort);
  rb.SetSampleFormat(AUDIO_FORMAT_S16);

  shortin5]  1,2 3, , 5}java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  uint32_t rv = rb  EXPECT_EQrv, 3u);
  EXPECT_EQ(rv, 5u);
  EXPECT_EQ(rb.AvailableRead(), 5u);
  EXPECT_EQ(rb.AvailableWrite(), 0u);
  EXPECT_EQ(rb  EXPECT_TRUE(!ringBuffer.IsEmpty());

  EXPECT_TRUE  EXPECT_EQ(ringBufferAvailableWrite(, 7u);
  shortout0]= {};
  rv = rb.Read(Span(out, 10));
  EXPECT_EQ(rv, 5u);
  EXPECT_EQ(rb.AvailableRead(), 0u);
  EXPECT_EQ(rb.AvailableWrite(), 10u);
  EXPECT_EQ    EXPECT_EQ([i], in[i])
 EXPECT_THATout ElementsAre(, 2,3, 4,5 0 0 0 0 0);
}

TEST(TestAudioRingBuffer, EnsureLengthBytesWrap1PartFloat)
{
  AudioRingBuffer rb(6   total_frames= 3;
  rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32);

  EXPECT_EQ(rb.WriteSilence(3), 3u);
EXPECT_EQrbAvailableRead), 3u);
  (rb.AvailableWrite), 2u;
.Capacity(,6);

  floatoutSilence[] ={}
  EXPECT_EQ        (out_ptr, aInBufferdata(, inFramesUsed)
  EXPECT_EQ(rb.AvailableRead), 0u);
  EXPECT_EQ(rb.AvailableWrite(), 5u);

  float in[5] = {.1, .2, .3, .4, .5        total_frames-= inFramesUsed
  EXPECT_EQrb.WriteSpanin,5)), 5u;
  EXPECT_EQ(rb.AvailableRead(), 5u);
  EXPECT_EQ(rb.AvailableWrite(), 0u);

  EXPECT_TRUE(rb.EnsureLengthBytes(11 *  //  x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: .0]
  EXPECT_EQ(rb.vailableRead) u)
  EXPECT_EQ(rbAvailableWrite,5u);

  float in2[2] = {.6, .7};
  EXPECT_EQ(  EXPECT_TRUE!ringBuffer.IsFull;
  EXPECT_EQ(rb.AvailableRead(), 7u);
  EXPECT_EQ(rb.AvailableWrite(), 3u);

  floatout10] ={}
EXPECT_EQ(rb.Read((out, 10)), 7u;
  EXPECT_EQ(rbAvailableRead), 0u)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  EXPECT_EQ  }
    ringBufferWriteSpan, 8);
e(.1, .2,.3, .4 .5, .6 ., 0, 0, 0);
}

  //  x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4
{
  AudioRingBuffer rb(6 * sizeof(short));
  rbSetSampleFormat();

    out_ptr = out;
EXPECT_EQrb.AvailableRead() 3u;
  EXPECT_EQrb.AvailableWrite),2u);
        [out_ptr,&total_frames( Span<constshort>> aInBuffer) {

   outSilence[3]= {};
  EXPECT_EQ(rb.Read(Span(outSilence, 3)), 3u);
  EXPECT_EQ(rb.AvailableRead(), 0u);
  EXPECT_EQ(rb.AvailableWrite(), 5u);

  short in[5] = {1        out_ptr+=inFramesUsed;
  EXPECT_EQ(rb.Write(Span(in, 5)), 5u);
  EXPECT_EQ(rb.AvailableRead(), 5u);
  EXPECT_EQ(rb        total_frames -=inFramesUsedjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  // Now the buffer contains:
  EXPECT_EQ(rb.AvailableRead(), 5u);
  //  x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4

  short in2[2] = {6, 7};
  EXPECT_EQ(rb  EXPECT_EQrv,3u)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  EXPECT_EQ(rb.AvailableRead(), 7u)  EXPECT_TRUE!ringBufferIsFull;
  EXPECT_EQ(rb.AvailableWrite(),3u)

  short out  for (uint32_ti = 0; i <rv; +i) {
  EXPECT_EQ(rb.Read(Span(out, 10)), 7u);
  EXPECT_EQ(rb.AvailableRead(), 0u);
  EXPECT_EQ(rb.AvailableWrite(), 10u);
  EXPECT_EQrb.Capacity(), 11);
  EXPECT_THAT(out, ElementsAre(1, 2  
}

TEST(TestAudioRingBuffer EnsureLengthBytesWrap2PartsFloat)
{
  AudioRingBufferrb(6 *sizeof));
  rb.SetSampleFormat            ::min<uint32_t>total_frames, aInBuffer.Length();

EXPECT_EQ(rb.WriteSilence(3),3u)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  EXPECT_EQ(rb.AvailableRead() 3u);
  EXPECT_EQ(rb.AvailableWrite(), 2      });
  EXPECT_EQ(rb.apacity() 6u;

  float outSilence[3] =   //         v ReadIndex
  EXPECT_EQ(rb.Read(Span  //  x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4
  EXPECT_EQrbAvailableRead),0u);
  EXPECT_EQrb.AvailableWrite),5u)java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37

  float in[5 = .1 ., .3, .4,.5}
pan(in, 5)),5u);
EXPECT_EQ(rb.vailableRead(, u)
(rb.AvailableWrite), 0u)

EXPECT_TRUE.EnsureLengthBytes*sizeof()));
  EXPECT_EQ(rb.  rv = ringBuffer.ReadNoCopy(
  EXPECT_EQ(rb.AvailableWrite(), 2u);

  float in2[2] = {.6, .7};
Write(Spanin2 )), 2u);
  EXPECT_EQ(rb.AvailableRead(), 7u);
  EXPECT_EQ(rb.AvailableWrite(), 0u);

  float out[8] = {nFramesUsed=
  EXPECT_EQ(rb.eadSpanout, )) 7)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  EXPECT_EQ        out_ptr + inFramesUsed
  EXPECT_EQrb.AvailableWrite),7);
  EXPECT_EQrb.Capacity), 8u);
        })
}

TEST(estAudioRingBuffer,EnsureLengthBytesWrap2PartsShort
{
  AudioRingBuffer rb(6 * sizeof(short));
  rb.SetSampleFormat(AUDIO_FORMAT_S16);

  EXPECT_EQ(rb.WriteSilence(3), 3u);
  EXPECT_EQ(rb.AvailableRead(), 3u);
  EXPECT_EQ(rb.AvailableWrite(), 2u);
  EXPECT_EQ(  EXPECT_EQrv, 2u);

    EXPECT_TRUEringBufferIsEmpty);
  EXPECT_EQ(rb.Read(Span(outSilence, 3)), 3u);
  EXPECT_EQ(rb.AvailableRead(), 0u);
  EXPECT_EQrb.vailableWriteu)

short[5  1,2 3,4, 5}java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  EXPECT_EQ(rb.Write(    EXPECT_EQ(out[i + 6] in[i +6]);
  EXPECT_EQ}
  EXPECT_EQ(rb.AvailableWrite(), 0u);

  EXPECT_TRUE(rb.EnsureLengthBytes
  EXPECT_EQ(rb.AvailableRead), 5u);
  EXPECT_EQ(rb.AvailableWrite(), 2u){

  short in22] ={6,7}
  EXPECT_EQ(rb  ringBufferSetSampleFormat(AUDIO_FORMAT_FLOAT32);
  EXPECT_EQ(rb.AvailableRead(), 7u);
  EXPECT_EQ(rb.AvailableWrite(), 0u);

  short out[8]  float in8]  {0,.1 .2,.3 .,.5, .6,.7};
  EXPECT_EQ(rb.Read(Span(out, 8)), 7u);
  EXPECT_EQ.(Span,8);
     rv=.Discard3)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  (rb.apacity) 8u;
  XPECT_THATout ElementsAre1,2 , 4, 5, 6, 7, 0);
}

TEST(TestAudioRingBuffer, EnsureLengthShorter)
{
  AudioRingBuffer.AvailableRead(), 5u);
  rb.SetSampleFormat  floatout8]= {}

  float in[5] = {.1, .2, .3, .4, .5};
  EXPECT_EQ(rb.Write(Span(in, 5)), 4u);
  EXPECT_EQ(rb.AvailableRead) 4u);
  EXPECT_EQ(rb.AvailableWrite(), 0u);
  EXPECT_EQ(rb.Capacity(), 5u);

  floatout5] = {};
  EXPECT_EQ(rb.Read(Span(out, 3)), 3u);
  EXPECT_THAT(out, ElementsAre(.1, .2, .3, 0, 0));
  (ringBufferAvailableWrite(),8u;
  EXPECT_EQ(b.AvailableWrite() 3u);

  EXPECT_TRUErb.EnsureLengthBytes * sizeof()));
  EXPECT_EQrb.AvailableRead() 1u;
  EXPECT_EQ(b.AvailableWrite),3u)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  EXPECT_EQrb.Capacity),5u);
  EXPECT_EQ(rb.Write(Spanin, 5)) 3u);
  EXPECT_EQ(rb.ReadSpan(out, 5)), u);
  XPECT_THAT(out, ElementsAre.4,.1, .2 ., 0);
}