public void ElementAt_Selector_With_ValidData_Must_Return_Some(int[] source, int skip, int take, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = new ArraySegment <int>(source);
var expected = Enumerable
.Skip(source, skip)
.Take(take)
.Select(selector.AsFunc())
.ToList();
for (var index = 0; index < expected.Count; index++)
{
// Act
var result = ArrayExtensions
.Skip(wrapped, skip)
.Take(take)
.Select(selector)
.ElementAt(index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected[index]),
() => throw new Exception());
}
}
public void Single_Predicate_Selector_With_Single_Must_Return_Some(int[] source, int skip, int take, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
var expected = Enumerable
.Skip(source, skip)
.Take(take)
.Where(predicate.AsFunc())
.Select(selector.AsFunc())
.Single();
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Where(predicate)
.Select(selector)
.Single();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ToList_Predicate_Selector_Must_Succeed(int[] source, int skip, int take, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = new ArraySegment <int>(source);
var expected = Enumerable
.Skip(wrapped, skip)
.Take(take)
.Where(predicate.AsFunc())
.Select(selector.AsFunc())
.ToList();
// Act
var result = ArrayExtensions
.Skip(wrapped, skip)
.Take(take)
.Where(predicate)
.Select(selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void ToArray_Predicate_Selector_Must_Succeed(int[] source, int skip, int take, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected = Enumerable
.Skip(source, skip)
.Take(take)
.Where(predicate.AsFunc())
.Select(selector.AsFunc())
.ToArray();
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Where(predicate)
.Select(selector)
.ToArray();
// Assert
_ = result.Must()
.BeNotSameAs(source)
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public void ToList_Skip_Take_Predicate_Selector_With_ValidData_Must_Succeed(int[] source, int skipCount, int takeCount, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected = Enumerable
.Skip(source, skipCount)
.Take(takeCount)
.Where(predicate.AsFunc())
.Select(selector.AsFunc())
.ToArray();
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void ElementAt_Skip_Take_Predicate_Selector_With_ValidData_Must_Return_Some(int[] source, int skipCount, int takeCount, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected = Enumerable
.Skip(source, skipCount)
.Take(takeCount)
.Where(predicate.AsFunc())
.Select(selector.AsFunc())
.ToList();
for (var index = 0; index < expected.Count; index++)
{
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.ElementAt(index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected[index]),
() => throw new Exception());
}
}
public void Select_With_ValidData_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.Select(source, selector.AsFunc());
// Act
var result = ArrayExtensions.Select((ReadOnlySpan <int>)source.AsSpan(), selector);
// Assert
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void WhereSelect_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc());
// Act
var result = ArrayExtensions
.Where(source.AsSpan(), predicate)
.Select(selector);
// Assert
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void Select_With_ValidData_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.Select(source, selector.AsFunc());
// Act
var result = ArrayExtensions.Select(source.AsMemory(), selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected, testRefStructs: false);
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void Select_With_ValidData_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyCollection(source);
var expected =
System.Linq.Enumerable.Select(wrapped, selector.AsFunc());
// Act
var result = ValueReadOnlyCollectionExtensions
.Select <Wrap.ValueReadOnlyCollectionWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void ToArray_With_Selector_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Select(source, selector.AsFunc()));
// Act
var result = ArrayExtensions
.Select <int, string>((ReadOnlySpan <int>)source.AsSpan(), selector)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public void ToArray_With_Selector_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToArray();
// Act
var result = ArrayExtensions
.Select(source.AsMemory(), selector)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public void ToArray_Selector_MemoryPool_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var pool = MemoryPool <string> .Shared;
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToArray();
// Act
using var result = ArrayExtensions
.Select((ReadOnlyMemory <int>)source.AsMemory(), selector)
.ToArray(pool);
// Assert
_ = result.Memory.Must()
.BeEqualTo(expected);
}
public void Select_Selector_With_ValidData_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var list = source.ToList();
var expected = Enumerable
.Select(source, selector.AsFunc());
// Act
var result = ListBindings
.Select(list, selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected, testRefStructs: false);
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void Single_Selector_With_Single_Must_Return_Some(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var expected =
Enumerable.Single(
Enumerable.Select(source, selector.AsFunc()));
// Act
var result = ArrayExtensions
.Select <int, string>(source.AsMemory(), selector)
.Single();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void First_Selector_With_ValidData_Must_Return_Some(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var expected = Enumerable
.Select(source, selector.AsFunc())
.First();
// Act
var result = ArrayExtensions
.Select((ReadOnlySpan <int>)source.AsSpan(), selector)
.First();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ToList_With_Selector_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToList();
// Act
var result = ArrayExtensions
.Select((ReadOnlySpan <int>)source.AsSpan(), selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void WhereSelect_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var expected = Enumerable
.Where(source, predicate.AsFunc())
.Select(selector.AsFunc());
// Act
var result = ArrayExtensions
.Where(source, predicate)
.Select(selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected, testRefStructs: false);
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void Select_With_ValidData_Must_Succeed(int[] source, int skip, int take, NullableSelector <int, string> selector)
{
// Arrange
var(offset, count) = Utils.SkipTake(source.Length, skip, take);
var wrapped = new ArraySegment <int>(source, offset, count);
var expected = Enumerable
.Select(wrapped, selector.AsFunc());
// Act
var result = ArrayExtensions
.Select(wrapped, selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected, testRefStructs: false);
_ = result.SequenceEqual(expected).Must().BeTrue();
}
public void WhereSelect_Predicate_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsAsyncValueEnumerable(source);
var expected =
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc());
// 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 void ToArray_Selector_MemoryPool_With_ValidData_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var pool = MemoryPool <string> .Shared;
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.ToArray();
// Act
using var result = ValueEnumerableExtensions
.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.ToArray(pool);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
public void First_Selector_With_ValidData_Must_Return_Some(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyCollection(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.First();
// Act
var result = ValueReadOnlyCollectionExtensions
.Select <Wrap.ValueReadOnlyCollectionWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.First();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask ToArrayAsync_Selector_With_ValidData_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.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 void Single_Predicate_Selector_With_Single_Must_Return_Some(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var expected = Enumerable
.Where(source, predicate.AsFunc())
.Select(selector.AsFunc())
.Single();
// Act
var result = ArrayExtensions
.Where((ReadOnlyMemory <int>)source.AsMemory(), predicate)
.Select(selector)
.Single();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ToArray_Predicate_Selector_MemoryPool_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var pool = MemoryPool <string> .Shared;
var expected = Enumerable
.Where(source, predicate.AsFunc())
.Select(selector.AsFunc())
.ToArray();
// Act
using var result = ArrayExtensions
.Where((ReadOnlySpan <int>)source.AsSpan(), predicate)
.Select(selector)
.ToArray(pool);
// Assert
_ = result.Memory.Must()
.BeEqualTo(expected);
}
public void ToArray_With_Predicate_Selector_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(source, predicate.AsFunc()), selector.AsFunc()));
// Act
var result = ArrayExtensions
.Where <int>(source.AsSpan(), predicate)
.Select(selector)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public void ToArray_Selector_With_ValidData_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.ToArray(
System.Linq.Enumerable.Select(source, selector.AsFunc()));
// Act
var result = ValueEnumerableExtensions
.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <string>()
.BeEqualTo(expected);
}
public async ValueTask FirstAsync_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())
.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_Selector_MemoryPool_Must_Succeed(int[] source, NullableSelector <int, string> selector)
{
// Arrange
var pool = MemoryPool <string> .Shared;
var wrapped = Wrap
.AsAsyncValueEnumerable(source);
var expected = Enumerable
.Select(source, selector.AsFunc())
.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 void ToList_With_Predicate_Selector_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var expected = Enumerable
.Where(source, predicate.AsFunc())
.Select(selector.AsFunc())
.ToList();
// Act
var result = ArrayExtensions
.Where(source.AsMemory(), predicate)
.Select(selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
