public void AllAsync_With_NullPredicate_Must_Throw()
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(new int[0]);
var predicate = (AsyncPredicate <int>)null;
// Act
Action action = () => _ = AsyncValueEnumerableExtensions
.AllAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public async void FirstAsync_With_Empty_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerableExtensions
.FirstAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public async ValueTask AnyAsync_Predicate_With_ValidData_Must_Succeed(int[] source, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Any(source, predicate);
// Act
var result = await AsyncValueEnumerableExtensions
.AnyAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync());
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void AsAsyncEnumerable_With_ReferenceType_Must_ReturnSame()
{
// Arrange
var source = Array.Empty <int>();
var wrapped = Wrap
.AsAsyncValueEnumerable(source) as IAsyncValueEnumerable <int, Wrap.AsyncEnumerator <int> >;
// Act
var result = AsyncValueEnumerableExtensions
.AsAsyncEnumerable <IAsyncValueEnumerable <int, Wrap.AsyncEnumerator <int> >, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeSameAs(wrapped);
}
public async void SingleAsync_SelectorAt_With_Multiple_Must_Return_None(int[] source, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.SingleAsync();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public async void SingleAsync_Predicate_With_Empty_Must_Return_None(int[] source, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.SingleAsync();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void WhereSelect_Predicate_With_Null_Must_Throw()
{
// Arrange
var enumerable = Wrap.AsAsyncValueEnumerable(new int[0]);
var predicate = (AsyncPredicate <int>)null;
// Act
Action action = () => _ = AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(enumerable, predicate)
.Select((item, _) => new ValueTask <string>(item.ToString()));
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void WhereSelect_Selector_With_Null_Must_Throw()
{
// Arrange
var enumerable = Wrap.AsAsyncValueEnumerable(new int[0]);
var selector = (AsyncSelector <int, string>)null;
// Act
Action action = () => _ = AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(enumerable, (_, __) => new ValueTask <bool>(true))
.Select(selector);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "selector");
}
public async ValueTask AllAsync_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Count(
System.Linq.Enumerable.Where(source, predicate.AsFunc())) == source.Length;
// Act
var result = await AsyncValueEnumerableExtensions
.AllAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync());
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Distinct_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Distinct(source);
// Act
var result = AsyncValueEnumerableExtensions
.Distinct <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask CountAsync_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Count(source);
// Act
var result = await AsyncValueEnumerableExtensions
.CountAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Select_Selector_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected = System.Linq.Enumerable
.Select(source, selector.AsFunc());
// Act
var result = AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync());
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <string>()
.BeEqualTo(expected);
}
public async ValueTask SingleAsync_With_SingleAsync_Must_Return_Some(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Single(source);
// Act
var result = await AsyncValueEnumerableExtensions
.SingleAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async void FirstAsync_Predicate_Selector_With_Empty_Must_Return_None(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.FirstAsync();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void AsAsyncValueEnumerable6_Enumerator_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = AsyncValueEnumerableExtensions
.AsAsyncValueEnumerable <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(
wrapped,
(enumerable, _) => enumerable.GetAsyncEnumerator());
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(source);
}
public void Take_With_ValidData_Must_Succeed(int[] source, int count)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Take(source, count);
// Act
var result = AsyncValueEnumerableExtensions
.Take <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, count);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask ToArrayAsync_MemoryPool_Must_Succeed(int[] source)
{
// Arrange
var pool = MemoryPool <int> .Shared;
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.ToArray(source);
// Act
var result = await AsyncValueEnumerableExtensions
.ToArrayAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, pool);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
public void Where_Predicate_With_ValidData_Must_Succeed(int[] source, Func <int, int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate);
// Act
var result = AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync());
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask Distinct_ToArrayAsync_MemoryPool_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var pool = MemoryPool <int> .Shared;
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Distinct(source));
// Act
var result = await AsyncValueEnumerableExtensions
.Distinct <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped)
.ToArrayAsync(pool);
// Assert
_ = result
.SequenceEqual(expected);
}
public void WhereSelect_Predicate_With_ValidData_Must_Succeed(int[] source, Func <int, bool> predicate, Func <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate), selector);
// Act
var result = AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync());
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <string>()
.BeEqualTo(expected);
}
public async ValueTask FirstAsync_Predicate_With_ValidData_Must_Return_Some(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.First(source, predicate.AsFunc());
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.FirstAsync();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask FirstAsync_SelectorAt_With_ValidData_Must_Return_Some(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.First();
// Act
var result = await AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.FirstAsync();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask ToArrayAsync_SelectorAt_MemoryPool_Must_Succeed(int[] source, Func <int, int, string> selector)
{
// Arrange
var pool = MemoryPool <string> .Shared;
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Select(source, selector)
.ToArray();
// Act
var result = await AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.ToArrayAsync(pool);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
public async ValueTask ToArrayAsync_SelectorAt_With_ValidData_Must_Succeed(int[] source, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Select(source, selector)
.ToArray();
// Act
var result = await AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public async ValueTask ToArrayAsync_Predicate_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate.AsFunc())
.ToArray();
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public async ValueTask SingleAsync_Predicate_Selector_With_SingleAsync_Must_Return_Some(int[] source, Func <int, bool> predicate, Func <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate)
.Select(selector)
.Single();
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <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 ElementAtAsync_With_ValidData_Must_Return_Some(int[] source)
{
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
for (var index = 0; index < source.Length; index++)
{
// Arrange
var expected = Enumerable
.ElementAt(source, index);
// Act
var result = await AsyncValueEnumerableExtensions
.ElementAtAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
}
public async ValueTask ElementAtAsync_Selector_With_ValidData_Must_Return_Some(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToList();
for (var index = 0; index < source.Length; index++)
{
// Act
var result = await AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.ElementAtAsync(index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected[index]),
() => throw new Exception());
}
}
public async ValueTask ElementAtAsync_PredicateAt_With_ValidData_Must_Return_Some(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate.AsFunc())
.ToList();
for (var index = 0; index < expected.Count; index++)
{
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ElementAtAsync(index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected[index]),
() => throw new Exception());
}
}
public async void ElementAtAsync_With_OutOfRange_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var optionNegative = await AsyncValueEnumerableExtensions
.ElementAtAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, -1);
var optionTooLarge = await AsyncValueEnumerableExtensions
.ElementAtAsync <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, source.Length);
// Assert
_ = optionNegative.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
_ = optionTooLarge.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
