Or Elimination, Or Introduction, Not Introduction, and And Introduction Test Cases

src/test/java/puzzles/shorttruthtable/rules/AndIntroductionDirectRuleTest.java

@@ -0,0 +1,105 @@
+package puzzles.shorttruthtable.rules;
+
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTable;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableBoard;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableCell;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableCellType;
+import edu.rpi.legup.puzzle.shorttruthtable.rules.basic.introduction.DirectRuleAndIntroduction;
+import edu.rpi.legup.save.InvalidFileFormatException;
+import legup.MockGameBoardFacade;
+import legup.TestUtilities;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class AndIntroductionDirectRuleTest {
+    private static final DirectRuleAndIntroduction RULE = new DirectRuleAndIntroduction();
+    private static ShortTruthTable stt;
+
+    @BeforeClass
+    public static void setup() {
+        MockGameBoardFacade.getInstance();
+        stt = new ShortTruthTable();
+    }
+
+    /**
+     * Given a statement: A ^ B
+     *
+     * Asserts that if at least 1 of A or B is false, then this is a valid application
+     * of the rule if and only if ^ is false.
+     *
+     * @param filePath The file path for test board setup.
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void FalseAndTest() throws InvalidFileFormatException {
+        String path = "puzzles/shorttruthtable/rules/AndIntroductionDirectRule/";
+        falseAndTestHelper(path + "FUF");
+        falseAndTestHelper(path + "FUU");
+        falseAndTestHelper(path + "UUF");
+        falseAndTestHelper(path + "FUT");
+        falseAndTestHelper(path + "TUF");
+    }
+
+    private void falseAndTestHelper(String filePath) throws InvalidFileFormatException {
+        TestUtilities.importTestBoard(filePath, stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+        ShortTruthTableCell and = board.getCell(1, 0);
+
+        and.setData(ShortTruthTableCellType.TRUE);
+        board.addModifiedData(and);
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        and.setData(ShortTruthTableCellType.FALSE);
+        board.addModifiedData(and);
+        Assert.assertNull(RULE.checkRule(transition));
+    }
+
+    /**
+     * Given a statement: A ^ B
+     *
+     * Asserts that setting ^ to true is a valid application of the rule if
+     * and only if both A and B are true.
+     *
+     * @param filePath The file path for test board setup.
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void FalseOrTest() throws InvalidFileFormatException {
+        String path = "puzzles/shorttruthtable/rules/AndIntroductionDirectRule/";
+        String[] letters = {"T", "F", "U"};
+        for (String first : letters) {
+            for (String second : letters) {
+                trueAndTestHelper(path + first + "U" + second);
+            }
+        }
+    }
+
+    private void trueAndTestHelper(String filePath) throws InvalidFileFormatException {
+        TestUtilities.importTestBoard(filePath, stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+        ShortTruthTableCell a = board.getCell(0, 0);
+        ShortTruthTableCell b = board.getCell(2, 0);
+        ShortTruthTableCell and = board.getCell(1, 0);
+
+        and.setData(ShortTruthTableCellType.TRUE);
+        board.addModifiedData(and);
+
+        if (a.getType() == ShortTruthTableCellType.TRUE && b.getType() == ShortTruthTableCellType.TRUE) {
+            Assert.assertNull(RULE.checkRule(transition));
+        }
+        else {
+            Assert.assertNotNull(RULE.checkRule(transition));
+        }
+    }
+}

src/test/java/puzzles/shorttruthtable/rules/NotIntroductionTest.java

@@ -0,0 +1,122 @@
+package puzzles.shorttruthtable.rules;
+
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTable;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableBoard;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableCell;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableCellType;
+import edu.rpi.legup.puzzle.shorttruthtable.rules.basic.introduction.DirectRuleNotIntroduction;
+import edu.rpi.legup.save.InvalidFileFormatException;
+import legup.MockGameBoardFacade;
+import legup.TestUtilities;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class NotIntroductionTest {
+    private static final DirectRuleNotIntroduction RULE = new DirectRuleNotIntroduction();
+    private static ShortTruthTable stt;
+
+    @BeforeClass
+    public static void setup() {
+        MockGameBoardFacade.getInstance();
+        stt = new ShortTruthTable();
+    }
+
+    /**
+     * Given one statement: ¬A where A is false
+     *
+     * Asserts that this is a valid application of this rule if and only if ¬ is true
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void FalseNot() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/NotIntroductionDirectRule/FalseA", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableCellType[] cellTypes = {ShortTruthTableCellType.TRUE, ShortTruthTableCellType.FALSE, ShortTruthTableCellType.UNKNOWN};
+
+        for (ShortTruthTableCellType cellType : cellTypes) {
+            ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+            ShortTruthTableCell not = board.getCell(0, 0);
+            not.setData(cellType);
+            board.addModifiedData(not);
+
+            if (cellType == ShortTruthTableCellType.TRUE) {
+                Assert.assertNull(RULE.checkRule(transition));
+            }
+            else {
+                Assert.assertNotNull(RULE.checkRule(transition));
+            }
+        }
+    }
+
+    /**
+     * Given one statement: ¬A where A is true
+     *
+     * Asserts that this is a valid application of this rule if and only if ¬ is false
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void TrueNot() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/NotIntroductionDirectRule/TrueA", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableCellType[] cellTypes = {ShortTruthTableCellType.TRUE, ShortTruthTableCellType.FALSE, ShortTruthTableCellType.UNKNOWN};
+
+        for (ShortTruthTableCellType cellType : cellTypes) {
+            ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+            ShortTruthTableCell not = board.getCell(0, 0);
+            not.setData(cellType);
+            board.addModifiedData(not);
+
+            if (cellType == ShortTruthTableCellType.FALSE) {
+                Assert.assertNull(RULE.checkRule(transition));
+            }
+            else {
+                Assert.assertNotNull(RULE.checkRule(transition));
+            }
+        }
+    }
+
+    /**
+     * Given one statement: ¬A
+     *
+     * Asserts that setting both ¬ and A to any values would not be a valid
+     * application of this rule
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void CannotSetBothAtOnceTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/NotIntroductionDirectRule/BlankA", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableCellType[] cellTypes = {ShortTruthTableCellType.TRUE, ShortTruthTableCellType.FALSE, ShortTruthTableCellType.UNKNOWN};
+
+        for (ShortTruthTableCellType cellType1 : cellTypes) {
+            for (ShortTruthTableCellType cellType2 : cellTypes) {
+                ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+                ShortTruthTableCell not = board.getCell(0, 0);
+                ShortTruthTableCell a = board.getCell(1, 0);
+
+                not.setData(cellType1);
+                a.setData(cellType2);
+
+                board.addModifiedData(not);
+                board.addModifiedData(a);
+
+                Assert.assertNotNull(RULE.checkRule(transition));
+            }
+        }
+    }
+}

src/test/java/puzzles/shorttruthtable/rules/OrEliminationTest.java

@@ -0,0 +1,150 @@
+package puzzles.shorttruthtable.rules;
+
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTable;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableBoard;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableCell;
+import edu.rpi.legup.puzzle.shorttruthtable.ShortTruthTableCellType;
+import edu.rpi.legup.puzzle.shorttruthtable.rules.basic.elimination.DirectRuleOrElimination;
+import edu.rpi.legup.save.InvalidFileFormatException;
+import legup.MockGameBoardFacade;
+import legup.TestUtilities;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class OrEliminationTest {
+    private static final DirectRuleOrElimination RULE = new DirectRuleOrElimination();
+    private static ShortTruthTable stt;
+
+    @BeforeClass
+    public static void setup() {
+        MockGameBoardFacade.getInstance();
+        stt = new ShortTruthTable();
+    }
+
+    /**
+     * Given a statement: A V B, where A is false and V is true
+     *
+     * Asserts that this is a valid application of the rule if and only if B is true.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void FTUTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/OrEliminationDirectRule/FTU", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+        ShortTruthTableCell cell = board.getCell(2, 0);
+
+        cell.setData(ShortTruthTableCellType.TRUE);
+        board.addModifiedData(cell);
+        Assert.assertNull(RULE.checkRule(transition));
+
+        cell.setData(ShortTruthTableCellType.FALSE);
+        board.addModifiedData(cell);
+        Assert.assertNotNull(RULE.checkRule(transition));
+    }
+
+    /**
+     * Given a statement: A V B, where B is false and V is true
+     *
+     * Asserts that this is a valid application of the rule if and only if B is true.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void UTFTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/OrEliminationDirectRule/UTF", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+        ShortTruthTableCell cell = board.getCell(0, 0);
+
+        cell.setData(ShortTruthTableCellType.TRUE);
+        board.addModifiedData(cell);
+        Assert.assertNull(RULE.checkRule(transition));
+
+        cell.setData(ShortTruthTableCellType.FALSE);
+        board.addModifiedData(cell);
+        Assert.assertNotNull(RULE.checkRule(transition));
+    }
+
+    /**
+     * Given a statement: A V B, where V is false
+     *
+     * Asserts that this is a valid application of the rule if and only if both A
+     * and B are false.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void UFUTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/OrEliminationDirectRule/UFU", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableCellType[] cellTypes = {ShortTruthTableCellType.TRUE, ShortTruthTableCellType.FALSE, ShortTruthTableCellType.UNKNOWN};
+
+        for (ShortTruthTableCellType cellType1 : cellTypes) {
+            for (ShortTruthTableCellType cellType2 : cellTypes) {
+                ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+                ShortTruthTableCell a = board.getCell(0, 0);
+                ShortTruthTableCell b = board.getCell(2, 0);
+
+                a.setData(cellType1);
+                b.setData(cellType2);
+
+                board.addModifiedData(a);
+                board.addModifiedData(b);
+
+                if (cellType1 == ShortTruthTableCellType.FALSE && cellType2 == ShortTruthTableCellType.FALSE) {
+                    Assert.assertNull(RULE.checkRule(transition));
+                }
+                else {
+                    Assert.assertNotNull(RULE.checkRule(transition));
+                }
+            }
+        }
+    }
+
+    /**
+     * Given a statement: A V B, where V is true
+     *
+     * Asserts that setting both A and B is not a valid application of this rule.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void UTUTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/OrEliminationDirectRule/UTU", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableCellType[] cellTypes = {ShortTruthTableCellType.TRUE, ShortTruthTableCellType.FALSE, ShortTruthTableCellType.UNKNOWN};
+
+        for (ShortTruthTableCellType cellType1 : cellTypes) {
+            for (ShortTruthTableCellType cellType2 : cellTypes) {
+                ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+                ShortTruthTableCell a = board.getCell(0, 0);
+                ShortTruthTableCell b = board.getCell(2, 0);
+
+                a.setData(cellType1);
+                b.setData(cellType2);
+
+                board.addModifiedData(a);
+                board.addModifiedData(b);
+
+                Assert.assertNotNull(RULE.checkRule(transition));
+            }
+        }
+    }
+}