public Hangman(string word) { HashSet <char> emptySetOfChars = new HashSet <char>(); var stateSubject = new BehaviorSubject <HangmanState>(new HangmanState(MaskedWord(word, emptySetOfChars), emptySetOfChars.ToImmutableHashSet(), MaxGuessCount)); StateObservable = stateSubject; GuessObserver = Observer.Create <char>(x => { HashSet <char> guessedChars = new HashSet <char>(stateSubject.Value.GuessedChars); bool isHit = !guessedChars.Contains(x) && word.Contains(x); guessedChars.Add(x); string maskedWord = MaskedWord(word, guessedChars); if (maskedWord == word) { stateSubject.OnCompleted(); } else if (stateSubject.Value.RemainingGuesses < 1) { stateSubject.OnError(new TooManyGuessesException()); } else { stateSubject.OnNext(new HangmanState(maskedWord, guessedChars.ToImmutableHashSet(), isHit ? stateSubject.Value.RemainingGuesses : stateSubject.Value.RemainingGuesses - 1)); } }); }
public void OnOuterError() { var lbs1 = new ListBehaviorSubject <int>(); lbs1.OnAdd(1); lbs1.OnAdd(2); var source = new BehaviorSubject <IObservableList <int> >(lbs1); var list = new List <int>(); var completed = false; Exception error = null; var sub = source .Switch() .Subscribe( Observer.Create <ListChange <int> >( change => change.Apply(list), e => error = e, () => completed = true)); var ex = new Exception("AAAAAA"); source.OnError(ex); Assert.AreEqual(ex, error); Assert.IsFalse(completed); sub.Dispose(); }
public void TestOnError() { var expectedOnNext = new List <int> { 7, 1, 10, 100 }; var onNext = new List <int>(); var exceptions = new List <Exception>(); var onCompletedCallCount = 0; var subject = new BehaviorSubject <int>(7); subject.Subscribe(x => onNext.Add(x), x => exceptions.Add(x), () => onCompletedCallCount++); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); Assert.That(onNext, Is.EqualTo(expectedOnNext)); Assert.That(exceptions, Has.Count.EqualTo(0)); Assert.That(onCompletedCallCount, Is.EqualTo(0)); subject.OnError(new Exception()); Assert.That(exceptions, Has.Count.EqualTo(1)); subject.OnNext(1); subject.OnNext(10); subject.OnNext(200); Assert.That(onNext, Is.EqualTo(expectedOnNext)); Assert.That(onCompletedCallCount, Is.EqualTo(0)); }
private void OnNextGuess(char guess) { if (_state.Value.RemainingGuesses == 0) { _state.OnError(new TooManyGuessesException()); return; } var currentState = _state.Value; var remaining = currentState.GuessedChars.Contains(guess) || !_word.Contains(guess) ? currentState.RemainingGuesses - 1 : currentState.RemainingGuesses; var guessed = currentState.GuessedChars.Add(guess); var masked = MaskWord(guessed); if (masked == _word) { _state.OnCompleted(); } else { _state.OnNext(new HangmanState(masked, guessed, remaining)); } }
public override void OnError(Exception error) { if (_isDisposed) { throw error; } _subject.OnError(error); }
public void Value_ThrowsAfterOnError() { var s = new BehaviorSubject <int>(42); Assert.AreEqual(42, s.Value); s.OnError(new InvalidOperationException()); Assert.Fail("Should not be able to read Value: {0}", s.Value); }
public void Should_Invoke_OnError_On_Activator_Error() { var activator = new BehaviorSubject <bool>(false); var source = new TestSubject(); var target = new ActivatedSubject(activator, source, string.Empty); activator.OnError(new Exception()); Assert.NotNull(source.Error); }
public void Should_Complete_When_Source_Observable_Errors() { var source = new BehaviorSubject <object>(1); var target = new ExpressionObserver(source, "Foo"); var completed = false; target.Subscribe(_ => { }, () => completed = true); source.OnError(new Exception()); Assert.True(completed); }
public void Should_Complete_When_Source_Observable_Errors() { var source = new BehaviorSubject<object>(1); var target = new ExpressionObserver(source, "Foo"); var completed = false; target.Subscribe(_ => { }, () => completed = true); source.OnError(new Exception()); Assert.True(completed); }
public void Should_Error_When_Activator_Errors() { var activator = new BehaviorSubject <bool>(false); var target = new ActivatedValue(activator, 1, string.Empty); var error = new Exception(); var completed = false; target.Subscribe(_ => { }, x => completed = true); activator.OnError(error); Assert.True(completed); }
public void replays_error_sequence() { BehaviorSubject <int> subject = new BehaviorSubject <int>(0); StatsObserver <int> stats = new StatsObserver <int>(); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.IsTrue(stats.ErrorCalled); }
public void Should_Error_When_Source_Errors() { var activator = new BehaviorSubject <bool>(false); var source = new BehaviorSubject <object>(1); var target = new ActivatedObservable(activator, source, string.Empty); var error = new Exception(); var completed = false; target.Subscribe(_ => { }, x => completed = true); source.OnError(error); Assert.True(completed); }
public ReactiveAsyncAgent( TState initialState, Func <TState, TMessage, CancellationToken, Task <TState> > messageHandler, Func <Exception, CancellationToken, Task <bool> > errorHandler) { if (initialState == null) { throw new ArgumentNullException(nameof(initialState)); } if (messageHandler == null) { throw new ArgumentNullException(nameof(messageHandler)); } if (errorHandler == null) { throw new ArgumentNullException(nameof(errorHandler)); } _stateSubject = new BehaviorSubject <TState>(initialState); _asyncAgent = new AsyncAgent <TState, TMessage>( initialState: initialState, messageHandler: async(state, msg, ct) => { TState newState = state; newState = await messageHandler(state, msg, ct); if (!ct.IsCancellationRequested) { _stateSubject.OnNext(newState); } return(newState); }, errorHandler: async(ex, ct) => { bool shouldContinue = false; shouldContinue = await errorHandler(ex, ct); if (!shouldContinue && !ct.IsCancellationRequested) { _stateSubject.OnError(ex); } return(shouldContinue); }); State = _stateSubject.AsObservable(); }
public void Should_Invoke_OnError_On_Activator_Error() { var activator = new BehaviorSubject <bool>(false); var source = new TestSubject(); var target = new ActivatedSubject(activator, source, string.Empty); var targetError = default(Exception); var error = new Exception(); target.Subscribe(_ => { }, e => targetError = e); activator.OnError(error); Assert.Same(error, source.Error); Assert.Same(error, targetError); }
public async Task Start() { try { _stateSignal.OnNext(TestState.Running); _output.OnNext("========================================\\"); _output.OnNext(Name); if (FilePath.HasValue) { _output.OnNext(FilePath.Value.ToString()); } Stopwatch sw = new Stopwatch(); sw.Start(); await _toDo(_output); sw.Stop(); _output.OnNext("Passed"); _output.OnNext($"{sw.ElapsedMilliseconds / 1000d}s"); _output.OnNext("========================================/"); _stateSignal.OnNext(TestState.Complete); if (_parallel) { await Task.WhenAll(_children.Select(c => Task.Run(c.Start))); } else { await Task.WhenAll(_children.Select(c => c.Start())); } _disposables.Dispose(); } catch (Exception ex) { _stateSignal.OnError(ex); while (ex != null) { _output.OnNext(ex.ToString()); ex = ex.InnerException; } _output.OnNext("Failed"); _output.OnNext("========================================/"); _stateSignal.OnNext(TestState.Error); } finally { _output.OnCompleted(); _stateSignal.OnCompleted(); } }
public void replays_no_values_when_errored() { BehaviorSubject <int> subject = new BehaviorSubject <int>(0); StatsObserver <int> stats = new StatsObserver <int>(); subject.OnNext(1); subject.OnNext(2); subject.OnNext(3); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.AreEqual(0, stats.NextCount); Assert.IsTrue(stats.ErrorCalled); }
public void HasObservers_OnError() { var s = new BehaviorSubject <int>(42); Assert.IsFalse(s.HasObservers); var d = s.Subscribe(_ => { }, ex => { }); Assert.IsTrue(s.HasObservers); s.OnNext(42); Assert.IsTrue(s.HasObservers); s.OnError(new Exception()); Assert.IsFalse(s.HasObservers); }
public void errors_are_sent_through_scheduler() { ManualScheduler scheduler = new ManualScheduler(); BehaviorSubject <int> subject = new BehaviorSubject <int>(0, scheduler); StatsObserver <int> stats = new StatsObserver <int>(); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.IsFalse(stats.ErrorCalled); scheduler.RunNext(); Assert.IsTrue(stats.ErrorCalled); }
public void errors_are_sent_through_scheduler() { ManualScheduler scheduler = new ManualScheduler(); BehaviorSubject<int> subject = new BehaviorSubject<int>(0, scheduler); StatsObserver<int> stats = new StatsObserver<int>(); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.IsFalse(stats.ErrorCalled); scheduler.RunNext(); Assert.IsTrue(stats.ErrorCalled); }
public void Value_ThrowsAfterOnError() { var s = new BehaviorSubject <int>(42); Assert.Equal(42, s.Value); s.OnError(new InvalidOperationException()); ReactiveAssert.Throws <InvalidOperationException>(() => { var ignored = s.Value; }); ReactiveAssert.Throws <InvalidOperationException>(() => { s.TryGetValue(out var x); }); }
public async Task Observable_Current_propagates_exception() { var subject = new BehaviorSubject <int>(1); var asyncEnumerable = subject.Current(); await using (var asyncEnumerator = asyncEnumerable.GetAsyncEnumerator()) { subject.OnNext(1); subject.OnNext(2); subject.OnNext(3); subject.OnError(new DivideByZeroException()); asyncEnumerator .Awaiting(_ => _.MoveNextAsync().AsTask()) .Should() .ThrowExactly <DivideByZeroException>(); } }
public Hangman(string word) { var emptySet = new HashSet <char>(); var subject = new BehaviorSubject <HangmanState>(new HangmanState( Mask(word, emptySet), emptySet.ToImmutableHashSet(), MaxGuesses )); this.StateObservable = subject; this.GuessObserver = Observer.Create <char>(ch => { var guessedChars = new HashSet <char>(subject.Value.GuessedChars); var remainingGuesses = subject.Value.RemainingGuesses; if (!word.Contains(ch) || guessedChars.Contains(ch)) { remainingGuesses--; } guessedChars.Add(ch); var masked = Mask(word, guessedChars); if (masked == word) { subject.OnCompleted(); } else if (remainingGuesses < 0) // Game over { subject.OnError(new TooManyGuessesException()); } else { subject.OnNext(new HangmanState( masked, guessedChars.ToImmutableHashSet(), remainingGuesses )); } } ); }
public async Task Observable_Current_propagates_exception() { var subject = new BehaviorSubject<int>(1); var asyncEnumerable = subject.Current(); using (var asyncEnumerator = asyncEnumerable.GetEnumerator()) { subject.OnNext(1); subject.OnNext(2); subject.OnNext(3); subject.OnError(new InvalidOperationException()); asyncEnumerator .Awaiting(_ => _.MoveNext(CancellationToken.None)) .ShouldThrowExactly<AggregateException>() .Where(ex => ex.GetBaseException() is InvalidOperationException); } }
public void replays_no_values_when_errored() { BehaviorSubject<int> subject = new BehaviorSubject<int>(0); StatsObserver<int> stats = new StatsObserver<int>(); subject.OnNext(1); subject.OnNext(2); subject.OnNext(3); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.AreEqual(0, stats.NextCount); Assert.IsTrue(stats.ErrorCalled); }
public void BehaviorSubject() { // OnCompletedPattern { var subject = new BehaviorSubject<int>(3333); var onNext = new List<int>(); var exception = new List<Exception>(); int onCompletedCallCount = 0; var _ = subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.IsCollection(3333); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); subject.OnNext(1000); onNext.IsCollection(3333, 1, 10, 100, 1000); // re subscription onNext.Clear(); _.Dispose(); subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.IsCollection(1000); subject.OnCompleted(); onCompletedCallCount.Is(1); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); onNext.Count.Is(1); subject.OnCompleted(); subject.OnError(new Exception()); exception.Count.Is(0); onCompletedCallCount.Is(1); // ++subscription onNext.Clear(); onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Count.Is(0); exception.Count.Is(0); onCompletedCallCount.Is(1); } // OnErrorPattern { var subject = new BehaviorSubject<int>(3333); var onNext = new List<int>(); var exception = new List<Exception>(); int onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); subject.OnNext(1000); onNext.IsCollection(3333, 1, 10, 100, 1000); subject.OnError(new Exception()); exception.Count.Is(1); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); onNext.Count.Is(5); subject.OnCompleted(); subject.OnError(new Exception()); exception.Count.Is(1); onCompletedCallCount.Is(0); // ++subscription onNext.Clear(); exception.Clear(); onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Count.Is(0); exception.Count.Is(1); onCompletedCallCount.Is(0); } }
public void HasObservers_OnError() { var s = new BehaviorSubject<int>(42); Assert.IsFalse(s.HasObservers); var d = s.Subscribe(_ => { }, ex => { }); Assert.IsTrue(s.HasObservers); s.OnNext(42); Assert.IsTrue(s.HasObservers); s.OnError(new Exception()); Assert.IsFalse(s.HasObservers); }
public void Value_ThrowsAfterOnError() { var s = new BehaviorSubject<int>(42); Assert.AreEqual(42, s.Value); s.OnError(new InvalidOperationException()); Assert.Fail("Should not be able to read Value: {0}", s.Value); }
void IObserver <T> .OnError(Exception error) => subject.OnError(error);
public void Value_ThrowsAfterOnError() { var s = new BehaviorSubject<int>(42); Assert.AreEqual(42, s.Value); s.OnError(new InvalidOperationException()); ReactiveAssert.Throws<InvalidOperationException>(() => { var ignored = s.Value; }); ReactiveAssert.Throws<InvalidOperationException>(() => { var x = default(int); s.TryGetValue(out x); }); }
public void replays_error_sequence() { BehaviorSubject<int> subject = new BehaviorSubject<int>(0); StatsObserver<int> stats = new StatsObserver<int>(); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.IsTrue(stats.ErrorCalled); }
public void BehaviorSubject() { // OnCompletedPattern { var subject = new BehaviorSubject <int>(3333); var onNext = new List <int>(); var exception = new List <Exception>(); int onCompletedCallCount = 0; var _ = subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Is(3333); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); subject.OnNext(1000); onNext.Is(3333, 1, 10, 100, 1000); // re subscription onNext.Clear(); _.Dispose(); subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Is(1000); subject.OnCompleted(); onCompletedCallCount.Is(1); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); onNext.Count.Is(1); subject.OnCompleted(); subject.OnError(new Exception()); exception.Count.Is(0); onCompletedCallCount.Is(1); // ++subscription onNext.Clear(); onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Count.Is(0); exception.Count.Is(0); onCompletedCallCount.Is(1); } // OnErrorPattern { var subject = new BehaviorSubject <int>(3333); var onNext = new List <int>(); var exception = new List <Exception>(); int onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); subject.OnNext(1000); onNext.Is(3333, 1, 10, 100, 1000); subject.OnError(new Exception()); exception.Count.Is(1); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); onNext.Count.Is(5); subject.OnCompleted(); subject.OnError(new Exception()); exception.Count.Is(1); onCompletedCallCount.Is(0); // ++subscription onNext.Clear(); exception.Clear(); onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Count.Is(0); exception.Count.Is(1); onCompletedCallCount.Is(0); } }
public void OnError(Exception error) { _subject.OnError(error); }