public void TestCircularStream()
{
const int LineCount = 100;
var cs = new CircularStream();
Task.Run(() =>
{
using (var writer = cs.CreateWriterView())
using (var sw = new StreamWriter(writer))
{
for (int i = 0; i < LineCount; i++)
{
sw.WriteLine($"Line {i}: test!");
}
}
});
using (var reader = cs.CreateReaderView())
using (var sr = new StreamReader(reader))
{
for (int i = 0; i < LineCount; i++)
{
Assert.Equal($"Line {i}: test!", sr.ReadLine());
}
Assert.Equal(string.Empty, sr.ReadToEnd());
}
}
public async Task TestCompositeStream()
{
const int LineCount = 100;
var ms = new MemoryStream();
var cs = new CircularStream();
var task = Task.Run(() =>
{
using (var stream = cs.CreateReaderView())
{
return(SHA1.Create().ComputeHash(stream));
}
});
byte[] expected;
using (var ds = new CompositeStream(ms, cs.CreateWriterView()))
{
var sw = new StreamWriter(ds);
for (int i = 0; i < LineCount; i++)
{
sw.WriteLine($"Line {i}: test!");
}
sw.Flush();
expected = SHA1.Create().ComputeHash(ms.ToArray());
}
Assert.Equal(expected, await task);
}
public void TestCircularStream()
{
const int LineCount = 100;
var cs = new CircularStream();
Task.Run(() =>
{
using (var writer = cs.CreateWriterView())
using (var sw = new StreamWriter(writer))
{
for (int i = 0; i < LineCount; i++)
{
sw.WriteLine($"Line {i}: test!");
}
}
});
using (var reader = cs.CreateReaderView())
using (var sr = new StreamReader(reader))
{
for (int i = 0; i < LineCount; i++)
{
Assert.Equal($"Line {i}: test!", sr.ReadLine());
}
Assert.Equal(string.Empty, sr.ReadToEnd());
}
}
public void ReadWrite_WithWriteReadWrite_HasExpectedBuffer()
{
// Assign
var stream = new CircularStream(BufferInitialSize);
// Act
var bufferStub1 = CreateByteArray(4, 12);
stream.Write(bufferStub1, 0, bufferStub1.Length);
var bufferOut = new byte[6];
stream.Read(bufferOut, 0, bufferOut.Length);
var bufferStub2 = CreateByteArray(6, 6);
stream.Write(bufferStub2, 0, bufferStub2.Length);
var bufferRemains = stream.ToArray();
// Assert
const string expected = "6600004444446666";
var actual = bufferRemains.GetString();
Assert.Equal(expected, actual);
}
public int Generate(XmlDocument sourceDocument, Stream output)
{
var source = new CircularStream();
XmlWriter w = new XmlTextWriter(source, Encoding.Default);
sourceDocument.WriteTo(w);
return Generate(source, output);
}
public int Generate(XslCompiledTransform transform, XmlDocument sourceDocument, Stream output)
{
var source = new CircularStream();
XmlWriter w = new XmlTextWriter(source, Encoding.Default);
transform.Transform(sourceDocument, w);
return Generate(source, output);
}
public int Generate(XmlDocument sourceDocument, Stream output)
{
var source = new CircularStream();
XmlWriter w = new XmlTextWriter(source, Encoding.Default);
sourceDocument.WriteTo(w);
return(Generate(source, output));
}
public int Generate(XslCompiledTransform transform, XmlDocument sourceDocument, Stream output)
{
var source = new CircularStream();
XmlWriter w = new XmlTextWriter(source, Encoding.Default);
transform.Transform(sourceDocument, w);
return(Generate(source, output));
}
public void Read_WithNoWritePreciding_ThrowsTimeoutException()
{
// Assign
var stream = new CircularStream(BufferInitialSize, true, ReadMode.Wait, 100);
// Act
var bufferOut = new byte[6];
Assert.Throws <TimeoutException>(() => stream.Read(bufferOut, 0, bufferOut.Length));
}
public static Stream WithMd5Hash(this Stream stream, out Task <byte[]> hashTask)
{
var cs = new CircularStream();
hashTask = Task.Run(() =>
{
using var csr = cs.CreateReaderView();
return(MD5.Create().ComputeHash(csr));
});
return(new CompositeStream(stream, cs.CreateWriterView()));
}
public static Stream WithSha256Hash(this Stream stream, out Task <byte[]> hashTask)
{
var cs = new CircularStream();
hashTask = Task.Run(() =>
{
using var csr = cs.CreateReaderView();
return(HashUtility.GetSha256Hash(csr));
});
return(new CompositeStream(stream, cs.CreateWriterView()));
}
public static Stream WithMd5Hash(this Stream stream, out Task<byte[]> hashTask)
{
var cs = new CircularStream();
hashTask = Task.Run(() =>
{
using (var csr = cs.CreateReaderView())
{
return MD5.Create().ComputeHash(csr);
}
});
return new CompositeStream(stream, cs.CreateWriterView());
}
private LogSequence FindActiveLogSequence()
{
using (
Stream logStream =
new CircularStream(new SubStream(_fileStream, (long)_header.LogOffset, _header.LogLength),
Ownership.Dispose))
{
LogSequence candidateActiveSequence = new LogSequence();
LogEntry logEntry = null;
long oldTail;
long currentTail = 0;
do
{
oldTail = currentTail;
logStream.Position = currentTail;
LogSequence currentSequence = new LogSequence();
while (LogEntry.TryRead(logStream, out logEntry) &&
logEntry.LogGuid == _header.LogGuid &&
(currentSequence.Count == 0 ||
logEntry.SequenceNumber == currentSequence.Head.SequenceNumber + 1))
{
currentSequence.Add(logEntry);
logEntry = null;
}
if (currentSequence.Count > 0 &&
currentSequence.Contains(currentSequence.Head.Tail) &&
currentSequence.HigherSequenceThan(candidateActiveSequence))
{
candidateActiveSequence = currentSequence;
}
if (currentSequence.Count == 0)
{
currentTail += LogEntry.LogSectorSize;
}
else
{
currentTail = currentSequence.Head.Position + LogEntry.LogSectorSize;
}
currentTail = currentTail % logStream.Length;
} while (currentTail > oldTail);
return(candidateActiveSequence);
}
}
public void SimpleTest()
{
const string msg = "olá!";
var cb = new CircularStream();
using (var w = new StreamWriter(cb))
w.Write(msg);
string v;
using (var r = new StreamReader(cb))
v = r.ReadToEnd();
Assert.AreEqual(msg, v);
}
public void BufferFullTest()
{
const string msg = "olá, esta é uma mensagem que com certeza vai ultrapassar o buffer";
var cb = new CircularStream(new CircularBuffer(10));
using (var w = new StreamWriter(cb))
w.Write(msg);
string v;
using (var r = new StreamReader(cb))
v = r.ReadToEnd();
Assert.AreEqual(msg, v);
}
public void Read_ReadLessThanBufferLength_ReturnsSomeOfTheBuffer()
{
// Arrange
var uut = new CircularStream(2);
uut.Write(new byte[] { 0, 1 }, 0, 2);
var result = new byte[1];
// Act
uut.Read(result, 0, 1);
// Assert
Assert.AreEqual(1, result.Length);
Assert.AreEqual(0, result[0]);
}
public void Write_DoNotCompletelyFillBuffer_ReturnsJustWhatIsWritten()
{
// Arrange
var uut = new CircularStream(2);
var bytesToWrite = new Byte[] { 0 };
// Act
uut.Write(bytesToWrite, 111, 222);
var result = new Byte[1];
uut.Read(result, 0, 1);
// Assert
Assert.AreEqual(1, result.Length);
Assert.AreEqual(0, result[0]);
}
public void BufferFullTest()
{
const string msg = "olá, esta é uma mensagem que com certeza vai ultrapassar o buffer";
var cb = new CircularStream(new CircularBuffer(10));
using (var w = new StreamWriter(cb))
w.Write(msg);
string v;
using (var r = new StreamReader(cb))
v = r.ReadToEnd();
Assert.AreEqual(msg, v);
}
public void SimpleTest()
{
const string msg = "olá!";
var cb = new CircularStream();
using (var w = new StreamWriter(cb))
w.Write(msg);
string v;
using (var r = new StreamReader(cb))
v = r.ReadToEnd();
Assert.AreEqual(msg, v);
}
public void ReadWrite_WithOneCall_HasExpectedBuffer()
{
// Assign
var stream = new CircularStream(BufferInitialSize);
// Act
var bufferStub = CreateByteArray(4, 6);
stream.Write(bufferStub, 0, bufferStub.Length);
var bufferRemains = stream.ToArray();
// Assert
const string expected = "4444440000000000";
var actual = bufferRemains.GetString();
Assert.Equal(expected, actual);
}
public void Write_FillPastBuffer_ReturnsJustLengthOfBuffer()
{
// Arrange
var uut = new CircularStream(2);
var bytesToWrite = new Byte[] { 0, 1, 2, 3 };
// Act
uut.Write(bytesToWrite, 111, 222);
var result = new Byte[2];
uut.Read(result, 0, 2);
// Assert
Assert.AreEqual(2, result.Length);
Assert.AreEqual(2, result[0]);
Assert.AreEqual(3, result[1]);
}
public void Read_PastBuffer_ReturnsCircularly()
{
// Arrange
var uut = new CircularStream(2);
uut.Write(new byte[] { 0, 1 }, 0, 2);
var result = new byte[4];
// Act
uut.Read(result, 0, 4);
// Assert
Assert.AreEqual(4, result.Length);
Assert.AreEqual(0, result[0]);
Assert.AreEqual(1, result[1]);
Assert.AreEqual(0, result[2]);
Assert.AreEqual(1, result[3]);
}
public void Write_FillBuffer_WritesToBuffer()
{
// Arrange
var uut = new CircularStream(5);
var bytesToWrite = new Byte[] { 0, 1, 2, 3, 4 };
// Act
uut.Write(bytesToWrite, 111, 222);
var result = new Byte[5];
uut.Read(result, 0, 5);
// Assert
Assert.AreEqual(0, result[0]);
Assert.AreEqual(1, result[1]);
Assert.AreEqual(2, result[2]);
Assert.AreEqual(3, result[3]);
Assert.AreEqual(4, result[4]);
}
public void Read_FillBuffer_WritesToBuffer()
{
// Arrange
var uut = new CircularStream(5);
uut.Write(new byte[] { 0, 1, 2, 3, 4 }, 0, 5);
var result = new byte[5];
// Act
uut.Read(result, 0, 5);
// Assert
Assert.AreEqual(5, result.Length);
Assert.AreEqual(0, result[0]);
Assert.AreEqual(1, result[1]);
Assert.AreEqual(2, result[2]);
Assert.AreEqual(3, result[3]);
Assert.AreEqual(4, result[4]);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProtoDataStream"/> class.
/// </summary>
/// <param name="reader">The <see cref="IDataReader"/>who's contents to serialize.</param>
/// <param name="options"><see cref="ProtoDataWriterOptions"/> specifying any custom serialization options.</param>
/// <param name="bufferSize">Buffer size to use when serializing rows.
/// You should not need to change this unless you have exceptionally
/// large rows or an exceptionally high number of columns.</param>
public ProtoDataStream(
IDataReader reader,
ProtoDataWriterOptions options,
int bufferSize = DefaultBufferSize)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
this.reader = reader;
this.options = options;
this.resultIndex = 0;
this.bufferStream = new CircularStream(bufferSize);
this.writer = new ProtoWriter(this.bufferStream, null, null);
}
public async void Read_WithWriteCallAfter_DoesNotThrowTimeoutException()
{
// Assign
var stream = new CircularStream(BufferInitialSize, true, ReadMode.Wait, 1000);
// Act
var bufferOut = new byte[6];
var readTask = Task.Run(() => stream.Read(bufferOut, 0, bufferOut.Length));
var bufferStub = CreateByteArray(4, 6);
stream.Write(bufferStub, 0, bufferStub.Length);
int bytesRead = await readTask;
var bufferRemains = stream.ToArray();
// Assert
const string expected = "4444440000000000";
var actual = bufferRemains.GetString();
Assert.Equal(expected, actual);
Assert.Equal(bufferOut.Length, bytesRead);
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="ProtoDataStream"/> and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
this.CloseReader();
if (this.writer != null)
{
((IDisposable)this.writer).Dispose();
this.writer = null;
}
if (this.bufferStream != null)
{
this.bufferStream.Dispose();
this.bufferStream = null;
}
}
this.disposed = true;
}
}
public CircularStreamView(CircularStream circularStream, bool writeMode)
{
_circularStream = circularStream;
_writeMode = writeMode;
}
public async Task TestCompositeStream()
{
const int LineCount = 100;
var ms = new MemoryStream();
var cs = new CircularStream();
var task = Task.Run(() =>
{
using (var stream = cs.CreateReaderView())
{
return SHA1.Create().ComputeHash(stream);
}
});
byte[] expected;
using (var ds = new CompositeStream(ms, cs.CreateWriterView()))
{
var sw = new StreamWriter(ds);
for (int i = 0; i < LineCount; i++)
{
sw.WriteLine($"Line {i}: test!");
}
sw.Flush();
expected = SHA1.Create().ComputeHash(ms.ToArray());
}
Assert.Equal(expected, await task);
}
public CircularTraceListener(CircularStream stream)
: base(stream)
{
this.m_stream = stream;
}
public CircularTraceListener()
: base(m_stream = new CircularStream(DefaultTraceFile))
{
}
public CircularTraceListener(string file)
: base(m_stream = new CircularStream(file))
{
}
public BroadcastServer(string source)
{
_source = source;
buffer = new CircularStream(ushort.MaxValue);
}
