package games.strategy.triplea.ui.logic;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import games.strategy.triplea.ui.MapPanel;
import games.strategy.triplea.ui.mapdata.MapData;
@RunWith(MockitoJUnitRunner.class)
public class RouteCalculatorTest {
@Mock
private MapPanel mapPanel;
@Mock
private MapData mapData;
@Test
public void testRouteTranslation() {
Point[] inputArray = new Point[] {point(1, 4), point(1001, 1001), point(600, 600)};
assertArrayEquals(new Point[] {point(1, 4), point(1, 1), point(-400, -400)},
new RouteCalculator(true, true, 1000, 1000).getTranslatedRoute(inputArray));
assertArrayEquals(new Point[] {point(1, 4), point(1, 1001), point(-400, 600)},
new RouteCalculator(true, false, 1000, 1000).getTranslatedRoute(inputArray));
assertArrayEquals(new Point[] {point(1, 4), point(1001, 1), point(600, -400)},
new RouteCalculator(false, true, 1000, 1000).getTranslatedRoute(inputArray));
assertArrayEquals(inputArray, new RouteCalculator(false, false, 1000, 1000).getTranslatedRoute(inputArray));
}
private static Point point(double x, double y) {
return new Point(x, y);
}
@Test
public void testClosestPoint() {
Point origin = new Point();
Point closestPoint = new Point(1, 1);
List<Point> pool = new ArrayList<>();
for (int i = 0; i < 9; i++) {
pool.add(point((int) (Math.random() * 1000 + 1), (int) (Math.random() * 1000 + 1)));
}
pool.add(closestPoint);
assertEquals(closestPoint, RouteCalculator.getClosestPoint(origin, pool));
}
@Test
public void testPossiblePoints() {
List<Point> possiblePoints = new ArrayList<>();
// The values below must be all combinations of
// x and y values 0, -mapWidth/height, +mapWidth/Height
possiblePoints.add(point(-1000, -1000));
possiblePoints.add(point(-1000, 0));
possiblePoints.add(point(-1000, 1000));
possiblePoints.add(point(0, -1000));
possiblePoints.add(point(0, 0));
possiblePoints.add(point(0, 1000));
possiblePoints.add(point(1000, -1000));
possiblePoints.add(point(1000, 0));
possiblePoints.add(point(1000, 1000));
checkPoints(0, possiblePoints, true, true);
checkPoints(6, possiblePoints, true, false);
checkPoints(6, possiblePoints, false, true);
checkPoints(8, possiblePoints, false, false);
}
private void checkPoints(int offset, List<Point> expected, boolean isInfiniteX, boolean isInfiniteY) {
List<Point> calculatedPoints =
new RouteCalculator(isInfiniteX, isInfiniteY, 1000, 1000).getPossiblePoints(new Point());
assertEquals(expected.size(), calculatedPoints.size() + offset);
for (Point point : calculatedPoints) {
assertTrue(expected.contains(point));
}
}
@Test
public void testMatrixTransposal() {
final Point[] input = new Point[] {point(0, 0), point(1, 1)};
final Point[] nw = new Point[] {point(-1000, -1000), point(-999, -999)};
final Point[] n = new Point[] {point(0, -1000), point(1, -999)};
final Point[] ne = new Point[] {point(1000, -1000), point(1001, -999)};
final Point[] w = new Point[] {point(-1000, 0), point(-999, 1)};
final Point[] e = new Point[] {point(1000, 0), point(1001, 1)};
final Point[] sw = new Point[] {point(-1000, 1000), point(-999, 1001)};
final Point[] s = new Point[] {point(0, 1000), point(1, 1001)};
final Point[] se = new Point[] {point(1000, 1000), point(1001, 1001)};
List<Point[]> points = new RouteCalculator(true, true, 1000, 1000).getAllPoints(input);
// This may be changed along with the RouteOptimizer#getPossiblePoints method
assertArrayEquals(input, points.get(0));
assertArrayEquals(nw, points.get(1));
assertArrayEquals(sw, points.get(2));
assertArrayEquals(ne, points.get(3));
assertArrayEquals(se, points.get(4));
assertArrayEquals(w, points.get(5));
assertArrayEquals(e, points.get(6));
assertArrayEquals(n, points.get(7));
assertArrayEquals(s, points.get(8));
}
}