public void Contains_SelectorAt_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source, SelectorAt <int, string> selector)
{
// Arrange
var value = "!";
var wrapped = Wrap.AsValueEnumerable(source);
// Act
var result = ValueEnumerable
.Select <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.Contains(value, EqualityComparer <string> .Default);
// Assert
_ = result.Must()
.BeFalse();
}
public void Contains_Predicate_With_Null_And_NotContains_Must_ReturnFalse(int[] source, Predicate <int> predicate)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsValueEnumerable(source);
// Act
var result = ValueEnumerable
.Where <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.Contains(value, null);
// Assert
_ = result.Must()
.BeFalse();
}
public void First_With_Empty_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerableExtensions
.First <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void AsEnumerable_With_ReferenceType_Must_ReturnSame()
{
// Arrange
var source = new int[0];
var wrapped = Wrap
.AsValueEnumerable(source) as IValueEnumerable <int, Wrap.Enumerator <int> >;
// Act
var result = ValueEnumerable
.AsEnumerable <IValueEnumerable <int, Wrap.Enumerator <int> >, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeSameAs(wrapped);
}
public void All_With_NullPredicate_Must_Throw()
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(new int[0]);
var predicate = (Predicate <int>)null;
// Act
Action action = () => _ = ValueEnumerable
.All <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
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 = ValueEnumerable
.All <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Sum_With_NullableDecimal_Must_Succeed(decimal?[] source)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected = source
.Sum();
// Act
var result = wrapped.AsValueEnumerable()
.Sum();
// Assert
_ = result.Must()
.BeEqualTo(expected !.Value);
}
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 First_PredicateAt_With_Empty_Must_Throw(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
Action action = () => _ = ValueEnumerable
.Where <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.First();
// Assert
_ = action.Must()
.Throw <InvalidOperationException>()
.EvaluateTrue(exception => exception.Message == "Sequence contains no elements");
}
public void Any_PredicateAt_With_Null_Must_Throw()
{
// Arrange
var source = new int[0];
var wrapped = Wrap.AsValueEnumerable(source);
var predicate = (PredicateAt <int>)null;
// Act
Action action = () => _ = ValueEnumerableExtensions
.Any <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void ElementAt_With_ValidData_Must_Succeed(int[] source, int index)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.ElementAt(wrapped, index);
// Act
var result = ValueEnumerable
.ElementAt <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, index);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void First_PredicateAt_With_Empty_Must_Return_None(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerable
.Where <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.First();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void Count_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected = source
.Count();
// Act
var result = wrapped
.Count <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>();
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void First_SelectorAt_With_Empty_Must_Return_None(int[] source, SelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerable
.Select <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int, string>(wrapped, selector)
.First();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void Contains_ReferenceType_With_Null_And_Contains_Must_ReturnTrue(int[] source)
{
// Arrange
var value = source
.Last()
.ToString();
var wrapped = Wrap.AsValueEnumerable(source.Select(item => item.ToString()).ToArray());
// Act
var result = wrapped
.Contains <Wrap.ValueEnumerableWrapper <string>, Wrap.Enumerator <string>, string>(value);
// Assert
_ = result.Must()
.BeTrue();
}
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 All_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.Count(
System.Linq.Enumerable.Where(source, predicate.AsFunc())) == source.Length;
// Act
var result = ValueEnumerableExtensions
.All <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, predicate);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void SingleOrDefault_Predicate_With_Multiple_Must_Throw(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
Action action = () => _ = ValueEnumerable
.Where <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.SingleOrDefault();
// Assert
_ = action.Must()
.Throw <InvalidOperationException>()
.EvaluateTrue(exception => exception.Message == "Sequence contains more than one element");
}
public void SelectIndex_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.Select(wrapped, (item, index) => (item + index).ToString());
// Act
var result = ValueEnumerable
.Select <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int, string>(wrapped, (item, index) => (item + index).ToString());
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void Where_Predicate_With_Null_Must_Throw()
{
// Arrange
var enumerable = Wrap
.AsValueEnumerable(new int[0]);
var predicate = (Predicate <int>)null;
// Act
Action action = () => _ = ValueEnumerableExtensions
.Where <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(enumerable, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void SingleOrDefault_With_EmptyOrSingle_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.SingleOrDefault(source);
// Act
var result = ValueEnumerable
.SingleOrDefault <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Take_With_ValidData_Must_Succeed(int[] source, int count)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.Take(wrapped, count);
// Act
var result = ValueEnumerableExtensions
.Take <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int>(wrapped, count);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Distinct_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected = source
.Distinct();
// Act
var result = wrapped.AsValueEnumerable()
.Distinct();
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void First_With_ValidData_Must_Return_Some(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
var expected =
System.Linq.Enumerable.First(source);
// Act
var result = ValueEnumerable
.First <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
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 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 Select_Sum_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsValueEnumerable(source);
var expected = source
.Select((item, _) => item)
.Sum();
// Act
var result = wrapped
.Select <Wrap.ValueEnumerableWrapper <int>, Wrap.Enumerator <int>, int, int>((item, _) => item)
.Sum();
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Single_Predicate_Selector_With_Multiple_Must_Return_None(int[] source, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsValueEnumerable(source);
// Act
var result = ValueEnumerable
.Where <Wrap.ValueEnumerable <int>, Wrap.Enumerator <int>, int>(wrapped, predicate)
.Select(selector)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
