Import new given intermediate tests

34 files changed, 8879 insertions, 4 deletions

diff --git a/test/ch/epfl/xblast/ArgumentCheckerTest.java b/test/ch/epfl/xblast/ArgumentCheckerTest.java
new file mode 100644
index 0000000..b439700
--- /dev/null
+++ b/test/ch/epfl/xblast/ArgumentCheckerTest.java
@@ -0,0 +1,36 @@
+package ch.epfl.xblast;
+
+import org.junit.Test;
+
+import static ch.epfl.xblast.ArgumentChecker.requireNonNegative;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author EPFL
+ */
+public class ArgumentCheckerTest {
+
+    @Test
+    public void requireNonNegativeAcceptPositives() {
+        assertEquals("Zero is accepted", 0, requireNonNegative(0));
+        assertEquals("One is accepted", 1, requireNonNegative(1));
+        assertEquals("42 is accepted", 42, requireNonNegative(42));
+        assertEquals("Max integer is accepted", Integer.MAX_VALUE, requireNonNegative(Integer.MAX_VALUE));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void requireNonNegativeRejectMinusOne() {
+        requireNonNegative(-1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void requireNonNegativeRejectMinus42() {
+        requireNonNegative(-42);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void requireNonNegativeRejectMinInteger() {
+        requireNonNegative(Integer.MIN_VALUE);
+    }
+
+}
diff --git a/test/ch/epfl/xblast/BlockEnumTests.java b/test/ch/epfl/xblast/BlockEnumTests.java
new file mode 100644
index 0000000..dcf2939
--- /dev/null
+++ b/test/ch/epfl/xblast/BlockEnumTests.java
@@ -0,0 +1,87 @@
+package ch.epfl.xblast;
+
+import org.junit.Test;
+
+import java.util.NoSuchElementException;
+
+import static ch.epfl.xblast.server.Block.*;
+import static ch.epfl.xblast.server.Bonus.INC_BOMB;
+import static ch.epfl.xblast.server.Bonus.INC_RANGE;
+import static org.junit.Assert.*;
+
+/**
+ * @author EPFL
+ */
+public class BlockEnumTests {
+
+    @Test
+    public void isFreeBehaviourIsCorrect() {
+        assertTrue(FREE.isFree());
+        assertFalse(INDESTRUCTIBLE_WALL.isFree());
+        assertFalse(DESTRUCTIBLE_WALL.isFree());
+        assertFalse(CRUMBLING_WALL.isFree());
+        assertFalse(BONUS_BOMB.isFree());
+        assertFalse(BONUS_RANGE.isFree());
+    }
+
+    @Test
+    public void canHostPlayerBehaviorIsCorrect() {
+        assertTrue(FREE.canHostPlayer());
+        assertTrue(BONUS_BOMB.canHostPlayer());
+        assertTrue(BONUS_RANGE.canHostPlayer());
+        assertFalse(INDESTRUCTIBLE_WALL.canHostPlayer());
+        assertFalse(DESTRUCTIBLE_WALL.canHostPlayer());
+        assertFalse(CRUMBLING_WALL.canHostPlayer());
+    }
+
+    @Test
+    public void castsShadowBehaviourIsCorrect() {
+        assertTrue(INDESTRUCTIBLE_WALL.castsShadow());
+        assertTrue(DESTRUCTIBLE_WALL.castsShadow());
+        assertTrue(CRUMBLING_WALL.castsShadow());
+        assertFalse(FREE.castsShadow());
+        assertFalse(BONUS_BOMB.castsShadow());
+        assertFalse(BONUS_RANGE.castsShadow());
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void freeBlockThrowsExceptionWhenRetrievingBonus() {
+        FREE.associatedBonus();
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void indestructibleWallBlockThrowsExceptionWhenRetrievingBonus() {
+        INDESTRUCTIBLE_WALL.associatedBonus();
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void destructibleWallBlockThrowsExceptionWhenRetrievingBonus() {
+        DESTRUCTIBLE_WALL.associatedBonus();
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void crumblingWallBlockThrowsExceptionWhenRetrievingBonus() {
+        CRUMBLING_WALL.associatedBonus();
+    }
+
+    @Test
+    public void bonusBombBlockHasCorrectBonus() {
+        assertEquals(INC_BOMB, BONUS_BOMB.associatedBonus());
+    }
+
+    @Test
+    public void bonusRangeBlockHasCorrectBonus() {
+        assertEquals(INC_RANGE, BONUS_RANGE.associatedBonus());
+    }
+
+    @Test
+    public void isBonusBehaviourIsCorrect() {
+        assertTrue(BONUS_RANGE.isBonus());
+        assertTrue(BONUS_BOMB.isBonus());
+        assertFalse(FREE.isBonus());
+        assertFalse(INDESTRUCTIBLE_WALL.isBonus());
+        assertFalse(DESTRUCTIBLE_WALL.isBonus());
+        assertFalse(CRUMBLING_WALL.isBonus());
+    }
+
+}
diff --git a/test/ch/epfl/xblast/BoardTests.java b/test/ch/epfl/xblast/BoardTests.java
new file mode 100644
index 0000000..7add23f
--- /dev/null
+++ b/test/ch/epfl/xblast/BoardTests.java
@@ -0,0 +1,217 @@
+package ch.epfl.xblast;
+
+import ch.epfl.cs108.Sq;
+import ch.epfl.xblast.server.Block;
+import ch.epfl.xblast.server.Board;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static ch.epfl.xblast.server.Block.*;
+import static org.junit.Assert.*;
+
+/**
+ * @author EPFL
+ */
+public class BoardTests {
+
+    @Test
+    public void boardClassIsImmutable() {
+        List<Sq<Block>> matrix = new ArrayList<>(Cell.COUNT);
+
+        for (int i = 0; i < Cell.COUNT; i++) {
+            matrix.add(Sq.constant(INDESTRUCTIBLE_WALL));
+        }
+
+        Board b = new Board(matrix);
+
+        for (int i = 0; i < Cell.COUNT; i++) {
+            matrix.set(i, matrix.get(i).limit(1).concat(Sq.constant(FREE)));
+        }
+
+        for (int y = 0; y < Cell.ROWS; y++) {
+            for (int x = 0; x < Cell.COLUMNS; x++) {
+                assertNotEquals(FREE, b.blocksAt(new Cell(x, y)).tail().head());
+            }
+        }
+
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void emptyListOfBlockSequencesRaisesException() {
+        new Board(new ArrayList<Sq<Block>>());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void invalidNumberOfBlockSequencesRaisesException() {
+        Sq<Block> freeBlockSequence = Sq.constant(FREE);
+        List<Sq<Block>> wholeBoardList = new ArrayList<>(Cell.COUNT);