public async ValueTask FirstAsync_SelectorAt_With_ValidData_Must_Return_Some(int[] source, SelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.First(
System.Linq.Enumerable.Select(source, selector.AsFunc()));
// Act
var result = await AsyncValueEnumerable
.Select <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.FirstAsync();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask FirstAsync_PredicateAt_With_ValidData_Must_Return_Some(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.First(
System.Linq.Enumerable.Where(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_Comparer_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, EqualityComparer <string> .Default);
// Assert
_ = result.Must()
.BeTrue();
}
public void Skip_Take_With_ValidData_Must_Succeed(int[] source, int skip, int take)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.Skip(skip)
.Take(take);
// Act
var result = wrapped.AsAsyncValueEnumerable()
.Skip(skip)
.Take(take);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask FirstAsync_Predicate_With_ValidData_Must_Return_Some(int[] source, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.First(predicate);
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.Where(predicate.AsAsync())
.FirstAsync()
.ConfigureAwait(false);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask ToArrayAsync_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Where(source, predicate.AsFunc()));
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public async ValueTask ToArrayAsync_Predicate_With_ValidData_Must_Succeed(int[] source, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate)
.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_SelectorAt_With_SingleAsync_Must_Return_Some(int[] source, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Select(source, selector)
.Single();
// Act
var result = await AsyncValueEnumerableExtensions
.Select <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.SingleAsync();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
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_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 CountAsync_PredicateAt_With_ValidData_Must_Succeed(int[] source, Func <int, int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.Where(predicate)
.Count();
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.Where(predicate.AsAsync())
.CountAsync()
.ConfigureAwait(false);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public async ValueTask SingleAsync_PredicateAt_With_SingleAsync_Must_Return_Some(int[] source, Func <int, int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate)
.Single();
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.SingleAsync();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void Skip_Skip_With_ValidData_Must_Succeed(int[] source, int count0, int count1)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Skip(source, count0)
.Skip(count1);
// Act
var result = AsyncValueEnumerableExtensions
.Skip <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, count0)
.Skip(count1);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask ToListAsync_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.ToList();
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.ToListAsync()
.ConfigureAwait(false);
// Assert
_ = result.Must()
.BeOfType <List <int> >()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Take_Take_With_ValidData_Must_Succeed(int[] source, int count0, int count1)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.Take(count0)
.Take(count1);
// Act
var result = wrapped.AsAsyncValueEnumerable()
.Take(count0)
.Take(count1);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask ToArrayAsync_Predicate_MemoryPool_Must_Succeed(int[] source, Func <int, bool> predicate)
{
// Arrange
var pool = MemoryPool <int> .Shared;
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate)
.ToArray();
// Act
var result = await AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ToArrayAsync(pool);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
public async ValueTask ToListAsync_Selector_With_ValidData_Must_Succeed(int[] source, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.ToList(
System.Linq.Enumerable.Select(source, selector.AsFunc()));
// Act
var result = await AsyncValueEnumerable
.Select <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.ToListAsync();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public async ValueTask FirstAsync_SelectorAt_With_ValidData_Must_Return_Some(int[] source, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.Select(selector)
.First();
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.Select(selector.AsAsync())
.FirstAsync()
.ConfigureAwait(false);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask WhereSelect_Sum_Predicate_With_ValidData_Must_Succeed(int[] source, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected = source
.Where(predicate)
.Select(item => item)
.Sum();
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.Where(predicate.AsAsync())
.Select((item, _) => new ValueTask <int>(item))
.SumAsync()
.ConfigureAwait(false);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
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 =
System.Linq.Enumerable.ElementAt(source, index);
// Act
var result = await AsyncValueEnumerable
.ElementAtAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
}
public async void ElementAtAsync_With_OutOfRange_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var optionNegative = await AsyncValueEnumerable
.ElementAtAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, -1);
var optionTooLarge = await AsyncValueEnumerable
.ElementAtAsync <Wrap.AsyncValueEnumerable <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);
}
public async ValueTask ForEachAsync_Action_Selector_With_ValidData_Must_Succeed(int[] source, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var result = new List <string>();
var expected = new List <string>();
System.Linq.EnumerableEx.ForEach(
System.Linq.Enumerable.Select(source, selector.AsFunc()), item => expected.Add(item));
// Act
await AsyncValueEnumerable
.Select <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.ForEachAsync((item, cancellationToken) => { result.Add(item); return(new ValueTask()); });
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public async ValueTask ForEachAsync_ActionAt_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var result = new List <(int, int)>();
var expected = new List <(int, int)>();
System.Linq.EnumerableEx.ForEach(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), (item, index) => expected.Add((item, index)));
// Act
await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.ForEachAsync((item, index, cancellationToken) => { result.Add((item, index)); return(new ValueTask()); });
// Assert
_ = result.Must()
.BeEnumerableOf <(int, int)>()
.BeEqualTo(expected);
}
public async ValueTask ToArrayAsync_Predicate_MemoryPool_Must_Succeed(int[] source, Func <int, bool> predicate)
{
// Arrange
var pool = ArrayPool <int> .Shared;
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.Where(predicate)
.ToArray();
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.Where(predicate.AsAsync())
.ToArrayAsync(pool)
.ConfigureAwait(false);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
public void AsAsyncValueEnumerable6_Enumerator2_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = AsyncValueEnumerableExtensions
.AsAsyncValueEnumerable <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, AsyncValueEnumerator <int>, int>(
wrapped,
(enumerable, _) => enumerable.GetAsyncEnumerator(),
(enumerable, cancellationToken) =>
new AsyncValueEnumerator <int>(
((IAsyncEnumerable <int>)enumerable).GetAsyncEnumerator(cancellationToken)));
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(source);
}
public async ValueTask ToArrayAsync_SelectorAt_MemoryPool_Must_Succeed(int[] source, Func <int, int, string> selector)
{
// Arrange
var pool = ArrayPool <string> .Shared;
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = source
.Select(selector)
.ToArray();
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.Select(selector.AsAsync())
.ToArrayAsync(pool)
.ConfigureAwait(false);
// 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 = source
.Select(selector)
.ToArray();
// Act
var result = await wrapped.AsAsyncValueEnumerable()
.Select(selector.AsAsync())
.ToArrayAsync()
.ConfigureAwait(false);
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
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 ValueTask ToArrayAsync_Predicate_Selector_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <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 AsyncValueEnumerableExtensions
.Where <Wrap.AsyncValueEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.Select(selector.AsAsync())
.ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
