public void Length(int start, int end, long expectedLength)
{
// Arrange
var sut = new IntervalInt32(start, end);
// Assert
Assert.That(sut.Length, Is.EqualTo(expectedLength));
Assert.That(sut.IsEmpty, Is.EqualTo(expectedLength == 0));
}
/// <summary>
/// Splits the interval into two.
/// </summary>
/// <param name="interval">The interval to split.</param>
/// <param name="splitAt">Where to split the interval at.</param>
/// <returns>A tuple with the resulting two intervals.</returns>
public static Tuple<IntervalInt32, IntervalInt32> Split(IntervalInt32 interval, int splitAt)
{
#region Contract
Contract.Requires<ArgumentOutOfRangeException>(interval.Contains(splitAt) || splitAt == interval.End);
#endregion
return Tuple.Create(new IntervalInt32(interval.Start, splitAt), new IntervalInt32(splitAt, interval.End));
}
/// <summary>
/// Merges two overlapping intervals into one.
/// </summary>
/// <param name="x">The first interval to merge.</param>
/// <param name="y">The second interval to merge.</param>
/// <returns>The merged interval.</returns>
public static IntervalInt32 Merge(IntervalInt32 x, IntervalInt32 y)
{
#region Contract
Contract.Requires<ArgumentNullException>(x.Intersects(y) || x.End == y.Start);
#endregion
int start = Math.Min(x.Start, y.Start);
int end = x.End != Int32.MinValue && y.End != Int32.MinValue ? Math.Max(x.End, y.End) : Int32.MinValue;
return new IntervalInt32(start, end);
}
public bool Intersects(IntervalInt32 other)
{
if (this.End != Int32.MinValue && other.End != Int32.MinValue)
return this.Start < other.End && other.Start < this.End;
else if (other.End != Int32.MinValue)
return this.Start < other.End;
else if (this.End != Int32.MinValue)
return other.Start < this.End;
else
return true;
}
/// <inheritdoc />
public bool Equals(IntervalInt32 other)
{
return this.Start == other.Start
&& this.End == other.End;
}
public void Contains(int start, int end, int value, bool expectedResult)
{
// Arrange
var sut = new IntervalInt32(start, end);
// Act
bool contains = sut.Contains(value);
// Assert
Assert.That(contains, Is.EqualTo(expectedResult));
}
public void WithLength(int start, int length, int expectedEnd)
{
// Arrange
var expected = new IntervalInt32(start, expectedEnd);
// Act
var result = IntervalInt32.WithLength(start, length);
// Assert
Assert.That(result, Is.EqualTo(expected));
}
public void Split(int start, int end, int splitAt)
{
// Arrange
var sut = new IntervalInt32(start, end);
var expected1 = new IntervalInt32(start, splitAt);
var expected2 = new IntervalInt32(splitAt, end);
// Act
var result = IntervalInt32.Split(sut, splitAt);
var mergedResult = IntervalInt32.Merge(result.Item1, result.Item2);
// Assert
Assert.That(result.Item1, Is.EqualTo(expected1));
Assert.That(result.Item2, Is.EqualTo(expected2));
Assert.That(mergedResult, Is.EqualTo(sut));
}
public void Merge(int xStart, int xEnd, int yStart, int yEnd, int expectedStart, int expectedEnd)
{
// Arrange
var x = new IntervalInt32(xStart, xEnd);
var y = new IntervalInt32(yStart, yEnd);
var expected = new IntervalInt32(expectedStart, expectedEnd);
// Act
var result = IntervalInt32.Merge(x, y);
// Assert
Assert.That(result, Is.EqualTo(expected));
}
public void Intersects(int xStart, int xEnd, int yStart, int yEnd, bool expectedResult)
{
// Arrange
var x = new IntervalInt32(xStart, xEnd);
var y = new IntervalInt32(yStart, yEnd);
// Act
bool intersects = x.Intersects(y);
bool intersects2 = y.Intersects(x);
// Assert
Assert.That(intersects, Is.EqualTo(expectedResult));
Assert.That(intersects, Is.EqualTo(intersects2));
}
