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)); }