public async Task WritingNotifiesCallbackWhenHostHasCrashed() { var hostCrashed = new AutoResetEvent(false); var exception = new TaskCompletionSource <Exception>(); var disposed = false; var p = RunTestProcess("NotifiesCallbackWhenHostCrashes " + _pipeName); Thread.Sleep(1000); var task = Task.Run(() => { using (_pipeName.BeginWritingMessages("name", e => exception.SetResult(e), Observable.Create <IBinaryMessage>(obs => { obs.OnNext(IntMessage.Compose(42)); hostCrashed.WaitOne(); obs.OnNext(IntMessage.Compose(43)); return(Disposable.Create(() => disposed = true)); }))){} }); Thread.Sleep(1000); //Give writing thread time to connect, if we kill the host too early, Connect() will block Assert.IsFalse(exception.Task.IsCompleted); p.Kill(); p.WaitForExit(); hostCrashed.Set(); await task; Assert.IsNotNull(await exception.Task); Assert.IsTrue(disposed); }
public async Task CanReadAMessage() { using (var inbox = StreamWithMessages(IntMessage.Compose(42))) { Assert.AreEqual(42, await inbox.ReadMessages("name").SelectSome(IntMessage.TryParse).FirstAsync()); } }
public async Task WritingNotifiesCallbackWhenHostHasClosed() { var wroteMessage = new TaskCompletionSource <Unit>(); var hostClosed = new AutoResetEvent(false); var exception = new TaskCompletionSource <Exception>(); var disposed = false; var hostTask = Pipe.Host(_pipeName); var task = Task.Run(() => { using (_pipeName.BeginWritingMessages("name", e => exception.SetResult(e), Observable.Create <IBinaryMessage>(obs => { obs.OnNext(IntMessage.Compose(42)); wroteMessage.SetResult(Unit.Default); hostClosed.WaitOne(); obs.OnNext(IntMessage.Compose(43)); return(Disposable.Create(() => disposed = true)); }))){} }); var host = await hostTask; await wroteMessage.Task; using (var reader = new BinaryReader(host)) { var msg = IntMessage.TryParse(BinaryMessage.ReadFrom(reader)); Assert.AreEqual(42, msg.Value); } Assert.IsFalse(exception.Task.IsCompleted); host.Close(); hostClosed.Set(); await task; Assert.IsNotNull(await exception.Task); Assert.IsTrue(disposed); }
IObservable <IBinaryMessage> OneMessageThenError(int i, Exception error, Action dispose) { return(Observable.Create <IBinaryMessage>(obs => { obs.OnNext(IntMessage.Compose(i)); obs.OnError(error); return dispose; })); }
public async Task NotifiesOnWriteError() { var stream = new CantDoAnythingStream(); var source = new TaskCompletionSource <Unit>(); using (stream.BeginWritingMessages("name", e => { source.SetResult(Unit.Default); }, Observable.Return(IntMessage.Compose(42)))) { await source.Task; } }
public async Task CanWriteAMessage() { using (var stream = new MemoryStream()) { Exception exception = null; var message = IntMessage.Compose(42); var notifyingStream = new NotifyingStream(stream, (int)LengthOf(message)); using (notifyingStream.BeginWritingMessages("name", e => exception = e, Observable.Return(message))) { await notifyingStream.Task; var msg = IntMessage.TryParse(MessageFromStream(stream)); Assert.AreEqual(42, msg.Value); Assert.IsNull(exception); } } }
public async Task CompletesAtClosedPipe() { WriteMessagesToCurrentPipe(IntMessage.Compose(42)); int result = -1; var completed = new TaskCompletionSource <Exception>(); using (_pipeName.ReadMessages("name").RefCount().SelectSome(IntMessage.TryParse) .Subscribe( i => result = i, e => completed.SetResult(e), () => completed.SetResult(null))) { var exception = await completed.Task; Assert.AreEqual(42, result); Assert.IsNull(exception); } }
public async Task CompletesAtEndOfStream() { using (var inbox = StreamWithMessages(IntMessage.Compose(42))) { int result = -1; var completed = new TaskCompletionSource <Exception>(); using (inbox.ReadMessages("name").SelectSome(IntMessage.TryParse) .Subscribe( i => result = i, e => completed.SetResult(e), () => completed.SetResult(null))) { var exception = await completed.Task; Assert.AreEqual(42, result); Assert.IsNull(exception); } } }
public async Task ErrorsAtOtherExceptions() { using (var messages = StreamWithMessages(IntMessage.Compose(42))) using (var closingStream = new ReadThenThrowStream(messages, new Exception("Alderaan destroyed"))) { int result = -1; var completed = new TaskCompletionSource <Exception>(); using (closingStream.ReadMessages("name").SelectSome(IntMessage.TryParse) .Subscribe( i => result = i, e => completed.SetResult(e), () => completed.SetResult(null))) { var exception = await completed.Task; Assert.AreEqual(42, result); Assert.AreEqual("Alderaan destroyed", exception.Message); } } }
public async Task CompletesAtClosedConnection() { using (var messages = StreamWithMessages(IntMessage.Compose(42))) using (var closingStream = new ReadThenThrowStream(messages, new IOException("", _forciblyClosedConnection))) { int result = -1; var completed = new TaskCompletionSource <Exception>(); using (closingStream.ReadMessages("name").SelectSome(IntMessage.TryParse) .Subscribe( i => result = i, e => completed.SetResult(e), () => completed.SetResult(null))) { var exception = await completed.Task; Assert.AreEqual(42, result); Assert.IsNull(exception); } } }
//Characterization test, not sure if this is the desired behaviour public async Task CompletesWhenClientCrashes() { var messageToSend = GetMessageAsBase64ForUseInTestProcess(IntMessage.Compose(42)); //Paste this in the testprocess if the format changes var result = new TaskCompletionSource <int>(); var completed = new TaskCompletionSource <Exception>(); var p = RunTestProcess("CompletesWhenClientCrashes " + _pipeName); using (_pipeName.ReadMessages("name").RefCount().SelectSome(IntMessage.TryParse) .Subscribe( i => result.SetResult(i), e => completed.SetResult(e), () => completed.SetResult(null))) { await result.Task; p.Kill(); p.WaitForExit(); Console.WriteLine(); var exception = await completed.Task; Assert.IsNull(exception); } }
public async Task CanReadAMessage() { WriteMessagesToCurrentPipe(IntMessage.Compose(42)); Assert.AreEqual(42, await _pipeName.ReadMessages("name").RefCount().SelectSome(IntMessage.TryParse).FirstAsync()); }
[Ignore("This is currently not the case, maybe it should be?")] //Just wrote this as an experiment, and left it in in case we want it later public async Task ReaderCompletesWhenWriterCompletes() { Exception writeError = null; Exception readError = null; var result = -1; var completed = new TaskCompletionSource <Unit>(); using (_pipeName.BeginWritingMessages("name", e => { writeError = e; }, Observable.Return(IntMessage.Compose(42)))) { using (_pipeName.ReadMessages("name").RefCount().SelectSome(IntMessage.TryParse) .Subscribe( i => result = i, e => readError = e, () => completed.SetResult(Unit.Default))) { await completed.Task; Assert.AreEqual(42, result); Assert.IsNull(writeError); Assert.IsNull(readError); } } }
public async Task CanCommunicate() { Exception error = null; using (_pipeName.BeginWritingMessages("name", e => { error = e; }, Observable.Return(IntMessage.Compose(42)))) { var msg = await _pipeName.ReadMessages("name").RefCount().SelectSome(IntMessage.TryParse).FirstAsync(); Assert.AreEqual(42, msg); Assert.IsNull(error); } }