public async Task CanConsumeLessDataThanProduced() { var stream = new CallbackStream(async(s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); await sw.WriteAsync("World"); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); int index = 0; var message = "Hello World"; while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } var ch = (char)buffer.First.Span[0]; Assert.Equal(message[index++], ch); reader.Advance(buffer.Start.Seek(1, buffer.End)); } Assert.Equal(message.Length, index); }
public async Task AccessingUnownedMemoryThrowsIfUsedAfterAdvance() { var stream = new CallbackStream(async(s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); var data = Memory <byte> .Empty; while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } data = buffer.First; reader.Advance(buffer.End); } Assert.Throws <ObjectDisposedException>(() => data.Span); }
public async Task CancellingBeforeAdvance() { var stream = new CallbackStream(async(s, token) => { var bytes = Encoding.ASCII.GetBytes("Hello World"); await s.WriteAsync(bytes, 0, bytes.Length); }); var reader = stream.AsPipelineReader(); var result = await reader.ReadAsync(); var buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.False(result.IsCancelled); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); reader.CancelPendingRead(); reader.Advance(buffer.End); var awaitable = reader.ReadAsync(); Assert.True(awaitable.IsCompleted); result = await awaitable; Assert.True(result.IsCancelled); }
public async Task PreservingUnownedBufferCopies() { var stream = new CallbackStream(async(s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); var result = await reader.ReadAsync(); var buffer = result.Buffer; var preserved = buffer.Preserve(); // Make sure we can access the span EnsureSpanValid(buffer.First); Assert.True(buffer.First.Length > 0); buffer.First.Span[0] = (byte)'J'; Assert.Equal("Jello ", Encoding.UTF8.GetString(buffer.ToArray())); reader.Advance(buffer.End); result = await reader.ReadAsync(); Assert.True(result.IsCompleted); using (preserved) { // Preserved was copied, so it still contains "Hello " instead of "Jello ". Assert.Equal("Hello ", Encoding.UTF8.GetString(preserved.Buffer.ToArray())); } // There is currently no way to verify that OwnedArray<byte> is fully released. }
public async Task NotCallingAdvanceWillCauseReadToThrow() { var stream = new CallbackStream(async(s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello"); await sw.FlushAsync(); await sw.WriteAsync("World"); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); int calls = 0; InvalidOperationException thrown = null; while (true) { ReadResult result; ReadableBuffer buffer; try { result = await reader.ReadAsync(); buffer = result.Buffer; } catch (InvalidOperationException ex) { thrown = ex; break; } calls++; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } var segment = buffer.ToArray(); var data = Encoding.UTF8.GetString(segment); if (calls == 1) { Assert.Equal("Hello", data); } else { Assert.Equal("World", data); } } Assert.Equal(1, calls); Assert.NotNull(thrown); Assert.Equal("Cannot Read until the previous read has been acknowledged by calling Advance", thrown.Message); }
public async Task CanCancelConsumingData() { var cts = new CancellationTokenSource(); var stream = new CallbackStream(async(s, token) => { var hello = Encoding.UTF8.GetBytes("Hello"); var world = Encoding.UTF8.GetBytes("World"); await s.WriteAsync(hello, 0, hello.Length, token); cts.Cancel(); await s.WriteAsync(world, 0, world.Length, token); }); var reader = stream.AsPipelineReader(cts.Token); int calls = 0; while (true) { ReadResult result; ReadableBuffer buffer; try { result = await reader.ReadAsync(); buffer = result.Buffer; } catch (OperationCanceledException) { break; } finally { calls++; } if (buffer.IsEmpty && result.IsCompleted) { // Done break; } var segment = buffer.ToArray(); var data = Encoding.UTF8.GetString(segment); Assert.Equal("Hello", data); reader.Advance(buffer.End); } Assert.Equal(2, calls); }
public void Calcular(ConfigProceso config, FuenteRedes fuente) { var pathScript = Path.GetDirectoryName(config.ScriptFile); Engine = Utils.GetScriptingEngine(f => f.AddSearchPath(pathScript)); var outs = new CallbackStream(); outs.Callback += s => AppNotifier.Print(s); Engine.Runtime.IO.SetOutput(outs, outs.OutEncoding); try { Procesar(config, fuente); } catch (Exception ex) { var error = Engine.GetService<ExceptionOperations>().FormatException(ex); AppNotifier.Print(error, ex); } }
public async Task CanCancelConsumingData() { var cts = new CancellationTokenSource(); var stream = new CallbackStream(async (s, token) => { var hello = Encoding.UTF8.GetBytes("Hello"); var world = Encoding.UTF8.GetBytes("World"); await s.WriteAsync(hello, 0, hello.Length, token); cts.Cancel(); await s.WriteAsync(world, 0, world.Length, token); }); var reader = stream.AsPipelineReader(cts.Token); int calls = 0; while (true) { ReadResult result; ReadableBuffer buffer; try { result = await reader.ReadAsync(); buffer = result.Buffer; } catch (OperationCanceledException) { break; } finally { calls++; } if (buffer.IsEmpty && result.IsCompleted) { // Done break; } var segment = buffer.ToArray(); var data = Encoding.UTF8.GetString(segment); Assert.Equal("Hello", data); reader.Advance(buffer.End); } Assert.Equal(2, calls); }
public void Correr(string script, string carpeta) { var engine = Utils.GetScriptingEngine(f => f.AddSearchPath(carpeta)); var outs = new CallbackStream(); outs.Callback += s => Print(s); engine.Runtime.IO.SetOutput(outs, outs.OutEncoding); try { var scope = engine.CreateScope(Data); var source = engine.CreateScriptSourceFromString(script); source.Execute(scope); } catch (Exception ex) { //http://stackoverflow.com/questions/1465262/getting-traceback-information-from-ironpython-exceptions //engine.GetService<ExceptionOperations>().FormatException(exception); var error = engine.GetService<ExceptionOperations>().FormatException(ex); Print(error, ex); //var msg = "Error de sintaxis " + Utils.FormatSyntaxError(exs); } }
public async Task CanConsumeData() { var stream = new CallbackStream(async(s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello"); await sw.FlushAsync(); await sw.WriteAsync("World"); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); int calls = 0; while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; calls++; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } var segment = buffer.ToArray(); var data = Encoding.UTF8.GetString(segment); if (calls == 1) { Assert.Equal("Hello", data); } else { Assert.Equal("World", data); } reader.Advance(buffer.End); } }
public async Task CancellingPendingAfterReadAsync() { var tcs = new TaskCompletionSource <object>(); var stream = new CallbackStream(async(s, token) => { await tcs.Task; var bytes = Encoding.ASCII.GetBytes("Hello World"); await s.WriteAsync(bytes, 0, bytes.Length); }); var reader = stream.AsPipelineReader(); var task = Task.Run(async() => { var result = await reader.ReadAsync(); var buffer = result.Buffer; reader.Advance(buffer.End); Assert.False(result.IsCompleted); Assert.True(result.IsCancelled); Assert.True(buffer.IsEmpty); tcs.TrySetResult(null); result = await reader.ReadAsync(); buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.False(result.IsCancelled); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); }); await((UnownedBufferReader)reader).ReadingStarted; reader.CancelPendingRead(); await task; }
public async Task CanConsumeData() { var stream = new CallbackStream(async (s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello"); await sw.FlushAsync(); await sw.WriteAsync("World"); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); int calls = 0; while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; calls++; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } var segment = buffer.ToArray(); var data = Encoding.UTF8.GetString(segment); if (calls == 1) { Assert.Equal("Hello", data); } else { Assert.Equal("World", data); } reader.Advance(buffer.End); } }
public async Task PreservingUnownedBufferCopies() { var stream = new CallbackStream(async(s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); var preserved = default(PreservedBuffer); while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } preserved = buffer.Preserve(); // Make sure we can acccess the span var span = buffer.First.Span; reader.Advance(buffer.End); } using (preserved) { Assert.Equal("Hello ", Encoding.UTF8.GetString(preserved.Buffer.ToArray())); } Assert.Throws <ObjectDisposedException>(() => preserved.Buffer.First.Span); }
public async Task CanConsumeLessDataThanProducedAndPreservingUnOwnedBuffers() { var stream = new CallbackStream(async(s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); await sw.WriteAsync("World"); await sw.FlushAsync(); }); var channel = stream.AsReadableChannel(); int index = 0; var message = "Hello World"; while (true) { var result = await channel.ReadAsync(); var buffer = result.Buffer; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } using (buffer.Preserve()) { var ch = (char)buffer.First.Span[0]; Assert.Equal(message[index++], ch); channel.Advance(buffer.Start.Seek(1)); } } Assert.Equal(message.Length, index); }
public async Task CanConsumeLessDataThanProducedWithBufferReuse() { var stream = new CallbackStream(async(s, token) => { var data = new byte[4096]; Encoding.UTF8.GetBytes("Hello ", 0, 6, data, 0); await s.WriteAsync(data, 0, 6); Encoding.UTF8.GetBytes("World", 0, 5, data, 0); await s.WriteAsync(data, 0, 5); }); var reader = stream.AsPipelineReader(); int index = 0; var message = "Hello World"; while (index <= message.Length) { var result = await reader.ReadAsync(); var buffer = result.Buffer; var ch = Encoding.UTF8.GetString(buffer.Slice(0, index).ToArray()); Assert.Equal(message.Substring(0, index), ch); // Never consume, to force buffers to be copied reader.Advance(buffer.Start, buffer.Start.Seek(index, buffer.End)); // Yield the task. This will ensure that we don't have any Tasks idling // around in UnownedBufferReader.OnCompleted await Task.Yield(); index++; } Assert.Equal(message.Length + 1, index); }
public async Task CancellingPendingAfterReadAsync() { var tcs = new TaskCompletionSource<object>(); var stream = new CallbackStream(async (s, token) => { await tcs.Task; var bytes = Encoding.ASCII.GetBytes("Hello World"); await s.WriteAsync(bytes, 0, bytes.Length); }); var reader = stream.AsPipelineReader(); var task = Task.Run(async () => { var result = await reader.ReadAsync(); var buffer = result.Buffer; reader.Advance(buffer.End); Assert.False(result.IsCompleted); Assert.True(result.IsCancelled); Assert.True(buffer.IsEmpty); tcs.TrySetResult(null); result = await reader.ReadAsync(); buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.False(result.IsCancelled); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); }); await ((UnownedBufferReader)reader).ReadingStarted; reader.CancelPendingRead(); await task; }
public async Task AccessingUnownedMemoryThrowsIfUsedAfterAdvance() { var stream = new CallbackStream(async (s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); var data = Memory<byte>.Empty; while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } data = buffer.First; reader.Advance(buffer.End); } Assert.Throws<ObjectDisposedException>(() => data.Span); }
public async Task CanConsumeLessDataThanProducedWithBufferReuse() { var stream = new CallbackStream(async (s, token) => { var data = new byte[4096]; Encoding.UTF8.GetBytes("Hello ", 0, 6, data, 0); await s.WriteAsync(data, 0, 6); Encoding.UTF8.GetBytes("World", 0, 5, data, 0); await s.WriteAsync(data, 0, 5); }); var reader = stream.AsPipelineReader(); int index = 0; var message = "Hello World"; while (index <= message.Length) { var result = await reader.ReadAsync(); var buffer = result.Buffer; var ch = Encoding.UTF8.GetString(buffer.Slice(0, index).ToArray()); Assert.Equal(message.Substring(0, index), ch); // Never consume, to force buffers to be copied reader.Advance(buffer.Start, buffer.Start.Seek(index)); // Yield the task. This will ensure that we don't have any Tasks idling // around in UnownedBufferReader.OnCompleted await Task.Yield(); index++; } Assert.Equal(message.Length + 1, index); }
public void Calcular(ConfigProceso config) { Engine = Utils.GetScriptingEngine(f => f.AddSearchPath(config.CarpetaTrabajo)); var outs = new CallbackStream(); outs.Callback += s => Print(s); Engine.Runtime.IO.SetOutput(outs, outs.OutEncoding); try { Calcular2(config); } catch (Exception ex) { //http://stackoverflow.com/questions/1465262/getting-traceback-information-from-ironpython-exceptions //engine.GetService<ExceptionOperations>().FormatException(exception); var error = Engine.GetService<ExceptionOperations>().FormatException(ex); Print(error, ex); //var msg = "Error de sintaxis " + Utils.FormatSyntaxError(exs); } }
public async Task NotCallingAdvanceWillCauseReadToThrow() { var stream = new CallbackStream(async (s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello"); await sw.FlushAsync(); await sw.WriteAsync("World"); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); int calls = 0; InvalidOperationException thrown = null; while (true) { ReadResult result; ReadableBuffer buffer; try { result = await reader.ReadAsync(); buffer = result.Buffer; } catch (InvalidOperationException ex) { thrown = ex; break; } calls++; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } var segment = buffer.ToArray(); var data = Encoding.UTF8.GetString(segment); if (calls == 1) { Assert.Equal("Hello", data); } else { Assert.Equal("World", data); } } Assert.Equal(1, calls); Assert.NotNull(thrown); Assert.Equal("Cannot Read until the previous read has been acknowledged by calling Advance", thrown.Message); }
public async Task CancellingBeforeAdvance() { var stream = new CallbackStream(async (s, token) => { var bytes = Encoding.ASCII.GetBytes("Hello World"); await s.WriteAsync(bytes, 0, bytes.Length); }); var reader = stream.AsPipelineReader(); var result = await reader.ReadAsync(); var buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.False(result.IsCancelled); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); reader.CancelPendingRead(); reader.Advance(buffer.End); var awaitable = reader.ReadAsync(); Assert.True(awaitable.IsCompleted); result = await awaitable; Assert.True(result.IsCancelled); }
public async Task PreservingUnownedBufferCopies() { var stream = new CallbackStream(async (s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); var preserved = default(PreservedBuffer); while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } preserved = buffer.Preserve(); // Make sure we can acccess the span var span = buffer.First.Span; reader.Advance(buffer.End); } using (preserved) { Assert.Equal("Hello ", Encoding.UTF8.GetString(preserved.Buffer.ToArray())); } Assert.Throws<ObjectDisposedException>(() => preserved.Buffer.First.Span); }
public async Task CanConsumeLessDataThanProducedAndPreservingUnOwnedBuffers() { var stream = new CallbackStream(async (s, token) => { var sw = new StreamWriter(s); await sw.WriteAsync("Hello "); await sw.FlushAsync(); await sw.WriteAsync("World"); await sw.FlushAsync(); }); var reader = stream.AsPipelineReader(); int index = 0; var message = "Hello World"; while (true) { var result = await reader.ReadAsync(); var buffer = result.Buffer; if (buffer.IsEmpty && result.IsCompleted) { // Done break; } using (buffer.Preserve()) { var ch = (char)buffer.First.Span[0]; Assert.Equal(message[index++], ch); reader.Advance(buffer.Start.Seek(1)); } } Assert.Equal(message.Length, index); }