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(); }