public void ElementAt_Skip_Take_Predicate_Selector_With_ValidData_Must_Return_Some(int[] source, int skipCount, int takeCount, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.ToList(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(
System.Linq.Enumerable.Take(
System.Linq.Enumerable.Skip(source, skipCount), takeCount), predicate.AsFunc()), selector.AsFunc()));
for (var index = 0; index < expected.Count; index++)
{
// Act
var result = ReadOnlyList
.Skip <Wrap.ValueReadOnlyList <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, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.ToList(
System.Linq.Enumerable.Select(
System.Linq.Enumerable.Where(
System.Linq.Enumerable.Take(
System.Linq.Enumerable.Skip(source, skipCount), takeCount), predicate.AsFunc()), selector.AsFunc()));
// Act
var result = ReadOnlyList
.Skip <Wrap.ValueReadOnlyList <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_OutOfRange_Must_Return_None(int[] source, int skipCount, int takeCount, Predicate <int> predicate, Selector <int, string> selector)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var optionNegative = ReadOnlyList
.Skip <Wrap.ValueReadOnlyList <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.ElementAt(-1);
var optionTooLarge = ReadOnlyList
.Skip <Wrap.ValueReadOnlyList <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Where(predicate)
.Select(selector)
.ElementAt(wrapped.Count);
// Assert
_ = optionNegative.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
_ = optionTooLarge.Must()
.BeOfType <Option <string> >()
.EvaluateTrue(option => option.IsNone);
}
public void ElementAtOrDefault_With_OutOfRange_Must_ReturnDefault(int[] source, int index)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyList.ElementAtOrDefault <Wrap.ValueReadOnlyList <int>, int>(wrapped, index);
// Assert
_ = result.Must()
.BeEqualTo(default);
public void WhereIndex_With_NullPredicate_Must_Throw()
{
// Arrange
var list = Wrap.AsValueReadOnlyList(new int[0]);
var predicate = (Predicate <int>)null;
// Act
Action action = () => _ = ReadOnlyList.Where(list, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void Contains_ValueType_With_Null_And_Contains_Must_ReturnTrue(int[] source)
{
// Arrange
var value = System.Linq.Enumerable.Last(source);
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.Contains <Wrap.ValueReadOnlyListWrapper <int>, int>(wrapped, value);
// Assert
_ = result.Must()
.BeTrue();
}
public void ElementAt_With_OutOfRange_Must_Throw(int[] source, int index)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
// Act
Action action = () => _ = ReadOnlyList
.ElementAt <Wrap.ValueReadOnlyList <int>, int>(wrapped, index);
// Assert
_ = action.Must()
.Throw <ArgumentOutOfRangeException>();
}
public void Skip_With_ValidData_Must_Succeed(int[] source, int count)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected = System.Linq.Enumerable.Skip(source, count);
// Act
var result = ReadOnlyList.Skip <Wrap.ValueReadOnlyList <int>, int>(wrapped, count);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Contains_ReferenceType_With_Null_And_NotContains_Must_ReturnFalse(int[] source)
{
// Arrange
var value = default(string);
var wrapped = Wrap.AsValueReadOnlyList(source.Select(item => item.ToString()).ToArray());
// Act
var result = ReadOnlyListExtensions
.Contains <Wrap.ValueReadOnlyListWrapper <string>, string>(wrapped, value);
// Assert
_ = result.Must()
.BeFalse();
}
public void Contains_With_Comparer_And_Contains_Must_ReturnTrue(int[] source)
{
// Arrange
var value = System.Linq.Enumerable.Last(source);
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyList
.Contains <Wrap.ValueReadOnlyList <int>, int>(wrapped, value, EqualityComparer <int> .Default);
// Assert
_ = result.Must()
.BeTrue();
}
public void Contains_With_Null_And_NotContains_Must_ReturnFalse(int[] source)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyList
.Contains <Wrap.ValueReadOnlyList <int>, int>(wrapped, value, null);
// Assert
_ = result.Must()
.BeFalse();
}
public void WhereIndex_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected = System.Linq.Enumerable.Where(wrapped, predicate.AsFunc());
// Act
var result = ReadOnlyList.Where(wrapped, predicate);
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
public void Contains_ReferenceType_With_Null_And_Contains_Must_ReturnTrue(int[] source)
{
// Arrange
var value = System.Linq.Enumerable.Last(source).ToString();
var wrapped = Wrap.AsValueReadOnlyList(source.AsValueEnumerable().Select(item => item.ToString()).ToArray());
// Act
var result = ReadOnlyListExtensions
.Contains <Wrap.ValueReadOnlyListWrapper <string>, string>(wrapped, value);
// Assert
_ = result.Must()
.BeTrue();
}
public void Contains_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.Contains <Wrap.ValueReadOnlyListWrapper <int>, int>(wrapped, value, EqualityComparer <int> .Default);
// Assert
_ = result.Must()
.BeFalse();
}
public void Select_With_NullSelector_Must_Throw()
{
// Arrange
var list = Wrap.AsValueReadOnlyList(new int[0]);
var selector = (Selector <int, string>)null;
// Act
Action action = () => _ = ReadOnlyList.Select <Wrap.ValueReadOnlyList <int>, int, string>(list, selector);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "selector");
}
public void First_With_Empty_Must_Throw(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
// Act
Action action = () => _ = ReadOnlyList
.First <Wrap.ValueReadOnlyList <int>, int>(wrapped);
// Assert
_ = action.Must()
.Throw <InvalidOperationException>()
.EvaluateTrue(exception => exception.Message == "Sequence contains no elements");
}
public void All_With_NullPredicate_Must_Throw()
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(new int[0]);
var predicate = (Predicate <int>)null;
// Act
Action action = () => _ = ReadOnlyListExtensions
.All <Wrap.ValueReadOnlyListWrapper <int>, int>(wrapped, predicate);
// Assert
_ = action.Must()
.Throw <ArgumentNullException>()
.EvaluateTrue(exception => exception.ParamName == "predicate");
}
public void SkipTake_Indexer_With_OutOfRange__Must_Throw(int takeCount, int index)
{
// Arrange
var source = new int[] { 1, 2, 3, 4, 5 };
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
Func <int> action = () => ReadOnlyList
.SkipTake <Wrap.ValueReadOnlyList <int>, int>(wrapped, 0, takeCount)[index];
// Assert
_ = action.Must()
.Throw <ArgumentOutOfRangeException>()
.EvaluateTrue(exception => exception.ParamName == "index");
}
public void Single_With_Multiple_Must_Return_None(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyList
.Single <Wrap.ValueReadOnlyList <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeOfType <Option <int> >()
.EvaluateTrue(option => option.IsNone);
}
public void Any_Predicate_With_ValidData_Must_Succeed(int[] source, Predicate <int> predicate)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.Any(wrapped, predicate.AsFunc());
// Act
var result = ReadOnlyListExtensions
.Any <Wrap.ValueReadOnlyListWrapper <int>, int>(wrapped, predicate);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void AsValueReadOnlyList1_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
// Act
var result = wrapped
.AsValueEnumerable();
// Assert
_ = result.Must()
.BeEnumerableOf <int>()
.BeEqualTo(source);
}
public void Single_With_Multiple_Must_Throw(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
// Act
Action action = () => _ = ReadOnlyList
.Single <Wrap.ValueReadOnlyList <int>, int>(wrapped);
// Assert
_ = action.Must()
.Throw <InvalidOperationException>()
.EvaluateTrue(exception => exception.Message == "Sequence contains more than one element");
}
public void ElementAt_With_ValidData_Must_Succeed(int[] source, int index)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.ElementAt(wrapped, index);
// Act
var result = ReadOnlyList
.ElementAt <Wrap.ValueReadOnlyList <int>, int>(wrapped, index);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Contains_Skip_Take_With_Null_And_NotContains_Must_ReturnFalse(int[] source, int skipCount, int takeCount)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyList
.Skip <Wrap.ValueReadOnlyList <int>, int>(wrapped, skipCount)
.Take(takeCount)
.Contains(value, null);
// Assert
_ = result.Must()
.BeFalse();
}
public void Select_With_ValidData_Must_Succeed(int[] source, Func <int, int, string> selector)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected = source
.Select(selector);
// Act
var result = wrapped.AsValueEnumerable()
.Select(selector);
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void Single_With_Single_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.Single(source);
// Act
var result = ReadOnlyList
.Single <Wrap.ValueReadOnlyList <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void ToArray_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.ToArray(source);
// Act
var result = ReadOnlyList
.ToArray <Wrap.ValueReadOnlyList <int>, int>(wrapped);
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public void Select_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.Select(wrapped, item => item.ToString());
// Act
var result = ReadOnlyList
.Select <Wrap.ValueReadOnlyList <int>, int, string>(wrapped, item => item.ToString());
// Assert
_ = result.Must()
.BeEnumerableOf <string>()
.BeEqualTo(expected);
}
public void All_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate)
{
// Arrange
var wrapped = Wrap.AsValueReadOnlyList(source);
var expected =
System.Linq.Enumerable.Count(
System.Linq.Enumerable.Where(source, predicate.AsFunc())) == source.Length;
// Act
var result = ReadOnlyListExtensions
.All <Wrap.ValueReadOnlyListWrapper <int>, int>(wrapped, predicate);
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
public void Contains_Skip_Take_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source, int skip, int take)
{
// Arrange
var value = int.MaxValue;
var wrapped = Wrap.AsValueReadOnlyList(source);
// Act
var result = ReadOnlyListExtensions
.Skip <Wrap.ValueReadOnlyListWrapper <int>, int>(wrapped, skip)
.Take(take)
.Contains(value, TestComparer <int> .Instance);
// Assert
_ = result.Must()
.BeFalse();
}
