public void ShouldSerializeSuccessiveResultColumns()
{
// Arrange
var dataSet = new DataSet();
dataSet.Tables.Add(new DataTable());
dataSet.Tables.Add(new DataTable());
dataSet.Tables[0].Columns.Add("foo", typeof(int));
dataSet.Tables[0].Rows.Add(1);
var columnName = "bar";
dataSet.Tables[1].Columns.Add(columnName, typeof(int));
dataSet.Tables[1].Rows.Add(1);
var dataReader = dataSet.CreateDataReader();
var stream = new ProtoDataStream(dataReader);
// Act
var reader = ProtoReader.Create(this.CopyStream(stream), null, null);
// Assert
var readerContext = new ProtoReaderContext(reader);
readerContext.ReadUntilResultEnd();
readerContext.ReadUntilColumnName();
Assert.Equal(columnName, reader.ReadString());
}
public void ShouldSerializeMultipleResults()
{
// Arrange
var dataSet = new DataSet();
dataSet.Tables.Add(new DataTable());
dataSet.Tables.Add(new DataTable());
dataSet.Tables[0].Columns.Add("foo", typeof(int));
dataSet.Tables[0].Rows.Add(1);
dataSet.Tables[1].Columns.Add("bar", typeof(int));
dataSet.Tables[1].Rows.Add(1);
var dataReader = dataSet.CreateDataReader();
var stream = new ProtoDataStream(dataReader);
// Act
var reader = ProtoReader.Create(this.CopyStream(stream), null, null);
// Assert
var readerContext = new ProtoReaderContext(reader);
readerContext.ReadUntilResultEnd();
Assert.Equal(ResultFieldHeader, reader.ReadFieldHeader());
}
public When_reading_from_a_stream_containing_multiple_data_tables_with_big_buffer()
{
var testData = new DataSet
{
Tables =
{
TestData.GenerateRandomDataTable(10, 50),
TestData.GenerateRandomDataTable(5, 100),
TestData.GenerateRandomDataTable(20, 10000)
}
};
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
this.expectedBytes = memoryStream.GetTrimmedBuffer();
}
this.reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(this.reader, 50 * 1024 * 1024)) // 50 Mb buffer which
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
this.actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public void SetUp()
{
var testData = new DataSet
{
Tables =
{
TestData.GenerateRandomDataTable(10, 50),
TestData.GenerateRandomDataTable(5, 100),
TestData.GenerateRandomDataTable(20, 10000)
}
};
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
expectedBytes = memoryStream.GetTrimmedBuffer();
}
reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(reader))
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public void ShouldThrowException()
{
// Arrange
var stream = new ProtoDataStream(this.CreateDataReader("foo"));
// Assert
Assert.Throws <NotSupportedException>(() => stream.SetLength(0));
}
public When_the_proto_stream_has_been_closed()
{
using (var table = TestData.SmallDataTable())
using (var tableReader = table.CreateDataReader())
{
this.protoStream = new ProtoDataStream(tableReader);
}
this.protoStream.Close();
}
public void ShouldReturnFalse()
{
// Arrange
var stream = new ProtoDataStream(this.CreateDataReader("foo"));
// Act
var result = stream.CanWrite;
// Assert
Assert.False(result);
}
public void ShouldReturnTrueIfNotDisposed()
{
// Arrange
var stream = new ProtoDataStream(this.CreateDataReader("foo"));
// Act
var result = stream.CanRead;
// Assert
Assert.True(result);
}
public void ShouldDisposeReader()
{
// Arrange
var reader = this.CreateDataReader("foo");
var stream = new ProtoDataStream(reader);
// Act
stream.Read(new byte[1024], 0, 1024);
// Assert
Assert.Throws <InvalidOperationException>(() => reader.FieldCount);
}
public void ShouldDisposeReader()
{
// Arrange
var reader = this.CreateDataReader("foo");
var stream = new ProtoDataStream(reader);
// Act
reader.Dispose();
// Assert
Assert.Throws <InvalidOperationException>(() => reader.Read());
}
public void ShouldReturnZeroWhenReaderIsClosed()
{
// Arrange
var stream = new ProtoDataStream(this.CreateDataReader("foo"));
stream.Read(new byte[1024], 0, 1024);
// Act
var result = stream.Read(new byte[1024], 0, 1024);
// Assert
Assert.Equal(0, result);
}
public void It_should_copy_with_various_buffers(int protoBufferSize, int copyBufferSize)
{
byte[] actualBytes;
using (var reader = this.testData.CreateDataReader())
using (var stream = new ProtoDataStream(reader, protoBufferSize * 1024))
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream, copyBufferSize * 1024);
actualBytes = memoryStream.GetTrimmedBuffer();
}
Assert.Equal(this.expectedBytes.LongLength, actualBytes.LongLength);
Assert.Equal(this.expectedBytes, actualBytes);
}
public void It_should_populate_the_buffer_correctly()
{
using (var reader = testData.CreateDataReader())
using (var stream = new ProtoDataStream(reader))
{
var buffer1 = new byte[16];
stream.Read(buffer1, 0, buffer1.Length).Should().Be(buffer1.Length);
buffer1.Should().Have.SameSequenceAs(expectedBytes.Take(buffer1.Length));
stream.Read(buffer1, 0, 0).Should().Be(0);
var buffer2 = new byte[16 * 1024];
stream.Read(buffer2, 0, buffer2.Length).Should().Be(buffer2.Length);
buffer2.Should().Have.SameSequenceAs(expectedBytes.Skip(buffer1.Length).Take(buffer2.Length));
}
}
public When_the_proto_stream_has_been_disposed()
{
Stream stream;
using (var table = TestData.SmallDataTable())
using (var tableReader = table.CreateDataReader())
{
stream = new ProtoDataStream(tableReader);
}
Assert.True(stream.CanRead);
this.weakRef = new WeakReference(stream);
stream.Dispose();
}
public void ShouldSerializeField()
{
// Arrange
var value = "foo";
var dataReader = this.CreateDataReader(value);
var stream = new ProtoDataStream(dataReader);
// Act
var reader = ProtoReader.Create(this.CopyStream(stream), null, null);
// Assert
var readerContext = new ProtoReaderContext(reader);
readerContext.ReadUntilFieldValue();
Assert.Equal(value, reader.ReadString());
}
public When_reading_from_a_stream()
{
var testData = TestData.GenerateRandomDataTable(10, 10000);
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
this.expectedBytes = memoryStream.GetTrimmedBuffer();
}
this.reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(this.reader))
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
this.actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public void SetUp()
{
var testData = TestData.SmallDataTable();
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
expectedBytes = memoryStream.GetTrimmedBuffer();
}
reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(reader))
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public When_reading_from_a_stream_less_than_protobuf_nets_flush_size()
{
var testData = TestData.SmallDataTable();
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
this.expectedBytes = memoryStream.GetTrimmedBuffer();
}
this.reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(this.reader))
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
this.actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public void It_should_populate_the_buffer_correctly()
{
using (var reader = this.testData.CreateDataReader())
using (var stream = new ProtoDataStream(reader))
{
var buffer1 = new byte[16];
var buffer1Readed = stream.Read(buffer1, 0, buffer1.Length);
Assert.Equal(buffer1.Length, buffer1Readed);
Assert.Equal(this.expectedBytes.Take(buffer1.Length), buffer1);
buffer1Readed = stream.Read(buffer1, 0, 0);
Assert.Equal(0, buffer1Readed);
var buffer2 = new byte[16 * 1024];
var buffer2Readed = stream.Read(buffer2, 0, buffer2.Length);
Assert.Equal(buffer2.Length, buffer2Readed);
Assert.Equal(this.expectedBytes.Skip(buffer1.Length).Take(buffer2.Length), buffer2);
}
}
public void ShouldSerializeUsingMultipleIterations()
{
// Arrange
var stream = new ProtoDataStream(this.CreateDataReader("foo", 1000));
var outputStream = new MemoryStream();
var buffer = new byte[1];
int read;
// Act
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
outputStream.Write(buffer, 0, read);
}
// Assert
outputStream.Position = 0;
var reader = ProtoReader.Create(outputStream, null, null);
Assert.Equal(ResultFieldHeader, reader.ReadFieldHeader());
}
public void ShouldSerializeColumns()
{
// Arrange
var columnName = "foo";
var dataTable = new DataTable();
dataTable.Columns.Add(columnName, typeof(int));
dataTable.Rows.Add(1);
var dataReader = dataTable.CreateDataReader();
var stream = new ProtoDataStream(dataReader);
// Act
var reader = ProtoReader.Create(this.CopyStream(stream), null, null);
// Assert
var readerContext = new ProtoReaderContext(reader);
readerContext.ReadUntilColumnName();
Assert.Equal(columnName, reader.ReadString());
}
public void SetUp()
{
var testData = TestData.GenerateRandomDataTable(10, 10000);
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
expectedBytes = memoryStream.GetTrimmedBuffer();
}
reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(reader))
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public void It_should_populate_the_buffer_correctly()
{
using (var reader = testData.CreateDataReader())
using (var stream = new ProtoDataStream(reader))
{
var buffer1 = new byte[16];
stream.Read(buffer1, 0, buffer1.Length).Should().Be(buffer1.Length);
buffer1.Should().Have.SameSequenceAs(expectedBytes.Take(buffer1.Length));
stream.Read(buffer1, 0, 0).Should().Be(0);
var buffer2 = new byte[16 * 1024];
stream.Read(buffer2, 0, buffer2.Length).Should().Be(buffer2.Length);
buffer2.Should().Have.SameSequenceAs(expectedBytes.Skip(buffer1.Length).Take(buffer2.Length));
}
}
