mirror of
https://athene2.informatik.unibw-muenchen.de/progproj/gruppen-ht24/Gruppe-02.git
synced 2026-10-06 12:01:23 +02:00
added contents
This commit is contained in:
Mark Minas
@@ -0,0 +1,157 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.game.client.ClientGameLogic;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Battleship.Status;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.Rotation;
|
||||
|
||||
import java.util.Properties;
|
||||
|
||||
import static java.util.Collections.emptyList;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
public class EditorTest {
|
||||
private static final BattleshipConfig CONFIG = new BattleshipConfig();
|
||||
|
||||
static {
|
||||
final Properties props = new Properties();
|
||||
props.setProperty("map.width", "10");
|
||||
props.setProperty("map.height", "10");
|
||||
props.setProperty("harbor.width", "6");
|
||||
props.setProperty("harbor.height", "10");
|
||||
props.setProperty("ship.nums", "1,1");
|
||||
CONFIG.readFrom(props);
|
||||
}
|
||||
|
||||
private ClientGameLogic logic;
|
||||
|
||||
private static IntPoint p(int x, int y) {
|
||||
return new IntPoint(x, y);
|
||||
}
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
logic = new ClientGameLogic(null);
|
||||
logic.received(new GameDetails(CONFIG));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInit() {
|
||||
assertEquals(emptyList(), logic.getOwnMap().getItems());
|
||||
assertEquals(2, logic.getHarbor().getItems().size());
|
||||
|
||||
final Battleship ship1 = (Battleship) logic.getHarbor().getItems().get(0);
|
||||
checkShip(ship1, 1, 0, 0, Rotation.RIGHT, Status.NORMAL);
|
||||
|
||||
final Battleship ship2 = (Battleship) logic.getHarbor().getItems().get(1);
|
||||
checkShip(ship2, 2, 0, 1, Rotation.RIGHT, Status.NORMAL);
|
||||
}
|
||||
|
||||
private void checkShip(Battleship ship, int length, int x, int y, Rotation rot, Status status) {
|
||||
assertEquals(length, ship.getLength());
|
||||
assertEquals(x, ship.getX());
|
||||
assertEquals(y, ship.getY());
|
||||
assertEquals(rot, ship.getRot());
|
||||
assertEquals(status, ship.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRun1() {
|
||||
logic.clickHarbor(p(0, 0));
|
||||
logic.clickOwnMap(p(0, 0)); // place ship 1 at (0,0)
|
||||
|
||||
assertEquals(1, logic.getOwnMap().getShips().count());
|
||||
assertEquals(1, logic.getHarbor().getShips().count());
|
||||
checkShip((Battleship) logic.getHarbor().getItems().get(0),
|
||||
2, 0, 1, Rotation.RIGHT, Status.NORMAL);
|
||||
checkShip((Battleship) logic.getOwnMap().getItems().get(0),
|
||||
1, 0, 0, Rotation.RIGHT, Status.NORMAL);
|
||||
assertEquals(logic.getOwnMap().findShipAt(0, 0), logic.getOwnMap().getShips().findFirst().get());
|
||||
assertNull(logic.getOwnMap().findShipAt(1, 0));
|
||||
assertNull(logic.getOwnMap().findShipAt(0, 1));
|
||||
|
||||
logic.clickOwnMap(p(0, 0)); // select ship1
|
||||
logic.clickHarbor(p(0, 0)); // return it to harbor
|
||||
|
||||
assertEquals(0, logic.getOwnMap().getShips().count());
|
||||
assertEquals(2, logic.getHarbor().getShips().count());
|
||||
|
||||
logic.clickHarbor(p(0, 0)); // select ship 1 in harbor
|
||||
logic.clickOwnMap(p(0, 0)); // place it at (0,0)
|
||||
|
||||
checkShip((Battleship) logic.getHarbor().getItems().get(0),
|
||||
2, 0, 1, Rotation.RIGHT, Status.NORMAL);
|
||||
checkShip((Battleship) logic.getOwnMap().getItems().get(0),
|
||||
1, 0, 0, Rotation.RIGHT, Status.NORMAL);
|
||||
|
||||
logic.clickHarbor(p(0, 1)); // select ship 2 in harbor
|
||||
logic.clickOwnMap(p(0, 0)); // try to place it at (0,0); this is too close to ship 1
|
||||
|
||||
assertEquals(2, logic.getOwnMap().getShips().count());
|
||||
assertEquals(1, logic.getHarbor().getShips().count());
|
||||
checkShip((Battleship) logic.getHarbor().getItems().get(0),
|
||||
2, 0, 1, Rotation.RIGHT, Status.VALID_PREVIEW);
|
||||
checkShip((Battleship) logic.getOwnMap().getItems().get(0),
|
||||
1, 0, 0, Rotation.RIGHT, Status.NORMAL);
|
||||
checkShip((Battleship) logic.getOwnMap().getItems().get(1),
|
||||
2, 0, 0, Rotation.RIGHT, Status.INVALID_PREVIEW);
|
||||
|
||||
logic.rotateShip(); // rotate selected ship 2
|
||||
logic.clickOwnMap(p(5, 5)); // place it at (5,5)
|
||||
|
||||
assertEquals(2, logic.getOwnMap().getShips().count());
|
||||
assertEquals(0, logic.getHarbor().getShips().count());
|
||||
checkShip((Battleship) logic.getOwnMap().getItems().get(0),
|
||||
1, 0, 0, Rotation.RIGHT, Status.NORMAL);
|
||||
checkShip((Battleship) logic.getOwnMap().getItems().get(1),
|
||||
2, 5, 5, Rotation.DOWN, Status.NORMAL);
|
||||
|
||||
assertEquals(logic.getOwnMap().getShips().toList().get(1), logic.getOwnMap().findShipAt(5, 5));
|
||||
assertEquals(logic.getOwnMap().getShips().toList().get(1), logic.getOwnMap().findShipAt(5, 4));
|
||||
assertTrue(logic.isMapComplete());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRun2() {
|
||||
logic.clickHarbor(p(0, 0));
|
||||
logic.clickOwnMap(p(9, 9)); // place ship 1 at (9,9)
|
||||
|
||||
assertEquals(1, logic.getOwnMap().getShips().count());
|
||||
assertEquals(1, logic.getHarbor().getShips().count());
|
||||
checkShip((Battleship) logic.getHarbor().getItems().get(0),
|
||||
2, 0, 1, Rotation.RIGHT, Status.NORMAL);
|
||||
checkShip((Battleship) logic.getOwnMap().getItems().get(0),
|
||||
1, 9, 9, Rotation.RIGHT, Status.NORMAL);
|
||||
|
||||
assertEquals(logic.getOwnMap().findShipAt(9, 9), logic.getOwnMap().getShips().findFirst().get());
|
||||
assertNull(logic.getOwnMap().findShipAt(10, 9));
|
||||
assertNull(logic.getOwnMap().findShipAt(9, 10));
|
||||
|
||||
assertFalse(logic.isMapComplete());
|
||||
|
||||
logic.clickHarbor(p(0, 1)); // select ship 2 in harbor of player 2
|
||||
logic.clickOwnMap(p(0, 0)); // place it at (0,0)
|
||||
|
||||
assertEquals(2, logic.getOwnMap().getShips().count());
|
||||
assertEquals(0, logic.getHarbor().getShips().count());
|
||||
assertEquals(logic.getOwnMap().getShips().toList().get(0), logic.getOwnMap().findShipAt(9, 9));
|
||||
assertEquals(logic.getOwnMap().getShips().toList().get(1), logic.getOwnMap().findShipAt(0, 0));
|
||||
assertEquals(logic.getOwnMap().getShips().toList().get(1), logic.getOwnMap().findShipAt(1, 0));
|
||||
assertTrue(logic.isMapComplete());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import org.junit.Before;
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Battleship.Status;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.Rotation;
|
||||
import pp.battleship.notification.GameEventListener;
|
||||
import pp.battleship.notification.InfoTextEvent;
|
||||
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.Deque;
|
||||
import java.util.logging.Handler;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.LogManager;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public abstract class AbstractClientGameTest {
|
||||
final Deque<String> infoTexts = new ArrayDeque<>();
|
||||
final Deque<ClientMessage> messages = new ArrayDeque<>();
|
||||
final ClientGameLogic clientLogic = new ClientGameLogic(messages::offer);
|
||||
|
||||
static {
|
||||
// Configure logging
|
||||
final Logger rootLogger = LogManager.getLogManager().getLogger("");
|
||||
rootLogger.setLevel(Level.WARNING);
|
||||
for (Handler h : rootLogger.getHandlers()) {
|
||||
h.setLevel(Level.WARNING);
|
||||
}
|
||||
}
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
clientLogic.addListener(new GameEventListener() {
|
||||
@Override
|
||||
public void receivedEvent(InfoTextEvent event) {
|
||||
infoTexts.offer(event.key());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
static IntPoint p(int x, int y) {
|
||||
return new IntPoint(x, y);
|
||||
}
|
||||
|
||||
void checkShip(Battleship ship, int length, int x, int y, Rotation rot, Status status) {
|
||||
assertEquals(length, ship.getLength());
|
||||
assertEquals(x, ship.getX());
|
||||
assertEquals(y, ship.getY());
|
||||
assertEquals(rot, ship.getRot());
|
||||
assertEquals(status, ship.getStatus());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,243 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import org.junit.Test;
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static pp.battleship.model.Battleship.Status.NORMAL;
|
||||
import static pp.battleship.model.Battleship.Status.VALID_PREVIEW;
|
||||
import static pp.battleship.model.Rotation.DOWN;
|
||||
import static pp.battleship.model.Rotation.RIGHT;
|
||||
|
||||
/**
|
||||
* Integration test cases for the client game logic of Player 1 in a small game, called "Game 1".
|
||||
* The test cases for Player 2 are contained in {@linkplain ClientGame1Player2Test}
|
||||
* and the test cases for the server in {@linkplain pp.battleship.game.server.ServerGame1Test}.
|
||||
*
|
||||
* @see ClientGame1Player2Test
|
||||
* @see pp.battleship.game.server.ServerGame1Test
|
||||
*/
|
||||
public class ClientGame1Player1Test extends AbstractClientGameTest {
|
||||
@Test
|
||||
public void testClient() {
|
||||
BattleshipConfig config;
|
||||
Properties props;
|
||||
List<Battleship> ships;
|
||||
MapMessage mapMsg;
|
||||
ShootMessage shootMsg;
|
||||
|
||||
config = new BattleshipConfig();
|
||||
props = new Properties();
|
||||
props.setProperty("map.width", "6");
|
||||
props.setProperty("map.height", "6");
|
||||
props.setProperty("harbor.width", "6");
|
||||
props.setProperty("harbor.height", "6");
|
||||
props.setProperty("ship.nums", "1,1");
|
||||
config.readFrom(props);
|
||||
clientLogic.received(new GameDetails(config));
|
||||
assertEquals("place.ships.in.your.map", infoTexts.poll());
|
||||
clientLogic.clickHarbor(p(0, 1));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(4, 1));
|
||||
clientLogic.movePreview(p(4, 1));
|
||||
clientLogic.movePreview(p(3, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(0, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
clientLogic.movePreview(p(2, 1));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.clickOwnMap(p(2, 1));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
clientLogic.clickHarbor(p(0, 0));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 5, 1, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.clickOwnMap(p(5, 1));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 5, 1, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(0, ships.size());
|
||||
clientLogic.mapFinished();
|
||||
mapMsg = (MapMessage) messages.poll();
|
||||
assertEquals(2, mapMsg.getShips().size());
|
||||
checkShip(mapMsg.getShips().get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
checkShip(mapMsg.getShips().get(1), 1, 5, 1, RIGHT, NORMAL);
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(new StartBattleMessage(true));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(3, 3));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(3, 3), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.miss(true, p(3, 3)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.miss(false, p(2, 2)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(1, 3));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(1, 3), shootMsg.getPosition());
|
||||
clientLogic.clickOpponentMap(p(1, 3));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(1, 3), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.miss(true, p(1, 3)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.hit(false, p(2, 1)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.shipDestroyed(false, p(3, 1), new Battleship(2, 2, 1, RIGHT)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.miss(false, p(5, 3)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(2, 3));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(2, 3), shootMsg.getPosition());
|
||||
clientLogic.clickOpponentMap(p(2, 3));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(2, 3), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.miss(true, p(2, 3)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.miss(false, p(3, 3)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(1, 4));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(1, 4), shootMsg.getPosition());
|
||||
clientLogic.clickOpponentMap(p(1, 4));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(1, 4), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.hit(true, p(1, 4)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.hit(true, p(1, 4)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(1, 5));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(1, 5), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.shipDestroyed(true, p(1, 5), new Battleship(2, 1, 5, DOWN)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
ships = clientLogic.getOpponentMap().getShips().toList();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 1, 5, DOWN, NORMAL);
|
||||
clientLogic.clickOpponentMap(p(2, 2));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(2, 2), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.miss(true, p(2, 2)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.lost(p(5, 1), new Battleship(1, 5, 1, RIGHT), List.of(new Battleship(1, 1, 2, RIGHT))));
|
||||
assertEquals("you.lost.the.game", infoTexts.poll());
|
||||
ships = clientLogic.getOpponentMap().getShips().toList();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 1, 5, DOWN, NORMAL);
|
||||
checkShip(ships.get(1), 1, 1, 2, RIGHT, NORMAL);
|
||||
|
||||
assertEquals(0, infoTexts.size());
|
||||
assertEquals(0, messages.size());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,389 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import org.junit.Test;
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static pp.battleship.model.Battleship.Status.NORMAL;
|
||||
import static pp.battleship.model.Battleship.Status.VALID_PREVIEW;
|
||||
import static pp.battleship.model.Rotation.DOWN;
|
||||
import static pp.battleship.model.Rotation.RIGHT;
|
||||
|
||||
/**
|
||||
* Integration test cases for the client game logic of Player 2 in a small game, called "Game 1".
|
||||
* The test cases for Player 1 are contained in {@linkplain ClientGame1Player1Test}
|
||||
* and the test cases for the server in {@linkplain pp.battleship.game.server.ServerGame1Test}.
|
||||
*
|
||||
* @see ClientGame1Player1Test
|
||||
* @see pp.battleship.game.server.ServerGame1Test
|
||||
*/
|
||||
public class ClientGame1Player2Test extends AbstractClientGameTest {
|
||||
@Test
|
||||
public void testClient() {
|
||||
BattleshipConfig config;
|
||||
Properties props;
|
||||
List<Battleship> ships;
|
||||
MapMessage mapMsg;
|
||||
ShootMessage shootMsg;
|
||||
|
||||
config = new BattleshipConfig();
|
||||
props = new Properties();
|
||||
props.setProperty("map.width", "6");
|
||||
props.setProperty("map.height", "6");
|
||||
props.setProperty("harbor.width", "6");
|
||||
props.setProperty("harbor.height", "6");
|
||||
props.setProperty("ship.nums", "1,1");
|
||||
config.readFrom(props);
|
||||
clientLogic.received(new GameDetails(config));
|
||||
assertEquals("place.ships.in.your.map", infoTexts.poll());
|
||||
clientLogic.clickHarbor(p(1, 1));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(3, 3));
|
||||
clientLogic.movePreview(p(3, 3));
|
||||
clientLogic.movePreview(p(3, 3));
|
||||
clientLogic.movePreview(p(3, 3));
|
||||
clientLogic.movePreview(p(2, 3));
|
||||
clientLogic.movePreview(p(2, 3));
|
||||
clientLogic.movePreview(p(2, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 2, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.clickOwnMap(p(2, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 2, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, NORMAL);
|
||||
clientLogic.clickHarbor(p(0, 0));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 1));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 5, 2, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.clickOwnMap(p(5, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 5, 2, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(0, ships.size());
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 5, 2, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(0, ships.size());
|
||||
clientLogic.clickOwnMap(p(2, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 5, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 2, 2, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.clickHarbor(p(1, 1));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 5, 2, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, NORMAL);
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 5, 2, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, NORMAL);
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 5, 2, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, NORMAL);
|
||||
clientLogic.clickOwnMap(p(5, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 5, 2, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(5, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(4, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(3, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(2, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 1, 2, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 0, 1, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.clickOwnMap(p(1, 2));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 1, 1, 2, RIGHT, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, NORMAL);
|
||||
clientLogic.clickHarbor(p(0, 0));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 1, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 1, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.movePreview(p(5, 0));
|
||||
clientLogic.movePreview(p(5, 0));
|
||||
clientLogic.movePreview(p(4, 0));
|
||||
clientLogic.movePreview(p(4, 0));
|
||||
clientLogic.movePreview(p(3, 0));
|
||||
clientLogic.movePreview(p(3, 0));
|
||||
clientLogic.rotateShip();
|
||||
clientLogic.movePreview(p(1, 0));
|
||||
clientLogic.movePreview(p(1, 1));
|
||||
clientLogic.movePreview(p(1, 2));
|
||||
clientLogic.movePreview(p(1, 3));
|
||||
clientLogic.movePreview(p(1, 4));
|
||||
clientLogic.movePreview(p(1, 4));
|
||||
clientLogic.movePreview(p(1, 5));
|
||||
clientLogic.movePreview(p(1, 5));
|
||||
clientLogic.movePreview(p(1, 5));
|
||||
clientLogic.movePreview(p(1, 5));
|
||||
clientLogic.movePreview(p(1, 5));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 1, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 1, 5, DOWN, VALID_PREVIEW);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 0, 0, RIGHT, VALID_PREVIEW);
|
||||
clientLogic.clickOwnMap(p(1, 5));
|
||||
ships = clientLogic.getOwnMap().getRemainingShips();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 1, 1, 2, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 2, 1, 5, DOWN, NORMAL);
|
||||
ships = clientLogic.getHarbor().getRemainingShips();
|
||||
assertEquals(0, ships.size());
|
||||
clientLogic.mapFinished();
|
||||
mapMsg = (MapMessage) messages.poll();
|
||||
assertEquals(2, mapMsg.getShips().size());
|
||||
checkShip(mapMsg.getShips().get(0), 1, 1, 2, RIGHT, NORMAL);
|
||||
checkShip(mapMsg.getShips().get(1), 2, 1, 5, DOWN, NORMAL);
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(new StartBattleMessage(false));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.miss(false, p(3, 3)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(2, 2));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(2, 2), shootMsg.getPosition());
|
||||
clientLogic.clickOpponentMap(p(2, 2));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(2, 2), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.miss(true, p(2, 2)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.miss(false, p(1, 3)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(2, 1));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(2, 1), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.hit(true, p(2, 1)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(3, 1));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(3, 1), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.shipDestroyed(true, p(3, 1), new Battleship(2, 2, 1, RIGHT)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
ships = clientLogic.getOpponentMap().getShips().toList();
|
||||
assertEquals(1, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
clientLogic.clickOpponentMap(p(5, 3));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(5, 3), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.miss(true, p(5, 3)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.miss(false, p(2, 3)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(3, 3));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(3, 3), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.miss(true, p(3, 3)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.hit(false, p(1, 4)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.hit(false, p(1, 4)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.shipDestroyed(false, p(1, 5), new Battleship(2, 1, 5, DOWN)));
|
||||
assertEquals("wait.for.opponent", infoTexts.poll());
|
||||
clientLogic.received(EffectMessage.miss(false, p(2, 2)));
|
||||
assertEquals("its.your.turn", infoTexts.poll());
|
||||
clientLogic.clickOpponentMap(p(5, 1));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(5, 1), shootMsg.getPosition());
|
||||
clientLogic.clickOpponentMap(p(5, 1));
|
||||
shootMsg = (ShootMessage) messages.poll();
|
||||
assertEquals(p(5, 1), shootMsg.getPosition());
|
||||
clientLogic.received(EffectMessage.won(p(5, 1), new Battleship(1, 5, 1, RIGHT)));
|
||||
assertEquals("you.won.the.game", infoTexts.poll());
|
||||
ships = clientLogic.getOpponentMap().getShips().toList();
|
||||
assertEquals(2, ships.size());
|
||||
checkShip(ships.get(0), 2, 2, 1, RIGHT, NORMAL);
|
||||
checkShip(ships.get(1), 1, 5, 1, RIGHT, NORMAL);
|
||||
|
||||
assertEquals(0, infoTexts.size());
|
||||
assertEquals(0, messages.size());
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,187 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.IntPoint;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
public class ClientGameLogicTest {
|
||||
private ClientGameLogic logic;
|
||||
private ClientSender clientSender;
|
||||
private ClientState initialState;
|
||||
private ClientState editorState;
|
||||
private ClientState gameOverState;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
clientSender = mock(ClientSender.class);
|
||||
initialState = mock(ClientState.class);
|
||||
editorState = mock(ClientState.class);
|
||||
gameOverState = mock(ClientState.class);
|
||||
logic = new ClientGameLogic(clientSender);
|
||||
logic.setState(initialState);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetState() {
|
||||
logic.setState(editorState);
|
||||
assertEquals(editorState, logic.getState());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShowEditor() {
|
||||
when(initialState.showEditor()).thenReturn(true);
|
||||
when(editorState.showEditor()).thenReturn(false);
|
||||
assertTrue(logic.showEditor());
|
||||
logic.setState(editorState);
|
||||
assertFalse(logic.showEditor());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShowBattle() {
|
||||
when(initialState.showBattle()).thenReturn(false);
|
||||
when(gameOverState.showBattle()).thenReturn(true);
|
||||
assertFalse(logic.showBattle());
|
||||
logic.setState(gameOverState);
|
||||
assertTrue(logic.showBattle());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReceivedGameDetails() {
|
||||
final GameDetails details = mock(GameDetails.class);
|
||||
logic.received(details);
|
||||
verify(initialState).receivedGameDetails(details);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMovePreview() {
|
||||
final IntPoint pos = new IntPoint(42, 42);
|
||||
logic.movePreview(pos);
|
||||
verify(initialState).movePreview(pos);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testClickOwnMap() {
|
||||
final IntPoint pos = new IntPoint(42, 42);
|
||||
logic.clickOwnMap(pos);
|
||||
verify(initialState).clickOwnMap(pos);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testClickHarbor() {
|
||||
final IntPoint pos = new IntPoint(42, 42);
|
||||
logic.clickHarbor(pos);
|
||||
verify(initialState).clickHarbor(pos);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testClickOpponentMap() {
|
||||
final IntPoint pos = new IntPoint(42, 42);
|
||||
logic.clickOpponentMap(pos);
|
||||
verify(initialState).clickOpponentMap(pos);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRotateShip() {
|
||||
logic.rotateShip();
|
||||
verify(initialState).rotateShip();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapFinished() {
|
||||
logic.mapFinished();
|
||||
verify(initialState).mapFinished();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsMapComplete() {
|
||||
logic.setState(editorState);
|
||||
when(editorState.isMapComplete()).thenReturn(true);
|
||||
assertTrue(logic.isMapComplete());
|
||||
when(editorState.isMapComplete()).thenReturn(false);
|
||||
assertFalse(logic.isMapComplete());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMovingShip() {
|
||||
logic.setState(editorState);
|
||||
when(editorState.movingShip()).thenReturn(true);
|
||||
assertTrue(logic.movingShip());
|
||||
when(editorState.movingShip()).thenReturn(false);
|
||||
assertFalse(logic.movingShip());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReceivedStartShooting() {
|
||||
final StartBattleMessage msg = mock(StartBattleMessage.class);
|
||||
logic.received(msg);
|
||||
verify(initialState).receivedStartBattle(msg);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReceivedEffectMessage() {
|
||||
final EffectMessage msg = mock(EffectMessage.class);
|
||||
logic.received(msg);
|
||||
verify(initialState).receivedEffect(msg);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLoadMap() throws IOException {
|
||||
final File file = mock(File.class);
|
||||
logic.loadMap(file);
|
||||
verify(initialState).loadMap(file);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMayLoadMap() {
|
||||
logic.setState(editorState);
|
||||
when(editorState.mayLoadMap()).thenReturn(true);
|
||||
assertTrue(logic.mayLoadMap());
|
||||
when(editorState.mayLoadMap()).thenReturn(false);
|
||||
assertFalse(logic.mayLoadMap());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMaySaveMap() {
|
||||
logic.setState(editorState);
|
||||
when(editorState.maySaveMap()).thenReturn(true);
|
||||
assertTrue(logic.maySaveMap());
|
||||
when(editorState.maySaveMap()).thenReturn(false);
|
||||
assertFalse(logic.maySaveMap());
|
||||
}
|
||||
|
||||
@Test(expected = IOException.class)
|
||||
public void testSaveMap() throws IOException {
|
||||
final File file = mock(File.class);
|
||||
logic.setState(editorState);
|
||||
when(editorState.maySaveMap()).thenReturn(false);
|
||||
logic.saveMap(file);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSend() {
|
||||
final ClientMessage msg = mock(ClientMessage.class);
|
||||
logic.send(msg);
|
||||
verify(clientSender).send(msg);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.message.server.ServerMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Battleship.Status;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.Rotation;
|
||||
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.Deque;
|
||||
import java.util.logging.Handler;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.LogManager;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public abstract class AbstractServerGameTest {
|
||||
static final BattleshipConfig CONFIG = new BattleshipConfig();
|
||||
|
||||
static {
|
||||
// Configure logging
|
||||
final Logger rootLogger = LogManager.getLogManager().getLogger("");
|
||||
rootLogger.setLevel(Level.WARNING);
|
||||
for (Handler h : rootLogger.getHandlers()) {
|
||||
h.setLevel(Level.WARNING);
|
||||
}
|
||||
}
|
||||
|
||||
record ServerMessageWrapper(int id, ServerMessage msg) {}
|
||||
|
||||
final Deque<ServerMessageWrapper> messages = new ArrayDeque<>();
|
||||
final ServerSender serverSender = (id, msg) -> messages.offer(new ServerMessageWrapper(id, msg));
|
||||
final ServerGameLogic serverLogic = new ServerGameLogic(serverSender, CONFIG);
|
||||
|
||||
static IntPoint p(int x, int y) {
|
||||
return new IntPoint(x, y);
|
||||
}
|
||||
|
||||
void checkShip(Battleship ship, int length, int x, int y, Rotation rot, Status status) {
|
||||
assertEquals(length, ship.getLength());
|
||||
assertEquals(x, ship.getX());
|
||||
assertEquals(y, ship.getY());
|
||||
assertEquals(rot, ship.getRot());
|
||||
assertEquals(status, ship.getStatus());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,254 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
import org.junit.Test;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Shot;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static pp.battleship.model.Battleship.Status.NORMAL;
|
||||
import static pp.battleship.model.Rotation.DOWN;
|
||||
import static pp.battleship.model.Rotation.RIGHT;
|
||||
|
||||
/**
|
||||
* Integration test cases for the server game logic in a small game, called "Game 1", where Player 2 (with id 1) wins.
|
||||
* The test cases for the players are contained in {@linkplain pp.battleship.game.client.ClientGame1Player1Test}
|
||||
* and {@linkplain pp.battleship.game.client.ClientGame1Player2Test}.
|
||||
*
|
||||
* @see pp.battleship.game.client.ClientGame1Player1Test
|
||||
* @see pp.battleship.game.client.ClientGame1Player2Test
|
||||
*/
|
||||
public class ServerGame1Test extends AbstractServerGameTest {
|
||||
static {
|
||||
final Properties props = new Properties();
|
||||
props.setProperty("map.width", "6");
|
||||
props.setProperty("map.height", "6");
|
||||
props.setProperty("ship.nums", "1,1");
|
||||
CONFIG.readFrom(props);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRun() {
|
||||
EffectMessage effectMsg;
|
||||
GameDetails details;
|
||||
StartBattleMessage startShooting;
|
||||
|
||||
serverLogic.addPlayer(0); // Player 1
|
||||
serverLogic.addPlayer(1); // Player 2
|
||||
assertEquals(0, messages.peek().id());
|
||||
details = (GameDetails) messages.poll().msg();
|
||||
assertEquals(6, details.getWidth());
|
||||
assertEquals(6, details.getHeight());
|
||||
assertEquals(2, details.getShipNums().size());
|
||||
assertEquals(Integer.valueOf(1), details.getShipNums().get(1));
|
||||
assertEquals(Integer.valueOf(1), details.getShipNums().get(2));
|
||||
assertEquals(1, messages.peek().id());
|
||||
details = (GameDetails) messages.poll().msg();
|
||||
assertEquals(6, details.getWidth());
|
||||
assertEquals(6, details.getHeight());
|
||||
assertEquals(2, details.getShipNums().size());
|
||||
assertEquals(Integer.valueOf(1), details.getShipNums().get(1));
|
||||
assertEquals(Integer.valueOf(1), details.getShipNums().get(2));
|
||||
serverLogic.received(new MapMessage(List.of(new Battleship(1, 1, 2, RIGHT), new Battleship(2, 1, 5, DOWN))), 1);
|
||||
serverLogic.received(new MapMessage(List.of(new Battleship(2, 2, 1, RIGHT), new Battleship(1, 5, 1, RIGHT))), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
startShooting = (StartBattleMessage) messages.poll().msg();
|
||||
assertTrue(startShooting.isMyTurn());
|
||||
assertEquals(1, messages.peek().id());
|
||||
startShooting = (StartBattleMessage) messages.poll().msg();
|
||||
assertFalse(startShooting.isMyTurn());
|
||||
serverLogic.received(new ShootMessage(p(3, 3)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 2)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 2, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 2, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 2)), 1);
|
||||
serverLogic.received(new ShootMessage(p(1, 3)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(1, 3)), 0);
|
||||
serverLogic.received(new ShootMessage(p(2, 1)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 1, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 1, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(3, 1)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 1, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 2, 1, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 1, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 2, 1, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 3)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 3)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 3)), 0);
|
||||
serverLogic.received(new ShootMessage(p(3, 3)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(1, 4)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 4, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 4, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(1, 4)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 4, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 4, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(1, 5)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 5, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 1, 5, DOWN, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(1, 5, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 1, 5, DOWN, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 2)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 2, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 2, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 1)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 1, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 5, 1, RIGHT, NORMAL);
|
||||
assertEquals(0, effectMsg.getRemainingOpponentShips().size());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 1, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 5, 1, RIGHT, NORMAL);
|
||||
assertEquals(1, effectMsg.getRemainingOpponentShips().size());
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(0), 1, 1, 2, RIGHT, NORMAL);
|
||||
// Player 2 wins
|
||||
|
||||
assertEquals(0, messages.size());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,574 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
import org.junit.Test;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Shot;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static pp.battleship.model.Battleship.Status.NORMAL;
|
||||
import static pp.battleship.model.Rotation.DOWN;
|
||||
import static pp.battleship.model.Rotation.RIGHT;
|
||||
|
||||
/**
|
||||
* Integration test cases for the server game logic in a larger game, called "Game 2", where Player 1 (with id 0) wins.
|
||||
* The test cases for the players are contained in {@linkplain pp.battleship.game.client.ClientGame2Player1Test}
|
||||
* and {@linkplain pp.battleship.game.client.ClientGame2Player2Test}.
|
||||
*
|
||||
* @see pp.battleship.game.client.ClientGame2Player1Test
|
||||
* @see pp.battleship.game.client.ClientGame2Player2Test
|
||||
*/
|
||||
public class ServerGame2Test extends AbstractServerGameTest {
|
||||
static {
|
||||
final Properties props = new Properties();
|
||||
props.setProperty("map.width", "10");
|
||||
props.setProperty("map.height", "10");
|
||||
props.setProperty("ship.nums", "4,3,2,1");
|
||||
CONFIG.readFrom(props);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRun() {
|
||||
EffectMessage effectMsg;
|
||||
GameDetails details;
|
||||
StartBattleMessage startShooting;
|
||||
|
||||
serverLogic.addPlayer(0); // Player 1
|
||||
serverLogic.addPlayer(1); // Player 2
|
||||
assertEquals(0, messages.peek().id());
|
||||
details = (GameDetails) messages.poll().msg();
|
||||
assertEquals(10, details.getWidth());
|
||||
assertEquals(10, details.getHeight());
|
||||
assertEquals(4, details.getShipNums().size());
|
||||
assertEquals(Integer.valueOf(4), details.getShipNums().get(1));
|
||||
assertEquals(Integer.valueOf(3), details.getShipNums().get(2));
|
||||
assertEquals(Integer.valueOf(2), details.getShipNums().get(3));
|
||||
assertEquals(Integer.valueOf(1), details.getShipNums().get(4));
|
||||
assertEquals(1, messages.peek().id());
|
||||
details = (GameDetails) messages.poll().msg();
|
||||
assertEquals(10, details.getWidth());
|
||||
assertEquals(10, details.getHeight());
|
||||
assertEquals(4, details.getShipNums().size());
|
||||
assertEquals(Integer.valueOf(4), details.getShipNums().get(1));
|
||||
assertEquals(Integer.valueOf(3), details.getShipNums().get(2));
|
||||
assertEquals(Integer.valueOf(2), details.getShipNums().get(3));
|
||||
assertEquals(Integer.valueOf(1), details.getShipNums().get(4));
|
||||
serverLogic.received(new MapMessage(List.of(new Battleship(3, 2, 3, DOWN), new Battleship(2, 2, 6, DOWN), new Battleship(2, 4, 6, RIGHT), new Battleship(2, 4, 4, RIGHT), new Battleship(1, 7, 6, RIGHT), new Battleship(1, 7, 4, RIGHT), new Battleship(1, 4, 2, RIGHT), new Battleship(1, 6, 2, RIGHT), new Battleship(4, 2, 8, RIGHT), new Battleship(3, 7, 8, RIGHT))), 1);
|
||||
serverLogic.received(new MapMessage(List.of(new Battleship(4, 0, 5, DOWN), new Battleship(3, 0, 9, DOWN), new Battleship(3, 0, 0, RIGHT), new Battleship(2, 4, 0, RIGHT), new Battleship(2, 2, 9, RIGHT), new Battleship(2, 5, 9, RIGHT), new Battleship(1, 8, 9, RIGHT), new Battleship(1, 7, 0, RIGHT), new Battleship(1, 9, 0, RIGHT), new Battleship(1, 9, 7, RIGHT))), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
startShooting = (StartBattleMessage) messages.poll().msg();
|
||||
assertTrue(startShooting.isMyTurn());
|
||||
assertEquals(1, messages.peek().id());
|
||||
startShooting = (StartBattleMessage) messages.poll().msg();
|
||||
assertFalse(startShooting.isMyTurn());
|
||||
serverLogic.received(new ShootMessage(p(5, 5)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 5, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 5, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 5)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 5, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 5, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 6)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 6, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 6, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(6, 6)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 6, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 6, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 6)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 6, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 6, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(4, 6)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 6, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 4, 6, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 6, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 4, 6, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(4, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(6, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 8, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 8, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(3, 7)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 7, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 7, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(3, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 8, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 4, 2, 8, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 8, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 4, 2, 8, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(0, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(0, 8, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(0, 8, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 9)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 9, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 9, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(6, 9)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 9, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 5, 9, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 9, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 5, 9, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(7, 7)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 7, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 7, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(0, 6)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(0, 6, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(0, 6, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 5)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 5, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 5, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(7, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(8, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(8, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(8, 8, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(9, 8)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(9, 8, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 3, 7, 8, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(9, 8, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 3, 7, 8, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 6)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 6, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 6, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 5)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 5, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 2, 6, DOWN, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 5, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 2, 6, DOWN, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(3, 3)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(3, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(8, 9)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(8, 9, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 8, 9, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(8, 9, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 8, 9, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 3)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 3, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 3)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 3, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 3, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 2)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 2, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 2, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(2, 1)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 1, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 3, 2, 3, DOWN, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(2, 1, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 3, 2, 3, DOWN, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(4, 4)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 4, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 4, true), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(5, 4)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 4, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 4, 4, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(5, 4, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 2, 4, 4, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(7, 4)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 4, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 7, 4, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 4, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 7, 4, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(9, 4)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(9, 4, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(9, 4, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(8, 4)), 1);
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(8, 4, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(8, 4, false), effectMsg.getShot());
|
||||
assertNull(effectMsg.getDestroyedShip());
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(7, 6)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 6, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 7, 6, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(7, 6, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 7, 6, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(4, 2)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 2, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 4, 2, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(4, 2, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 4, 2, RIGHT, NORMAL);
|
||||
assertNull(effectMsg.getRemainingOpponentShips());
|
||||
serverLogic.received(new ShootMessage(p(6, 2)), 0);
|
||||
assertEquals(0, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertTrue(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 2, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 6, 2, RIGHT, NORMAL);
|
||||
assertEquals(0, effectMsg.getRemainingOpponentShips().size());
|
||||
assertEquals(1, messages.peek().id());
|
||||
effectMsg = (EffectMessage) messages.poll().msg();
|
||||
assertFalse(effectMsg.isOwnShot());
|
||||
assertEquals(new Shot(6, 2, true), effectMsg.getShot());
|
||||
checkShip(effectMsg.getDestroyedShip(), 1, 6, 2, RIGHT, NORMAL);
|
||||
assertEquals(8, effectMsg.getRemainingOpponentShips().size());
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(0), 4, 0, 5, DOWN, NORMAL);
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(1), 3, 0, 9, DOWN, NORMAL);
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(2), 3, 0, 0, RIGHT, NORMAL);
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(3), 2, 4, 0, RIGHT, NORMAL);
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(4), 2, 2, 9, RIGHT, NORMAL);
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(5), 1, 7, 0, RIGHT, NORMAL);
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(6), 1, 9, 0, RIGHT, NORMAL);
|
||||
checkShip(effectMsg.getRemainingOpponentShips().get(7), 1, 9, 7, RIGHT, NORMAL);
|
||||
// Player 1 wins
|
||||
|
||||
assertEquals(0, messages.size());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.Rotation;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.mockito.Mockito.any;
|
||||
import static org.mockito.Mockito.anyInt;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
public class ServerGameLogicTest {
|
||||
private ServerGameLogic serverGameLogic;
|
||||
private ServerSender mockServerSender;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
mockServerSender = mock(ServerSender.class);
|
||||
serverGameLogic = new ServerGameLogic(mockServerSender, new BattleshipConfig());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAddPlayer() {
|
||||
serverGameLogic.addPlayer(1);
|
||||
serverGameLogic.addPlayer(2);
|
||||
verify(mockServerSender, times(2)).send(anyInt(), any(GameDetails.class));
|
||||
assertEquals(ServerState.SET_UP, serverGameLogic.getState());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetPlayerById() {
|
||||
final Player player1 = serverGameLogic.addPlayer(1);
|
||||
final Player player2 = serverGameLogic.addPlayer(2);
|
||||
assertEquals(player1, serverGameLogic.getPlayerById(1));
|
||||
assertEquals(player2, serverGameLogic.getPlayerById(2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReceivedMapMessage() {
|
||||
serverGameLogic.addPlayer(1);
|
||||
serverGameLogic.addPlayer(2);
|
||||
List<Battleship> ships = List.of(new Battleship(3, 2, 2, Rotation.RIGHT));
|
||||
MapMessage mapMessage = new MapMessage(ships);
|
||||
serverGameLogic.received(mapMessage, 1);
|
||||
serverGameLogic.received(mapMessage, 2);
|
||||
verify(mockServerSender, times(2)).send(anyInt(), any(StartBattleMessage.class));
|
||||
assertEquals(ServerState.BATTLE, serverGameLogic.getState());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReceivedShootMessage() {
|
||||
serverGameLogic.addPlayer(1);
|
||||
serverGameLogic.addPlayer(2);
|
||||
List<Battleship> ships = List.of(new Battleship(3, 2, 2, Rotation.RIGHT));
|
||||
MapMessage mapMessage = new MapMessage(ships);
|
||||
serverGameLogic.received(mapMessage, 1);
|
||||
serverGameLogic.received(mapMessage, 2);
|
||||
|
||||
ShootMessage shootMessage = new ShootMessage(p(2, 2));
|
||||
serverGameLogic.received(shootMessage, 1);
|
||||
verify(mockServerSender, times(2)).send(anyInt(), any(EffectMessage.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPlayerReady() {
|
||||
final Player player1 = serverGameLogic.addPlayer(1);
|
||||
final Player player2 = serverGameLogic.addPlayer(2);
|
||||
List<Battleship> ships = List.of(new Battleship(3, 2, 2, Rotation.RIGHT));
|
||||
serverGameLogic.playerReady(player1, ships);
|
||||
serverGameLogic.playerReady(player2, ships);
|
||||
verify(mockServerSender, times(2)).send(anyInt(), any(StartBattleMessage.class));
|
||||
assertEquals(ServerState.BATTLE, serverGameLogic.getState());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testShoot() {
|
||||
final Player player1 = serverGameLogic.addPlayer(1);
|
||||
final Player player2 = serverGameLogic.addPlayer(2);
|
||||
List<Battleship> ships = List.of(new Battleship(3, 2, 2, Rotation.RIGHT));
|
||||
serverGameLogic.playerReady(player1, ships);
|
||||
serverGameLogic.playerReady(player2, ships);
|
||||
|
||||
serverGameLogic.shoot(player1, p(2, 2));
|
||||
verify(mockServerSender, times(2)).send(anyInt(), any(EffectMessage.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetState() {
|
||||
serverGameLogic.setState(ServerState.BATTLE);
|
||||
assertEquals(ServerState.BATTLE, serverGameLogic.getState());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetOpponent() {
|
||||
final Player player1 = serverGameLogic.addPlayer(1);
|
||||
final Player player2 = serverGameLogic.addPlayer(2);
|
||||
assertEquals(player2, serverGameLogic.getOpponent(player1));
|
||||
}
|
||||
|
||||
static IntPoint p(int x, int y) {
|
||||
return new IntPoint(x, y);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.model;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
public class BattleshipTest {
|
||||
private Battleship ship;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
ship = new Battleship(3, 2, 2, Rotation.RIGHT);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDefaultConstructor() {
|
||||
Battleship defaultShip = new Battleship(1, 0, 0, Rotation.RIGHT);
|
||||
assertEquals(1, defaultShip.getLength());
|
||||
assertEquals(0, defaultShip.getX());
|
||||
assertEquals(0, defaultShip.getY());
|
||||
assertEquals(Rotation.RIGHT, defaultShip.getRot());
|
||||
assertEquals(Battleship.Status.NORMAL, defaultShip.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructorWithParameters() {
|
||||
assertEquals(3, ship.getLength());
|
||||
assertEquals(2, ship.getX());
|
||||
assertEquals(2, ship.getY());
|
||||
assertEquals(Rotation.RIGHT, ship.getRot());
|
||||
assertEquals(Battleship.Status.NORMAL, ship.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetPosition() {
|
||||
ship.moveTo(4, 5);
|
||||
assertEquals(4, ship.getX());
|
||||
assertEquals(5, ship.getY());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetPositionWithIntPosition() {
|
||||
IntPoint pos = p(5, 6);
|
||||
ship.moveTo(pos);
|
||||
assertEquals(5, ship.getX());
|
||||
assertEquals(6, ship.getY());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetStatus() {
|
||||
assertEquals(Battleship.Status.NORMAL, ship.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithStatus() {
|
||||
ship.setStatus(Battleship.Status.VALID_PREVIEW);
|
||||
assertEquals(Battleship.Status.VALID_PREVIEW, ship.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetLength() {
|
||||
assertEquals(3, ship.getLength());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetMinX() {
|
||||
assertEquals(2, ship.getMinX());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetMaxX() {
|
||||
assertEquals(4, ship.getMaxX());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetMaxY() {
|
||||
assertEquals(2, ship.getMaxY());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetMinY() {
|
||||
assertEquals(2, ship.getMinY());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRotation() {
|
||||
assertEquals(Rotation.RIGHT, ship.getRot());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetRotation() {
|
||||
ship.setRotation(Rotation.DOWN);
|
||||
assertEquals(Rotation.DOWN, ship.getRot());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRotated() {
|
||||
ship.rotated();
|
||||
assertEquals(Rotation.DOWN, ship.getRot());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHit() {
|
||||
assertTrue(ship.hit(2, 2));
|
||||
assertTrue(ship.hit(2, 2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testContains() {
|
||||
IntPoint pos = p(3, 2);
|
||||
assertTrue(ship.contains(pos));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsDestroyed() {
|
||||
ship.hit(2, 2);
|
||||
ship.hit(3, 2);
|
||||
ship.hit(4, 2);
|
||||
assertTrue(ship.isDestroyed());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCollidesWith() {
|
||||
Battleship otherShip = new Battleship(3, 3, 2, Rotation.RIGHT);
|
||||
assertTrue(ship.collidesWith(otherShip));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToString() {
|
||||
assertEquals("Ship{length=3, x=2, y=2, rot=RIGHT}", ship.toString());
|
||||
}
|
||||
|
||||
static IntPoint p(int x, int y) {
|
||||
return new IntPoint(x, y);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package pp.battleship.model;
|
||||
|
||||
import org.junit.Test;
|
||||
import pp.util.RandomPositionIterator;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
public class RandomPositionIteratorTest {
|
||||
@Test
|
||||
public void testEqualsOccurs() {
|
||||
final var it = new RandomPositionIterator<>(IntPoint::new, 2, 2);
|
||||
final Set<IntPoint> positions = new HashSet<>();
|
||||
positions.add(new IntPoint(0, 0));
|
||||
positions.add(new IntPoint(1, 1));
|
||||
|
||||
int n = 0;
|
||||
while (it.hasNext() && ++n <= 3) {
|
||||
if (!positions.add(it.next()))
|
||||
return;
|
||||
}
|
||||
fail("not found");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoEquals() {
|
||||
final var it = new RandomPositionIterator<>(IntPoint::new, 2, 2);
|
||||
final Set<IntPoint> positions = new HashSet<>();
|
||||
|
||||
while (it.hasNext()) {
|
||||
if (!positions.add(it.next()))
|
||||
fail("not found");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.model;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import pp.battleship.notification.GameEventBroker;
|
||||
import pp.battleship.notification.ItemAddedEvent;
|
||||
import pp.battleship.notification.ItemRemovedEvent;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.any;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static pp.battleship.model.BattleshipTest.p;
|
||||
|
||||
public class ShipMapTest {
|
||||
private ShipMap map;
|
||||
private GameEventBroker mockBroker;
|
||||
private Battleship battleship;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
mockBroker = mock(GameEventBroker.class);
|
||||
map = new ShipMap(10, 10, mockBroker);
|
||||
battleship = new Battleship(3, 2, 2, Rotation.RIGHT);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructorWithValidSize() {
|
||||
assertEquals(10, map.getWidth());
|
||||
assertEquals(10, map.getHeight());
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testConstructorWithInvalidSize() {
|
||||
new ShipMap(0, 10, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAddItem() {
|
||||
map.add(battleship);
|
||||
List<Item> items = map.getItems();
|
||||
assertTrue(items.contains(battleship));
|
||||
verify(mockBroker).notifyListeners(any(ItemAddedEvent.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRemoveItem() {
|
||||
map.add(battleship);
|
||||
map.remove(battleship);
|
||||
final List<Item> items = map.getItems();
|
||||
assertFalse(items.contains(battleship));
|
||||
verify(mockBroker).notifyListeners(any(ItemAddedEvent.class));
|
||||
verify(mockBroker).notifyListeners(any(ItemRemovedEvent.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testClear() {
|
||||
map.add(battleship);
|
||||
map.clear();
|
||||
final List<Item> items = map.getItems();
|
||||
assertTrue(items.isEmpty());
|
||||
verify(mockBroker).notifyListeners(any(ItemAddedEvent.class));
|
||||
verify(mockBroker).notifyListeners(any(ItemRemovedEvent.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRemainingShips() {
|
||||
map.add(battleship);
|
||||
final List<Battleship> remainingShips = map.getRemainingShips();
|
||||
assertTrue(remainingShips.contains(battleship));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetShots() {
|
||||
final Shot shot = new Shot(1, 1, false);
|
||||
map.add(shot);
|
||||
final List<Shot> shots = map.getShots().toList();
|
||||
assertTrue(shots.contains(shot));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetItems() {
|
||||
map.add(battleship);
|
||||
final List<Item> items = map.getItems();
|
||||
assertTrue(items.contains(battleship));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindShipAt() {
|
||||
map.add(battleship);
|
||||
Battleship foundShip = map.findShipAt(2, 2);
|
||||
assertEquals(battleship, foundShip);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsValidPosition() {
|
||||
assertTrue(map.isValid(p(5, 5)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsValidCoordinates() {
|
||||
assertTrue(map.isValid(5, 5));
|
||||
assertFalse(map.isValid(10, 10));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user