diff --git a/modules/juce_audio_formats/format/juce_BufferingAudioFormatReader.cpp b/modules/juce_audio_formats/format/juce_BufferingAudioFormatReader.cpp
index b4cf4b86aa..230188671d 100644
--- a/modules/juce_audio_formats/format/juce_BufferingAudioFormatReader.cpp
+++ b/modules/juce_audio_formats/format/juce_BufferingAudioFormatReader.cpp
@@ -187,15 +187,16 @@ static bool isSilent (const AudioBuffer<float>& b)
 
 struct TestAudioFormatReader  : public AudioFormatReader
 {
-    explicit TestAudioFormatReader (AudioBuffer<float>& b)
+    explicit TestAudioFormatReader (const AudioBuffer<float>* b)
         : AudioFormatReader (nullptr, {}),
           buffer (b)
     {
+        jassert (buffer != nullptr);
         sampleRate            = 44100.0f;
         bitsPerSample         = 32;
         usesFloatingPointData = true;
-        lengthInSamples       = buffer.getNumSamples();
-        numChannels           = (unsigned int) buffer.getNumChannels();
+        lengthInSamples       = buffer->getNumSamples();
+        numChannels           = (unsigned int) buffer->getNumChannels();
     }
 
     bool readSamples (int* const* destChannels, int numDestChannels, int startOffsetInDestBuffer,
@@ -214,7 +215,7 @@ struct TestAudioFormatReader  : public AudioFormatReader
                 dest += startOffsetInDestBuffer;
 
                 if (j < (int) numChannels)
-                    FloatVectorOperations::copy (dest, buffer.getReadPointer (j, (int) startSampleInFile), numSamples);
+                    FloatVectorOperations::copy (dest, buffer->getReadPointer (j, (int) startSampleInFile), numSamples);
                 else
                     FloatVectorOperations::clear (dest, numSamples);
             }
@@ -223,9 +224,20 @@ struct TestAudioFormatReader  : public AudioFormatReader
         return true;
     }
 
-    const AudioBuffer<float>& buffer;
+    const AudioBuffer<float>* buffer;
 };
 
+static AudioBuffer<float> generateTestBuffer (Random& random, int bufferSize)
+{
+    AudioBuffer<float> buffer { 2, bufferSize };
+
+    for (int channel = 0; channel < buffer.getNumChannels(); ++channel)
+        for (int sample = 0; sample < buffer.getNumSamples(); ++sample)
+            buffer.setSample (channel, sample, random.nextFloat());
+
+    return buffer;
+}
+
 class BufferingAudioReaderTests  : public UnitTest
 {
 public:
@@ -238,44 +250,54 @@ public:
 
         beginTest ("Timeout");
         {
-            struct BlockingReader  : public AudioFormatReader
+            struct BlockingReader  : public TestAudioFormatReader
             {
-                BlockingReader()
-                    : AudioFormatReader (nullptr, {})
+                explicit BlockingReader (const AudioBuffer<float>* b)
+                    : TestAudioFormatReader (b)
                 {
-                    sampleRate            = 44100.0f;
-                    bitsPerSample         = 32;
-                    usesFloatingPointData = true;
-                    lengthInSamples       = 1024;
-                    numChannels           = 2;
                 }
 
-                bool readSamples (int* const*, int, int, int64, int) override
+                bool readSamples (int* const* destChannels,
+                                  int numDestChannels,
+                                  int startOffsetInDestBuffer,
+                                  int64 startSampleInFile,
+                                  int numSamples) override
                 {
                     Thread::sleep (100);
-                    return true;
+                    return TestAudioFormatReader::readSamples (destChannels, numDestChannels, startOffsetInDestBuffer, startSampleInFile, numSamples);
                 }
             };
 
-            BufferingAudioReader bufferingReader (new BlockingReader(), timeSlice, 64);
+            Random random { getRandom() };
+
+            const auto blockingBuffer = generateTestBuffer (random, 1024);
+            expect (! isSilent (blockingBuffer));
+
+            BufferingAudioReader bufferingReader (new BlockingReader (&blockingBuffer), timeSlice, 64);
             bufferingReader.setReadTimeout (10);
 
-            AudioBuffer<float> readBuffer { 2, 1024 };
+            const auto originalBuffer = generateTestBuffer (random, 1024);
+            expect (! isSilent (originalBuffer));
+            expect (originalBuffer != blockingBuffer);
+
+            auto readBuffer = originalBuffer;
+            expect (readBuffer == originalBuffer);
 
-            readBuffer.clear();
             read (bufferingReader, readBuffer);
-
+            expect (readBuffer != originalBuffer);
             expect (isSilent (readBuffer));
         }
 
         beginTest ("Read samples");
         {
+            Random random { getRandom() };
+
             for (auto i = 4; i < 18; ++i)
             {
                 const auto backgroundBufferSize = 1 << i;
-                auto buffer = generateTestBuffer (backgroundBufferSize);
+                const auto buffer = generateTestBuffer (random, backgroundBufferSize);
 
-                BufferingAudioReader bufferingReader (new TestAudioFormatReader (buffer), timeSlice, backgroundBufferSize);
+                BufferingAudioReader bufferingReader (new TestAudioFormatReader (&buffer), timeSlice, backgroundBufferSize);
                 bufferingReader.setReadTimeout (-1);
 
                 AudioBuffer<float> readBuffer { buffer.getNumChannels(), buffer.getNumSamples() };
@@ -287,19 +309,6 @@ public:
     }
 
 private:
-    AudioBuffer<float> generateTestBuffer (int bufferSize) const
-    {
-        auto random = getRandom();
-
-        AudioBuffer<float> buffer { 2, random.nextInt ({ bufferSize, bufferSize * 10 }) };
-
-        for (int channel = 0; channel < buffer.getNumChannels(); ++channel)
-            for (int sample = 0; sample < buffer.getNumSamples(); ++sample)
-                buffer.setSample (channel, sample, random.nextFloat());
-
-        return buffer;
-    }
-
     void read (BufferingAudioReader& reader, AudioBuffer<float>& readBuffer)
     {
         constexpr int blockSize = 1024;