public void ElementAt_Skip_Take_Predicate_Selector_With_OutOfRange_Must_Return_None(int[] source, int skipCount, int takeCount, Func <int, bool> predicate, Func <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
// Act
var optionTooSmall = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.ElementAt(-1);
var optionTooLarge = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.ElementAt(takeCount);
// Assert
_ = optionTooSmall.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
_ = optionTooLarge.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void ToArray_Predicate_Selector_Must_Succeed(int[] source, int skip, int take, Func <int, bool> predicate, Func <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected = Enumerable
.Skip(source, skip)
.Take(take)
.Where(predicate)
.Select(selector)
.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 First_Predicate_Selector_With_ValidData_Must_Return_Some(int[] source, int skip, int take, Func <int, bool> predicate, Func <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList <int>(source);
var expected = Enumerable
.Skip(source, skip)
.Take(take)
.Where(predicate)
.Select(selector)
.First();
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Where(predicate)
.Select(selector)
.First();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ForEach_ActionAt_Predicate_Selector_With_ValidData_Must_Succeed(int[] source, int skipTake, int takeCount, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var result = new List <(string, int)>();
var expected = new List <(string, int)>();
System.Linq.EnumerableEx.ForEach(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(
System.Linq.Enumerable.Take(
System.Linq.Enumerable.Skip(source, skipTake), takeCount), predicate.AsFunc()), selector.AsFunc()), (item, index) => expected.Add((item, index)));
// Act
ReadOnlyList
.Skip <Wrap.ReadOnlyList <int>, int>(wrapped, skipTake)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.ForEach((item, index) => result.Add((item, index)));
// Assert
_ = result.Must()
.BeEnumerableOf <(string, int)>()
.BeEqualTo(expected);
}
public void ToArray_Predicate_Must_Succeed(int[] source, int skip, int take, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected = source
.Skip(skip)
.Take(take)
.Where(predicate)
.ToArray();
// Act
var result = wrapped.AsValueEnumerable()
.Skip(skip)
.Take(take)
.Where(predicate)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
if (result.Length is not 0)
{
_ = result.Must().BeNotSameAs(source);
}
}
public void ToList_Skip_Take_Predicate_Selector_With_ValidData_Must_Succeed(int[] source, int skip, int take, Func <int, bool> predicate, Func <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected = source
.Skip(skip)
.Take(take)
.Where(predicate)
.Select(selector)
.ToArray();
// Act
var result = wrapped.AsValueEnumerable()
.Skip(skip)
.Take(take)
.Where(predicate)
.Select(selector)
.ToList();
// Assert
_ = result.Must()
.BeOfType <List <string> >()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void Single_Predicate_Selector_With_Single_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())
.Single();
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.Single();
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void ElementAt_Skip_Take_Predicate_Selector_With_ValidData_Must_Return_Some(int[] source, int skipCount, int takeCount, Func <int, bool> predicate, Func <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected = Enumerable
.Skip(source, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.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 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 Select_With_NullSelector_Must_Throw()
{
// Arrange
var source = Wrap.AsReadOnlyList(new int[0]);
var selector = (NullableSelectorAt <int, string>)null;
// Act
Action action = () => _ = ReadOnlyListExtensions.Select <Wrap.ReadOnlyListWrapper <int>, int, string>(source, selector);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "selector");
}
public void Where_With_NullPredicate_Must_Throw()
{
// Arrange
var list = Wrap
.AsReadOnlyList(new int[0]);
var predicate = (PredicateAt <int>)null;
// Act
Action action = () => _ = ReadOnlyListExtensions.Where(list, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void First_With_Empty_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList <int>(source);
// Act
var result = ReadOnlyListExtensions
.First <Wrap.ReadOnlyListWrapper <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void AsValueEnumerable_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.AsValueEnumerable(wrapped);
// Assert
_ = result.Must()
.BeOfType <ReadOnlyListExtensions.ValueEnumerableWrapper <int> >()
.BeEnumerableOf <int>()
.BeEqualTo(wrapped);
}
public void WhereSelect_Predicate_With_Null_Must_Throw()
{
// Arrange
var source = Wrap.AsReadOnlyList(new int[0]);
var predicate = (Predicate <int>)null;
// Act
Action action = () => _ = ReadOnlyListExtensions
.Where <Wrap.ReadOnlyListWrapper <int>, int>(source, predicate)
.Select(item => item.ToString());
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void Select_With_ValidData_Must_Succeed(int[] source, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var expected =
System.Linq.Enumerable.Select(wrapped, selector.AsFunc());
// Act
var result = ReadOnlyListExtensions
.Select <Wrap.ReadOnlyListWrapper <int>, int, string>(wrapped, selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void Count_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
var expected = Enumerable
.Count(source);
// Act
var result = ReadOnlyListExtensions
.Count <Wrap.ReadOnlyListWrapper <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void ToList_SelectorAt_With_Null_Must_Throw()
{
// Arrange
var source = new int[0];
var wrapped = Wrap.AsReadOnlyList(source);
var selector = (NullableSelectorAt <int, string>)null;
// Act
Action action = () => _ = ReadOnlyListExtensions
.Select(wrapped, selector)
.ToList();
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "selector");
}
public void ToList_Predicate_With_Null_Must_Throw()
{
// Arrange
var source = new int[0];
var wrapped = Wrap.AsReadOnlyList(source);
var predicate = (Predicate <int>)null;
// Act
Action action = () => _ = ReadOnlyListExtensions
.Where(wrapped, predicate)
.ToList();
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void First_With_ValidData_Must_Return_Some(int[] source)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList <int>(source);
var expected = Enumerable
.First(source);
// Act
var result = ReadOnlyListExtensions
.First <Wrap.ReadOnlyListWrapper <int>, int>(wrapped);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(expected),
() => throw new Exception());
}
public void Single_SkipTake_With_Empty_Must_Return_None(int[] source, int skip, int take)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void ElementAt_With_ValidData_Must_Return_Some(int[] source)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
for (var index = 0; index < source.Length; index++)
{
// Act
var result = ReadOnlyListExtensions
.ElementAt <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, index);
// Assert
_ = result.Match(
value => value.Must().BeEqualTo(source[index]),
() => throw new Exception());
}
}
public void AsValueEnumerable_With_ToArray_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
var expected = Enumerable
.ToArray(source);
// Act
var result = ReadOnlyListExtensions
.AsValueEnumerable <int>(wrapped)
.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public void ForEach_ActionAt_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
var result = new List <(int, int)>();
var expected = new List <(int, int)>();
System.Linq.EnumerableEx.ForEach(source, (item, index) => expected.Add((item, index)));
// Act
ReadOnlyList
.ForEach <Wrap.ReadOnlyList <int>, int>(wrapped, (item, index) => result.Add((item, index)));
// Assert
_ = result.Must()
.BeEnumerableOf <(int, int)>()
.BeEqualTo(expected);
}
public void First_Predicate_With_Empty_Must_Return_None(int[] source, int skip, int take, Func <int, bool> predicate)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList <int>(source);
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Where(predicate)
.First();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void Single_SelectorAt_With_Multiple_Must_Return_None(int[] source, int skipCount, int takeCount, NullableSelectorAt <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Select(selector)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void First_SelectorAt_With_Empty_Must_Return_None(int[] source, int skip, int take, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList <int>(source);
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Select(selector)
.First();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void Single_PredicateAt_With_Multiple_Must_Return_None(int[] source, int skipCount, int takeCount, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void Single_Predicate_Selector_With_Empty_Must_Return_None(int[] source, int skip, int take, Predicate <int> predicate, NullableSelector <int, string> selector)
{
// Arrange
var wrapped = Wrap
.AsReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Where(predicate)
.Select(selector)
.Single();
// Assert
_ = result.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void ElementAt_With_OutOfRange_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap.AsReadOnlyList(source);
// Act
var optionTooSmall = ReadOnlyListExtensions
.ElementAt <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, -1);
var optionTooLarge = ReadOnlyListExtensions
.ElementAt <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, source.Length);
// Assert
_ = optionTooSmall.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
_ = optionTooLarge.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void ToArray_MemoryPool_Must_Succeed(int[] source, int skip, int take)
{
// Arrange
var pool = MemoryPool <int> .Shared;
var wrapped = Wrap.AsReadOnlyList(source);
var expected = Enumerable
.Skip(source, skip)
.Take(take)
.ToArray();
// Act
using var result = ReadOnlyListExtensions
.Skip <Wrap.ReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.ToArray(pool);
// Assert
_ = result.Memory
.SequenceEqual(expected);
}
