public async ValueTask ContainsAsync_Predicate_With_Null_And_NotContains_Must_ReturnFalse(int[] source, Predicate <int> predicate)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ContainsAsync(value, null);
// Assert
_ = result.Must()
.BeFalse();
}
public void Where_Predicate_With_Null_Must_Throw()
{
// Arrange
var enumerable = Wrap.AsAsyncValueEnumerable(new int[0]);
var predicate = (AsyncPredicate <int>)null;
// Act
Action action = () => _ = AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(enumerable, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public async void FirstAsync_PredicateAt_With_Empty_Must_Return_None(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.FirstAsync();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void SingleAsync_Predicate_With_Empty_Must_Throw(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
Func <ValueTask> action = async() => _ = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.SingleAsync();
// Assert
_ = action.Must()
.Throw <InvalidOperationException>()
.EvaluateTrue(exception => exception.Message == "Sequence contains no elements");
}
public async ValueTask ContainsAsync_Predicate_Selector_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var value = "!";
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.ContainsAsync(value, EqualityComparer <string> .Default);
// Assert
_ = result.Must()
.BeFalse();
}
public async ValueTask SingleAsync_Predicate_With_SingleAsync_Must_Succeed(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Single(source, predicate.AsFunc());
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.SingleAsync();
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public async ValueTask ContainsAsync_PredicateAt_With_Comparer_And_Contains_Must_ReturnTrue(int[] source, PredicateAt <int> predicate)
{
// Arrange
var value =
System.Linq.Enumerable.Last(
System.Linq.Enumerable.Where(source, predicate.AsFunc()));
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ContainsAsync(value, EqualityComparer <int> .Default);
// Assert
_ = result.Must()
.BeTrue();
}
public async void SingleAsync_Predicate_Selector_With_Multiple_Must_Return_None(int[] source, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.SingleAsync();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public async ValueTask FirstAsync_Predicate_With_ValidData_Must_Return_Some(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.First(source, predicate.AsFunc());
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.FirstAsync();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask ContainsAsync_Predicate_Selector_With_Null_And_Contains_Must_ReturnTrue(int[] source, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var value =
System.Linq.Enumerable.Last(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc()));
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.ContainsAsync(value, null);
// Assert
_ = result.Must()
.BeTrue();
}
public async ValueTask ToListAsync_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.ToList(
System.Linq.Enumerable.Where(source, predicate.AsFunc()));
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ToListAsync();
// Assert
_ = result.Must()
.BeOfType <List <int> >()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask ForEachAsync_Action_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var result = new List <int>();
var expected = new List <int>();
System.Linq.EnumerableEx.ForEach(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), item => expected.Add(item));
// Act
await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ForEachAsync((item, cancellationToken) => { result.Add(item); return(new ValueTask()); });
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask SingleAsync_Predicate_Selector_With_SingleAsync_Must_Return_Some(int[] source, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Single(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc()));
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.SingleAsync();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask ToArrayAsync_Predicate_Selector_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc()));
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public async ValueTask ElementAtAsync_Predicate_With_ValidData_Must_Return_Some(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.ToList(
System.Linq.Enumerable.Where(source, predicate.AsFunc()));
for (var index = 0; index < expected.Count; index++)
{
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ElementAtAsync(index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected[index]),
() => throw new Exception());
}
}
public async ValueTask ForEachAsync_ActionAt_Predicate_Selector_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var result = new List <(string, int)>();
var expected = new List <(string, int)>();
System.Linq.EnumerableEx.ForEach(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc()), (item, index) => expected.Add((item, index)));
// Act
await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.ForEachAsync((item, index, cancellationToken) => { result.Add((item, index)); return(new ValueTask()); });
// Assert
_ = result.Must()
.BeEnumerableOf <(string, int)>()
.BeEqualTo(expected);
}
public async void ElementAtAsync_Predicate_With_OutOfRange_Must_Return_None(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var optionNegative = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ElementAtAsync(-1);
var optionTooLarge = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ElementAtAsync(source.Length);
// Assert
_ = optionNegative.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
_ = optionTooLarge.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
