public void Select_With_NullSelector_Must_Throw()
{
// Arrange
var enumerable = Wrap.AsValueEnumerable(new int[0]);
var selector = (NullableSelectorAt <int, string>)null;
// Act
Action action = () => _ = ValueEnumerableExtensions.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, string>(enumerable, selector);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "selector");
}
public void Contains_With_DefaultComparer_And_NotContains_Must_ReturnFalse(int[] source)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.Contains <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, value, EqualityComparer <int> .Default);
// Assert
_ = result.Must()
.BeFalse();
}
public async ValueTask AsAsyncValueEnumerable_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.AsAsyncValueEnumerable <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
var enumerator = result.GetAsyncEnumerator();
await using (enumerator.ConfigureAwait(false))
{
var index = 0;
while (true)
{
var isResultCompleted = !await enumerator.MoveNextAsync();
var isSourceCompleted = index == source.Length;
if (isResultCompleted && isSourceCompleted)
{
return;
}
if (isResultCompleted)
{
throw new Exception("'result' is shorter.");
}
if (isSourceCompleted)
{
throw new Exception("'result' is longer.");
}
if (!EqualityComparer <int> .Default.Equals(enumerator.Current, source[index]))
{
throw new Exception($"Items are not equal at index '{index}'.");
}
index++;
}
}
// TODO: figure out why this doesn't work...
//_ = result.Must()
// .BeAsyncEnumerableOf<int>()
// .BeEqualTo(source);
}
public void Contains_ReferenceType_With_Null_And_Contains_Must_ReturnTrue(int[] source)
{
// Arrange
var value = Enumerable.Last(source).ToString();
var wrapped = Wrap.AsValueEnumerable(source.Select(item => item.ToString()).ToArray());
// Act
var result = ValueEnumerableExtensions
.Contains <Wrap.ValueEnumerableWrapper <string>, Wrap.Enumerator <string>, string>(wrapped, value);
// Assert
_ = result.Must()
.BeTrue();
}
public void Contains_ValueType_With_Null_And_Contains_Must_ReturnTrue(int[] source)
{
// Arrange
var value = Enumerable.Last(source);
var wrapped = Wrap.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.Contains <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, value);
// Assert
_ = result.Must()
.BeTrue();
}
public void AsValueEnumerable_With_ValueType_Must_ReturnCopy()
{
// Arrange
var source = new int[0];
var wrapped = Wrap.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.AsValueEnumerable <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEqualTo(wrapped);
}
public void Single_With_Multiple_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.Single <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void Skip_With_ValidData_Must_Succeed(int[] source, int count)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected = System.Linq.Enumerable.Skip(source, count);
// Act
var result = ValueEnumerableExtensions
.Skip <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, count);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void All_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.All(wrapped, predicate.AsFunc());
// Act
var result = ValueEnumerableExtensions
.All <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void All_With_NullPredicate_Must_Throw()
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(new int[0]);
var predicate = (Predicate <int>)null;
// Act
Action action = () => _ = ValueEnumerableExtensions
.All <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void AsValueEnumerable_With_ReferenceType_Must_ReturnSame()
{
// Arrange
var source = new int[0];
var wrapped = Wrap
.AsValueEnumerable(source) as IValueEnumerable <int, Wrap.Enumerator <int> >;
// Act
var result = ValueEnumerableExtensions
.AsValueEnumerable <IValueEnumerable <int, Wrap.Enumerator <int> >, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeSameAs(wrapped);
}
public void Any_PredicateAt_With_ValidData_Must_Succeed(int[] source, Func <int, int, bool> predicate)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.Count(
System.Linq.Enumerable.Where(source, predicate)) != 0;
// Act
var result = ValueEnumerableExtensions
.Any <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Single_Predicate_With_Empty_Must_Return_None(int[] source, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void Single_SelectorAt_With_Multiple_Must_Return_None(int[] source, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void Distinct_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected = Enumerable
.Distinct(wrapped);
// Act
var result = ValueEnumerableExtensions
.Distinct <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Select_With_ValidData_Must_Succeed(int[] source, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.Select(wrapped, selector);
// Act
var result = ValueEnumerableExtensions
.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void ToArray_MemoryPool_Must_Succeed(int[] source)
{
// Arrange
var pool = MemoryPool <int> .Shared;
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.ToArray(source);
// Act
using var result = ValueEnumerableExtensions
.ToArray <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, pool);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
public void Where_With_ValidData_Must_Succeed(int[] source, Func <int, int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Where(wrapped, predicate);
// Act
var result = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Single_With_Single_Must_Return_Some(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Single(source);
// Act
var result = ValueEnumerableExtensions
.Single <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ToArray_With_ValidData_Collections_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueCollection(source);
var expected = Enumerable
.ToArray(source);
// Act
var result = ValueEnumerableExtensions
.ToArray <Wrap.ValueCollectionWrapper <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public void AsValueEnumerable6_Enumerator2_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
// Act
var result = ValueEnumerableExtensions
.AsValueEnumerable <Wrap.ValueReadOnlyListWrapper <int>, Wrap.Enumerator <int>, int>(
wrapped,
enumerable => enumerable.GetEnumerator());
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(source);
}
public void First_Predicate_Selector_With_Empty_Must_Return_None(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.Select(selector)
.First();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void Count_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate.AsFunc())
.Count();
// Act
var result = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.Count();
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void First_Predicate_With_ValidData_Must_Return_Some(int[] source, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.First(source, predicate);
// Act
var result = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.First();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public async ValueTask AsAsyncValueEnumerable_With_ToArrayAsync_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.ToArray(source);
// Act
var result = await ValueEnumerableExtensions
.AsAsyncValueEnumerable <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped)
.ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public void WhereSelect_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(wrapped, predicate.AsFunc()), selector.AsFunc());
// Act
var result = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.Select(selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void Take_Take_With_ValidData_Must_Succeed(int[] source, int count0, int count1)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected = Enumerable
.Take(wrapped, count0)
.Take(count1);
// Act
var result = ValueEnumerableExtensions
.Take <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, count0)
.Take(count1);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void ToArray_SelectorAt_MemoryPool_With_ValidData_Must_Succeed(int[] source, Func <int, int, string> selector)
{
// Arrange
var pool = MemoryPool <string> .Shared;
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Select(source, selector)
.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 ToArray_PredicateAt_MemoryPool_With_ValidData_Must_Succeed(int[] source, Func <int, int, bool> predicate)
{
// Arrange
var pool = MemoryPool <int> .Shared;
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Where(source, predicate)
.ToArray();
// Act
using var result = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.ToArray(pool);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
public void Skip_Take_With_ValidData_Must_Succeed(int[] source, int skip, int take)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = Enumerable
.Skip(source, skip)
.Take(take);
// Act
var result = ValueEnumerableExtensions
.Skip <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, skip)
.Take(take);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
