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);
}
