210 lines
7.4 KiB
Java
210 lines
7.4 KiB
Java
package ch.epfl.alpano;
|
|
|
|
import static ch.epfl.test.ObjectTest.hashCodeIsCompatibleWithEquals;
|
|
import static ch.epfl.test.TestRandomizer.RANDOM_ITERATIONS;
|
|
import static ch.epfl.test.TestRandomizer.newRandom;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertTrue;
|
|
|
|
import java.util.Random;
|
|
|
|
import org.junit.Test;
|
|
|
|
public class Interval2DTestP {
|
|
private static Interval2D newInterval2D(int x1, int x2, int y1, int y2) {
|
|
return new Interval2D(new Interval1D(x1, x2), new Interval1D(y1, y2));
|
|
}
|
|
|
|
private static Interval2D i_0_10_0_10() {
|
|
return newInterval2D(0, 10, 0, 10);
|
|
}
|
|
|
|
private static Interval2D i_0_9_0_11() {
|
|
return newInterval2D(0, 9, 0, 11);
|
|
}
|
|
|
|
private static Interval2D i_0_10_11_20() {
|
|
return newInterval2D(0, 10, 11, 20);
|
|
}
|
|
|
|
private static Interval2D i_0_10_0_20() {
|
|
return newInterval2D(0, 10, 0, 20);
|
|
}
|
|
|
|
private static Interval2D i_11_20_0_10() {
|
|
return newInterval2D(11, 20, 0, 10);
|
|
}
|
|
|
|
private static Interval2D i_0_20_0_10() {
|
|
return newInterval2D(0, 20, 0, 10);
|
|
}
|
|
|
|
private static Interval2D i_2_2_2_2() {
|
|
return newInterval2D(2, 2, 2, 2);
|
|
}
|
|
|
|
@Test(expected = NullPointerException.class)
|
|
public void constructorFailsOnInvalidInterval() {
|
|
new Interval2D(null, null);
|
|
}
|
|
|
|
@Test
|
|
public void containsWorksOnKnownIntervals() {
|
|
Interval2D i = i_2_2_2_2();
|
|
for (int x = 1; x <= 3; ++x) {
|
|
for (int y = 1; y <= 3; ++y) {
|
|
assertEquals(x == 2 && y == 2, i.contains(x, y));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void sizeWorksOnKnownIntervals() {
|
|
assertEquals(1, i_2_2_2_2().size());
|
|
assertEquals(21 * 11, i_0_20_0_10().size());
|
|
assertEquals(10 * 11, i_11_20_0_10().size());
|
|
}
|
|
|
|
@Test
|
|
public void sizeOfIntersectionWorksOnNonIntersectingIntervals() {
|
|
assertEquals(0, i_2_2_2_2().sizeOfIntersectionWith(i_11_20_0_10()));
|
|
assertEquals(0, i_11_20_0_10().sizeOfIntersectionWith(i_2_2_2_2()));
|
|
}
|
|
|
|
@Test
|
|
public void sizeOfIntersectionWorksOnIntersectingIntervals() {
|
|
assertEquals(1, i_2_2_2_2().sizeOfIntersectionWith(i_2_2_2_2()));
|
|
assertEquals(21 * 11, i_0_20_0_10().sizeOfIntersectionWith(i_0_20_0_10()));
|
|
assertEquals(1, i_2_2_2_2().sizeOfIntersectionWith(i_0_20_0_10()));
|
|
assertEquals(1, i_0_20_0_10().sizeOfIntersectionWith(i_2_2_2_2()));
|
|
assertEquals(10 * 11, i_0_10_0_10().sizeOfIntersectionWith(i_0_9_0_11()));
|
|
}
|
|
|
|
@Test
|
|
public void boudingUnionWorksOnKnownIntervals() {
|
|
assertEquals(i_2_2_2_2(), i_2_2_2_2().boundingUnion(i_2_2_2_2()));
|
|
|
|
Interval2D i1 = i_0_10_0_10().boundingUnion(i_0_9_0_11());
|
|
assertEquals(0, i1.iX().includedFrom());
|
|
assertEquals(10, i1.iX().includedTo());
|
|
assertEquals(0, i1.iY().includedFrom());
|
|
assertEquals(11, i1.iY().includedTo());
|
|
|
|
Interval2D i2 = i_2_2_2_2().boundingUnion(i_11_20_0_10());
|
|
assertEquals(2, i2.iX().includedFrom());
|
|
assertEquals(20, i2.iX().includedTo());
|
|
assertEquals(0, i2.iY().includedFrom());
|
|
assertEquals(10, i2.iY().includedTo());
|
|
}
|
|
|
|
@Test
|
|
public void isUnionableWorksOnKnownUnionableIntervals() {
|
|
assertTrue(i_0_10_0_10().isUnionableWith(i_0_10_0_10()));
|
|
assertTrue(i_0_10_0_10().isUnionableWith(i_0_10_11_20()));
|
|
assertTrue(i_0_10_11_20().isUnionableWith(i_0_10_0_10()));
|
|
assertTrue(i_0_10_0_10().isUnionableWith(i_11_20_0_10()));
|
|
assertTrue(i_11_20_0_10().isUnionableWith(i_0_10_0_10()));
|
|
assertTrue(i_0_10_0_10().isUnionableWith(i_2_2_2_2()));
|
|
assertTrue(i_2_2_2_2().isUnionableWith(i_0_10_0_10()));
|
|
}
|
|
|
|
@Test
|
|
public void isUnionableWorksOnKnownNonUnionableIntervals() {
|
|
assertFalse(i_2_2_2_2().isUnionableWith(i_11_20_0_10()));
|
|
assertFalse(i_11_20_0_10().isUnionableWith(i_2_2_2_2()));
|
|
assertFalse(i_0_9_0_11().isUnionableWith(i_0_10_0_10()));
|
|
assertFalse(i_0_10_0_10().isUnionableWith(i_0_9_0_11()));
|
|
}
|
|
|
|
@Test
|
|
public void isUnionableWithIsReflexive() {
|
|
Random rng = newRandom();
|
|
for (int i = 0; i < RANDOM_ITERATIONS; ++i) {
|
|
Interval2D interval = nextInterval(rng, 500, 1000);
|
|
assertTrue(interval.isUnionableWith(interval));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void isUnionableWithIsSymmetric() {
|
|
Random rng = newRandom();
|
|
for (int i = 0; i < RANDOM_ITERATIONS; ++i) {
|
|
Interval2D i1 = nextInterval(rng, 5, 10);
|
|
Interval2D i2 = nextInterval(rng, 5, 10);
|
|
assertTrue(! i1.isUnionableWith(i2) || i2.isUnionableWith(i1));
|
|
}
|
|
}
|
|
|
|
@Test(expected = IllegalArgumentException.class)
|
|
public void unionFailsOnNonUnionableIntervals() {
|
|
i_2_2_2_2().union(i_11_20_0_10());
|
|
}
|
|
|
|
@Test
|
|
public void unionWorksOnASingleInterval() {
|
|
assertEquals(i_0_10_0_10(), i_0_10_0_10().union(i_0_10_0_10().union(i_0_10_0_10())));
|
|
}
|
|
|
|
@Test
|
|
public void unionWorksOnKnownIntervals() {
|
|
assertEquals(i_0_10_0_10(), i_0_10_0_10().union(i_2_2_2_2()));
|
|
assertEquals(i_0_10_0_10(), i_2_2_2_2().union(i_0_10_0_10()));
|
|
|
|
assertEquals(i_0_10_0_20(), i_0_10_0_10().union(i_0_10_11_20()));
|
|
assertEquals(i_0_10_0_20(), i_0_10_11_20().union(i_0_10_0_10()));
|
|
|
|
assertEquals(i_0_20_0_10(), i_0_10_0_10().union(i_11_20_0_10()));
|
|
assertEquals(i_0_20_0_10(), i_11_20_0_10().union(i_0_10_0_10()));
|
|
}
|
|
|
|
@Test
|
|
public void unionIsCommutative() {
|
|
Random rng = newRandom();
|
|
for (int i = 0; i < RANDOM_ITERATIONS; ++i) {
|
|
Interval2D i1 = nextInterval(rng, 5, 10);
|
|
Interval2D i2 = nextInterval(rng, 5, 10);
|
|
if (i1.isUnionableWith(i2))
|
|
assertEquals(i1.union(i2), i2.union(i1));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void equalsIsStructural() {
|
|
Random rng = newRandom();
|
|
for (int i = 0; i < RANDOM_ITERATIONS; ++i) {
|
|
int x1 = rng.nextInt(1000) - 500;
|
|
int x2 = x1 + rng.nextInt(1000);
|
|
int y1 = rng.nextInt(1000) - 500;
|
|
int y2 = y1 + rng.nextInt(1000);
|
|
Interval2D int1 = newInterval2D(x1, x2, y1, y2);
|
|
Interval2D int2 = newInterval2D(x1, x2, y1, y2);
|
|
Interval2D int3 = newInterval2D(x1, x2, y1, y2 + 1);
|
|
assertTrue(int1.equals(int2));
|
|
assertTrue(int2.equals(int1));
|
|
assertFalse(int1.equals(int3));
|
|
assertFalse(int3.equals(int1));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void hashCodeAndEqualsAreCompatible() {
|
|
Random rng = newRandom();
|
|
for (int i = 0; i < RANDOM_ITERATIONS; ++i) {
|
|
int a = rng.nextInt(1000) - 500, b = a + rng.nextInt(20);
|
|
int c = rng.nextInt(1000) - 500, d = c + rng.nextInt(20);
|
|
Interval2D i1 = newInterval2D(a, b, c, d);
|
|
Interval2D i1b = newInterval2D(a, b, c, d);
|
|
Interval2D i2 = newInterval2D(a, b, c, d + 1);
|
|
assertTrue(hashCodeIsCompatibleWithEquals(i1, i1b));
|
|
assertTrue(hashCodeIsCompatibleWithEquals(i1, i2));
|
|
}
|
|
}
|
|
|
|
private Interval2D nextInterval(Random rng, int maxOffset, int maxSize) {
|
|
int offsetX = rng.nextInt(maxOffset), offsetY = rng.nextInt(maxOffset);
|
|
int sizeX = rng.nextInt(maxSize), sizeY = rng.nextInt(maxSize);
|
|
return newInterval2D(-offsetX, sizeX - offsetX, -offsetY, sizeY - offsetY);
|
|
}
|
|
}
|