public void ShouldPickUpSame()
{
var date = new DateTime(2012, 06, 06);
var cache = new MonitorRecordComparison<double> { TimeStamp = date };
Assert.Equal(0, cache.CompareTo(new MonitorRecord<double>(date, 1)));
}
public void ShouldReturnNotNullInstances()
{
var cache = new MonitorRecordComparison<double>(10);
Assert.Equal(1, cache.Number);
Assert.Equal(DateTime.Now.Date, cache.TimeStamp.Date);
Assert.Equal(10, cache.Value);
}
private void ProcessResult(long reduceResolution, DateTime lastPredictionTime, IList<MonitorRecord<double>> reducedOrdered, IDictionary<long, MonitorRecordComparison<double>> expectedValues)
{
var halfResolution = TimeSpan.FromMilliseconds((long)(reduceResolution / 2));
//If we have some data to be reduced, reduece it down
if (reducedOrdered.Count > 0)
{
//Loop through and index each to-be-reduced item
var updates = new Dictionary<long, MonitorRecord<double>>(reducedOrdered.Count);
foreach (var update in reducedOrdered)
updates.Add(update.TimeStamp.Ticks - halfResolution.Ticks, update);
//Going between the first date we have and the last date plus 7 days we loop around.
//The loop increments on what ever the resolution we have for the ReductionLevel provided.
//Then for each value in the loop we go backwards in time a week at a time for 4 weeks.
//For each of these weeks we look to see if there is a week in the list passed in that
//matches. This results in us coming up with the dates in the future that the data for a
//given input date should be used for.
//This is a seems like a really inefficient way of doing this... as in really really bad.
//There has to be a better way of doing this. Don't want to change at the moment until the
//test coverage gets up and I know we aren't breaking anything
var startTime = lastPredictionTime == Constant.MinDbDateTime ? Support.RoundToResolution(reducedOrdered.Last().TimeStamp, reduceResolution) : lastPredictionTime;
var endTime = reducedOrdered.Last().TimeStamp.AddDays(7);
for (var currentTime = startTime; currentTime.Ticks < endTime.Ticks; currentTime = currentTime.AddTicks(reduceResolution * Constant.TicksInMillisecond))
{
var samples = new List<MonitorRecord<double>>();
//Starts going backwards in time a week at a time for the number of weeks described
for (var i = 0; i < WeeksHistory; ++i)
{
var timeIndex = currentTime.AddTicks(-(i + 1)*TimeSpan.FromDays(7).Ticks).Ticks;
MonitorRecord<double> sample;
if (updates.TryGetValue(timeIndex, out sample))
samples.Add(sample);
}
// ReduceMethodAverage the samples
if (samples.Count > 0)
{
long count = 0;
double sum = 0;
foreach (var sample in samples)
{
count += sample.Number;
sum += sample.Value * sample.Number;
}
var mean = sum/count;
var expectedValue = new MonitorRecordComparison<double> { TimeStamp = currentTime + halfResolution, Value = mean, Number = (int)count };
expectedValues.Add(expectedValue.TimeStamp.Ticks, expectedValue);
}
}
}
}
public void ShouldPickUpLower()
{
var cache = new MonitorRecordComparison<double> { TimeStamp = new DateTime(2012, 06, 06) };
Assert.Equal(1, cache.CompareTo(new MonitorRecord<double>(new DateTime(2012, 06, 05), 1)));
}
