public void AferTerminate_Basic_Twice() { var count = 0; CompletableSource.Empty() .DoAfterTerminate(() => count++) .DoAfterTerminate(() => count++) .Test() .AssertResult(); Assert.AreEqual(2, count); }
public void OnCompleted_Basic_Twice() { var count = 0; CompletableSource.Empty() .DoOnCompleted(() => count++) .DoOnCompleted(() => count++) .Test() .AssertResult(); Assert.AreEqual(2, count); }
public void OnDispose_Basic_Twice() { var count = 0; CompletableSource.Never() .DoOnDispose(() => count++) .DoOnDispose(() => count++) .Test(true) .AssertEmpty(); Assert.AreEqual(2, count); }
public void Disposed_Upfront() { var count = 0; var c = CompletableSource.FromAction(() => count++); c.Test(true) .AssertSubscribed() .AssertEmpty(); Assert.AreEqual(0, count); }
public void Enumerable_Empty() { CompletableSource.Amb(new List <ICompletableSource>() { CompletableSource.Never(), CompletableSource.Never(), CompletableSource.Never(), CompletableSource.Empty() }) .Test() .AssertResult(); }
public void Error() { try { CompletableSource.Error(new InvalidOperationException()) .Wait(); Assert.Fail(); } catch (InvalidOperationException) { // expected } }
public void Dispose() { var resource = new SingleAssignmentDisposable(); var source = CompletableSource.Create(e => { e.SetResource(resource); }); source.Test().Dispose(); Assert.True(resource.IsDisposed()); }
public void Basic_Error_Delay() { var count = 0; CompletableSource.Concat(true, CompletableSource.Error(new InvalidOperationException()), CompletableSource.FromAction(() => count++) ) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(1, count); }
public void Basic_Delay_Errors() { var count = 0; CompletableSource.Concat(true, CompletableSource.FromAction(() => count++), CompletableSource.FromAction(() => count++) ) .Test() .AssertResult(); Assert.AreEqual(2, count); }
public void Basic_Delay_Errors() { var count = 0; var source = CompletableSource.FromAction(() => count++); new[] { source, source, source } .ToObservable() .FlatMap(v => v, true) .Test() .AssertResult(); Assert.AreEqual(3, count); }
public void Enumerable_Many() { var list = new List <ICompletableSource>(); for (int i = 0; i < 32; i++) { list.Add(CompletableSource.Never()); } list.Add(CompletableSource.Error(new InvalidOperationException())); CompletableSource.Amb(list) .Test() .AssertFailure(typeof(InvalidOperationException)); }
public void Predicate_Finite() { for (int i = 0; i < 100; i++) { var count = 0; CompletableSource.FromAction(() => count++) .Repeat(times => times <= i) .Test() .AssertResult(); Assert.AreEqual(i + 1, count); } }
public void Error() { var name = ""; CompletableSource.Error(new InvalidOperationException()) .ObserveOn(NewThreadScheduler.Default) .DoOnError(e => name = Thread.CurrentThread.Name) .Test() .AwaitDone(TimeSpan.FromSeconds(5)) .AssertFailure(typeof(InvalidOperationException)); Assert.AreNotEqual("", name); Assert.AreNotEqual(Thread.CurrentThread.Name, name); }
public void Basic() { var name = ""; CompletableSource.Empty() .ObserveOn(NewThreadScheduler.Default) .DoOnCompleted(() => name = Thread.CurrentThread.Name) .Test() .AwaitDone(TimeSpan.FromSeconds(5)) .AssertResult(); Assert.AreNotEqual("", name); Assert.AreNotEqual(Thread.CurrentThread.Name, name); }
public void Observable_Dispose_Next() { var us = new UnicastSubject <int>(); var to = CompletableSource.Empty() .AndThen(us) .Test(); Assert.True(us.HasObserver()); to.Dispose(); Assert.False(us.HasObserver()); }
public void Single_Dispose_Other() { var ms = new SingleSubject <int>(); var to = CompletableSource.Empty() .AndThen(ms) .Test(); Assert.True(ms.HasObserver()); to.Dispose(); Assert.False(ms.HasObserver()); }
public void Basic_Enumerable_Error() { var count = 0; CompletableSource.Concat(new List <ICompletableSource>() { CompletableSource.Error(new InvalidOperationException()), CompletableSource.FromAction(() => count++) }) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(0, count); }
public void Error() { var count = 0; var source = CompletableSource.FromAction(() => count++); var err = CompletableSource.Error(new InvalidOperationException()); new [] { source, err, source } .ToObservable() .FlatMap(v => v) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(1, count); }
public void Basic_Array_Delay_Errors() { var count = 0; new[] { CompletableSource.FromAction(() => count++), CompletableSource.FromAction(() => count++) }.ConcatAll(true) .Test() .AssertResult(); Assert.AreEqual(2, count); }
public void Task_Basic_From() { var count = 0; var task = Task.Factory.StartNew(() => { count++; }); var co = CompletableSource.FromTask(task); co.Test() .AwaitDone(TimeSpan.FromSeconds(5)) .AssertResult(); Assert.AreEqual(1, count); }
public void Enumerable_Error_Delayed() { var count = 0; var source = CompletableSource.FromAction(() => count++); var err = CompletableSource.Error(new InvalidOperationException()); CompletableSource.Merge(new List <ICompletableSource>() { source, err, source }, true) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(2, count); }
public void DisposeUpfront() { var name = ""; CompletableSource.FromAction(() => { name = Thread.CurrentThread.Name; throw new InvalidOperationException(); }) .SubscribeOn(NewThreadScheduler.Default) .Test(true) .AssertEmpty(); Assert.AreEqual("", name); }
public void Basic_Enumerable_Delay_Errors() { var count = 0; CompletableSource.Concat(new List <ICompletableSource>() { CompletableSource.FromAction(() => count++), CompletableSource.FromAction(() => count++) }, true ) .Test() .AssertResult(); Assert.AreEqual(2, count); }
public void Repeat() { var subs = 0; CompletableSource.FromAction(() => subs++) .RepeatWhen(v => { var count = 0; return(v.TakeWhile(_ => ++ count < 5)); }) .Test() .AssertResult(); Assert.AreEqual(5, subs); }
public void Array_Error_Delayed_Max_Concurrency() { for (int i = 1; i < 5; i++) { var count = 0; var source = CompletableSource.FromAction(() => count++); var err = CompletableSource.Error(new InvalidOperationException()); CompletableSource.Merge(true, i, source, err, source) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(2, count); } }
public void OnDispose_Error() { var count = 0; CompletableSource.Error(new InvalidOperationException()) .DoOnDispose(() => { count++; }) .Test() .AssertFailure(typeof(InvalidOperationException)); ; Assert.AreEqual(0, count); }
public void OnDispose_Complete() { var count = 0; CompletableSource.Empty() .DoOnDispose(() => { count++; }) .Test() .AssertResult(); ; Assert.AreEqual(0, count); }
public void Array_Basic_Max_Concurrency_Delay_Errors() { for (int i = 1; i < 5; i++) { var count = 0; var source = CompletableSource.FromAction(() => count++); CompletableSource.Merge(true, i, new[] { source, source, source }) .Test() .WithTag("maxConcurrency=" + i) .AssertResult(); Assert.AreEqual(3, count); } }
public void Enumerable_Basic() { var count = 0; var source = CompletableSource.FromAction(() => count++); new List <ICompletableSource>() { source, source, source } .Merge() .Test() .AssertResult(); Assert.AreEqual(3, count); }
public void Resource_Supplier_Crash() { var cleanup = -1; var run = 0; CompletableSource.Using <int>(() => { throw new InvalidOperationException(); }, v => { run = 1; return(CompletableSource.Never()); }, v => cleanup = run ) .Test() .AssertFailure(typeof(InvalidOperationException)); Assert.AreEqual(-1, cleanup); Assert.AreEqual(0, run); }