public async Task TakeWhileException()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeWhile(x => x < 5).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeWhile((x, i) => x < 5).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeWhileAwait((x) => UniTask.Run(() => x < 5)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeWhileAwait((x, i) => UniTask.Run(() => x < 5)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < 5)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < 5)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
public async Task GroupJoinThrow()
{
var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 }.ToUniTaskAsyncEnumerable();
var inner = new[] { 1, 2, 1, 2, 1, 14, 2 }.ToUniTaskAsyncEnumerable();
foreach (var item in UniTaskTestException.Throws())
{
{
var xs = item.GroupJoin(outer, x => x, x => x, (x, y) => x).ToArrayAsync();
var ys = inner.GroupJoin(item, x => x, x => x, (x, y) => x).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await ys);
}
{
var xs = item.GroupJoinAwait(outer, x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun(x)).ToArrayAsync();
var ys = inner.GroupJoinAwait(item, x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun(x)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await ys);
}
{
var xs = item.GroupJoinAwaitWithCancellation(outer, (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun(x)).ToArrayAsync();
var ys = inner.GroupJoinAwaitWithCancellation(item, (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun(x)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await ys);
}
}
}
public async Task TakeLastException()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeLast(5).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
public async Task OfTypeException()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.Select(x => (object)x).OfType <int>().ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
public async Task BufferError()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.Buffer(3).ToArrayAsync();
var ys = item.Buffer(3, 2).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await ys);
}
}
public async Task PrependThrow()
{
var xs = UniTaskTestException.ThrowImmediate().Prepend(99).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
var ys = UniTaskTestException.ThrowAfter().Prepend(99).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await ys);
var zs = UniTaskTestException.ThrowInMoveNext().Prepend(99).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await zs);
}
public async Task UnionThrow()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.Union(UniTaskAsyncEnumerable.Return(10)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = UniTaskAsyncEnumerable.Return(10).Union(item).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
public async Task JoinAwaitThrow()
{
var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
foreach (var item in UniTaskTestException.Throws())
{
var xs = outer.ToUniTaskAsyncEnumerable().JoinAwait(item, x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun(x + y)).ToArrayAsync();
var ys = item.Join(inner.ToUniTaskAsyncEnumerable(), x => x, x => x, (x, y) => x + y).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await ys);
}
}
public async Task Throws()
{
foreach (var item in UniTaskTestException.Throws())
{
{
var a = item.OrderBy(x => x).ToArrayAsync();
var b = item.OrderByDescending(x => x).ToArrayAsync();
var c = item.OrderBy(x => x).ThenBy(x => x).ToArrayAsync();
var d = item.OrderBy(x => x).ThenByDescending(x => x).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await a);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await b);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await c);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await d);
}
{
var a = item.OrderByAwait(RandomRun).ToArrayAsync();
var b = item.OrderByDescendingAwait(RandomRun).ToArrayAsync();
var c = item.OrderByAwait(RandomRun).ThenByAwait(RandomRun).ToArrayAsync();
var d = item.OrderByAwait(RandomRun).ThenByDescendingAwait(RandomRun).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await a);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await b);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await c);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await d);
}
{
var a = item.OrderByAwaitWithCancellation(RandomRun).ToArrayAsync();
var b = item.OrderByDescendingAwaitWithCancellation(RandomRun).ToArrayAsync();
var c = item.OrderByAwaitWithCancellation(RandomRun).ThenByAwaitWithCancellation(RandomRun).ToArrayAsync();
var d = item.OrderByAwaitWithCancellation(RandomRun).ThenByDescendingAwaitWithCancellation(RandomRun).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await a);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await b);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await c);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await d);
}
}
}
public async Task GroupByThrow()
{
var arr = new[] { 1, 4, 10, 10, 4, 5, 10, 9 };
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.GroupBy(x => x).ToArrayAsync();
var ys = item.GroupByAwait(x => RandomRun(x)).ToArrayAsync();
var zs = item.GroupByAwaitWithCancellation((x, _) => RandomRun(x)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await ys);
await Assert.ThrowsAsync <UniTaskTestException>(async() => await zs);
}
}
public async Task SelectManyException()
{
// error + exists
// exists + error
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.SelectMany(x => UniTaskAsyncEnumerable.Range(0, 1)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectMany(x => item).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
// await
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.SelectManyAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectManyAwait(x => UniTask.Run(() => item)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
// with c
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => item)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
public async Task WhereException()
{
foreach (var item in UniTaskTestException.Throws())
{
{
var xs = item.Where(x => x % 2 == 0).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
{
var xs = item.Where((x, i) => x % 2 == 0).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
{
var xs = item.WhereAwait(x => UniTask.FromResult(x % 2 == 0)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
{
var xs = item.WhereAwait((x, i) => UniTask.FromResult(x % 2 == 0)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
}
public async Task ZipException()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.Zip(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = UniTaskAsyncEnumerable.Range(1, 10).Zip(item).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
// a
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.ZipAwait(UniTaskAsyncEnumerable.Range(1, 10), (x, y) => UniTask.Run(() => (x, y))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = UniTaskAsyncEnumerable.Range(1, 10).ZipAwait(item, (x, y) => UniTask.Run(() => (x, y))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
// c
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.ZipAwaitWithCancellation(UniTaskAsyncEnumerable.Range(1, 10), (x, y, c) => UniTask.Run(() => (x, y))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
foreach (var item in UniTaskTestException.Throws())
{
var xs = UniTaskAsyncEnumerable.Range(1, 10).ZipAwaitWithCancellation(item, (x, y, c) => UniTask.Run(() => (x, y))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
public async Task DistinctUntilChangedThrow()
{
foreach (var item in UniTaskTestException.Throws())
{
{
var xs = item.DistinctUntilChanged().ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
{
var xs = item.DistinctUntilChanged(x => x).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
{
var xs = item.DistinctUntilChangedAwait(x => UniTask.Run(() => x)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
{
var xs = item.DistinctUntilChangedAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
}
public async Task SelectException()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.Select(x => UniTaskAsyncEnumerable.Range(0, 1)).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
// await
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.SelectAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
// cancel
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.SelectAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
await Assert.ThrowsAsync <UniTaskTestException>(async() => await xs);
}
}
