public void AggregateEmptyDefault()
{
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.Aggregate(s_emptyDefault, (a, b) => a + b));
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.Aggregate(s_emptyDefault, 1, (a, b) => a + b));
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.Aggregate <int, int, int>(s_emptyDefault, 1, (a, b) => a + b, a => a));
}
public void AggregateEmpty()
{
Assert.Equal(0, ImmutableArrayExtensions.Aggregate(s_empty, (a, b) => a + b));
Assert.Equal(1, ImmutableArrayExtensions.Aggregate(s_empty, 1, (a, b) => a + b));
Assert.Equal(1, ImmutableArrayExtensions.Aggregate <int, int, int>(s_empty, 1, (a, b) => a + b, a => a));
}
public void AllEmpty()
{
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.All(s_empty, null));
Assert.True(ImmutableArrayExtensions.All(s_empty, n => { throw new ShouldNotBeInvokedException(); })); // predicate should never be invoked.
}
public void Aggregate()
{
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.Aggregate(s_oneElement, null));
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.Aggregate(s_oneElement, 1, null));
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.Aggregate <int, int, int>(s_oneElement, 1, null, null));
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.Aggregate <int, int, int>(s_oneElement, 1, (a, b) => a + b, null));
Assert.Equal(Enumerable.Aggregate(s_manyElements, (a, b) => a * b), ImmutableArrayExtensions.Aggregate(s_manyElements, (a, b) => a * b));
Assert.Equal(Enumerable.Aggregate(s_manyElements, 5, (a, b) => a * b), ImmutableArrayExtensions.Aggregate(s_manyElements, 5, (a, b) => a * b));
Assert.Equal(Enumerable.Aggregate(s_manyElements, 5, (a, b) => a * b, a => - a), ImmutableArrayExtensions.Aggregate(s_manyElements, 5, (a, b) => a * b, a => - a));
}
public void All()
{
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.All(s_oneElement, null));
Assert.False(ImmutableArrayExtensions.All(s_manyElements, n => n == 2));
Assert.True(ImmutableArrayExtensions.All(s_manyElements, n => n > 0));
}
public void AllEmptyDefault()
{
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.All(s_emptyDefault, n => true));
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.All(s_emptyDefault, null));
}
public void WhereEmpty()
{
Assert.Throws <ArgumentNullException>("predicate", () => ImmutableArrayExtensions.Where(s_empty, null));
Assert.False(ImmutableArrayExtensions.Where(s_empty, n => true).Any());
}
public void SelectEmpty()
{
Assert.Throws <ArgumentNullException>("selector", () => ImmutableArrayExtensions.Select <int, bool>(s_empty, null));
Assert.False(ImmutableArrayExtensions.Select(s_empty, n => true).Any());
}
public void ToArray()
{
Assert.Equal(0, ImmutableArrayExtensions.ToArray(s_empty).Length);
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.ToArray(s_emptyDefault));
Assert.Equal(s_manyElements.ToArray(), ImmutableArrayExtensions.ToArray(s_manyElements));
}
public void Where()
{
Assert.Equal(new[] { 2, 3 }, ImmutableArrayExtensions.Where(s_manyElements, n => n > 1));
Assert.Throws <ArgumentNullException>("predicate", () => ImmutableArrayExtensions.Where(s_manyElements, null));
}
public void SingleOrDefaultEmptyDefault()
{
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.SingleOrDefault(s_emptyDefault));
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.SingleOrDefault(s_emptyDefault, n => true));
Assert.Throws <ArgumentNullException>("predicate", () => ImmutableArrayExtensions.SingleOrDefault(s_emptyDefault, null));
}
public void SingleOrDefaultEmpty()
{
Assert.Equal(0, ImmutableArrayExtensions.SingleOrDefault(s_empty));
Assert.Equal(0, ImmutableArrayExtensions.SingleOrDefault(s_empty, n => true));
Assert.Throws <ArgumentNullException>("predicate", () => ImmutableArrayExtensions.SingleOrDefault(s_empty, null));
}
public void SingleEmpty()
{
Assert.Throws <InvalidOperationException>(() => ImmutableArrayExtensions.Single(s_empty));
Assert.Throws <InvalidOperationException>(() => ImmutableArrayExtensions.Single(s_empty, n => true));
Assert.Throws <ArgumentNullException>("predicate", () => ImmutableArrayExtensions.Single(s_empty, null));
}
public void Select()
{
Assert.Equal(new[] { 4, 5, 6 }, ImmutableArrayExtensions.Select(s_manyElements, n => n + 3));
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.Select <int, bool>(s_manyElements, null));
}
public void AnyEmpty()
{
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.Any(s_empty, null));
Assert.False(ImmutableArrayExtensions.Any(s_empty));
Assert.False(ImmutableArrayExtensions.Any(s_empty, n => true));
}
public void FirstEmptyDefault()
{
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.First(s_emptyDefault));
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.First(s_emptyDefault, n => true));
Assert.Throws <ArgumentNullException>(() => ImmutableArrayExtensions.First(s_emptyDefault, null));
}
public void SelectEmptyDefault()
{
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.Select <int, bool>(s_emptyDefault, null));
Assert.Throws <NullReferenceException>(() => ImmutableArrayExtensions.Select(s_emptyDefault, n => true));
}
