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 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 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); }