public void RefreshUnitStats(Unit unit)
{
var health = unit.Stats.Health();
var magic = unit.Stats.Magic();
StatsComputer.RecomputeStats(unit.Stats, unit.GetUnitEffects().ToArray());
unit.Stats.Health(health);
unit.Stats.Magic(magic);
}
public void IgnoresNaNValuesIfListHasNaN()
{
var statsComputer = new StatsComputer();
var returnedList = statsComputer.CalculateStatistics(new List <double> {
3.7, double.NaN, 7.0, double.NaN, 10.6, 4.5
});
Assert.True(statsComputer.numbers.Count == 6);
}
public void ReportsNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
List <float> numbers = new List <float>();
var computedStats = statsComputer.CalculateStatistics(numbers);
//All fields of computedStats (average, max, min) must be
//Double.NaN (not-a-number), as described in
//https://docs.microsoft.com/en-us/dotnet/api/system.double.nan?view=netcore-3.1
}
public void ReportsNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <float> {
});
Assert.Equal(Double.NaN, computedStats.average);
Assert.Equal(Double.NaN, computedStats.max);
Assert.Equal(Double.NaN, computedStats.min);
}
public void WnenCalledWithEmptyListThenReportsNANForAverageMinMax()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <double> {
});
Assert.True(Double.IsNaN(computedStats.average));
Assert.True(Double.IsNaN(computedStats.max));
Assert.True(Double.IsNaN(computedStats.min));
}
public void ReportsNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <double> {
});
Assert.True(Math.Abs(computedStats.average).Equals(double.NaN));
Assert.True(Math.Abs(computedStats.maximum).Equals(double.NaN));
Assert.True(Math.Abs(computedStats.minimum).Equals(double.NaN));
}
public void WhenCalculateStatisticsCalledwithEmptyInputThenReportsNaN()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
});
Assert.True(Double.IsNaN(computedStats.average));
Assert.True(Double.IsNaN(computedStats.max));
Assert.True(Double.IsNaN(computedStats.min));
}
public void ReportStatisticsAsNaNForEmplyInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <float> {
});
Assert.True((float)Double.NaN.CompareTo(statsComputer.Average) == 0);
Assert.True((float)Double.NaN.CompareTo(statsComputer.Average) == 0);
Assert.True((float)Double.NaN.CompareTo(statsComputer.Average) == 0);
Console.WriteLine("ReportStatisticsAsNaNForEmplyInput Done!");
}
public void ReportsNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
});
Assert.True(computedStats.average.Equals(float.NaN));
Assert.True(computedStats.min.Equals(float.NaN));
Assert.True(computedStats.max.Equals(float.NaN));
}
public void ReportsNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <double> {
});
Assert.True(Double.IsNaN(computedStats.average));
Assert.True(Double.IsNaN(computedStats.max));
Assert.True(Double.IsNaN(computedStats.min));
}
public void ReportsComputedStatsForListOfNumbersHavingFewNaNValues()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <double> {
3.7, double.NaN, 7.0, double.NaN, 10.6, 4.5
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.Average - 6.45) <= epsilon);
Assert.True(Math.Abs(computedStats.Max - 10.6) <= epsilon);
Assert.True(Math.Abs(computedStats.Min - 3.7) <= epsilon);
}
public void ReportsAverageMinMax()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <double> {
1.5, 8.9, 3.2, 4.5
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.average - 4.525) <= epsilon);
Assert.True(Math.Abs(computedStats.max - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.min - 1.5) <= epsilon);
}
public void ReportsNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
var list = new List <double> {
1.5, 8.9, 3.2, 4.5, double.NaN
};
var computedStats = statsComputer.CalculateStatistics(list);
Assert.True(double.IsNaN(computedStats.average));
Assert.True(double.IsNaN(computedStats.min));
Assert.True(double.IsNaN(computedStats.max));
}
public void ReportNaNForListHavingAllNaNElements()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
float.NaN, float.NaN
});
Assert.True(float.IsNaN(computedStats.Average));
Assert.True(float.IsNaN(computedStats.Max));
Assert.True(float.IsNaN(computedStats.Min));
}
public void TestForOneOrMoreNaNValueInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
1.5F, 8.9F, float.NaN, 4.5F
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.average - 4.967) <= epsilon);
Assert.True(Math.Abs(computedStats.max - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.min - 1.5) <= epsilon);
}
public void WhenCallerInvokesAListOfNumbersHavingNaNThenStatsOfRemainingAreReturned()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <double> {
1.8, double.NaN, 6.9, 1.1
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.Average - 3.26666667) <= epsilon);
Assert.True(Math.Abs(computedStats.Max - 6.9) <= epsilon);
Assert.True(Math.Abs(computedStats.Min - 1.1) <= epsilon);
}
public void WhenUserInputsAEmptyListOfFloatNANisReturned()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
});
//All fields of computedStats (average, max, min) must be
Assert.True(float.IsNaN(computedStats.average));
Assert.True(float.IsNaN(computedStats.max));
Assert.True(float.IsNaN(computedStats.min));
}
public void TestForListHavingSomeElementsAsNaN()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
float.NaN, 1.5F, 8.9F, 3.2F, 4.5F
});
float epsilon = 0.001F;
Assert.True(float.IsNaN(computedStats.Average));
Assert.True(Math.Abs(computedStats.Max - 8.9) <= epsilon);
Assert.True(float.IsNaN(computedStats.Min));
}
public void ReportsNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
});
float epsilon = 0.001F;
Assert.False(Math.Abs(computedStats.average - float.NaN) <= epsilon);
Assert.False(Math.Abs(computedStats.max - float.NaN) <= epsilon);
Assert.False(Math.Abs(computedStats.min - float.NaN) <= epsilon);
}
public void ReportStatisticsForValidFloatTypeInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <float> {
1.5F, 8.9F, 3.2F, 4.5F
});
float epsilon = 0.001F;
Assert.True(Math.Abs(statsComputer.Average - 4.525) <= epsilon);
Assert.True(Math.Abs(statsComputer.Max - 8.9) <= epsilon);
Assert.True(Math.Abs(statsComputer.Min - 1.5) <= epsilon);
Console.WriteLine("ReportStatisticsForValidFloatTypeInput Done!");
}
public void WhenUserInputsAnNonEmptyListOfFloatWithSomeNaNInputsStatisticsareProducedForTheNonNaNInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
1.5F, 8.9F, float.NaN, 3.2F, 4.5F
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.average - 4.525) <= epsilon);
Assert.True(Math.Abs(computedStats.max - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.min - 1.5) <= epsilon);
}
public void ReportsAllNaNForEmptyInput()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <double> {
});
Assert.True(Double.IsNaN(computedStats.Average));
Assert.True(Double.IsNaN(computedStats.Min));
Assert.True(Double.IsNaN(computedStats.Max));
//All fields of computedStats (average, max, min) must be
//Double.NaN (not-a-number), as described in
//https://docs.microsoft.com/en-us/dotnet/api/system.double.nan?view=netcore-3.1
}
public void whenListContainsNaNthenReportStatsForRestofTheElements()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
1.5f, 8.9f, float.NaN, 4.5f
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.average - 4.9666) <= epsilon);
Assert.True(Math.Abs(computedStats.max - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.min - 1.5) <= epsilon);
}
public void WhenNaNItemsAreInListThenStatisticsOfNonNanItemsIsCalculated()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <double> {
1.5, double.NaN, 3.2, 4.5
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.average - 3.067) <= epsilon);
Assert.True(Math.Abs(computedStats.max - 4.5) <= epsilon);
Assert.True(Math.Abs(computedStats.min - 1.5) <= epsilon);
}
public void WhenInputHavingOneOrMoreNanThenReturnStatisticsOfRemainingNumbers()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <float> {
5.4F, float.NaN, 8.9F, 1.6F
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.Average - 5.300) <= epsilon);
Assert.True(Math.Abs(computedStats.Max - 8.9F) <= epsilon);
Assert.True(Math.Abs(computedStats.Min - 1.6F) <= epsilon);
Console.WriteLine("ReportsAverageMinMax Complete");
}
public void ReportsAverageMinMax()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(new List <float> {
1.5F, 8.9F, 3.2F, 4.5F
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.Average - 4.525) <= epsilon);
Assert.True(Math.Abs(computedStats.Max - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.Min - 1.5) <= epsilon);
Console.WriteLine("ReportsAverageMinMax Complete");
}
public void ReportsStatsForAListOfNums()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <double> {
1.5, 8.9, 3.2, 4.5
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.AVG - 4.525) <= epsilon);
Assert.True(Math.Abs(computedStats.MAX - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.MIN - 1.5) <= epsilon);
}
public void TestForStatisticsWhenInputListContainsNaN()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <Double> {
1.5, 8.9, Double.NaN, 3.2, 4.5
});
float epsilon = 0.001F;
Console.WriteLine(computedStats.ave + " * " + computedStats.max + " * " + computedStats.min);
Assert.True(Math.Abs(computedStats.ave - 4.525) <= epsilon);
Assert.True(Math.Abs(computedStats.max - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.min - 1.5) <= epsilon);
}
public void ReportsNaNForMoreThanOneNaNValue()
{
var statsComputer = new StatsComputer();
var computedStats = statsComputer.CalculateStatistics(
new List <float> {
2.8F, float.NaN, 5.96F, 6.14F, 9.6F, float.NaN, float.NaN, 4.123F
});
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.Average - 5.7246) <= epsilon);
Assert.True(Math.Abs(computedStats.Max - 9.6) <= epsilon);
Assert.True(Math.Abs(computedStats.Min - 2.8) <= epsilon);
}
public void TestAverageMinMaxForAListOfFloatValues()
{
var statsComputer = new StatsComputer();
List <float> numbers = new List <float>()
{
1.5f, 8.9f, 3.2f, 4.5f
};
var computedStats = statsComputer.CalculateStatistics(numbers);
float epsilon = 0.001F;
Assert.True(Math.Abs(computedStats.Average - 4.525) <= epsilon);
Assert.True(Math.Abs(computedStats.Max - 8.9) <= epsilon);
Assert.True(Math.Abs(computedStats.Min - 1.5) <= epsilon);
}
