public async ValueTask <int> Hyperlinq_Repeat_Async()
{
var sum = 0;
await foreach (var item in AsyncValueEnumerable.Repeat(1, Count))
{
sum += item;
}
return(sum);
}
public void Range_With_NegativeCount_Must_Throw(int count)
{
// Arrange
// Act
Action action = () => _ = AsyncValueEnumerable.Range(0, count);
// Assert
_ = action.Must()
.Throw <ArgumentOutOfRangeException>()
.EvaluateTrue(exception => exception.ParamName == "count");
}
public async ValueTask Range_ContainsAsync_With_ValidData_Must_Succeed(int start, int count, int value)
{
// Arrange
var expected = Enumerable.Contains(Enumerable.Range(start, count), value);
// Act
var result = await AsyncValueEnumerable.Range(start, count).ContainsAsync(value);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public async ValueTask Repeat_All_With_ValidData_Must_Succeed(int value, int count)
{
// Arrange
var expected = Enumerable.All(Enumerable.Repeat(value, count), item => false);
// Act
var result = await AsyncValueEnumerable.Repeat(value, count).AllAsync(item => false);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public async ValueTask Range_AnyAsync_With_ValidData_Must_Succeed(int start, int count)
{
// Arrange
var expected = Enumerable.Any(Enumerable.Range(start, count));
// Act
var result = await AsyncValueEnumerable.Range(start, count).AnyAsync();
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Range_Take_With_ValidData_Must_Succeed(int start, int count, int take)
{
// Arrange
var expected = Enumerable.Take(Enumerable.Range(start, count), take);
// Act
var result = AsyncValueEnumerable.Range(start, count).Take(take);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Repeat_Skip_With_ValidData_Must_Succeed(int value, int count, int skip)
{
// Arrange
var expected = Enumerable.Skip(Enumerable.Repeat(value, count), skip);
// Act
var result = AsyncValueEnumerable.Repeat(value, count).Skip(skip);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask Repeat_ToArray_With_ValidData_Must_Succeed(int value, int count)
{
// Arrange
var expected = Enumerable.ToArray(Enumerable.Repeat(value, count));
// Act
var result = await AsyncValueEnumerable.Repeat(value, count).ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public void Return_With_Value_Must_Succeed(int value)
{
// Arrange
var expected = System.Linq.EnumerableEx.Return(value);
// Act
var result = AsyncValueEnumerable.Return(value);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Empty_Must_Succeed()
{
// Arrange
var expected = Enumerable.Empty <int>();
// Act
var result = AsyncValueEnumerable.Empty <int>();
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask Range_With_ToList_Must_Succeed(int start, int count)
{
// Arrange
var expected = Enumerable.ToList(Enumerable.Range(start, count));
// Act
var result = await AsyncValueEnumerable.Range(start, count).ToListAsync();
// Assert
_ = result.Must()
.BeOfType <List <int> >()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public async ValueTask ContainsAsync_With_Null_And_NotContains_Must_ReturnFalse(int[] source)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.ContainsAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, value, null);
// Assert
_ = result.Must()
.BeFalse();
}
public void AsAsyncEnumerable_With_ValueType_Must_ReturnCopy()
{
// Arrange
var source = new int[0];
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = AsyncValueEnumerable
.AsAsyncEnumerable <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEqualTo(wrapped);
}
public async ValueTask ContainsAsync_With_Comparer_And_Contains_Must_ReturnTrue(int[] source)
{
// Arrange
var value = System.Linq.Enumerable.Last(source);
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.ContainsAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, value, EqualityComparer <int> .Default);
// Assert
_ = result.Must()
.BeTrue();
}
public void AsAsyncEnumerable_With_ReferenceType_Must_ReturnSame()
{
// Arrange
var source = new int[0];
var wrapped = Wrap
.AsAsyncValueEnumerable(source) as IAsyncValueEnumerable <int, Wrap.AsyncEnumerator <int> >;
// Act
var result = AsyncValueEnumerable
.AsAsyncEnumerable <IAsyncValueEnumerable <int, Wrap.AsyncEnumerator <int> >, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeSameAs(wrapped);
}
public async void FirstAsync_With_Empty_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.FirstAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public async ValueTask ContainsAsync_SelectorAt_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source, SelectorAt <int, string> selector)
{
// Arrange
var value = "!";
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Select <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.ContainsAsync(value, EqualityComparer <string> .Default);
// Assert
_ = result.Must()
.BeFalse();
}
public async ValueTask AllAsync_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.All(source, predicate.AsFunc());
// Act
var result = await AsyncValueEnumerable
.AllAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync());
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public async ValueTask ContainsAsync_PredicateAt_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source, PredicateAt <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, EqualityComparer <int> .Default);
// Assert
_ = result.Must()
.BeFalse();
}
public void SingleAsync_With_Multiple_Must_Throw(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
Func <ValueTask> action = async() => _ = await AsyncValueEnumerable
.SingleAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = action.Must()
.Throw <InvalidOperationException>()
.EvaluateTrue(exception => exception.Message == "Sequence contains more than one element");
}
public async ValueTask Repeat_Any_With_ValidData_Must_Succeed(int value, int count)
{
// Arrange
var expected = Enumerable.Repeat(value, count).Any();
// Act
var result = await AsyncValueEnumerable
.Repeat(value, count)
.AnyAsync()
.ConfigureAwait(false);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void AllAsync_With_NullPredicate_Must_Throw()
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(new int[0]);
var predicate = (AsyncPredicate <int>)null;
// Act
Action action = () => _ = AsyncValueEnumerable
.AllAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public async ValueTask ContainsAsync_Predicate_Selector_With_Null_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, null);
// Assert
_ = result.Must()
.BeFalse();
}
public async ValueTask Range_ToArray_With_ValidData_Must_Succeed(int start, int count)
{
// Arrange
var expected = Enumerable.ToArray(Enumerable.Range(start, count));
// Act
var result = await AsyncValueEnumerable
.Range(start, count)
.ToArrayAsync()
.ConfigureAwait(false);
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public async void SingleAsync_Predicate_With_Empty_Must_Return_None(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync())
.SingleAsync();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public async void FirstAsync_SelectorAt_With_Empty_Must_Return_None(int[] source, SelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Select <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.FirstAsync();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.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 SingleAsync_With_SingleAsync_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Single(source);
// Act
var result = await AsyncValueEnumerable
.SingleAsync <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public async ValueTask ContainsAsync_PredicateAt_With_Null_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, null);
// Assert
_ = result.Must()
.BeTrue();
}
public async ValueTask ContainsAsync_SelectorAt_With_Null_And_Contains_Must_ReturnFalse(int[] source, SelectorAt <int, string> selector)
{
// Arrange
var value =
System.Linq.Enumerable.Last(
System.Linq.Enumerable.Select(source, selector.AsFunc()));
var wrapped = Wrap.AsAsyncValueEnumerable(source);
// Act
var result = await AsyncValueEnumerable
.Select <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int, string>(wrapped, selector.AsAsync())
.ContainsAsync(value, null);
// Assert
_ = result.Must()
.BeTrue();
}
