public void MinInt32()
{
var one = Enumerable.Range(1, 10).ToArray();
var minusTen = new[] { -1, -10, 10, 200, 1000 };
var hundred = new[] { 3000, 100, 200, 1000 };
Assert.Equal(1, one.Min());
Assert.Equal(-10, minusTen.Min());
Assert.Equal(100, hundred.Min());
Assert.Equal(int.MinValue, one.Concat(Enumerable.Repeat(int.MinValue, 1)).Min());
}
public void MinInt64()
{
var one = Enumerable.Range(1, 10).Select(i => (long)i).ToArray();
var minusTen = new[] { -1L, -10, 10, 200, 1000 };
var hundred = new[] { 3000L, 100, 200, 1000 };
Assert.Equal(42, Enumerable.Repeat(42L, 1).Min());
Assert.Equal(1, one.Min());
Assert.Equal(-10, minusTen.Min());
Assert.Equal(100, hundred.Min());
Assert.Equal(long.MinValue, one.Concat(Enumerable.Repeat(long.MinValue, 1)).Min());
Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<long>().Min());
}
public void MinSingle()
{
var one = Enumerable.Range(1, 10).Select(i => (float)i).ToArray();
var minusTen = new[] { -1F, -10, 10, 200, 1000 };
var hundred = new[] { 3000F, 100, 200, 1000 };
Assert.Equal(42F, Enumerable.Repeat(42F, 1).Min());
Assert.Equal(1L, one.Min());
Assert.Equal(-10L, minusTen.Min());
Assert.Equal(100L, hundred.Min());
Assert.Equal(float.MinValue, one.Concat(Enumerable.Repeat(float.MinValue, 1)).Min());
Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<float>().Min());
}
public void MinInt32()
{
var one = Enumerable.Range(1, 10).ToArray();
var minusTen = new[] { -1, -10, 10, 200, 1000 };
var hundred = new[] { 3000, 100, 200, 1000 };
Assert.Equal(42, Enumerable.Repeat(42, 1).Min());
Assert.Equal(1, one.Min());
Assert.Equal(-10, minusTen.Min());
Assert.Equal(100, hundred.Min());
Assert.Equal(int.MinValue, one.Concat(Enumerable.Repeat(int.MinValue, 1)).Min());
Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<int>().Min());
}
public void MinString()
{
var one = Enumerable.Range(1, 10).Select(i => i.ToString()).ToArray();
var agents = new[] { "Alice", "Bob", "Charlie", "Eve", "Mallory", "Trent", "Victor"};
var confusedAgents = new[] { null, "Charlie", null, "Victor", "Trent", null, "Eve", "Alice", "Mallory", "Bob" };
Assert.Equal("1", one.Min());
Assert.Equal("Alice", agents.Min());
Assert.Equal("Alice", confusedAgents.Min());
}
public void NaNFirstDouble()
{
var nanThenOne = Enumerable.Range(1, 10).Select(i => (double)i).Concat(Enumerable.Repeat(double.NaN, 1)).ToArray();
var nanThenMinusTen = new[] { -1F, -10, double.NaN, 10, 200, 1000 };
var nanThenMinValue = new[] { double.MinValue, 3000F, 100, 200, double.NaN, 1000 };
Assert.True(double.IsNaN(nanThenOne.Min()));
Assert.True(double.IsNaN(nanThenMinusTen.Min()));
Assert.True(double.IsNaN(nanThenMinValue.Min()));
var nanWithNull = new[] { default(double?), double.NaN, default(double?) };
Assert.True(double.IsNaN(nanWithNull.Min().Value));
}
public void MinDateTime()
{
var one = Enumerable.Range(1, 10).Select(i => new DateTime(2000, 1, i)).ToArray();
var newYears = new[]
{
new DateTime(2000, 12, 1),
new DateTime(2000, 1, 1),
new DateTime(2000, 1, 12)
};
var hundred = new[]
{
new DateTime(3000, 1, 1),
new DateTime(100, 1, 1),
new DateTime(200, 1, 1),
new DateTime(1000, 1, 1)
};
Assert.Equal(DateTime.MinValue, one.Concat(Enumerable.Repeat(DateTime.MinValue, 1)).Min());
Assert.Equal(new DateTime(2000, 1, 1), one.Min());
Assert.Equal(new DateTime(2000, 1, 1), newYears.Min());
Assert.Equal(new DateTime(100, 1, 1), hundred.Min());
}
public void MinDouble()
{
var one = Enumerable.Range(1, 10).Select(i => (double)i).ToArray();
var minusTen = new[] { -1D, -10, 10, 200, 1000 };
var hundred = new[] { 3000D, 100, 200, 1000 };
Assert.Equal(42D, Enumerable.Repeat(42D, 1).Min());
Assert.Equal(1D, one.Min());
Assert.Equal(-10D, minusTen.Min());
Assert.Equal(100D, hundred.Min());
Assert.Equal(double.MinValue, one.Concat(Enumerable.Repeat(double.MinValue, 1)).Min());
Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<double>().Min());
}
public void MinNullableDecimal()
{
var one = Enumerable.Range(1, 10).Select(i => (decimal?)i).ToArray();
var minusTen = new[] { default(decimal?), -1M, -10, 10, 200, 1000 };
var hundred = new[] { default(decimal?), 3000M, 100, 200, 1000 };
Assert.Equal(1M, one.Min());
Assert.Equal(-10M, minusTen.Min());
Assert.Equal(100M, hundred.Min());
Assert.Equal(decimal.MinValue, one.Concat(Enumerable.Repeat((decimal?)decimal.MinValue, 1)).Min());
}
public void Min_Int_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=10 },
new { name="John", num=-105 },
new { name="Bob", num=-30 }
};
Assert.Equal(-105, source.Min(e => e.num));
}
public void Min_Double_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=-45.5 },
new { name="John", num=-132.5 },
new { name="Bob", num=20.45 }
};
Assert.Equal(-132.5, source.Min(e => e.num));
}
public void NaNFirstSingleWithSelector()
{
var nanThenOne = Enumerable.Range(1, 10).Select(i => (float)i).Concat(Enumerable.Repeat(float.NaN, 1)).ToArray();
var nanThenMinusTen = new[] { -1F, -10, float.NaN, 10, 200, 1000 };
var nanThenMinValue = new[] { float.MinValue, 3000F, 100, 200, float.NaN, 1000 };
Assert.True(float.IsNaN(nanThenOne.Min(x => x)));
Assert.True(float.IsNaN(nanThenMinusTen.Min(x => x)));
Assert.True(float.IsNaN(nanThenMinValue.Min(x => x)));
var nanWithNull = new[] { default(float?), float.NaN, default(float?) };
Assert.True(float.IsNaN(nanWithNull.Min(x => x).Value));
}
public void MinDouble()
{
var one = Enumerable.Range(1, 10).Select(i => (double)i).ToArray();
var minusTen = new[] { -1D, -10, 10, 200, 1000 };
var hundred = new[] { 3000D, 100, 200, 1000 };
Assert.Equal(1D, one.Min());
Assert.Equal(-10D, minusTen.Min());
Assert.Equal(100D, hundred.Min());
Assert.Equal(double.MinValue, one.Concat(Enumerable.Repeat(double.MinValue, 1)).Min());
}
public void MinNullableSingleWithSelectorAccessingProperty()
{
var source = new[]{
new {name="Tim", num=(float?)-45.5f},
new {name="John", num=(float?)-132.5f},
new {name="Bob", num=default(float?)}
};
Assert.Equal(-132.5f, source.Min(e => e.num));
}
public void MinNullableDoubleWithSelector()
{
var one = Enumerable.Range(1, 10).Select(i => (double?)i).ToArray();
var minusTen = new[] { default(double?), -1D, -10, 10, 200, 1000 };
var hundred = new[] { default(double?), 3000D, 100, 200, 1000 };
Assert.Equal(42D, Enumerable.Repeat((double?)42, 1).Min(x => x));
Assert.Equal(1D, one.Min(x => x));
Assert.Equal(-10D, minusTen.Min(x => x));
Assert.Equal(100D, hundred.Min(x => x));
Assert.Equal(double.MinValue, one.Concat(Enumerable.Repeat((double?)double.MinValue, 1)).Min(x => x));
Assert.Null(Enumerable.Empty<double?>().Min(x => x));
Assert.Null(Enumerable.Repeat(default(double?), 100).Min(x => x));
}
public void MinNullableInt32WithSelector()
{
var one = Enumerable.Range(1, 10).Select(i => (int?)i).ToArray();
var minusTen = new[] { default(int?), -1, -10, 10, 200, 1000 };
var hundred = new[] { default(int?), 3000, 100, 200, 1000 };
Assert.Equal(42, Enumerable.Repeat((int?)42, 1).Min(x => x));
Assert.Equal(1, one.Min(x => x));
Assert.Equal(-10, minusTen.Min(x => x));
Assert.Equal(100, hundred.Min(x => x));
Assert.Null(Enumerable.Empty<int?>().Min(x => x));
Assert.Equal(int.MinValue, one.Concat(Enumerable.Repeat((int?)int.MinValue, 1)).Min(x => x));
Assert.Null(Enumerable.Repeat(default(int?), 100).Min(x => x));
}
public void MinDecimalWithSelector()
{
var one = Enumerable.Range(1, 10).Select(i => (decimal)i).ToArray();
var minusTen = new[] { -1M, -10, 10, 200, 1000 };
var hundred = new[] { 3000M, 100, 200, 1000 };
Assert.Equal(42M, Enumerable.Repeat(42M, 1).Min(x => x));
Assert.Equal(1M, one.Min(x => x));
Assert.Equal(-10M, minusTen.Min(x => x));
Assert.Equal(100M, hundred.Min(x => x));
Assert.Equal(decimal.MinValue, one.Concat(Enumerable.Repeat(decimal.MinValue, 1)).Min(x => x));
}
public void should_get_minimum_element_using_min()
{
var sequence = new[] { 1, 2, 3, 4, 5 };
int minNumber = sequence.Min();
// please update variable value to fix the test.
const int expectedMinNumber = 0;
Assert.Equal(expectedMinNumber, minNumber);
}
public void MinInt64WithSelector()
{
var one = Enumerable.Range(1, 10).Select(i => (long)i).ToArray();
var minusTen = new[] { -1L, -10, 10, 200, 1000 };
var hundred = new[] { 3000L, 100, 200, 1000 };
Assert.Equal(42, Enumerable.Repeat(42L, 1).Min(x => x));
Assert.Equal(1, one.Min(x => x));
Assert.Equal(-10, minusTen.Min(x => x));
Assert.Equal(100, hundred.Min(x => x));
Assert.Equal(long.MinValue, one.Concat(Enumerable.Repeat(long.MinValue, 1)).Min(x => x));
}
public void Min_NullableLong_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=default(long?) },
new { name="John", num=(long?)long.MinValue },
new { name="Bob", num=(long?)-10L }
};
Assert.Equal(long.MinValue, source.Min(e => e.num));
}
public void MinSingleWithSelector()
{
var one = Enumerable.Range(1, 10).Select(i => (float)i).ToArray();
var minusTen = new[] { -1F, -10, 10, 200, 1000 };
var hundred = new[] { 3000F, 100, 200, 1000 };
Assert.Equal(42F, Enumerable.Repeat(42F, 1).Min(x => x));
Assert.Equal(1L, one.Min(x => x));
Assert.Equal(-10L, minusTen.Min(x => x));
Assert.Equal(100L, hundred.Min(x => x));
Assert.Equal(float.MinValue, one.Concat(Enumerable.Repeat(float.MinValue, 1)).Min(x => x));
}
public void Min_NullableDecimal_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=(decimal?)100.45m },
new { name="John", num=(decimal?)10.5m },
new { name="Bob", num=default(decimal?) }
};
Assert.Equal(10.5m, source.Min(e => e.num));
}
public void Min_Long_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=10L },
new { name="John", num=long.MinValue },
new { name="Bob", num=-10L }
};
Assert.Equal(long.MinValue, source.Min(e => e.num));
}
public void MinDecimal()
{
var one = Enumerable.Range(1, 10).Select(i => (decimal)i).ToArray();
var minusTen = new[] { -1M, -10, 10, 200, 1000 };
var hundred = new[] { 3000M, 100, 200, 1000 };
Assert.Equal(42M, Enumerable.Repeat(42M, 1).Max());
Assert.Equal(1M, one.Min());
Assert.Equal(-10M, minusTen.Min());
Assert.Equal(100M, hundred.Min());
Assert.Equal(decimal.MinValue, one.Concat(Enumerable.Repeat(decimal.MinValue, 1)).Min());
Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<decimal>().Min());
}
public void Min_NullableInt_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=(int?)10 },
new { name="John", num=default(int?) },
new { name="Bob", num=(int?)-30 }
};
Assert.Equal(-30, source.Min(e => e.num));
}
public void MinDateTimeWithSelector()
{
var one = Enumerable.Range(1, 10).Select(i => new DateTime(2000, 1, i)).ToArray();
var newYears = new[]
{
new DateTime(2000, 12, 1),
new DateTime(2000, 1, 1),
new DateTime(2000, 1, 12)
};
var hundred = new[]
{
new DateTime(3000, 1, 1),
new DateTime(100, 1, 1),
new DateTime(200, 1, 1),
new DateTime(1000, 1, 1)
};
Assert.Equal(DateTime.MinValue, one.Concat(Enumerable.Repeat(DateTime.MinValue, 1)).Min(x => x));
Assert.Equal(new DateTime(2000, 1, 1), one.Min(x => x));
Assert.Equal(new DateTime(2000, 1, 1), newYears.Min(x => x));
Assert.Equal(new DateTime(100, 1, 1), hundred.Min(x => x));
Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<DateTime>().Min(x => x));
}
public void Min_NullableDouble_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=(double?)-45.5 },
new { name="John", num=(double?)-132.5 },
new { name="Bob", num=default(double?) }
};
Assert.Equal(-132.5, source.Min(e => e.num));
}
public void MinNullableInt64()
{
var one = Enumerable.Range(1, 10).Select(i => (long?)i).ToArray();
var minusTen = new[] { default(long?), -1L, -10, 10, 200, 1000 };
var hundred = new[] { default(long?), 3000L, 100, 200, 1000 };
Assert.Equal(1, one.Min());
Assert.Equal(-10, minusTen.Min());
Assert.Equal(100, hundred.Min());
Assert.Equal(long.MinValue, one.Concat(Enumerable.Repeat((long?)long.MinValue, 1)).Min());
}
public void Min_String_WithSelectorAccessingProperty()
{
var source = new[]
{
new { name="Tim", num=100.45m },
new { name="John", num=10.5m },
new { name="Bob", num=0.05m }
};
Assert.Equal("Bob", source.Min(e => e.name));
}
public void MinNullableSingle()
{
var one = Enumerable.Range(1, 10).Select(i => (float?)i).ToArray();
var minusTen = new[] { default(float?), -1F, -10, 10, 200, 1000 };
var hundred = new[] { default(float?), 3000F, 100, 200, 1000 };
Assert.Equal(1F, one.Min());
Assert.Equal(-10F, minusTen.Min());
Assert.Equal(100F, hundred.Min());
Assert.Equal(float.MinValue, one.Concat(Enumerable.Repeat((float?)float.MinValue, 1)).Min());
}
