blob: d0c571815f599f2136dc2e6e2c7ac7b979875bab [file] [log] [blame]
/*
* 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