1 files changed, 330 insertions, 0 deletions

diff --git a/src/ch/epfl/maze/tests/WorldTest.java b/src/ch/epfl/maze/tests/WorldTest.java
new file mode 100644
index 0000000..6d551b1
--- /dev/null
+++ b/src/ch/epfl/maze/tests/WorldTest.java
@@ -0,0 +1,330 @@
+package ch.epfl.maze.tests;
+
+import static org.junit.Assert.assertArrayEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+
+import ch.epfl.maze.physical.Animal;
+import ch.epfl.maze.physical.World;
+import ch.epfl.maze.util.Direction;
+import ch.epfl.maze.util.Vector2D;
+
+/**
+ * Test case for {@code World} implementation.
+ * 
+ */
+
+public class WorldTest extends TestCase {
+
+        /* sample labyrinth */
+        private static final int[][] LABYRINTH_SAMPLE = {
+                {1, 1, 1, 1, 1, 3, 1},
+                {1, 0, 0, 0, 0, 0, 1},
+                {1, 2, 1, 1, 1, 1, 1}
+        };
+
+        /* constants labyrinth for testing getChoices(Vector2D) */
+        private static final int[][] LABYRINTH_STUCK = {
+                {1, 1, 1},
+                {1, 0, 1},
+                {1, 1, 1}
+        };
+        private static final int[][] LABYRINTH_CORRIDOR = {
+                {1, 1, 1, 1, 1, 1},
+                {1, 0, 1, 0, 0, 1},
+                {1, 0, 1, 1, 1, 1},
+                {1, 1, 1, 1, 1, 1}
+        };
+        private static final int[][] LABYRINTH_DOGHNUT = {
+                {1, 1, 1, 1, 1},
+                {1, 0, 0, 0, 1},
+                {1, 0, 1, 0, 1},
+                {1, 0, 0, 0, 1},
+                {1, 1, 1, 1, 1}
+        };
+        private static final int[][] LABYRINTH_SQUARE = {
+                {1, 1, 1, 1, 1},
+                {1, 0, 0, 0, 1},
+                {1, 0, 0, 0, 1},
+                {1, 0, 0, 0, 1},
+                {1, 1, 1, 1, 1}
+        };
+
+        /**
+         * Test case for {@code getTile(int x, int y)}.
+         */
+
+        @Test
+        public void testGetTile() {
+                World world = new ConcreteWorld(LABYRINTH_SAMPLE);
+
+                // checks if positions are reversed
+                assertTrue("You reversed the coordinates in your method !",
+                                world.getTile(5, 1) != World.NOTHING);
+
+                // checks every position on the sample labyrinth
+                assertEquals(World.WALL, world.getTile(0, 0));
+                assertEquals(World.FREE, world.getTile(1, 1));
+                assertEquals(World.START, world.getTile(1, 2));
+                assertEquals(World.EXIT, world.getTile(5, 0));
+                assertEquals(World.NOTHING, world.getTile(0, 3));
+        }
+
+        /**
+         * Test case for {@code isFree(int x, int y)}.
+         */
+
+        @Test
+        public void testIsFree() {
+                World world = new ConcreteWorld(LABYRINTH_SAMPLE);
+
+                // checks FREE, START and EXIT positions
+                assertTrue("FREE tile should be free", world.isFree(3, 1));
+                assertTrue("START tile should be free", world.isFree(1, 2));
+                assertTrue("EXIT tile should be free", world.isFree(5, 0));
+
+                // checks WALL and NOTHING positions
+                assertFalse("WALL tile should NOT be free", world.isFree(0, 0));
+                assertFalse("NOTHING tile should NOT be free", world.isFree(0, 3));
+        }
+
+        /**
+         * Test case for {@code getWidth()}.
+         */
+
+        @Test
+        public void testGetWidth() {
+                World world = new ConcreteWorld(LABYRINTH_SAMPLE);
+
+                // checks width
+                assertEquals(7, world.getWidth());
+        }
+
+        /**
+         * Test case for {@code getHeight()}.
+         */
+
+        @Test
+        public void testGetHeight() {
+                World world = new ConcreteWorld(LABYRINTH_SAMPLE);
+
+                // checks height
+                assertEquals(3, world.getHeight());
+        }
+
+        /**
+         * Test case for {@code getStart()}.
+         */
+
+        @Test
+        public void testGetStart() {
+                World world = new ConcreteWorld(LABYRINTH_SAMPLE);
+
+                // checks starting position
+                assertEquals(new Vector2D(1, 2), world.getStart());
+        }
+
+        /**
+         * Test case for {@code getExit()}.
+         */
+
+        @Test
+        public void testGetExit() {
+                World world = new ConcreteWorld(LABYRINTH_SAMPLE);
+
+                // checks exiting position
+                assertEquals(new Vector2D(5, 0), world.getExit());
+        }
+
+        // ==========================================================
+
+        /**
+         * Test case for {@code getChoices(Vector2D position)}
+         * when there are 0 choices.
+         */
+
+        @Test
+        public void testZeroChoice() {
+                World world = new ConcreteWorld(LABYRINTH_STUCK);
+                Direction[] choices = world.getChoices(new Vector2D(1, 1));
+
+                // checks that the only choice is not to move
+                checkChoices(choices, new Direction[] { Direction.NONE });
+        }
+
+        /**
+         * Test case for {@code getChoices(Vector2D position)}
+         * when there is 1 choice.
+         */
+
+        @Test
+        public void testOneChoice() {
+                World world = new ConcreteWorld(LABYRINTH_CORRIDOR);
+                Direction[] choices;
+
+                // checks when the only choice is to move down
+                choices = world.getChoices(new Vector2D(1, 1));
+                checkChoices(choices, new Direction[] { Direction.DOWN });
+
+                // checks when the only choice is to move up
+                choices = world.getChoices(new Vector2D(1, 2));
+                checkChoices(choices, new Direction[] { Direction.UP });
+
+                // checks when the only choice is to move right
+                choices = world.getChoices(new Vector2D(3, 1));
+                checkChoices(choices, new Direction[] { Direction.RIGHT });
+
+                // checks when the only choice is to move left
+                choices = world.getChoices(new Vector2D(4, 1));
+                checkChoices(choices, new Direction[] { Direction.LEFT });
+        }
+
+        /**
+         * Test case for {@code getChoices(Vector2D position)}
+         * when there are 2 choices.
+         */
+
+        @Test
+        public void testTwoChoices() {
+                World world = new ConcreteWorld(LABYRINTH_DOGHNUT);
+                Direction[] choices;
+
+                // checks when the available choices are to move down and right
+                choices = world.getChoices(new Vector2D(1, 1));
+                checkChoices(choices,
+                                new Direction[] { Direction.DOWN, Direction.RIGHT });
+
+                // checks when the available choices are to move down and up
+                choices = world.getChoices(new Vector2D(1, 2));
+                checkChoices(choices,
+                                new Direction[] { Direction.DOWN, Direction.UP });
+
+                // checks when the available choices are to move up and right
+                choices = world.getChoices(new Vector2D(1, 3));
+                checkChoices(choices,
+                                new Direction[] { Direction.UP, Direction.RIGHT });
+
+                // checks when the available choices are to move right and left
+                choices = world.getChoices(new Vector2D(2, 1));
+                checkChoices(choices,
+                                new Direction[] { Direction.RIGHT, Direction.LEFT });
+
+                // checks when the available choices are to move down and left
+                choices = world.getChoices(new Vector2D(3, 1));
+                checkChoices(choices,
+                                new Direction[] { Direction.DOWN, Direction.LEFT });
+
+                // checks when the available choices are to move up and left
+                choices = world.getChoices(new Vector2D(3, 3));
+                checkChoices(choices,
+                                new Direction[] { Direction.UP, Direction.LEFT });
+        }