4 files changed, 264 insertions, 0 deletions

diff --git a/test/ch/epfl/xblast/ListsTest.java b/test/ch/epfl/xblast/ListsTest.java
new file mode 100644
index 0000000..6a98b3f
--- /dev/null
+++ b/test/ch/epfl/xblast/ListsTest.java
@@ -0,0 +1,32 @@
+package ch.epfl.xblast;
+
+import java.util.List;
+import java.util.Arrays;
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+/**
+* @author Pacien TRAN-GIRARD (261948)
+* @author Timothée FLOURE (257420)
+*/
+public class ListsTest {
+    @Test(expected=IllegalArgumentException.class)
+    public void isEmptyListThrowingException() {
+        List<Integer> sampleList = Arrays.asList();
+        Lists.<Integer>mirrored(sampleList);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void isNullListThrowingException() {
+        List<Integer> sampleList = Arrays.asList();
+        Lists.<Integer>mirrored(sampleList);
+    }
+
+    @Test
+    public void isListMirrored() {
+        List<Integer> sampleList = Arrays.asList(1,2,3,4,5);
+        List<Integer> expected = Arrays.asList(1,2,3,4,5,4,3,2,1);
+
+        assertEquals(expected, Lists.<Integer>mirrored(sampleList));
+    }
+}
diff --git a/test/ch/epfl/xblast/namecheck/NameCheck02.java b/test/ch/epfl/xblast/namecheck/NameCheck02.java
new file mode 100644
index 0000000..978526e
--- /dev/null
+++ b/test/ch/epfl/xblast/namecheck/NameCheck02.java
@@ -0,0 +1,60 @@
+package ch.epfl.xblast.namecheck;
+
+import java.util.List;
+
+import ch.epfl.cs108.Sq;
+import ch.epfl.xblast.Cell;
+import ch.epfl.xblast.Lists;
+import ch.epfl.xblast.server.Block;
+import ch.epfl.xblast.server.Board;
+import ch.epfl.xblast.server.Ticks;
+
+/**
+ * Classe abstraite utilisant tous les éléments de l'étape 2, pour essayer de
+ * garantir que ceux-ci ont le bon nom et les bons types. Attention, ceci n'est
+ * pas un test unitaire, et n'a pas pour but d'être exécuté!
+ */
+
+abstract class NameCheck02 {
+    void checkTicks() {
+        int x = Ticks.PLAYER_DYING_TICKS
+                + Ticks.PLAYER_INVULNERABLE_TICKS
+                + Ticks.BOMB_FUSE_TICKS
+                + Ticks.EXPLOSION_TICKS
+                + Ticks.WALL_CRUMBLING_TICKS
+                + Ticks.BONUS_DISAPPEARING_TICKS;
+        System.out.println(x);
+    }
+
+    void checkBlock() {
+        Block b = Block.FREE;
+        b = Block.INDESTRUCTIBLE_WALL;
+        b = Block.DESTRUCTIBLE_WALL;
+        b = Block.CRUMBLING_WALL;
+        boolean d = b.isFree() && b.canHostPlayer() && b.castsShadow();
+        System.out.println(b + "/" + d);
+    }
+
+    void checkLists() {
+        List<Integer> l1 = null;
+        List<String> l2 = null;
+        List<List<String>> l3 = null;
+        List<Integer> l1m = Lists.<Integer>mirrored(l1);
+        List<String> l2m = Lists.<String>mirrored(l2);
+        List<List<String>> l3m = Lists.<List<String>>mirrored(l3);
+        System.out.println("" + l1m + l2m + l3m);
+    }
+
+    void checkBoard() {
+        List<List<Block>> q = null;
+        Board b = Board.ofQuadrantNWBlocksWalled(q);
+        b = Board.ofInnerBlocksWalled(q);
+        b = Board.ofRows(q);
+        List<Sq<Block>> cells = null;
+        b = new Board(cells);
+        Cell c = null;
+        Sq<Block> bs = b.blocksAt(c);
+        Block l = b.blockAt(c);
+        System.out.println(bs + "/" + l);
+    }
+}
diff --git a/test/ch/epfl/xblast/server/BlockTest.java b/test/ch/epfl/xblast/server/BlockTest.java
new file mode 100644
index 0000000..bbe4376
--- /dev/null
+++ b/test/ch/epfl/xblast/server/BlockTest.java
@@ -0,0 +1,35 @@
+package ch.epfl.xblast.server;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author Timothée FLOURE (257420)
+ * @author pacien TRAN-GIRARD (261948)
+ */
+public class BlockTest {
+    @Test
+    public void free() {
+        assertFalse(Block.INDESTRUCTIBLE_WALL.isFree());
+        assertFalse(Block.DESTRUCTIBLE_WALL.isFree());
+        assertFalse(Block.CRUMBLING_WALL.isFree());
+        assertTrue(Block.FREE.isFree());
+    }
+
+    @Test
+    public void canHostPlayer() {
+        assertFalse(Block.INDESTRUCTIBLE_WALL.canHostPlayer());
+        assertFalse(Block.DESTRUCTIBLE_WALL.canHostPlayer());
+        assertFalse(Block.CRUMBLING_WALL.canHostPlayer());
+        assertTrue(Block.FREE.canHostPlayer());
+    }
+
+    @Test
+    public void castSadhow() {
+        assertTrue(Block.INDESTRUCTIBLE_WALL.castsShadow());
+        assertTrue(Block.DESTRUCTIBLE_WALL.castsShadow());
+        assertTrue(Block.CRUMBLING_WALL.castsShadow());
+        assertFalse(Block.FREE.castsShadow());
+    }
+}
diff --git a/test/ch/epfl/xblast/server/BoardTest.java b/test/ch/epfl/xblast/server/BoardTest.java
new file mode 100644
index 0000000..7868e70
--- /dev/null
+++ b/test/ch/epfl/xblast/server/BoardTest.java
@@ -0,0 +1,137 @@
+package ch.epfl.xblast.server;
+
+import java.util.List;
+import java.util.ArrayList;
+import org.junit.Test;
+import ch.epfl.cs108.Sq;
+
+import static org.junit.Assert.*;
+
+/**
+ * @author Timothée FLOURE (257420)
+ * @author Pacien TRAN-GIRARD (261948)
+ */
+public class BoardTest {
+
+    @Test(expected=IllegalArgumentException.class)
+    public void isBoardBuilderEmptyInputThrowingException() {
+        List<Sq<Block>> blocks = new ArrayList<Sq<Block>>();
+        new Board(blocks);
+
+    }
+
+
+    @Test(expected=IllegalArgumentException.class)
+    public void isBoardBuilderIllegalInputThrowingException() {
+        List<Sq<Block>> blocks = new ArrayList<Sq<Block>>();
+
+        for (int i = 0;i<8;i++) {
+            blocks.add(Sq.constant(Block.FREE));
+        }
+
+        new Board(blocks);
+
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void isOfRowsEmptyInputMatrixThrowingException() {
+        List<List<Block>> rowsList = new ArrayList<List<Block>>();
+        Board.ofRows(rowsList);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void isOfRowsIllegalInputThrowingException() {
+        List<List<Block>> rowsList = new ArrayList<List<Block>>();
+        List<Block> sampleRow = new ArrayList<Block>();
+
+        for (int i = 0;i < 8 ;i++) {
+            sampleRow.add(Block.FREE);
+        }
+        rowsList.add(sampleRow);
+
+        assertTrue(Board.ofRows(rowsList) instanceof Board);
+    }
+
+    @Test
+    public void buildBoardFromRowsMatrix() {
+        List<List<Block>> rowsList = new ArrayList<List<Block>>() ;
+
+        for (int i = 0; i < 13; i++) {
+            List<Block> sampleRow = new ArrayList<Block>();
+            for (int j = 0; j < 15; j++) {
+                sampleRow.add(Block.FREE);
+            }
+            rowsList.add(sampleRow);
+        }
+
+        assertTrue(Board.ofRows(rowsList) instanceof Board);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void isOfInnerBlocksWalledEmptyInputMatrixThrowingException() {
+        List<List<Block>> rowsList = new ArrayList<List<Block>>();
+        Board.ofInnerBlocksWalled(rowsList);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void isOfInnerBlocksWalledIllegalInputThrowingException() {
+        List<List<Block>> rowsList = new ArrayList<List<Block>>();
+        List<Block> sampleRow = new ArrayList<Block>();
+
+        for (int i = 0;i < 8 ;i++) {
+            sampleRow.add(Block.FREE);
+        }
+        rowsList.add(sampleRow);
+
+        assertTrue(Board.ofInnerBlocksWalled(rowsList) instanceof Board);
+    }
+
+    @Test
+    public void buildBoardFromInnerBlocks() {
+        List<List<Block>> rowsList = new ArrayList<List<Block>>() ;
+
+        for (int i = 0; i < 11; i++) {
+            List<Block> sampleRow = new ArrayList<Block>();
+            for (int j = 0; j &l