talk/base/stream_unittest.cc - vendor/opensource/libjingle - Git at Google

 /*
  * libjingle
  * Copyright 2004--2011, Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "talk/base/gunit.h"
 #include "talk/base/stream.h"

 namespace talk_base {

 ///////////////////////////////////////////////////////////////////////////////
 // TestStream
 ///////////////////////////////////////////////////////////////////////////////

 class TestStream : public StreamInterface {
 public:
   TestStream() : pos_(0) { }

   virtual StreamState GetState() const { return SS_OPEN; }
   virtual StreamResult Read(void* buffer, size_t buffer_len,
                             size_t* read, int* error) {
     unsigned char* uc_buffer = static_cast<unsigned char*>(buffer);
     for (size_t i=0; i<buffer_len; ++i) {
       uc_buffer[i] = pos_++;
     }
     if (read)
       *read = buffer_len;
     return SR_SUCCESS;
   }
   virtual StreamResult Write(const void* data, size_t data_len,
                              size_t* written, int* error) {
     if (error)
       *error = -1;
     return SR_ERROR;
   }
   virtual void Close() { }
   virtual bool SetPosition(size_t position) {
     pos_ = position;
     return true;
   }
   virtual bool GetPosition(size_t* position) const {
     if (position) *position = pos_;
     return true;
   }
   virtual bool GetSize(size_t* size) const {
     return false;
   }
   virtual bool GetAvailable(size_t* size) const {
     return false;
   }

 private:
   unsigned char pos_;
 };

 bool VerifyTestBuffer(unsigned char* buffer, size_t len,
                       unsigned char value) {
   bool passed = true;
   for (size_t i=0; i<len; ++i) {
     if (buffer[i] != value++) {
       passed = false;
       break;
     }
   }
   // Ensure that we don't pass again without re-writing
   memset(buffer, 0, len);
   return passed;
 }

 void SeekTest(StreamInterface* stream, const unsigned char value) {
   size_t bytes;
   unsigned char buffer[13] = { 0 };
   const size_t kBufSize = sizeof(buffer);

   EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
   EXPECT_EQ(bytes, kBufSize);
   EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value));
   EXPECT_TRUE(stream->GetPosition(&bytes));
   EXPECT_EQ(13U, bytes);

   EXPECT_TRUE(stream->SetPosition(7));

   EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
   EXPECT_EQ(bytes, kBufSize);
   EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value + 7));
   EXPECT_TRUE(stream->GetPosition(&bytes));
   EXPECT_EQ(20U, bytes);
 }

 TEST(StreamSegment, TranslatesPosition) {
   TestStream* test = new TestStream;
   // Verify behavior of original stream
   SeekTest(test, 0);
   StreamSegment* segment = new StreamSegment(test);
   // Verify behavior of adapted stream (all values offset by 20)
   SeekTest(segment, 20);
   delete segment;
 }

 TEST(StreamSegment, SupportsArtificialTermination) {
   TestStream* test = new TestStream;

   size_t bytes;
   unsigned char buffer[5000] = { 0 };
   const size_t kBufSize = sizeof(buffer);

   {
     StreamInterface* stream = test;

     // Read a lot of bytes
     EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
     EXPECT_EQ(bytes, kBufSize);
     EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, 0));

     // Test seeking far ahead
     EXPECT_TRUE(stream->SetPosition(12345));

     // Read a bunch more bytes
     EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
     EXPECT_EQ(bytes, kBufSize);
     EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, 12345 % 256));
   }

   // Create a segment of test stream in range [100,600)
   EXPECT_TRUE(test->SetPosition(100));
   StreamSegment* segment = new StreamSegment(test, 500);

   {
     StreamInterface* stream = segment;

     EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
     EXPECT_EQ(500U, bytes);
     EXPECT_TRUE(VerifyTestBuffer(buffer, 500, 100));
     EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);

     // Test seeking past "end" of stream
     EXPECT_FALSE(stream->SetPosition(12345));
     EXPECT_FALSE(stream->SetPosition(501));

     // Test seeking to end (edge case)
     EXPECT_TRUE(stream->SetPosition(500));
     EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);

     // Test seeking to start
     EXPECT_TRUE(stream->SetPosition(0));
     EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
     EXPECT_EQ(500U, bytes);
     EXPECT_TRUE(VerifyTestBuffer(buffer, 500, 100));
     EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);
   }

   delete segment;
 }

 TEST(FifoBufferTest, TestAll) {
   const size_t kSize = 16;
   const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
   char out[kSize * 2];
   void* p;
   const void* q;
   size_t bytes;
   FifoBuffer buf(kSize);
   StreamInterface* stream = &buf;

   // Test assumptions about base state
   EXPECT_EQ(SS_OPEN, stream->GetState());
   EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
   EXPECT_TRUE(NULL != stream->GetReadData(&bytes));
   EXPECT_EQ((size_t)0, bytes);
   stream->ConsumeReadData(0);
   EXPECT_TRUE(NULL != stream->GetWriteBuffer(&bytes));
   EXPECT_EQ(kSize, bytes);
   stream->ConsumeWriteBuffer(0);

   // Try a full write
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);

   // Try a write that should block
   EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));

   // Try a full read
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));

   // Try a read that should block
   EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

   // Try a too-big write
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, NULL));
   EXPECT_EQ(bytes, kSize);

   // Try a too-big read
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));

   // Try some small writes and reads
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));

   // Try wraparound reads and writes in the following pattern
   // WWWWWWWWWWWW.... 0123456789AB....
   // RRRRRRRRXXXX.... ........89AB....
   // WWWW....XXXXWWWW 4567....89AB0123
   // XXXX....RRRRXXXX 4567........0123
   // XXXXWWWWWWWWXXXX 4567012345670123
   // RRRRXXXXXXXXRRRR ....01234567....
   // ....RRRRRRRR.... ................
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
   EXPECT_EQ(kSize * 3 / 4, bytes);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, NULL));
   EXPECT_EQ(kSize / 4 , bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2 , bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   EXPECT_EQ(kSize / 2 , bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));

   // Use GetWriteBuffer to reset the read_position for the next tests
   stream->GetWriteBuffer(&bytes);
   stream->ConsumeWriteBuffer(0);

   // Try using GetReadData to do a full read
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
   q = stream->GetReadData(&bytes);
   EXPECT_TRUE(NULL != q);
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize));
   stream->ConsumeReadData(kSize);
   EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

   // Try using GetReadData to do some small reads
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
   q = stream->GetReadData(&bytes);
   EXPECT_TRUE(NULL != q);
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize / 2));
   stream->ConsumeReadData(kSize / 2);
   q = stream->GetReadData(&bytes);
   EXPECT_TRUE(NULL != q);
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
   stream->ConsumeReadData(kSize / 2);
   EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

   // Try using GetReadData in a wraparound case
   // WWWWWWWWWWWWWWWW 0123456789ABCDEF
   // RRRRRRRRRRRRXXXX ............CDEF
   // WWWWWWWW....XXXX 01234567....CDEF
   // ............RRRR 01234567........
   // RRRRRRRR........ ................
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
   q = stream->GetReadData(&bytes);
   EXPECT_TRUE(NULL != q);
   EXPECT_EQ(kSize / 4, bytes);
   EXPECT_EQ(0, memcmp(q, in + kSize * 3 / 4, kSize / 4));
   stream->ConsumeReadData(kSize / 4);
   q = stream->GetReadData(&bytes);
   EXPECT_TRUE(NULL != q);
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize / 2));
   stream->ConsumeReadData(kSize / 2);

   // Use GetWriteBuffer to reset the read_position for the next tests
   stream->GetWriteBuffer(&bytes);
   stream->ConsumeWriteBuffer(0);

   // Try using GetWriteBuffer to do a full write
   p = stream->GetWriteBuffer(&bytes);
   EXPECT_TRUE(NULL != p);
   EXPECT_EQ(kSize, bytes);
   memcpy(p, in, kSize);
   stream->ConsumeWriteBuffer(kSize);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));

   // Try using GetWriteBuffer to do some small writes
   p = stream->GetWriteBuffer(&bytes);
   EXPECT_TRUE(NULL != p);
   EXPECT_EQ(kSize, bytes);
   memcpy(p, in, kSize / 2);
   stream->ConsumeWriteBuffer(kSize / 2);
   p = stream->GetWriteBuffer(&bytes);
   EXPECT_TRUE(NULL != p);
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 2, kSize / 2);
   stream->ConsumeWriteBuffer(kSize / 2);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));

   // Try using GetWriteBuffer in a wraparound case
   // WWWWWWWWWWWW.... 0123456789AB....
   // RRRRRRRRXXXX.... ........89AB....
   // ........XXXXWWWW ........89AB0123
   // WWWW....XXXXXXXX 4567....89AB0123
   // RRRR....RRRRRRRR ................
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   p = stream->GetWriteBuffer(&bytes);
   EXPECT_TRUE(NULL != p);
   EXPECT_EQ(kSize / 4, bytes);
   memcpy(p, in, kSize / 4);
   stream->ConsumeWriteBuffer(kSize / 4);
   p = stream->GetWriteBuffer(&bytes);
   EXPECT_TRUE(NULL != p);
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 4, kSize / 4);
   stream->ConsumeWriteBuffer(kSize / 4);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
   EXPECT_EQ(kSize * 3 / 4, bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
   EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));

   // Check that the stream is now empty
   EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

   // Try growing the buffer
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_TRUE(buf.SetCapacity(kSize * 2));
   EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
   EXPECT_EQ(kSize * 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize * 2));

   // Try shrinking the buffer
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_TRUE(buf.SetCapacity(kSize));
   EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));

   // Write to the stream, close it, read the remaining bytes
   EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
   stream->Close();
   EXPECT_EQ(SS_CLOSED, stream->GetState());
   EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, NULL));
   EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
   EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, NULL));
 }

 TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
   const size_t kSize = 16;
   const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
   char out[kSize * 2];
   FifoBuffer buf(kSize);

   // Write 14 bytes.
   EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, NULL, NULL));

   // Make sure data is in |buf|.
   size_t buffered;
   EXPECT_TRUE(buf.GetBuffered(&buffered));
   EXPECT_EQ(14u, buffered);

   // Read 10 bytes.
   buf.ConsumeReadData(10);

   // There should be now 12 bytes of available space.
   size_t remaining;
   EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
   EXPECT_EQ(12u, remaining);

   // Write at offset 12, this should fail.
   EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, NULL));

   // Write 8 bytes at offset 4, this wraps around the buffer.
   EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, NULL));

   // Number of available space remains the same until we call
   // ConsumeWriteBuffer().
   EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
   EXPECT_EQ(12u, remaining);
   buf.ConsumeWriteBuffer(12);

   // There's 4 bytes bypassed and 4 bytes no read so skip them and verify the
   // 8 bytes written.
   size_t read;
   EXPECT_EQ(SR_SUCCESS, buf.ReadOffset(out, 8, 8, &read));
   EXPECT_EQ(8u, read);
   EXPECT_EQ(0, memcmp(out, in, 8));

   // There should still be 16 bytes available for reading.
   EXPECT_TRUE(buf.GetBuffered(&buffered));
   EXPECT_EQ(16u, buffered);

   // Read at offset 16, this should fail since we don't have that much data.
   EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, NULL));
 }

 } // namespace talk_base
	/*
	* libjingle
	* Copyright 2004--2011, Google Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "talk/base/gunit.h"
	#include "talk/base/stream.h"

	namespace talk_base {

	///////////////////////////////////////////////////////////////////////////////
	// TestStream
	///////////////////////////////////////////////////////////////////////////////

	class TestStream : public StreamInterface {
	public:
	TestStream() : pos_(0) { }

	virtual StreamState GetState() const { return SS_OPEN; }
	virtual StreamResult Read(void* buffer, size_t buffer_len,
	size_t* read, int* error) {
	unsigned char* uc_buffer = static_cast<unsigned char*>(buffer);
	for (size_t i=0; i<buffer_len; ++i) {
	uc_buffer[i] = pos_++;
	}
	if (read)
	*read = buffer_len;
	return SR_SUCCESS;
	}
	virtual StreamResult Write(const void* data, size_t data_len,
	size_t* written, int* error) {
	if (error)
	*error = -1;
	return SR_ERROR;
	}
	virtual void Close() { }
	virtual bool SetPosition(size_t position) {
	pos_ = position;
	return true;
	}
	virtual bool GetPosition(size_t* position) const {
	if (position) *position = pos_;
	return true;
	}
	virtual bool GetSize(size_t* size) const {
	return false;
	}
	virtual bool GetAvailable(size_t* size) const {
	return false;
	}

	private:
	unsigned char pos_;
	};

	bool VerifyTestBuffer(unsigned char* buffer, size_t len,
	unsigned char value) {
	bool passed = true;
	for (size_t i=0; i<len; ++i) {
	if (buffer[i] != value++) {
	passed = false;
	break;
	}
	}
	// Ensure that we don't pass again without re-writing
	memset(buffer, 0, len);
	return passed;
	}

	void SeekTest(StreamInterface* stream, const unsigned char value) {
	size_t bytes;
	unsigned char buffer[13] = { 0 };
	const size_t kBufSize = sizeof(buffer);

	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
	EXPECT_EQ(bytes, kBufSize);
	EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value));
	EXPECT_TRUE(stream->GetPosition(&bytes));
	EXPECT_EQ(13U, bytes);

	EXPECT_TRUE(stream->SetPosition(7));

	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
	EXPECT_EQ(bytes, kBufSize);
	EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value + 7));
	EXPECT_TRUE(stream->GetPosition(&bytes));
	EXPECT_EQ(20U, bytes);
	}

	TEST(StreamSegment, TranslatesPosition) {
	TestStream* test = new TestStream;
	// Verify behavior of original stream
	SeekTest(test, 0);
	StreamSegment* segment = new StreamSegment(test);
	// Verify behavior of adapted stream (all values offset by 20)
	SeekTest(segment, 20);
	delete segment;
	}

	TEST(StreamSegment, SupportsArtificialTermination) {
	TestStream* test = new TestStream;

	size_t bytes;
	unsigned char buffer[5000] = { 0 };
	const size_t kBufSize = sizeof(buffer);

	{
	StreamInterface* stream = test;

	// Read a lot of bytes
	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
	EXPECT_EQ(bytes, kBufSize);
	EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, 0));

	// Test seeking far ahead
	EXPECT_TRUE(stream->SetPosition(12345));

	// Read a bunch more bytes
	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
	EXPECT_EQ(bytes, kBufSize);
	EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, 12345 % 256));
	}

	// Create a segment of test stream in range [100,600)
	EXPECT_TRUE(test->SetPosition(100));
	StreamSegment* segment = new StreamSegment(test, 500);

	{
	StreamInterface* stream = segment;

	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
	EXPECT_EQ(500U, bytes);
	EXPECT_TRUE(VerifyTestBuffer(buffer, 500, 100));
	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);

	// Test seeking past "end" of stream
	EXPECT_FALSE(stream->SetPosition(12345));
	EXPECT_FALSE(stream->SetPosition(501));

	// Test seeking to end (edge case)
	EXPECT_TRUE(stream->SetPosition(500));
	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);

	// Test seeking to start
	EXPECT_TRUE(stream->SetPosition(0));
	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
	EXPECT_EQ(500U, bytes);
	EXPECT_TRUE(VerifyTestBuffer(buffer, 500, 100));
	EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);
	}

	delete segment;
	}

	TEST(FifoBufferTest, TestAll) {
	const size_t kSize = 16;
	const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
	char out[kSize * 2];
	void* p;
	const void* q;
	size_t bytes;
	FifoBuffer buf(kSize);
	StreamInterface* stream = &buf;

	// Test assumptions about base state
	EXPECT_EQ(SS_OPEN, stream->GetState());
	EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
	EXPECT_TRUE(NULL != stream->GetReadData(&bytes));
	EXPECT_EQ((size_t)0, bytes);
	stream->ConsumeReadData(0);
	EXPECT_TRUE(NULL != stream->GetWriteBuffer(&bytes));
	EXPECT_EQ(kSize, bytes);
	stream->ConsumeWriteBuffer(0);

	// Try a full write
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);

	// Try a write that should block
	EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));

	// Try a full read
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize));

	// Try a read that should block
	EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

	// Try a too-big write
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, NULL));
	EXPECT_EQ(bytes, kSize);

	// Try a too-big read
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize));

	// Try some small writes and reads
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize / 2));
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize / 2));
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize / 2));

	// Try wraparound reads and writes in the following pattern
	// WWWWWWWWWWWW.... 0123456789AB....
	// RRRRRRRRXXXX.... ........89AB....
	// WWWW....XXXXWWWW 4567....89AB0123
	// XXXX....RRRRXXXX 4567........0123
	// XXXXWWWWWWWWXXXX 4567012345670123
	// RRRRXXXXXXXXRRRR ....01234567....
	// ....RRRRRRRR.... ................
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
	EXPECT_EQ(kSize * 3 / 4, bytes);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize / 2));
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, NULL));
	EXPECT_EQ(kSize / 4 , bytes);
	EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2 , bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize / 2));
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	EXPECT_EQ(kSize / 2 , bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize / 2));

	// Use GetWriteBuffer to reset the read_position for the next tests
	stream->GetWriteBuffer(&bytes);
	stream->ConsumeWriteBuffer(0);

	// Try using GetReadData to do a full read
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
	q = stream->GetReadData(&bytes);
	EXPECT_TRUE(NULL != q);
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(0, memcmp(q, in, kSize));
	stream->ConsumeReadData(kSize);
	EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

	// Try using GetReadData to do some small reads
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
	q = stream->GetReadData(&bytes);
	EXPECT_TRUE(NULL != q);
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(0, memcmp(q, in, kSize / 2));
	stream->ConsumeReadData(kSize / 2);
	q = stream->GetReadData(&bytes);
	EXPECT_TRUE(NULL != q);
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
	stream->ConsumeReadData(kSize / 2);
	EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

	// Try using GetReadData in a wraparound case
	// WWWWWWWWWWWWWWWW 0123456789ABCDEF
	// RRRRRRRRRRRRXXXX ............CDEF
	// WWWWWWWW....XXXX 01234567....CDEF
	// ............RRRR 01234567........
	// RRRRRRRR........ ................
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
	q = stream->GetReadData(&bytes);
	EXPECT_TRUE(NULL != q);
	EXPECT_EQ(kSize / 4, bytes);
	EXPECT_EQ(0, memcmp(q, in + kSize * 3 / 4, kSize / 4));
	stream->ConsumeReadData(kSize / 4);
	q = stream->GetReadData(&bytes);
	EXPECT_TRUE(NULL != q);
	EXPECT_EQ(kSize / 2, bytes);
	EXPECT_EQ(0, memcmp(q, in, kSize / 2));
	stream->ConsumeReadData(kSize / 2);

	// Use GetWriteBuffer to reset the read_position for the next tests
	stream->GetWriteBuffer(&bytes);
	stream->ConsumeWriteBuffer(0);

	// Try using GetWriteBuffer to do a full write
	p = stream->GetWriteBuffer(&bytes);
	EXPECT_TRUE(NULL != p);
	EXPECT_EQ(kSize, bytes);
	memcpy(p, in, kSize);
	stream->ConsumeWriteBuffer(kSize);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize));

	// Try using GetWriteBuffer to do some small writes
	p = stream->GetWriteBuffer(&bytes);
	EXPECT_TRUE(NULL != p);
	EXPECT_EQ(kSize, bytes);
	memcpy(p, in, kSize / 2);
	stream->ConsumeWriteBuffer(kSize / 2);
	p = stream->GetWriteBuffer(&bytes);
	EXPECT_TRUE(NULL != p);
	EXPECT_EQ(kSize / 2, bytes);
	memcpy(p, in + kSize / 2, kSize / 2);
	stream->ConsumeWriteBuffer(kSize / 2);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize));

	// Try using GetWriteBuffer in a wraparound case
	// WWWWWWWWWWWW.... 0123456789AB....
	// RRRRRRRRXXXX.... ........89AB....
	// ........XXXXWWWW ........89AB0123
	// WWWW....XXXXXXXX 4567....89AB0123
	// RRRR....RRRRRRRR ................
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	p = stream->GetWriteBuffer(&bytes);
	EXPECT_TRUE(NULL != p);
	EXPECT_EQ(kSize / 4, bytes);
	memcpy(p, in, kSize / 4);
	stream->ConsumeWriteBuffer(kSize / 4);
	p = stream->GetWriteBuffer(&bytes);
	EXPECT_TRUE(NULL != p);
	EXPECT_EQ(kSize / 2, bytes);
	memcpy(p, in + kSize / 4, kSize / 4);
	stream->ConsumeWriteBuffer(kSize / 4);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
	EXPECT_EQ(kSize * 3 / 4, bytes);
	EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
	EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));

	// Check that the stream is now empty
	EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));

	// Try growing the buffer
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_TRUE(buf.SetCapacity(kSize * 2));
	EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
	EXPECT_EQ(kSize * 2, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize * 2));

	// Try shrinking the buffer
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_TRUE(buf.SetCapacity(kSize));
	EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
	EXPECT_EQ(kSize, bytes);
	EXPECT_EQ(0, memcmp(in, out, kSize));

	// Write to the stream, close it, read the remaining bytes
	EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
	stream->Close();
	EXPECT_EQ(SS_CLOSED, stream->GetState());
	EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, NULL));
	EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
	EXPECT_EQ(0, memcmp(in, out, kSize / 2));
	EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, NULL));
	}

	TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
	const size_t kSize = 16;
	const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
	char out[kSize * 2];
	FifoBuffer buf(kSize);

	// Write 14 bytes.
	EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, NULL, NULL));

	// Make sure data is in \|buf\|.
	size_t buffered;
	EXPECT_TRUE(buf.GetBuffered(&buffered));
	EXPECT_EQ(14u, buffered);

	// Read 10 bytes.
	buf.ConsumeReadData(10);

	// There should be now 12 bytes of available space.
	size_t remaining;
	EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
	EXPECT_EQ(12u, remaining);

	// Write at offset 12, this should fail.
	EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, NULL));

	// Write 8 bytes at offset 4, this wraps around the buffer.
	EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, NULL));

	// Number of available space remains the same until we call
	// ConsumeWriteBuffer().
	EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
	EXPECT_EQ(12u, remaining);
	buf.ConsumeWriteBuffer(12);

	// There's 4 bytes bypassed and 4 bytes no read so skip them and verify the
	// 8 bytes written.
	size_t read;
	EXPECT_EQ(SR_SUCCESS, buf.ReadOffset(out, 8, 8, &read));
	EXPECT_EQ(8u, read);
	EXPECT_EQ(0, memcmp(out, in, 8));

	// There should still be 16 bytes available for reading.
	EXPECT_TRUE(buf.GetBuffered(&buffered));
	EXPECT_EQ(16u, buffered);

	// Read at offset 16, this should fail since we don't have that much data.
	EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, NULL));
	}

	} // namespace talk_base