diff --git a/src/main/java/ch/zhaw/pm2/racetrack/UserInterface.java b/src/main/java/ch/zhaw/pm2/racetrack/UserInterface.java deleted file mode 100644 index d800a95..0000000 --- a/src/main/java/ch/zhaw/pm2/racetrack/UserInterface.java +++ /dev/null @@ -1,94 +0,0 @@ -package ch.zhaw.pm2.racetrack; - -import org.beryx.textio.TextIO; -import org.beryx.textio.TextIoFactory; -import org.beryx.textio.TextTerminal; - -import java.util.List; - -public class UserInterface { - - private final TextIO textIO; - private final TextTerminal textTerminal; - - /** - * Opens a new Terminal Window and prints the welcome Text - * @param welcomeText The Text which will be printed after the windows is opened. - */ - public UserInterface(String welcomeText) { - textIO = TextIoFactory.getTextIO(); - textTerminal = textIO.getTextTerminal(); - - textTerminal.println(welcomeText + "\n"); - } - - /** - * asks the user to choose one of the options given. - * @param text Text which is printed befor the options are printed. Example: "Select Track file:" - * @param options List with the options which can be selected. - * @return the list index of the selected option - */ - public int selectOption(String text, List options) { - textTerminal.println(text + ":\n"); - for(int option = 0; option < options.size(); option ++) { - textTerminal.println(" " + (option + 1) + ": " + options.get(option)); - } - return textIO.newIntInputReader().withMinVal(1).withMaxVal(options.size()).read("Enter your choice: ") - 1; - } - - /** - * gives information which player's turn it is and asks for the direction to accelerate - * @param playingCarIndex the index of the player - * @param playingCarID the ID of the player - * @return the direction which is selected by the player. If null -> quit game - */ - public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) { - PositionVector.Direction direction = null; - textTerminal.println("Playing Car " + playingCarIndex + ": " + playingCarIndex); - textTerminal.println("Directions are based on the number pad:"); - textTerminal.println("7 8 9 7=up-left, 8=up, 9=up-right"); - textTerminal.println("4 5 6 4=left, 5=no acceleration, 6=right"); - textTerminal.println("1 2 3 1=down-left, 2=down, 3=down-right"); - textTerminal.println("\n10 = quit \n"); - - while (direction == null) { //asks until a valid input in entered - int number = textIO.newIntInputReader().withMinVal(1).withMaxVal(10).read("choose your Acceleration direction: "); - if (number == 10) { //quit game - return null; - } - direction = getDirection(number); - } - return direction; - } - - /** - * returns the the associated direction Object - * @param number the number which was typed by the user - * @return the associated direction. If null -> unknown number - */ - private PositionVector.Direction getDirection(int number) { - return switch (number) { - case 1 -> PositionVector.Direction.DOWN_LEFT; - case 2 -> PositionVector.Direction.DOWN; - case 3 -> PositionVector.Direction.DOWN_RIGHT; - case 4 -> PositionVector.Direction.LEFT; - case 5 -> PositionVector.Direction.NONE; - case 6 -> PositionVector.Direction.RIGHT; - case 7 -> PositionVector.Direction.UP_LEFT; - case 8 -> PositionVector.Direction.UP; - case 9 -> PositionVector.Direction.UP_RIGHT; - default -> null; - }; - } - - /** - * prints the given Track in the terminal - * @param track the track which should be printed - */ - public void printTrack(Track track) { - textTerminal.println(track.toString()); - } - - - -} diff --git a/src/test/java/ch/zhaw/pm2/racetrack/CarTest.java b/src/test/java/ch/zhaw/pm2/racetrack/CarTest.java new file mode 100644 index 0000000..89b1965 --- /dev/null +++ b/src/test/java/ch/zhaw/pm2/racetrack/CarTest.java @@ -0,0 +1,191 @@ + +package ch.zhaw.pm2.racetrack; + +import ch.zhaw.pm2.racetrack.strategy.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for Class Car + */ +class CarTest { + + Car car; + + // Default coordinates for tests + int DEFAULT_X = 10; + int DEFAULT_Y = 10; + char DEFAULT_ID = 'f'; + + /** + * Create a new Car Object and set Position to a defined Default Position + */ + @BeforeEach + void setUp() { + car = new Car(DEFAULT_ID, new PositionVector(DEFAULT_X, DEFAULT_Y)); + } + + @Test + void getID() { + assertEquals(DEFAULT_ID, car.getID()); + } + + /** + * Method to check nextPosition with coordinates as int + * + * @param x the expected value for x coordinate + * @param y the expected value for y coordinate + */ + void checkNextPosition(int x, int y) { + assertEquals(new PositionVector(x, y), car.nextPosition()); + } + + /** + * - checks if the position of the car can be set and saved correctly with valid positions. + * - checks if an exception is throwed and position keeps unchanged if invalid coordinates are entered. + */ + @Test + void setPosition() { + checkNextPosition(DEFAULT_X, DEFAULT_Y); + + // List of valid Positions + List validPositions = new ArrayList<>(); + validPositions.add(new PositionVector(20, 20)); + validPositions.add(new PositionVector(0, 0)); + validPositions.add(new PositionVector(20, 0)); + validPositions.add(new PositionVector(0, 20)); + + for (PositionVector positionVector : validPositions) { + car.setPosition(positionVector); + assertEquals(positionVector, car.nextPosition()); + } + + // List of invalid positions. + List invalidPositions = new ArrayList<>(); + invalidPositions.add(new PositionVector(0, -20)); + invalidPositions.add(new PositionVector(-20, 0)); + invalidPositions.add(new PositionVector(-20, -20)); + + for (PositionVector positionVector : invalidPositions) { + boolean exception = false; + setUp(); + try { + car.setPosition(positionVector); + } catch (IllegalArgumentException e) { + exception = true; + } + assertTrue(exception); + + // position should keep unchanged + checkNextPosition(DEFAULT_X, DEFAULT_Y); + } + } + + void checkVelocity(int x, int y) { + assertEquals(new PositionVector(x, y), car.getVelocity()); + } + + + /** + * Checks if the methods accelerate, move and getVelocity are working correctly with acceleration in all directions. + * Checks also if velocity is calculated correctly if method accelerate is called a second time. + */ + @Test + void movement() { + // add all possible directions in a List + List directions = Arrays.asList(PositionVector.Direction.values()); + + //position shouldn't be changed because velocity should be 0. + car.move(); + checkNextPosition(DEFAULT_X, DEFAULT_Y); + + + + for (PositionVector.Direction direction1 : directions) { + for (PositionVector.Direction direction2 : directions) { + + //create a new instance of Car with default coordinates and velocity 0. + setUp(); + + //variables to save the actual expected result of method nextPosition + int expectedNextPosX = DEFAULT_X; + int expectedNextPosY = DEFAULT_Y; + + //variables to save the acutal expected result of method getVelocity + int expectedVelocityX = 0; + int expectedVelocityY = 0; + + car.accelerate(direction1); + expectedVelocityX += direction1.vector.getX(); + expectedVelocityY += direction1.vector.getY(); + expectedNextPosX += direction1.vector.getX(); + expectedNextPosY += direction1.vector.getY(); + checkVelocity(expectedVelocityX, expectedVelocityY); + checkNextPosition(expectedNextPosX, expectedNextPosY); + + car.move(); + expectedNextPosX += direction1.vector.getX(); + expectedNextPosY += direction1.vector.getY(); + checkVelocity(expectedVelocityX, expectedVelocityY); + checkNextPosition(expectedNextPosX, expectedNextPosY); + + + car.accelerate(direction2); + expectedVelocityX += direction2.vector.getX(); + expectedVelocityY += direction2.vector.getY(); + expectedNextPosX += direction2.vector.getX(); + expectedNextPosY += direction2.vector.getY(); + checkVelocity(expectedVelocityX, expectedVelocityY); + checkNextPosition(expectedNextPosX, expectedNextPosY); + + car.move(); + checkVelocity(expectedVelocityX, expectedVelocityY); + expectedNextPosX += (direction1.vector.getX() + direction2.vector.getX()); + expectedNextPosY += (direction1.vector.getY() + direction2.vector.getY()); + checkNextPosition(expectedNextPosX, expectedNextPosY); + } + } + } + + + /** + * test for methods crash and isCrashed. checks if state crashed is set and returned correctly. + */ + @Test + void crash() { + assertFalse(car.isCrashed()); + car.crash(); + assertTrue(car.isCrashed()); + } + + /** + * test for methods setMoveStrategy. Checks if the MoveStrategy Object is saved and returned correctly + * with all Types of MoveStrategy. + */ + @Test + void MoveStrategy() { + MoveStrategy moveStrategy; + + moveStrategy = new DoNotMoveStrategy(); + car.setMoveStrategy(moveStrategy); + assertEquals(moveStrategy, car.getMoveStrategy()); + + moveStrategy = new MoveListStrategy(); + car.setMoveStrategy(moveStrategy); + assertEquals(moveStrategy, car.getMoveStrategy()); + + moveStrategy = new PathFollowerMoveStrategy(); + car.setMoveStrategy(moveStrategy); + assertEquals(moveStrategy, car.getMoveStrategy()); + + moveStrategy = new UserMoveStrategy(); + car.setMoveStrategy(moveStrategy); + assertEquals(moveStrategy, car.getMoveStrategy()); + } +}