public void Query_ForDifferentDateIntervals_ShoudReturnCorrectOverlapsCount(int leftEdgeMinutes, int rightEdgeMinutes, int expectedOverlapsCount)
{
//Arrange
var intervals = new List <Interval <DateTime> >();
intervals.Add(ToDateTimeInterval(now, -300, -200));
intervals.Add(ToDateTimeInterval(now, -3, -2));
intervals.Add(ToDateTimeInterval(now, 1, 2));
intervals.Add(ToDateTimeInterval(now, 3, 6));
intervals.Add(ToDateTimeInterval(now, 2, 4));
intervals.Add(ToDateTimeInterval(now, 5, 7));
intervals.Add(ToDateTimeInterval(now, 1, 3));
intervals.Add(ToDateTimeInterval(now, 4, 6));
intervals.Add(ToDateTimeInterval(now, 8, 9));
intervals.Add(ToDateTimeInterval(now, 15, 20));
intervals.Add(ToDateTimeInterval(now, 40, 50));
intervals.Add(ToDateTimeInterval(now, 49, 60));
IIntervalContainer <DateTime> intervalContainer = this.CreateIntervalContainer(intervals);
//Act
var overlaps = intervalContainer.Query(ToDateTimeInterval(now, leftEdgeMinutes, rightEdgeMinutes));
//Assert
Assert.AreEqual(expectedOverlapsCount, overlaps.Count());
}
public void SetUp(int testIndex, IIntervalContainer<DateTime> intervalContainer)
{
this.numberOfIntervals = this.CollectionCount(testIndex);
var intervals = GenerateIncludedOneIntoAnotherIntervals(DateTime.Now, this.numberOfIntervals);
foreach (var interval in intervals)
{
intervalContainer.Add(interval);
}
}
public void SetUp(int testIndex, IIntervalContainer <DateTime> intervalContainer)
{
this.numberOfIntervals = this.CollectionCount(testIndex);
var intervals = GenerateIncludedOneIntoAnotherIntervals(DateTime.Now, this.numberOfIntervals);
foreach (var interval in intervals)
{
intervalContainer.Add(interval);
}
}
private IIntervalContainer <DateTime> CreateIntervalContainer(IEnumerable <Interval <DateTime> > intervals)
{
IIntervalContainer <DateTime> intervalContainer = CreateIntervalContainer();
foreach (var interval in intervals)
{
intervalContainer.Add(interval);
}
return(intervalContainer);
}
private IEnumerable<IInterval<DateTime>> TestSearchForInterval(DateTime startEdge, DateTime endEdge, IIntervalContainer<DateTime> searchIn, string testName)
{
stopwatch.Reset();
stopwatch.Start();
var foundIntervals = searchIn.Query(new Interval<DateTime>(startEdge, endEdge)).ToList();
stopwatch.Stop();
timeEllapsedReport.AppendLine(string.Format("Time taken for {0}: {1} ms", testName, stopwatch.ElapsedMilliseconds));
return foundIntervals;
}
public void Add_Interval(IIntervalContainer<DateTime> container)
{
const int intervalLength = 4;
const int spaceLength = 1;
const int intervalAndSpaceLength = intervalLength + spaceLength;
for (int i = 0; i < this.numberOfIntervals; i++)
{
var intervalToAdd = this.ToDateTimeInterval(this.now, i * intervalAndSpaceLength, ((i + 1) * intervalAndSpaceLength) - spaceLength);
container.Add(intervalToAdd);
}
}
public void Add_Interval(IIntervalContainer <DateTime> container)
{
const int intervalLength = 4;
const int spaceLength = 1;
const int intervalAndSpaceLength = intervalLength + spaceLength;
for (int i = 0; i < this.numberOfIntervals; i++)
{
var intervalToAdd = this.ToDateTimeInterval(this.now, i * intervalAndSpaceLength, ((i + 1) * intervalAndSpaceLength) - spaceLength);
container.Add(intervalToAdd);
}
}
public void Query_ForDifferentSideDateIntervals_ShoudReturnCorrectOverlapsCount(int leftEdgeMinutes, int rightEdgeMinutes, int expectedOverlapsCount)
{
//Arrange
#region Specification
// *************************************************************
// | X axis: |
// | 0 5 10 15 20 25 30 35 40 45 50 56|
// | | | | | | | | | | | | | |
// | Container intervals: |
// | [-------------] [-------------] [-------------] |
// | [-----] [-----] [-----] |
// | Test intervals: |
// | [-] |
// | [------] |
// | [----------------------] |
// | [---------------------------] |
// | [-------------------------------------------] |
// | [------------------------------------------------] |
// | [-------------------------------------------------------] |
// | [-] |
// | [------] |
// | [----------------------] |
// | [---------------------------] |
// | [-------------------------------------------] |
// | [------------------------------------------------] |
// | X axis: |
// | | | | | | | | | | | | | |
// | 0 5 10 15 20 25 30 35 40 45 50 56|
// *************************************************************
#endregion
var intervals = new List <Interval <DateTime> >();
intervals.Add(ToDateTimeInterval(now, 0, 14));
intervals.Add(ToDateTimeInterval(now, 4, 10));
intervals.Add(ToDateTimeInterval(now, 21, 35));
intervals.Add(ToDateTimeInterval(now, 25, 31));
intervals.Add(ToDateTimeInterval(now, 42, 56));
intervals.Add(ToDateTimeInterval(now, 46, 52));
IIntervalContainer <DateTime> intervalContainer = this.CreateIntervalContainer(intervals);
//Act
var overlaps = intervalContainer.Query(ToDateTimeInterval(now, leftEdgeMinutes, rightEdgeMinutes));
//Assert
Assert.AreEqual(expectedOverlapsCount, overlaps.Count());
}
private void RunQueryBenchmarkTestsForSquentialInterval(IIntervalContainer <DateTime> intervalContainer, int intervalLength, int intervalAndSpaceLength, int numberOfIntervals)
{
var beforeBeginnigResult = TestQueryForInterval(
ToDateTimeInterval(now, -2 * intervalLength, -intervalLength),
intervalContainer,
"Before The Beginning");
var atTheBeginnigResult = TestQueryForInterval(
ToDateTimeInterval(now, -1, 1),
intervalContainer,
"At The Beginning");
int middleIntervalIndex = numberOfIntervals / 2;
var inTheMiddleResult = TestQueryForInterval(
ToDateTimeInterval(now, (middleIntervalIndex) * intervalAndSpaceLength, ((middleIntervalIndex) + 1) * intervalAndSpaceLength - 1),
intervalContainer,
"In The Middle");
var atTheEndResult = TestQueryForInterval(
ToDateTimeInterval(now, (numberOfIntervals - 1) * intervalAndSpaceLength, numberOfIntervals * intervalAndSpaceLength),
intervalContainer,
"At The End");
var afterTheEndResult = TestQueryForInterval(
ToDateTimeInterval(now, (numberOfIntervals + 1) * intervalAndSpaceLength, (numberOfIntervals + 2) * intervalAndSpaceLength),
intervalContainer,
"After The End");
Assert.AreEqual(0, beforeBeginnigResult.Count());
Assert.AreEqual(1, atTheBeginnigResult.Count());
Assert.AreEqual(1, inTheMiddleResult.Count());
Assert.AreEqual(1, atTheEndResult.Count());
Assert.AreEqual(0, afterTheEndResult.Count());
}
private void AddRemovedIntervals(IIntervalContainer <DateTime> intervalContainer, List <Interval <DateTime> > intervals)
{
stopwatch.Reset();
long initalMemory = GC.GetTotalMemory(true);
stopwatch.Start();
//add second part of intervals
int halfNumberOfIntervals = intervals.Count / 2;
for (int i = 0; i < halfNumberOfIntervals; i++)
{
intervalContainer.Add(intervals[halfNumberOfIntervals + i]);
}
stopwatch.Stop();
long endAddIntervalsMemory = GC.GetTotalMemory(true);
long bytesUsed = endAddIntervalsMemory - initalMemory;
timeEllapsedReport.AppendLine();
timeEllapsedReport.AppendLine(string.Format("Time taken for adding {0} intervals: {1} ms", halfNumberOfIntervals, stopwatch.ElapsedMilliseconds));
timeEllapsedReport.AppendLine(string.Format("Memory used for adding {0} intervals: {1:0.00} MB", halfNumberOfIntervals, BytesToMegabytes(bytesUsed)));
timeEllapsedReport.AppendLine();
}
public void SetUp(int testIndex, IIntervalContainer <DateTime> intervalContainer)
{
this.numberOfIntervals = this.CollectionCount(testIndex);
}
private IEnumerable <IInterval <DateTime> > TestQueryForInterval(Interval <DateTime> intervalToQuery, IIntervalContainer <DateTime> queryIn, string testName)
{
stopwatch.Reset();
stopwatch.Start();
var foundIntervals = queryIn.Query(intervalToQuery).ToList();
stopwatch.Stop();
timeEllapsedReport.AppendLine(string.Format("Time taken for {0}: {1} ms", testName, stopwatch.ElapsedMilliseconds));
return(foundIntervals);
}
public void Query_MidInterval(IIntervalContainer<DateTime> container)
{
Interval<DateTime> queryInterval = this.ToDateTimeInterval(DateTime.Now, -1, 1);
container.Query(queryInterval).ToList();
}
private void RunQueryBenchmarkTestsForSquentialInterval(IIntervalContainer<DateTime> intervalContainer, int intervalLength, int intervalAndSpaceLength, int numberOfIntervals)
{
var beforeBeginnigResult = TestQueryForInterval(
ToDateTimeInterval(now, -2 * intervalLength, -intervalLength),
intervalContainer,
"Before The Beginning");
var atTheBeginnigResult = TestQueryForInterval(
ToDateTimeInterval(now, -1, 1),
intervalContainer,
"At The Beginning");
int middleIntervalIndex = numberOfIntervals / 2;
var inTheMiddleResult = TestQueryForInterval(
ToDateTimeInterval(now, (middleIntervalIndex) * intervalAndSpaceLength, ((middleIntervalIndex) + 1) * intervalAndSpaceLength - 1),
intervalContainer,
"In The Middle");
var atTheEndResult = TestQueryForInterval(
ToDateTimeInterval(now, (numberOfIntervals - 1) * intervalAndSpaceLength, numberOfIntervals * intervalAndSpaceLength),
intervalContainer,
"At The End");
var afterTheEndResult = TestQueryForInterval(
ToDateTimeInterval(now, (numberOfIntervals + 1) * intervalAndSpaceLength, (numberOfIntervals + 2) * intervalAndSpaceLength),
intervalContainer,
"After The End");
Assert.AreEqual(0, beforeBeginnigResult.Count());
Assert.AreEqual(1, atTheBeginnigResult.Count());
Assert.AreEqual(1, inTheMiddleResult.Count());
Assert.AreEqual(1, atTheEndResult.Count());
Assert.AreEqual(0, afterTheEndResult.Count());
}
public void SetUp(int testIndex, IIntervalContainer<DateTime> intervalContainer)
{
this.numberOfIntervals = this.CollectionCount(testIndex);
}
public void Query_MinToMaxSpanningInterval(IIntervalContainer <DateTime> container)
{
Interval <DateTime> queryInterval = this.ToDateTimeInterval(DateTime.Now, -this.numberOfIntervals, this.numberOfIntervals);
container.Query(queryInterval).ToList();
}
public void Query_RigthEndInterval(IIntervalContainer<DateTime> container)
{
Interval<DateTime> queryInterval = this.ToDateTimeInterval(DateTime.Now, this.numberOfIntervals - 1, this.numberOfIntervals);
container.Query(queryInterval).ToList();
}
public void Query_MinToMaxSpanningInterval(IIntervalContainer<DateTime> container)
{
Interval<DateTime> queryInterval = this.ToDateTimeInterval(DateTime.Now, -this.numberOfIntervals, this.numberOfIntervals);
container.Query(queryInterval).ToList();
}
private void RemoveHalfOfIntervals(IIntervalContainer<DateTime> intervalContainer, List<Interval<DateTime>> intervals)
{
stopwatch.Reset();
long initalMemory = GC.GetTotalMemory(true);
stopwatch.Start();
//remove second part of intervals
int halfNumberOfIntervals = intervals.Count / 2;
for (int i = 0; i < halfNumberOfIntervals; i++)
{
intervalContainer.Remove(intervals[halfNumberOfIntervals + i]);
}
stopwatch.Stop();
long endRemoveIntervalsMemory = GC.GetTotalMemory(true);
long bytesUsed = endRemoveIntervalsMemory - initalMemory;
timeEllapsedReport.AppendLine();
timeEllapsedReport.AppendLine(string.Format("Time taken for removing {0} intervals: {1} ms", halfNumberOfIntervals, stopwatch.ElapsedMilliseconds));
timeEllapsedReport.AppendLine(string.Format("Memory used for removing {0} intervals: {1:0.00} MB", halfNumberOfIntervals, BytesToMegabytes(bytesUsed)));
timeEllapsedReport.AppendLine();
}
public void Query_MidInterval(IIntervalContainer <DateTime> container)
{
Interval <DateTime> queryInterval = this.ToDateTimeInterval(DateTime.Now, -1, 1);
container.Query(queryInterval).ToList();
}
private IEnumerable<IInterval<DateTime>> TestQueryForInterval(Interval<DateTime> intervalToQuery, IIntervalContainer<DateTime> queryIn, string testName)
{
stopwatch.Reset();
stopwatch.Start();
var foundIntervals = queryIn.Query(intervalToQuery).ToList();
stopwatch.Stop();
timeEllapsedReport.AppendLine(string.Format("Time taken for {0}: {1} ms", testName, stopwatch.ElapsedMilliseconds));
return foundIntervals;
}
public void Query_RigthEndInterval(IIntervalContainer <DateTime> container)
{
Interval <DateTime> queryInterval = this.ToDateTimeInterval(DateTime.Now, this.numberOfIntervals - 1, this.numberOfIntervals);
container.Query(queryInterval).ToList();
}
