public void Error()
{
var count = 0;
var us = new UnicastSubject <int>();
var to = us
.ConcatMap(v => {
if (v == 2)
{
return(CompletableSource.Error(new InvalidOperationException()));
}
return(CompletableSource.FromAction(() => count++));
})
.Test();
to.AssertEmpty()
.AssertSubscribed();
us.OnNext(0);
us.OnNext(1);
us.OnNext(2);
to.AssertFailure(typeof(InvalidOperationException));
Assert.False(us.HasObserver());
Assert.AreEqual(2, count);
}
public void Main_Disposes_Others_On_Completion()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
us1.Emit(10);
us2.Emit(100);
var source = new Subject <int>();
var to = source.WithLatestFrom((a, bs) =>
{
foreach (var i in bs)
{
a += i;
}
return(a);
}, us1, us2).Test();
Assert.True(us1.HasObserver());
Assert.True(us2.HasObserver());
to.AssertEmpty();
source.EmitAll(1, 2, 3, 4, 5);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertResult(111, 112, 113, 114, 115);
}
public void Dispose()
{
var us = new UnicastSubject <int>();
var n0 = Thread.CurrentThread.Name;
var cdl = new CountdownEvent(1);
var n1 = default(string);
var to = us.DoOnDispose(() =>
{
n1 = Thread.CurrentThread.Name;
cdl.Signal();
})
.UnsubscribeOn(NewThreadScheduler.Default)
.Test();
us.OnNext(1);
to.AssertValuesOnly(1);
Assert.Null(n1);
to.Dispose();
Assert.True(cdl.Wait(TimeSpan.FromSeconds(5)));
Assert.AreNotEqual(n0, n1);
}
public void Race()
{
for (int i = 0; i < TestHelper.RACE_LOOPS; i++)
{
var us = new UnicastSubject <int>();
var to = new TestObserver <int>();
TestHelper.Race(() =>
{
for (int j = 0; j < 1000; j++)
{
us.OnNext(j);
}
us.OnCompleted();
},
() =>
{
foreach (var v in us.BlockingEnumerable())
{
to.OnNext(v);
}
to.OnCompleted();
});
to.AssertValueCount(1000)
.AssertNoError()
.AssertCompleted();
}
}
public void Switch_Outer_Completes_First()
{
var source = new Subject <IObservable <int> >();
var to = source.SwitchMany().Test();
to.AssertEmpty();
var us1 = new UnicastSubject <int>();
source.OnNext(us1);
Assert.True(us1.HasObserver());
var us2 = new UnicastSubject <int>();
source.OnNext(us2);
Assert.True(us2.HasObserver());
Assert.False(us1.HasObserver());
source.OnCompleted();
Assert.True(us2.HasObserver());
to.AssertEmpty();
us2.EmitAll(1, 2, 3, 4, 5);
to.AssertResult(1, 2, 3, 4, 5);
}
public void Main_Disposes_Others_On_Error()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
us1.Emit(10);
us2.Emit(100);
var source = new Subject <int>();
var to = source.WithLatestFrom((a, bs) =>
{
foreach (var i in bs)
{
a += i;
}
return(a);
}, us1, us2).Test();
Assert.True(us1.HasObserver());
Assert.True(us2.HasObserver());
to.AssertEmpty();
source.EmitError(new InvalidOperationException(), 1, 2, 3, 4, 5);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException), 111, 112, 113, 114, 115);
}
public void Race_While()
{
for (int i = 0; i < TestHelper.RACE_LOOPS; i++)
{
var us = new UnicastSubject <int>();
var to = new TestObserver <int>();
TestHelper.Race(() =>
{
for (int j = 0; j < 1000; j++)
{
us.OnNext(j);
}
us.OnCompleted();
},
() =>
{
us.BlockingSubscribeWhile(v =>
{
to.OnNext(v);
return(true);
}, to.OnError, to.OnCompleted);
});
to.AssertValueCount(1000)
.AssertNoError()
.AssertCompleted();
}
}
public void Error()
{
var us = new UnicastSubject <int>();
var n0 = Thread.CurrentThread.ManagedThreadId;
var cdl = new CountdownEvent(1);
var n1 = default(int);
var to = us.DoOnDispose(() =>
{
n1 = Thread.CurrentThread.ManagedThreadId;
cdl.Signal();
})
.UnsubscribeOn(NewThreadScheduler.Default)
.Test();
us.OnNext(1);
us.OnError(new InvalidOperationException());
to.AssertFailure(typeof(InvalidOperationException), 1);
Assert.True(cdl.Wait(TimeSpan.FromSeconds(5)));
Assert.AreNotEqual(n0, n1);
}
public void Mapper_Crashes()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.Zip(a =>
{
int s = 0;
foreach (var v in a)
{
s += v;
}
if (s == 33)
{
throw new InvalidOperationException();
}
return(s);
},
us1,
us2
).Test();
us1.Emit(1, 2, 3);
Assert.True(us1.HasObserver());
Assert.True(us2.HasObserver());
us2.Emit(10, 20, 30, 40);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException), 11, 22);
}
public void Disposed()
{
var us = new UnicastSubject <int>();
var to = new TestObserverLocal();
bool[] disposed = { false };
var d = us.ConcatMap(v => new OnDispose <int>(Enumerable.Range(v * 100, 5), disposed))
.Subscribe(to);
to.OnSubscribe(d);
Assert.True(us.HasObserver());
to.AssertEmpty();
us.OnNext(1);
to.AssertValuesOnly(100, 101, 102, 103, 104);
Assert.True(us.HasObserver());
us.OnNext(2);
Assert.False(us.HasObserver());
Assert.True(disposed[0]);
to.AssertResult(100, 101, 102, 103, 104, 200, 201);
}
public void Basic_Observer_Dispose()
{
var to = new TestObserver <int>();
var sad = new SingleAssignmentDisposable();
var cdl = new CountdownEvent(1);
var us = new UnicastSubject <int>();
Task.Factory.StartNew(() =>
{
while (to.ItemCount != 5)
{
;
}
sad.Dispose();
cdl.Signal();
});
Task.Factory.StartNew(() =>
{
us.Emit(1, 2, 3, 4, 5);
cdl.Signal();
});
us.BlockingSubscribe(to, d => sad.Disposable = d);
to.AssertValuesOnly(1, 2, 3, 4, 5);
Assert.True(cdl.Wait(3000));
Assert.False(us.HasObserver());
}
public void Error_Delayed()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.Zip(a =>
{
int s = 0;
foreach (var v in a)
{
s += v;
}
return(s);
}, true,
us1,
us2
).Test();
us1.EmitError(new InvalidOperationException(), 1, 2, 3);
Assert.True(us2.HasObserver(), "us2: No observers!");
us2.Emit(10, 20, 30, 40);
Assert.False(us2.HasObserver(), "us2: Observers present!");
to.AssertFailure(typeof(InvalidOperationException), 11, 22, 33);
}
public void Race()
{
for (int i = 0; i < TestHelper.RACE_LOOPS; i++)
{
var ups = new UnicastSubject <int>[]
{
new UnicastSubject <int>(),
new UnicastSubject <int>()
};
var to = Observable.Range(0, 2)
.Select(v => ups[v])
.MergeMany()
.Test();
TestHelper.Race(() => {
for (int j = 0; j < 1000; j++)
{
ups[0].OnNext(j);
}
ups[0].OnCompleted();
}, () => {
for (int j = 1000; j < 2000; j++)
{
ups[1].OnNext(j);
}
ups[1].OnCompleted();
});
to.AssertValueCount(2000)
.AssertNoError()
.AssertCompleted();
}
}
public void Error_Delayed()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
return(v);
}, true, us1, us2).Test();
to.AssertEmpty();
us1.OnNext(1);
us1.OnError(new InvalidOperationException());
Assert.True(us2.HasObserver());
us2.EmitAll(10, 20, 30, 40, 50);
to.AssertFailure(typeof(InvalidOperationException), 11, 21, 31, 41, 51);
}
public void No_Combinations_Complete_After_All()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
return(v);
}, us1, us2).Test();
to.AssertEmpty();
us1.OnCompleted();
Assert.True(us2.HasObserver(), "Other source disposed?");
us2.EmitAll(1, 2, 3, 4, 5);
to.AssertResult();
}
public void Mapper_Crash()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
if (v == 22)
{
throw new InvalidOperationException();
}
return(v);
}, us1, us2).Test();
to.AssertEmpty();
us1.OnNext(1);
us2.OnNext(10);
us1.OnNext(2);
us2.OnNext(20);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException), 11, 12);
}
public void Complete()
{
var us = new UnicastSubject <int>();
var n0 = Thread.CurrentThread.ManagedThreadId;
var cdl = new CountdownEvent(1);
var n1 = default(int);
var to = us.DoOnDispose(() =>
{
n1 = Thread.CurrentThread.ManagedThreadId;
cdl.Signal();
})
.UnsubscribeOn(NewThreadScheduler.Default)
.Test();
us.OnNext(1);
us.OnCompleted();
to.AssertResult(1);
Assert.True(cdl.Wait(TimeSpan.FromSeconds(5)));
Assert.AreNotEqual(n0, n1);
}
public void Basic_Handler_Crash()
{
var up = new UnicastSubject <int>();
var src = up.DoOnSubscribe(() => { throw new InvalidOperationException(); });
src.Test().AssertFailure(typeof(InvalidOperationException));
}
public void Basic_Error()
{
var us = new UnicastSubject <int>();
CompletableSource.Error(new InvalidOperationException())
.RepeatWhen(v => us)
.Test()
.AssertFailure(typeof(InvalidOperationException));
}
public void Basic_Error()
{
var us = new UnicastSubject <int>();
Observable.Range(1, 5).ConcatError(new InvalidOperationException())
.RepeatWhen(v => us)
.Test()
.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5);
}
public void Max_Concurrency_Honored_2_DelayErrors()
{
var us = new UnicastSubject <int>[]
{
new UnicastSubject <int>(),
new UnicastSubject <int>(),
new UnicastSubject <int>(),
};
var to = Observable.Range(0, 3)
.Select(v => us[v])
.MergeMany(delayErrors: true, maxConcurrency: 2)
.Test();
to.AssertEmpty();
Assert.True(us[0].HasObserver());
Assert.True(us[1].HasObserver());
Assert.False(us[2].HasObserver());
us[0].OnNext(1);
Assert.True(us[0].HasObserver());
Assert.True(us[1].HasObserver());
Assert.False(us[2].HasObserver());
to.AssertValuesOnly(1);
us[0].OnCompleted();
Assert.False(us[0].HasObserver());
Assert.True(us[1].HasObserver());
Assert.True(us[2].HasObserver());
us[1].OnNext(2);
to.AssertValuesOnly(1, 2);
us[1].OnCompleted();
Assert.False(us[0].HasObserver());
Assert.False(us[1].HasObserver());
Assert.True(us[2].HasObserver());
us[2].OnNext(3);
to.AssertValuesOnly(1, 2, 3);
us[2].OnCompleted();
Assert.False(us[0].HasObserver());
Assert.False(us[1].HasObserver());
Assert.False(us[2].HasObserver());
to.AssertResult(1, 2, 3);
}
public void Error()
{
var us = new UnicastSubject <int>().ToSerialized();
var to = us.Test();
us.EmitError(new InvalidOperationException(), 1, 2, 3, 4, 5);
to.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5);
}
public void Basic()
{
var us = new UnicastSubject <int>().ToSerialized();
var to = us.Test();
us.EmitAll(1, 2, 3, 4, 5);
to.AssertResult(1, 2, 3, 4, 5);
}
public void Main_Disposed_Handler_Completes()
{
var us = new UnicastSubject <int>();
us.RepeatWhen(v => Observable.Empty <int>())
.Test()
.AssertResult();
Assert.False(us.HasObserver());
}
public void Main_Disposed_Handler_Errors()
{
var us = new UnicastSubject <int>();
us.RepeatWhen(v => Observable.Throw <int>(new InvalidOperationException()))
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.False(us.HasObserver());
}
public void Max_Concurrency_Honored()
{
var us = new UnicastSubject <int>[]
{
new UnicastSubject <int>(),
new UnicastSubject <int>(),
new UnicastSubject <int>(),
};
var to = Observable.Range(0, 3)
.ConcatMapEager(v => us[v], 1)
.Test();
to.AssertEmpty();
Assert.True(us[0].HasObserver());
Assert.False(us[1].HasObserver());
Assert.False(us[2].HasObserver());
us[0].OnNext(1);
Assert.True(us[0].HasObserver());
Assert.False(us[1].HasObserver());
Assert.False(us[2].HasObserver());
to.AssertValuesOnly(1);
us[0].OnCompleted();
Assert.False(us[0].HasObserver());
Assert.True(us[1].HasObserver());
Assert.False(us[2].HasObserver());
us[1].OnNext(2);
to.AssertValuesOnly(1, 2);
us[1].OnCompleted();
Assert.False(us[0].HasObserver());
Assert.False(us[1].HasObserver());
Assert.True(us[2].HasObserver());
us[2].OnNext(3);
to.AssertValuesOnly(1, 2, 3);
us[2].OnCompleted();
Assert.False(us[0].HasObserver());
Assert.False(us[1].HasObserver());
Assert.False(us[2].HasObserver());
to.AssertResult(1, 2, 3);
}
public void Handler_Disposed()
{
var us = new UnicastSubject <int>();
CompletableSource.Empty()
.RetryWhen(v => us)
.Test()
.AssertResult();
Assert.False(us.HasObserver());
}
public void Handler_Disposed()
{
var us = new UnicastSubject <int>();
Observable.Range(1, 5)
.RetryWhen(v => us)
.Test()
.AssertResult(1, 2, 3, 4, 5);
Assert.False(us.HasObserver());
}
public void Observable_Error()
{
var us = new UnicastSubject <int>();
CompletableSource.Error(new InvalidOperationException())
.AndThen(us)
.Test()
.AssertFailure(typeof(InvalidOperationException));
Assert.False(us.HasObserver());
}
public void Handler_Completes_Immediately()
{
var us = new UnicastSubject <int>();
us
.RetryWhen(v => Observable.Empty <int>())
.Test()
.AssertResult();
Assert.False(us.HasObserver());
}
