public void Empty_Returns_Empty_Sequence()
{
var result = XEnumerable.Empty <int>();
(result as ICollection).Should().BeNull("Sequence should not be a collection");
result.Should().BeEmpty();
}
public void Unit_Returns_Sequence_With_Single_Element()
{
var result = XEnumerable.Unit(42);
(result as ICollection).Should().BeNull("Sequence should not be a collection");
result.Should().HaveCount(1);
}
public static void IsNullOrEmpty_NonGeneric_Returns_True_If_Source_Is_Empty()
{
IEnumerable source = XEnumerable.Empty <int>().ForbidMultipleEnumeration();
bool result = source.IsNullOrEmpty();
result.Should().BeTrue();
}
public static void IsNullOrEmpty_NonGeneric_Returns_False_If_Source_Is_Not_Empty()
{
IEnumerable source = XEnumerable.Unit(42).ForbidMultipleEnumeration();
bool result = source.IsNullOrEmpty();
result.Should().BeFalse();
}
public void SequenceEqualBy_Returns_True_If_Both_Sequences_Are_Empty()
{
var source = XEnumerable.Empty <string>().ForbidMultipleEnumeration();
var other = XEnumerable.Empty <string>().ForbidMultipleEnumeration();
source.SequenceEqualBy(other, s => s.Length).Should().BeTrue();
}
public void Generate_Returns_Sequence_Of_Values_Based_On_Previous_Value()
{
var sequence = XEnumerable.Generate(0, previous => previous + 2);
var expected = new[] { 0, 2, 4, 6, 8 };
var actual = sequence.Take(5);
actual.Should().Equal(expected);
}
public void Generate_By_Index_Returns_Sequence_Of_Values_Based_On_Index()
{
var sequence = XEnumerable.Generate(index => index * 2);
var expected = new[] { 0, 2, 4, 6, 8 };
var actual = sequence.Take(5);
actual.Should().Equal(expected);
}
public void RankBy_Throws_When_Argument_Is_Null()
{
var source = XEnumerable.Empty <int>().ForbidEnumeration();
TestHelper.AssertThrowsWhenArgumentNull(
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
() => source.RankBy(x => x, (x, r) => x, null));
}
public void ElementAtOrDefault_Throws_If_Index_Is_Negative()
{
var source = XEnumerable.Empty <int>().ForbidEnumeration();
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => source.ElementAtOrDefault(-1, 42));
ex.ParamName.Should().Be("index");
}
public void ToHierarchy_Throws_If_Argument_Is_Null()
{
var source = XEnumerable.Empty <Foo>().ForbidEnumeration();
TestHelper.AssertThrowsWhenArgumentNull(
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
() => source.ToHierarchy(f => f.Id, f => f.ParentId, null));
}
public void Generate_By_Index_Throws_If_Generator_Is_Null()
{
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
// ReSharper disable once AssignNullToNotNullAttribute
var ex = Assert.Throws <ArgumentNullException>(() => XEnumerable.Generate <int>(null));
ex.ParamName.Should().Be("generator");
}
public void SequenceEqualBy_Throws_If_Argument_Is_Null()
{
var source = XEnumerable.Empty <string>().ForbidEnumeration();
var other = XEnumerable.Empty <string>().ForbidEnumeration();
TestHelper.AssertThrowsWhenArgumentNull(
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
() => source.SequenceEqualBy(other, s => s.Length, null));
}
public void FullOuterJoin_Throws_If_Argument_Null()
{
var left = XEnumerable.Empty <int>().ForbidEnumeration();
var right = XEnumerable.Empty <int>().ForbidEnumeration();
TestHelper.AssertThrowsWhenArgumentNull(
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
() => left.FullOuterJoin(right, x => x, y => y, (k, x, y) => 0, 0, 0, null));
}
public void RankByDescending_Throws_When_Argument_Is_Null()
{
var source = XEnumerable.Empty <int>().ForbidEnumeration();
TestHelper.AssertThrowsWhenArgumentNull(
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
() => source.RankByDescending(x => x, (x, r) => x, null),
"source", "keySelector", "resultSelector");
}
public void SingleOrDefault_With_Predicate_Throws_If_Predicate_Is_Null()
{
var source = XEnumerable.Empty <int>().ForbidEnumeration();
Func <int, bool> predicate = null;
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
// ReSharper disable once AssignNullToNotNullAttribute
var ex = Assert.Throws <ArgumentNullException>(() => source.SingleOrDefault(predicate, 42));
ex.ParamName.Should().Be("predicate");
}
public void RightOuterJoin_Throws_If_Argument_Null()
{
var left = XEnumerable.Empty <int>().ForbidEnumeration();
var right = XEnumerable.Empty <int>().ForbidEnumeration();
TestHelper.AssertThrowsWhenArgumentNull(
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
() => left.RightOuterJoin(right, x => x, y => y, (x, y) => 0, 0, null),
"left", "right", "leftKeySelector", "rightKeySelector", "resultSelector");
}
public void SingleOrDefault_Returns_Single_Element_If_Sequence_Has_One_Element()
{
var source = XEnumerable.Unit(1).ForbidMultipleEnumeration();
source.SingleOrDefault(42).Should().Be(1);
}
public void None_With_Predicate_Returns_True_If_Source_Is_Empty()
{
var source = XEnumerable.Empty <int>().ForbidMultipleEnumeration();
source.None(IsEven).Should().BeTrue();
}
public void None_Returns_False_If_Source_Is_Not_Empty()
{
IEnumerable <int> source = XEnumerable.Unit(42).ForbidMultipleEnumeration();
source.None().Should().BeFalse();
}
public void None_Returns_True_If_Source_Is_Empty()
{
IEnumerable <int> source = XEnumerable.Empty <int>().ForbidMultipleEnumeration();
source.None().Should().BeTrue();
}
public void ElementAtOrDefault_Returns_Specified_Default_Value_If_Sequence_Is_Empty()
{
var source = XEnumerable.Empty <int>().ForbidMultipleEnumeration();
source.ElementAtOrDefault(0, 42).Should().Be(42);
}
public void SingleOrDefault_With_Predicate_Returns_Specified_Default_Value_If_Sequence_Is_Empty()
{
var source = XEnumerable.Empty <int>().ForbidMultipleEnumeration();
source.SingleOrDefault(IsEven, 42).Should().Be(42);
}
public void Generate_Throws_If_Argument_Is_Null()
{
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
TestHelper.AssertThrowsWhenArgumentNull(() => XEnumerable.Generate(0, i => i));
}
