Import unit 1 tests

4 files changed, 218 insertions, 0 deletions

diff --git a/test/ch/epfl/xblast/CellTest.java b/test/ch/epfl/xblast/CellTest.java
new file mode 100644
index 0000000..ba8becc
--- /dev/null
+++ b/test/ch/epfl/xblast/CellTest.java
@@ -0,0 +1,68 @@
+package ch.epfl.xblast;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+
+public class CellTest {
+    @Test
+    public void rowMajorIndexCorrespondsToOrder() {
+        int i = 0;
+        for (Cell c: Cell.ROW_MAJOR_ORDER)
+            assertEquals(i++, c.rowMajorIndex());
+        assertEquals(Cell.COUNT, i);
+    }
+
+    @Test
+    public void spiralOrderContainsAllCells() {
+        assertEquals(Cell.COUNT, Cell.SPIRAL_ORDER.size());
+
+        boolean[] cellSeen = new boolean[Cell.COUNT];
+        for (Cell c: Cell.SPIRAL_ORDER) {
+            assertFalse(cellSeen[c.rowMajorIndex()]);
+            cellSeen[c.rowMajorIndex()] = true;
+        }
+    }
+
+    @Test
+    public void spiralOrderNeighborsAreSpatialNeighbors() {
+        Cell pred = Cell.SPIRAL_ORDER.get(0);
+        for (Cell c: Cell.SPIRAL_ORDER.subList(1, Cell.SPIRAL_ORDER.size())) {
+            int areNeighborsCount = 0;
+            for (Direction d: Direction.values()) {
+                if (pred.equals(c.neighbor(d)))
+                    areNeighborsCount += 1;
+            }
+            assertEquals(1, areNeighborsCount);
+            pred = c;
+        }
+    }
+
+    @Test
+    public void constructorCorrectlyNormalizesCoordinates() {
+        for (int i = -2; i <= 2; ++i) {
+            Cell c = new Cell(14 + 15 * i, 12 + 13 * i);
+            assertEquals(14, c.x());
+            assertEquals(12, c.y());
+        }
+    }
+
+    @Test
+    public void neighborsOfOriginAreCorrect() {
+        Cell c = new Cell(0, 0);
+        assertEquals(new Cell( 0, 12), c.neighbor(Direction.N));
+        assertEquals(new Cell( 1,  0), c.neighbor(Direction.E));
+        assertEquals(new Cell( 0,  1), c.neighbor(Direction.S));
+        assertEquals(new Cell(14,  0), c.neighbor(Direction.W));
+    }
+
+    @Test
+    public void oppositeNeighborOfNeighborIsThis() {
+        for (Cell c: Cell.ROW_MAJOR_ORDER) {
+            for (Direction d: Direction.values()) {
+                assertEquals(c, c.neighbor(d).neighbor(d.opposite()));
+            }
+        }
+    }
+}
diff --git a/test/ch/epfl/xblast/DirectionTest.java b/test/ch/epfl/xblast/DirectionTest.java
new file mode 100644
index 0000000..a2ac9cd
--- /dev/null
+++ b/test/ch/epfl/xblast/DirectionTest.java
@@ -0,0 +1,41 @@
+package ch.epfl.xblast;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class DirectionTest {
+    @Test
+    public void oppositeOfOppositeIsIdentity() {
+        for (Direction d: Direction.values())
+            assertEquals(d, d.opposite().opposite());
+    }
+
+    @Test
+    public void oppositeIsTwoStepsAway() {
+        for (Direction d: Direction.values())
+            assertEquals(2, Math.abs(d.ordinal() - d.opposite().ordinal()));
+    }
+
+    @Test
+    public void isHorizontalIsCorrect() {
+        assertFalse(Direction.N.isHorizontal());
+        assertTrue(Direction.E.isHorizontal());
+        assertFalse(Direction.S.isHorizontal());
+        assertTrue(Direction.W.isHorizontal());
+    }
+
+    @Test
+    public void isParallelIsTrueOnlyForOppositeAndSelf() {
+        for (Direction d1: Direction.values()) {
+            for (Direction d2: Direction.values()) {
+                if (d1 == d2 || d1 == d2.opposite())
+                    assertTrue(d1.isParallelTo(d2));
+                else
+                    assertFalse(d1.isParallelTo(d2));
+            }
+        }
+    }
+}
diff --git a/test/ch/epfl/xblast/SubCellTest.java b/test/ch/epfl/xblast/SubCellTest.java
new file mode 100644
index 0000000..1c79791
--- /dev/null
+++ b/test/ch/epfl/xblast/SubCellTest.java
@@ -0,0 +1,60 @@
+package ch.epfl.xblast;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class SubCellTest {
+    @Test
+    public void centralSubCellOfKnowCellIsCorrect() {
+        SubCell c = SubCell.centralSubCellOf(new Cell(2, 1));
+        assertEquals(40, c.x());
+        assertEquals(24, c.y());
+    }
+
+    @Test
+    public void centralSubCellIsCentral() {
+        for (Cell c: Cell.ROW_MAJOR_ORDER)
+            assertTrue(SubCell.centralSubCellOf(c).isCentral());
+    }
+
+    @Test
+    public void distanceToCentralOfCentralIsZero() {
+        for (Cell c: Cell.ROW_MAJOR_ORDER)
+            assertEquals(0, SubCell.centralSubCellOf(c).distanceToCentral());
+    }
+
+    @Test
+    public void constructorCorrectlyNormalizesCoordinates() {
+        for (int i = -2; i <= 2; ++i) {
+            SubCell c = new SubCell(239 + 240 * i, 207 + 208 * i);
+            assertEquals(239, c.x());
+            assertEquals(207, c.y());
+        }
+    }
+
+    @Test
+    public void distanceToCentralOfOriginIsCorrect() {
+        SubCell s = new SubCell(0, 0);
+        assertEquals(16, s.distanceToCentral());
+    }
+
+    @Test
+    public void neighborsOfOriginAreCorrect() {
+        SubCell c = new SubCell(0, 0);
+        assertEquals(new SubCell(  0, 207), c.neighbor(Direction.N));
+        assertEquals(new SubCell(  1,   0), c.neighbor(Direction.E));
+        assertEquals(new SubCell(  0,   1), c.neighbor(Direction.S));
+        assertEquals(new SubCell(239,   0), c.neighbor(Direction.W));
+    }
+
+    @Test
+    public void containingCellOfCentralsNeighborIsCorrect() {
+        for (Cell c: Cell.ROW_MAJOR_ORDER) {
+            SubCell s = SubCell.centralSubCellOf(c);
+            for (Direction d: Direction.values())
+                assertEquals(c, s.neighbor(d).containingCell());
+        }
+    }
+}
diff --git a/test/ch/epfl/xblast/namecheck/NameCheck01.java b/test/ch/epfl/xblast/namecheck/NameCheck01.java
new file mode 100644
index 0000000..278d85b
--- /dev/null
+++ b/test/ch/epfl/xblast/namecheck/NameCheck01.java
@@ -0,0 +1,49 @@
+package ch.epfl.xblast.namecheck;
+
+import java.util.List;
+
+import ch.epfl.xblast.Cell;
+import ch.epfl.xblast.Direction;
+import ch.epfl.xblast.SubCell;
+
+/**
+ * Classe abstraite utilisant tous les éléments de l'étape 1, 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 NameCheck01 {
+    void checkDirection() {
+        Direction d = Direction.N;
+        d = Direction.E;
+        d = Direction.S;
+        d = Direction.W;
+        if (d.isHorizontal() || d.isParallelTo(d))
+            d = d.opposite();
+    }
+
+    void checkCell() {
+        int c = Cell.COLUMNS;
+        int r = Cell.ROWS;
+        int t = Cell.COUNT;
+        List<Cell> l = Cell.ROW_MAJOR_ORDER;
+        l.get(c + r + t);
+        l = Cell.SPIRAL_ORDER;
+        l.get(c + r + t);
+        Cell d = new Cell(c, r);
+        c = d.x() + d.y() + d.rowMajorIndex();
+        d = d.neighbor(Direction.N);
+    }
+
+    void checkSubCell() {
+        SubCell c = SubCell.centralSubCellOf(new Cell(0,0));
+        c = new SubCell(0, 0);
+        int t = c.x() + c.y() + c.distanceToCentral();
+        if (t < 10 && c.isCentral())
+            c = c.neighbor(Direction.N);
+        else {
+            Cell cc = c.containingCell();
+            System.out.println(cc);
+        }
+    }
+}