794 lines
31 KiB
C#
794 lines
31 KiB
C#
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
|
#if !NO_TPL
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
#if NUNIT
|
|
using NUnit.Framework;
|
|
using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
|
|
using TestMethodAttribute = NUnit.Framework.TestAttribute;
|
|
using TestInitializeAttribute = NUnit.Framework.SetUpAttribute;
|
|
#else
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
#endif
|
|
using System.Threading;
|
|
|
|
namespace Tests
|
|
{
|
|
public partial class AsyncTests
|
|
{
|
|
[TestMethod]
|
|
public void Concat_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(null, AsyncEnumerable.Return(42)));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(AsyncEnumerable.Return(42), null));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(default(IAsyncEnumerable<int>[])));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(default(IEnumerable<IAsyncEnumerable<int>>)));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Concat1()
|
|
{
|
|
var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable());
|
|
|
|
var e = ys.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 2);
|
|
HasNext(e, 3);
|
|
HasNext(e, 4);
|
|
HasNext(e, 5);
|
|
HasNext(e, 6);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Concat2()
|
|
{
|
|
var ex = new Exception("Bang");
|
|
var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(AsyncEnumerable.Throw<int>(ex));
|
|
|
|
var e = ys.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 2);
|
|
HasNext(e, 3);
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Concat3()
|
|
{
|
|
var ex = new Exception("Bang");
|
|
var ys = AsyncEnumerable.Throw<int>(ex).Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable());
|
|
|
|
var e = ys.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Concat4()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 4, 5 }.ToAsyncEnumerable();
|
|
var zs = new[] { 6, 7, 8 }.ToAsyncEnumerable();
|
|
|
|
var res = AsyncEnumerable.Concat(xs, ys, zs);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 2);
|
|
HasNext(e, 3);
|
|
HasNext(e, 4);
|
|
HasNext(e, 5);
|
|
HasNext(e, 6);
|
|
HasNext(e, 7);
|
|
HasNext(e, 8);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Concat5()
|
|
{
|
|
var ex = new Exception("Bang");
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 4, 5 }.ToAsyncEnumerable();
|
|
var zs = AsyncEnumerable.Throw<int>(ex);
|
|
|
|
var res = AsyncEnumerable.Concat(xs, ys, zs);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 2);
|
|
HasNext(e, 3);
|
|
HasNext(e, 4);
|
|
HasNext(e, 5);
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Concat6()
|
|
{
|
|
var res = AsyncEnumerable.Concat(ConcatXss());
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 2);
|
|
HasNext(e, 3);
|
|
HasNext(e, 4);
|
|
HasNext(e, 5);
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single().Message == "Bang!");
|
|
}
|
|
|
|
static IEnumerable<IAsyncEnumerable<int>> ConcatXss()
|
|
{
|
|
yield return new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
yield return new[] { 4, 5 }.ToAsyncEnumerable();
|
|
throw new Exception("Bang!");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Zip_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(null, AsyncEnumerable.Return(42), (x, y) => x + y));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(AsyncEnumerable.Return(42), null, (x, y) => x + y));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Zip1()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
|
|
var res = xs.Zip(ys, (x, y) => x * y);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1 * 4);
|
|
HasNext(e, 2 * 5);
|
|
HasNext(e, 3 * 6);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Zip2()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 4, 5, 6, 7 }.ToAsyncEnumerable();
|
|
var res = xs.Zip(ys, (x, y) => x * y);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1 * 4);
|
|
HasNext(e, 2 * 5);
|
|
HasNext(e, 3 * 6);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Zip3()
|
|
{
|
|
var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var ys = new[] { 4, 5, 6 }.ToAsyncEnumerable();
|
|
var res = xs.Zip(ys, (x, y) => x * y);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1 * 4);
|
|
HasNext(e, 2 * 5);
|
|
HasNext(e, 3 * 6);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Zip4()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var ys = AsyncEnumerable.Throw<int>(ex);
|
|
var res = xs.Zip(ys, (x, y) => x * y);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Zip5()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = AsyncEnumerable.Throw<int>(ex);
|
|
var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Zip(ys, (x, y) => x * y);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Zip6()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Zip(ys, (x, y) => { if (x > 0) throw ex; return x * y; });
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Union_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(null, AsyncEnumerable.Return(42)));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(AsyncEnumerable.Return(42), null));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(null, AsyncEnumerable.Return(42), new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(AsyncEnumerable.Return(42), null, new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Union1()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Union(ys);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 2);
|
|
HasNext(e, 3);
|
|
HasNext(e, 5);
|
|
HasNext(e, 4);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Union2()
|
|
{
|
|
var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Union(ys, new Eq());
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 2);
|
|
HasNext(e, -3);
|
|
HasNext(e, 5);
|
|
HasNext(e, 4);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Intersect_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(null, AsyncEnumerable.Return(42)));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(AsyncEnumerable.Return(42), null));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(null, AsyncEnumerable.Return(42), new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(AsyncEnumerable.Return(42), null, new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Intersect1()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Intersect(ys);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, 3);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Intersect2()
|
|
{
|
|
var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Intersect(ys, new Eq());
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 1);
|
|
HasNext(e, -3);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Except_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(null, AsyncEnumerable.Return(42)));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(AsyncEnumerable.Return(42), null));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(null, AsyncEnumerable.Return(42), new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(AsyncEnumerable.Return(42), null, new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Except1()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Except(ys);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 2);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Except2()
|
|
{
|
|
var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 5, -1, 4 }.ToAsyncEnumerable();
|
|
var res = xs.Except(ys, new Eq());
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 2);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42)));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq()));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), CancellationToken.None));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, CancellationToken.None));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42), new Eq(), CancellationToken.None));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), null, new Eq(), CancellationToken.None));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, CancellationToken.None));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual1()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(xs);
|
|
Assert.IsTrue(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual2()
|
|
{
|
|
var xs = AsyncEnumerable.Empty<int>();
|
|
var res = xs.SequenceEqual(xs);
|
|
Assert.IsTrue(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual3()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys);
|
|
Assert.IsFalse(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual4()
|
|
{
|
|
var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys);
|
|
Assert.IsFalse(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual5()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys);
|
|
Assert.IsFalse(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual6()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var ys = AsyncEnumerable.Throw<int>(ex);
|
|
var res = xs.SequenceEqual(ys);
|
|
|
|
AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual7()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = AsyncEnumerable.Throw<int>(ex);
|
|
var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys);
|
|
|
|
AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual8()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(xs, new Eq());
|
|
Assert.IsTrue(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual9()
|
|
{
|
|
var xs = AsyncEnumerable.Empty<int>();
|
|
var res = xs.SequenceEqual(xs, new Eq());
|
|
Assert.IsTrue(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual10()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys, new Eq());
|
|
Assert.IsFalse(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual11()
|
|
{
|
|
var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys, new Eq());
|
|
Assert.IsFalse(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual12()
|
|
{
|
|
var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys, new Eq());
|
|
Assert.IsFalse(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual13()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var ys = AsyncEnumerable.Throw<int>(ex);
|
|
var res = xs.SequenceEqual(ys, new Eq());
|
|
|
|
AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual14()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = AsyncEnumerable.Throw<int>(ex);
|
|
var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys, new Eq());
|
|
|
|
AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual15()
|
|
{
|
|
var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys, new Eq());
|
|
Assert.IsTrue(res.Result);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SequenceEqual16()
|
|
{
|
|
var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
|
|
var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
|
|
var res = xs.SequenceEqual(ys, new EqEx());
|
|
AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() is NotImplementedException);
|
|
}
|
|
|
|
class EqEx : IEqualityComparer<int>
|
|
{
|
|
public bool Equals(int x, int y)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public int GetHashCode(int obj)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer<int>)));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin1()
|
|
{
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 4, 7, 6, 2, 3, 4, 8, 9 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, "0 - 639");
|
|
HasNext(e, "1 - 474");
|
|
HasNext(e, "2 - 28");
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin2()
|
|
{
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, "0 - 36");
|
|
HasNext(e, "1 - 4");
|
|
HasNext(e, "2 - ");
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin3()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = AsyncEnumerable.Throw<int>(ex);
|
|
var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin4()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = AsyncEnumerable.Throw<int>(ex);
|
|
|
|
var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin5()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.GroupJoin(ys, x => { throw ex; }, y => y % 3, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin6()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.GroupJoin(ys, x => x % 3, y => { throw ex; }, (x, i) => x + " - " + i.Aggregate("", (s, j) => s + j).Result);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GroupJoin7()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.GroupJoin(ys, x => x % 3, y => y % 3, (x, i) => {
|
|
if (x == 1)
|
|
throw ex;
|
|
return x + " - " + i.Aggregate("", (s, j) => s + j).Result;
|
|
});
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, "0 - 36");
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null));
|
|
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), null, x => x, x => x, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, x => x, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, null, (x, y) => x, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, null, EqualityComparer<int>.Default));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer<int>)));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join1()
|
|
{
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 6, 4 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 0 + 3);
|
|
HasNext(e, 0 + 6);
|
|
HasNext(e, 1 + 4);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join2()
|
|
{
|
|
var xs = new[] { 3, 6, 4 }.ToAsyncEnumerable();
|
|
var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 3 + 0);
|
|
HasNext(e, 6 + 0);
|
|
HasNext(e, 4 + 1);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join3()
|
|
{
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 6 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 0 + 3);
|
|
HasNext(e, 0 + 6);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join4()
|
|
{
|
|
var xs = new[] { 3, 6 }.ToAsyncEnumerable();
|
|
var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 3 + 0);
|
|
HasNext(e, 6 + 0);
|
|
NoNext(e);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join5()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = AsyncEnumerable.Throw<int>(ex);
|
|
var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join6()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = AsyncEnumerable.Throw<int>(ex);
|
|
|
|
var res = xs.Join(ys, x => x % 3, y => y % 3, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join7()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join(ys, x => { throw ex; }, y => y, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join8()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join(ys, x => x, y => { throw ex; }, (x, y) => x + y);
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Join9()
|
|
{
|
|
var ex = new Exception("Bang!");
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.Join<int, int, int, int>(ys, x => x, y => y, (x, y) => { throw ex; });
|
|
|
|
var e = res.GetEnumerator();
|
|
AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SelectManyMultiple_Null()
|
|
{
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(default(IAsyncEnumerable<int>), AsyncEnumerable.Return(42)));
|
|
AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(AsyncEnumerable.Return(42), default(IAsyncEnumerable<int>)));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SelectManyMultiple1()
|
|
{
|
|
var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
|
|
var ys = new[] { 3, 4 }.ToAsyncEnumerable();
|
|
|
|
var res = xs.SelectMany(ys);
|
|
|
|
var e = res.GetEnumerator();
|
|
HasNext(e, 3);
|
|
HasNext(e, 4);
|
|
HasNext(e, 3);
|
|
HasNext(e, 4);
|
|
HasNext(e, 3);
|
|
HasNext(e, 4);
|
|
NoNext(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif |