private void Start()
{
//BehaviorSubjectは初期値を設定できる
behaviorSubject = new BehaviorSubject <int>(0);
/*
* OnNext → Subscribe と実行し、Subscribeした瞬間に直前の値が発行されることを確認しよう
*/
// Subscribeボタンが押されたらSubjectをSubscribeしてresultTextに表示する
subscribeButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.Subscribe(
time => resultText.text += time.ToString() + " ", //OnNext
() => resultText.text += "OnCompleted "); //OnCompleted
}
});
// OnNextボタンが押されたら今が何度目のOnNextであるかを発行する
onNextButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.OnNext(++onNextCount);
}
});
// OnCompletedボタンが押されたらOnCompletedを発行する
onCompletedButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.OnCompleted();
}
});
// Resetボタンが押されたら全体を初期化する
resetButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.OnCompleted();
}
behaviorSubject = new BehaviorSubject <int>(0);
resultText.text = "";
onNextCount = 0;
});
}
private void Start()
{
//BehaviorSubjectは初期値を設定できる
behaviorSubject = new BehaviorSubject<int>(0);
/*
OnNext → Subscribe と実行し、Subscribeした瞬間に直前の値が発行されることを確認しよう
*/
// Subscribeボタンが押されたらSubjectをSubscribeしてresultTextに表示する
subscribeButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.Subscribe(
time => resultText.text += time.ToString() + " ", //OnNext
() => resultText.text += "OnCompleted "); //OnCompleted
}
});
// OnNextボタンが押されたら今が何度目のOnNextであるかを発行する
onNextButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.OnNext(++onNextCount);
}
});
// OnCompletedボタンが押されたらOnCompletedを発行する
onCompletedButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.OnCompleted();
}
});
// Resetボタンが押されたら全体を初期化する
resetButton.OnClickAsObservable().Subscribe(_ =>
{
if (behaviorSubject != null)
{
behaviorSubject.OnCompleted();
}
behaviorSubject = new BehaviorSubject<int>(0);
resultText.text = "";
onNextCount = 0;
});
}
static void Main(string[] args)
{
//Need to provide a default value.
var subject = new BehaviorSubject <string>("a");
subject.Subscribe(Console.WriteLine);
//'b' is written to the console, but not 'a'.
var subject1 = new BehaviorSubject <string>("a");
subject1.OnNext("b");
subject1.Subscribe(Console.WriteLine);
// In this example the values 'b', 'c' & 'd' are all written to the console, but again not 'a'
var subject2 = new BehaviorSubject <string>("a");
subject2.OnNext("b");
subject2.Subscribe(Console.WriteLine);
subject2.OnNext("c");
subject2.OnNext("d");
//Finally in this example, no values will be published as the sequence has completed. Nothing is written to the console.
var subject3 = new BehaviorSubject <string>("a");
subject3.OnNext("b");
subject3.OnNext("c");
subject3.OnCompleted();
subject3.Subscribe(Console.WriteLine);
Console.ReadLine();
}
public static void TheLastValueBeforeSubscription()
{
var subject = new BehaviorSubject <int>(-1);
Console.WriteLine("First value");
subject.OnNext(4);
var consoleObserver = new ConsoleObserver <int>();
Console.WriteLine("We're gonna subscribe once");
var subscription = subject.Subscribe(consoleObserver);
subject.OnNext(5);
subject.OnNext(6);
var consoleObserver2 = new ConsoleObserver <int>();
Console.WriteLine("We're gonna subscribe a second time");
var subscription2 = subject.Subscribe(consoleObserver2);
subject.OnNext(7);
subject.OnNext(8);
subject.OnCompleted();
subscription.Dispose();
subscription2.Dispose();
}
public void OnCompleted()
{
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.OnCompleted();
Assert.That(onCompletedCallCount, Is.EqualTo(1));
subject.OnNext(1);
subject.OnNext(10);
subject.OnNext(200);
Assert.That(onNext, Is.EqualTo(expectedOnNext));
Assert.That(exceptions, Has.Count.EqualTo(0));
}
private void Start()
{
// BehaviorSubjectの定義には必ず初期値が必要
BehaviorSubject <int> behaviorSubject = new BehaviorSubject <int>(0);
//メッセージを発行
behaviorSubject.OnNext(1);
//購読開始
behaviorSubject.Subscribe(
x => Debug.Log("OnNext:" + x),
ex => Debug.LogError("OnError:" + ex),
() => Debug.Log("OnCompleted"));
//メッセージを発行
behaviorSubject.OnNext(2);
//Valueを参照すると最新の値を確認できる
Debug.Log("Last Value:" + behaviorSubject.Value);
behaviorSubject.OnNext(3);
behaviorSubject.OnCompleted();
//キャッシュを完全に削除
behaviorSubject.Dispose();
}
// Start is called before the first frame update
void Start()
{
var behaviourSubject = new BehaviorSubject <int>(0);
behaviourSubject.OnNext(0);
behaviourSubject.OnNext(1);
behaviourSubject.Subscribe(
x => Debug.Log("OnNext: " + x),
error => Debug.Log("OnError: " + error),
() => Debug.Log("OnCompleted"));
Debug.Log("購読後");
behaviourSubject.OnNext(2);
behaviourSubject.Subscribe(
x => Debug.Log("OnNext2: " + x),
error => Debug.Log("OnError2: " + error),
() => Debug.Log("OnCompleted2"));
Debug.Log("現在の値" + behaviourSubject.Value);
behaviourSubject.OnNext(3);
Debug.Log("Completedを呼ぶ直前");
behaviourSubject.OnCompleted();
}
public void live_values_are_sent_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
BehaviorSubject <int> subject = new BehaviorSubject <int>(0, scheduler);
StatsObserver <int> stats = new StatsObserver <int>();
subject.Subscribe(stats);
subject.OnNext(1);
subject.OnNext(2);
subject.OnCompleted();
Assert.IsFalse(stats.NextCalled);
scheduler.RunNext();
Assert.AreEqual(1, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.AreEqual(2, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.AreEqual(3, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1, 2 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.IsTrue(stats.CompletedCalled);
}
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 Completing_LocalValue_Binding_With_Style_Binding_Raises_PropertyChanged()
{
var target = new Class1();
var source = new BehaviorSubject <BindingValue <string> >("foo");
var property = Class1.FooProperty;
var raised = 0;
target.Bind(property, new BehaviorSubject <string>("bar"), BindingPriority.Style);
target.Bind(property, source);
Assert.Equal("foo", target.GetValue(property));
target.PropertyChanged += (s, e) =>
{
Assert.Equal(BindingPriority.Style, e.Priority);
Assert.Equal(property, e.Property);
Assert.Equal("foo", e.OldValue as string);
Assert.Equal("bar", e.NewValue as string);
++raised;
};
source.OnCompleted();
Assert.Equal("bar", target.GetValue(property));
Assert.Equal(1, raised);
}
private async Task CompleteAsync()
{
Debug.WriteLine("disposing GraphQLHttpWebSocket...");
_incomingMessagesConnection?.Dispose();
if (!_internalCancellationTokenSource.IsCancellationRequested)
{
_internalCancellationTokenSource.Cancel();
}
await CloseAsync();
_requestSubscription?.Dispose();
_clientWebSocket?.Dispose();
_stateSubject?.OnCompleted();
_stateSubject?.Dispose();
_exceptionSubject?.OnCompleted();
_exceptionSubject?.Dispose();
_internalCancellationTokenSource.Dispose();
_sendLoopScheduler?.Dispose();
_receiveLoopScheduler?.Dispose();
Debug.WriteLine("GraphQLHttpWebSocket disposed");
}
/// <summary>
/// BehaviorSubject
/// OnNextで発行された最新の値をキャッシュ
/// Subscribeでキャッシュされた値を発行
/// </summary>
private void ExcuteBehaviorSubject()
{
BehaviorSubject <int> subject = new BehaviorSubject <int>(0);
IDisposable stream1 = subject.Subscribe(x => {
Debug.Log("ストリーム1 : " + x);
}, () => {
Debug.Log("ストリーム1 OnCompleted");
});
subject.OnNext(1);
subject.OnNext(10);
// 最新の値のみキャッシュされているので、OnNext(10)のみ呼ばれる
IDisposable stream2 = subject.Subscribe(x => {
Debug.Log("ストリーム2 : " + x);
}, () => {
Debug.Log("ストリーム2 OnCompleted");
});
subject.OnCompleted();
// OnCompleted後なので呼ばれない
subject.OnNext(100);
// 最新の値のみキャッシュされているので、OnCompletedのみ呼ばれる
IDisposable stream3 = subject.Subscribe(x => {
Debug.Log("ストリーム3 : " + x);
}, () => {
Debug.Log("ストリーム3 OnCompleted");
});
}
public void Value_FrozenAfterOnCompleted()
{
var s = new BehaviorSubject <int>(42);
Assert.Equal(42, s.Value);
Assert.True(s.TryGetValue(out var x));
Assert.Equal(42, x);
s.OnNext(43);
Assert.Equal(43, s.Value);
Assert.True(s.TryGetValue(out x));
Assert.Equal(43, x);
s.OnNext(44);
Assert.Equal(44, s.Value);
Assert.True(s.TryGetValue(out x));
Assert.Equal(44, x);
s.OnCompleted();
Assert.Equal(44, s.Value);
Assert.True(s.TryGetValue(out x));
Assert.Equal(44, x);
s.OnNext(1234);
Assert.Equal(44, s.Value);
Assert.True(s.TryGetValue(out x));
Assert.Equal(44, x);
}
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));
}
}
static void WithBehaviourSubject()
{
var market = new BehaviorSubject <float>(1);
market.Inspect("market");
market.OnNext(2);
market.OnCompleted();
}
public void Dispose()
{
if (!_isActiveSubject.IsDisposed)
{
_isActiveSubject.OnCompleted();
_isActiveSubject.Dispose();
}
}
public static void Main(string[] args)
{
var sensorReader = new BehaviorSubject <double>(-1.0);
sensorReader.Inspect("Sensor");
sensorReader.OnNext(0.99);
sensorReader.OnCompleted();
}
public void Stop()
{
_isConnected.OnCompleted();
_disconnected.Dispose();
_worker.Close();
_worker.Dispose();
}
public static void BehaviorSubjectCompletedExample()
{
var subject = new BehaviorSubject<string>("a");
subject.OnNext("b");
subject.OnNext("c");
subject.OnCompleted();
subject.Subscribe(Console.WriteLine);
}
public void BehaviorSubjectNothingPublishedTest()
{
var subject = new BehaviorSubject <string>("a");
subject.OnNext("b");
subject.OnNext("c");
subject.OnCompleted();
SubscribeConsole(subject);
}
public void BehaviorSubjectCompletedExample()
{
var subject = new BehaviorSubject <string>("a");
subject.OnNext("b");
subject.OnNext("c");
subject.OnCompleted();
subject.Subscribe(Console.WriteLine);
}
private static void BehaviorSubjectCompletedExample()
{
var subject = new BehaviorSubject <string>("a");
subject.OnNext("b");
subject.OnNext("c");
subject.OnCompleted();//completed before subscribe was set
subject.Subscribe(Console.WriteLine);
}
public void Dispose()
{
if (0 == Interlocked.Exchange(ref _disposed, 1))
{
_asyncAgent.Dispose();
_stateSubject.OnCompleted();
_stateSubject.Dispose();
}
}
public static IObservable <long> CreateCustomBehaviorSubject()
{
var res = new BehaviorSubject <long>(42);
Task.Delay(2000).ContinueWith(t => res.OnNext(100));
Task.Delay(6000).ContinueWith(t => res.OnNext(200));
Task.Delay(9000).ContinueWith(t => res.OnCompleted());
return(res);
}
public static void CloseActiveObservables()
{
Parallel.ForEach(_observers.Values, x =>
{
x.Observer.OnCompleted();
x.Dispose();
});
_connectionCount.OnCompleted();
}
public async Task Stop()
{
_isConnected.OnCompleted();
_disconnected.Dispose();
_publishMarketUpdates.Close();
_publishMarketUpdates.Dispose();
await Cleanup();
}
static void Main(string[] args)
{
var subject = new BehaviorSubject <string>("a");
subject.OnNext("b");
subject.OnNext("c");
subject.OnCompleted();
subject.Subscribe(Console.WriteLine);
Console.Read();
}
public static void BehaviorSubjectCompletedExample()
{
var subject = new BehaviorSubject <string>("a");
subject.Subscribe(v => Console.WriteLine($"1: {v}"));
subject.OnNext("b");
subject.Subscribe(v => Console.WriteLine($"2: {v}"));
subject.OnNext("c");
subject.OnCompleted();
}
public void Should_Invoke_OnCompleted_On_Activator_Completed()
{
var activator = new BehaviorSubject <bool>(false);
var source = new TestSubject();
var target = new ActivatedSubject(activator, source, string.Empty);
activator.OnCompleted();
Assert.True(source.Completed);
}
static void Main(string[] args)
{
var sensorReading = new BehaviorSubject <double>(-1.0);
//到这一步的时候，就是默认值-1
sensorReading.Inspect("sensor");
sensorReading.OnNext(0.99);
sensorReading.OnCompleted();
}
public void Should_Complete_When_Source_Observable_Completes()
{
var source = new BehaviorSubject<object>(1);
var target = new ExpressionObserver(source, "Foo");
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
source.OnCompleted();
Assert.True(completed);
}
public void Should_Complete_When_Activator_Completes()
{
var activator = new BehaviorSubject<bool>(false);
var target = new ActivatedValue(activator, 1, string.Empty);
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
activator.OnCompleted();
Assert.True(completed);
}
/// <summary>
/// BehaviorSubject 可以设置初始值，并且每次都会发射并缓存最新值
/// BehaviorSubject.Value 可以获取到初始值或者最新值
/// 适合用于一些状态变化的场景
/// </summary>
public static void PreserveLastStateWithBehaviorSubject()
{
var sbj = new BehaviorSubject <int>(2);
Console.WriteLine($"BehaviorSubject.Value:{sbj.Value}");
sbj.SubscribeConsole("first");
sbj.OnNext(3);
sbj.SubscribeConsole("second");
sbj.OnCompleted();
Console.WriteLine($"BehaviorSubject.Value:{sbj.Value}");
}
public void Should_Complete_When_Activator_Completes()
{
var activator = new BehaviorSubject <bool>(false);
var target = new ActivatedValue(activator, 1, string.Empty);
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
activator.OnCompleted();
Assert.True(completed);
}
public void Should_Complete_When_Source_Completes()
{
var activator = new BehaviorSubject<bool>(false);
var source = new BehaviorSubject<object>(1);
var target = new ActivatedObservable(activator, source, string.Empty);
var completed = false;
target.Subscribe(_ => { }, () => completed = true);
source.OnCompleted();
Assert.True(completed);
}
static void Main(string[] args)
{
var serviceClient = new JsonRestClientAsync("http://g-un--:1337/");
var responseSubject = new BehaviorSubject<Unit>(Unit.Default);
responseSubject.Subscribe(_ =>
{
serviceClient.PostAsync<ResourceResponse>(
"/async",
new ResourceRequest()
{
ResourceKey = Guid.NewGuid().ToString()
},
response =>
{
Console.WriteLine("Data received");
Console.WriteLine(response.ResourceData);
responseSubject.OnNext(Unit.Default);
},
(response, ex) =>
{
Console.WriteLine("Exception on calling service post method");
Console.WriteLine(ex);
responseSubject.OnCompleted();
});
});
Observable.Interval(TimeSpan.FromSeconds(1))
.Subscribe(_ =>
{
var newClient = new JsonRestClientAsync("http://g-un--:1337/");
newClient.PutAsync<object>(
"/async",
new ResourceRequest() { ResourceKey = Guid.NewGuid().ToString() },
response =>
{
Console.WriteLine("Put was sent!");
},
(response, exception) =>
{
Console.WriteLine(exception);
});
});
Console.ReadLine();
}
public void complete_is_sent_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
BehaviorSubject<int> subject = new BehaviorSubject<int>(0, scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
subject.OnCompleted();
subject.Subscribe(stats);
Assert.IsFalse(stats.NextCalled);
scheduler.RunNext();
Assert.AreEqual(0, stats.NextCount);
Assert.IsTrue(stats.CompletedCalled);
}
public async Task Observable_Current_completes_on_source_completion()
{
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.OnCompleted();
Assert.False(await asyncEnumerator.MoveNext(CancellationToken.None));
}
}
public void Value_FrozenAfterOnCompleted()
{
var s = new BehaviorSubject<int>(42);
Assert.AreEqual(42, s.Value);
var x = default(int);
Assert.IsTrue(s.TryGetValue(out x));
Assert.AreEqual(42, x);
s.OnNext(43);
Assert.AreEqual(43, s.Value);
Assert.IsTrue(s.TryGetValue(out x));
Assert.AreEqual(43, x);
s.OnNext(44);
Assert.AreEqual(44, s.Value);
Assert.IsTrue(s.TryGetValue(out x));
Assert.AreEqual(44, x);
s.OnCompleted();
Assert.AreEqual(44, s.Value);
Assert.IsTrue(s.TryGetValue(out x));
Assert.AreEqual(44, x);
s.OnNext(1234);
Assert.AreEqual(44, s.Value);
Assert.IsTrue(s.TryGetValue(out x));
Assert.AreEqual(44, x);
}
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 Value_FrozenAfterOnCompleted()
{
var s = new BehaviorSubject<int>(42);
Assert.AreEqual(42, s.Value);
s.OnNext(43);
Assert.AreEqual(43, s.Value);
s.OnNext(44);
Assert.AreEqual(44, s.Value);
s.OnCompleted();
Assert.AreEqual(44, s.Value);
s.OnNext(1234);
Assert.AreEqual(44, s.Value);
}
public void HasObservers_OnCompleted()
{
var s = new BehaviorSubject<int>(42);
Assert.IsFalse(s.HasObservers);
var d = s.Subscribe(_ => { });
Assert.IsTrue(s.HasObservers);
s.OnNext(42);
Assert.IsTrue(s.HasObservers);
s.OnCompleted();
Assert.IsFalse(s.HasObservers);
}
public void replays_empty_sequence()
{
BehaviorSubject<int> subject = new BehaviorSubject<int>(0);
StatsObserver<int> stats = new StatsObserver<int>();
subject.OnCompleted();
subject.Subscribe(stats);
Assert.AreEqual(0, stats.NextCount);
Assert.IsTrue(stats.CompletedCalled);
}
public void live_values_are_sent_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
BehaviorSubject<int> subject = new BehaviorSubject<int>(0, scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
subject.Subscribe(stats);
subject.OnNext(1);
subject.OnNext(2);
subject.OnCompleted();
Assert.IsFalse(stats.NextCalled);
scheduler.RunNext();
Assert.AreEqual(1, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.AreEqual(2, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.AreEqual(3, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1, 2 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.IsTrue(stats.CompletedCalled);
}
public void replays_no_values_when_complete()
{
BehaviorSubject<int> subject = new BehaviorSubject<int>(0);
StatsObserver<int> stats = new StatsObserver<int>();
subject.OnNext(1);
subject.OnNext(2);
subject.OnNext(3);
subject.OnCompleted();
subject.Subscribe(stats);
Assert.AreEqual(0, stats.NextCount);
Assert.IsTrue(stats.CompletedCalled);
}
public void sends_live_values_after_replay()
{
BehaviorSubject<int> subject = new BehaviorSubject<int>(0);
StatsObserver<int> stats = new StatsObserver<int>();
subject.OnNext(1);
subject.OnNext(2);
subject.Subscribe(stats);
subject.OnNext(3);
subject.OnCompleted();
Assert.AreEqual(2, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2, 3 }));
Assert.IsTrue(stats.CompletedCalled);
}
