diff --git a/src/test/java/puzzles/shorttruthtable/rules/AndEliminationDirectRuleTest.java b/src/test/java/puzzles/shorttruthtable/rules/AndEliminationDirectRuleTest.java
new file mode 100644
index 000000000..0d94eb672
--- /dev/null
+++ b/src/test/java/puzzles/shorttruthtable/rules/AndEliminationDirectRuleTest.java
@@ -0,0 +1,204 @@
+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.DirectRuleAndElimination;
+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 AndEliminationDirectRuleTest {
+    private static final DirectRuleAndElimination RULE = new DirectRuleAndElimination();
+    private static ShortTruthTable stt;
+
+    @BeforeClass
+    public static void setup() {
+        MockGameBoardFacade.getInstance();
+        stt = new ShortTruthTable();
+    }
+
+    /**
+     * Given one statement: B^C where ^ is true
+     * 
+     * Checks all possible combinations of true, false, and unknown for B and C
+     * except for where both B and C are true and asserts that each one of them
+     * is not a valid application of the rule.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void trueAndTest1() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/AndEliminationDirectRule/TrueAnd", 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) {
+                if (cellType1 == cellType2 && cellType1 == ShortTruthTableCellType.TRUE) {
+                    continue;
+                }
+
+                ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+                ShortTruthTableCell bonnie = board.getCell(0, 0);
+                ShortTruthTableCell clyde = board.getCell(2, 0);
+
+                if (cellType1 != ShortTruthTableCellType.UNKNOWN) {
+                    bonnie.setData(cellType1);
+                    board.addModifiedData(bonnie);
+                }
+
+                if (cellType2 != ShortTruthTableCellType.UNKNOWN) {
+                    clyde.setData(cellType2);
+                    board.addModifiedData(clyde);
+                }
+
+                Assert.assertNotNull(RULE.checkRule(transition));
+            }
+        }
+    }
+
+    /**
+     * Given one statement: B^C where ^ is true
+     * 
+     * Checks all possible combinations of true and unknown for B and C
+     * except for where both B and C are unknown and asserts that each one
+     * of them is a valid application of the rule.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void trueAndTest2() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/AndEliminationDirectRule/TrueAnd", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableCellType[] cellTypes = {ShortTruthTableCellType.TRUE, ShortTruthTableCellType.UNKNOWN};
+
+        for (ShortTruthTableCellType cellType1 : cellTypes) {
+            for (ShortTruthTableCellType cellType2 : cellTypes) {
+                if (cellType1 == cellType2 && cellType1 == ShortTruthTableCellType.UNKNOWN) {
+                    continue;
+                }
+
+                ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+                ShortTruthTableCell bonnie = board.getCell(0, 0);
+                ShortTruthTableCell clyde = board.getCell(2, 0);
+
+                if (cellType1 != ShortTruthTableCellType.UNKNOWN) {
+                    bonnie.setData(cellType1);
+                    board.addModifiedData(bonnie);
+                }
+
+                if (cellType2 != ShortTruthTableCellType.UNKNOWN) {
+                    clyde.setData(cellType2);
+                    board.addModifiedData(clyde);
+                }
+
+                Assert.assertNull(RULE.checkRule(transition));
+            }
+        }
+    }
+
+    /**
+     * Given one statement: B^C where ^ is false
+     * 
+     * Checks all possible combinations of true, false, and unknown for B and C
+     * and asserts that each one of them is not a valid application of the rule.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void falseAndWithUnknownsTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAnd", 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 bonnie = board.getCell(0, 0);
+                ShortTruthTableCell clyde = board.getCell(2, 0);
+
+                if (cellType1 != ShortTruthTableCellType.UNKNOWN) {
+                    bonnie.setData(cellType1);
+                    board.addModifiedData(bonnie);
+                }
+
+                if (cellType2 != ShortTruthTableCellType.UNKNOWN) {
+                    clyde.setData(cellType2);
+                    board.addModifiedData(clyde);
+                }
+
+                Assert.assertNotNull(RULE.checkRule(transition));
+            }
+        }
+    }
+
+    /**
+     * Given one statement: B^C where both B and ^ are false
+     * 
+     * Asserts that this is not a valid application of the rule if C is set to
+     * either true or false.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void falseAndWithKnownFalseTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownFalse", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+
+        ShortTruthTableCell clyde = board.getCell(2, 0);
+        clyde.setData(ShortTruthTableCellType.TRUE);
+        board.addModifiedData(clyde);
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        clyde.setData(ShortTruthTableCellType.FALSE);
+        board.addModifiedData(clyde);
+        Assert.assertNotNull(RULE.checkRule(transition));
+    }
+
+    /**
+     * Given one statement: B^C where B is true and ^ is false
+     * 
+     * Asserts that this is a valid application of the rule if and only if C is
+     * set to false.
+     *
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void falseAndWithKnownTrueTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownTrue", stt);
+        TreeNode rootNode = stt.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        ShortTruthTableBoard board = (ShortTruthTableBoard) transition.getBoard();
+
+        ShortTruthTableCell clyde = board.getCell(2, 0);
+        clyde.setData(ShortTruthTableCellType.TRUE);
+        board.addModifiedData(clyde);
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        clyde.setData(ShortTruthTableCellType.FALSE);
+        board.addModifiedData(clyde);
+        Assert.assertNull(RULE.checkRule(transition));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/puzzles/treetent/rules/FinishWithGrassDirectRuleTest.java b/src/test/java/puzzles/treetent/rules/FinishWithGrassDirectRuleTest.java
index 8dbec657a..2517df563 100644
--- a/src/test/java/puzzles/treetent/rules/FinishWithGrassDirectRuleTest.java
+++ b/src/test/java/puzzles/treetent/rules/FinishWithGrassDirectRuleTest.java
@@ -15,6 +15,8 @@
 import org.junit.Test;
 
 import java.awt.*;
+import java.util.List;
+import java.util.ArrayList;
 
 public class FinishWithGrassDirectRuleTest {
 
@@ -27,15 +29,24 @@ public static void setUp() {
         treetent = new TreeTent();
     }
 
+    /**
+     * 3x3 TreeTent puzzle with a tent at (0,0)
+     * Tests FinishWithGrassDirectRule on GRASS tiles horizontal of the tent
+     * at (1,0) and (2,0)
+     * 
+     * @throws InvalidFileFormatException
+     */
     @Test
-    public void EmptyFieldTest() throws InvalidFileFormatException {
-        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/FinishWithGrass", treetent);
+    public void FinishWithGrassHorizontalTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/CornerTent", treetent);
         TreeNode rootNode = treetent.getTree().getRootNode();
         TreeTransition transition = rootNode.getChildren().get(0);
         transition.setRule(RULE);
 
+        // get board state
         TreeTentBoard board = (TreeTentBoard) transition.getBoard();
 
+        // change the board's cells considering the FinishWithGrass rule
         TreeTentCell cell1 = board.getCell(1, 0);
         cell1.setData(TreeTentType.GRASS);
         TreeTentCell cell2 = board.getCell(2, 0);
@@ -44,21 +55,316 @@ public void EmptyFieldTest() throws InvalidFileFormatException {
         board.addModifiedData(cell1);
         board.addModifiedData(cell2);
 
+        // confirm there is a logical following of the EmptyField rule
         Assert.assertNull(RULE.checkRule(transition));
 
+        // only the cell above should change following the rule
+        TreeTentCell c;
         for (int i = 0; i < board.getHeight(); i++) {
             for (int k = 0; k < board.getWidth(); k++) {
-                Point point = new Point(k, i);
-                if (point.equals(cell1.getLocation()) || point.equals(cell2.getLocation())) {
-                    Assert.assertNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+                c = board.getCell(k, i);
+                if (c.getLocation().equals(cell1.getLocation()) || c.getLocation().equals(cell2.getLocation())) {
+                    // logically follows
+                    Assert.assertNull(RULE.checkRuleAt(transition, c));
                 }
                 else {
-                    Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+                    // does not use the rule to logically follow
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, c));
                 }
             }
         }
     }
-}
 
+    /**
+     * 3x3 TreeTent puzzle with a tent at (0,0)
+     * Tests FinishWithGrassDirectRule on GRASS tiles vertical of the tent
+     * at (0,1) and (0,2)
+     * 
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void FinishWithGrassVerticalTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/CornerTent", treetent);
+        TreeNode rootNode = treetent.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
 
+        // get board state
+        TreeTentBoard board = (TreeTentBoard) transition.getBoard();
 
+        // change the board's cells considering the FinishWithGrass rule
+        TreeTentCell cell1 = board.getCell(0, 1);
+        cell1.setData(TreeTentType.GRASS);
+        TreeTentCell cell2 = board.getCell(0, 2);
+        cell2.setData(TreeTentType.GRASS);
+
+        board.addModifiedData(cell1);
+        board.addModifiedData(cell2);
+
+        // confirm there is a logical following of the EmptyField rule
+        Assert.assertNull(RULE.checkRule(transition));
+
+        // only the cell above should change following the rule
+        TreeTentCell c;
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                c = board.getCell(k, i);
+                if (c.getLocation().equals(cell1.getLocation()) || c.getLocation().equals(cell2.getLocation())) {
+                    // logically follows
+                    Assert.assertNull(RULE.checkRuleAt(transition, c));
+                }
+                else {
+                    // does not use the rule to logically follow
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, c));
+                }
+            }
+        }
+    }
+
+    /**
+     * 3x3 TreeTent puzzle with a tent at (0,0)
+     * Tests FinishWithGrassDirectRule on GRASS tiles
+     * at (1,0), (2,0), (0,1), and (0,2)
+     * 
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void FinishWithGrassTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/CornerTent", treetent);
+        TreeNode rootNode = treetent.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        // get board state
+        TreeTentBoard board = (TreeTentBoard) transition.getBoard();
+
+        // change the board's cells considering the FinishWithGrass rule
+        TreeTentCell cell1 = board.getCell(1, 0);
+        cell1.setData(TreeTentType.GRASS);
+        TreeTentCell cell2 = board.getCell(2, 0);
+        cell2.setData(TreeTentType.GRASS);
+        TreeTentCell cell3 = board.getCell(0, 1);
+        cell3.setData(TreeTentType.GRASS);
+        TreeTentCell cell4 = board.getCell(0, 2);
+        cell4.setData(TreeTentType.GRASS);
+
+        board.addModifiedData(cell1);
+        board.addModifiedData(cell2);
+        board.addModifiedData(cell3);
+        board.addModifiedData(cell4);
+
+        // confirm there is a logical following of the EmptyField rule
+        Assert.assertNull(RULE.checkRule(transition));
+
+        // only the cell above should change following the rule
+        TreeTentCell c;
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                c = board.getCell(k, i);
+                if (c.getLocation().equals(cell1.getLocation()) ||
+                    c.getLocation().equals(cell2.getLocation()) ||
+                    c.getLocation().equals(cell3.getLocation()) ||
+                    c.getLocation().equals(cell4.getLocation())) {
+                    // logically follows
+                    Assert.assertNull(RULE.checkRuleAt(transition, c));
+                }
+                else {
+                    // does not use the rule to logically follow
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, c));
+                }
+            }
+        }
+    }
+
+    /**
+     * 3x3 TreeTent puzzle with no tents
+     * Tests FinishWithGrassDirectRule on GRASS tiles
+     * GRASS tiles fill entire board
+     * 
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void NoTentTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/NoTent", treetent);
+        TreeNode rootNode = treetent.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        // get board state
+        TreeTentBoard board = (TreeTentBoard) transition.getBoard();
+
+        // change the board's cells considering the FinishWithGrass rule
+        List<TreeTentCell> cells = new ArrayList<TreeTentCell>();
+        for (int i = 0; i < board.getWidth(); i++) {
+            for (int k = 0; k < board.getHeight(); k++) {
+                TreeTentCell c = board.getCell(i, k);
+                c.setData(TreeTentType.GRASS);
+                cells.add(c);
+            }
+        }
+
+        for (TreeTentCell c : cells) {
+            board.addModifiedData(c);
+        }
+
+        // confirm there is a logical following of the EmptyField rule
+        Assert.assertNull(RULE.checkRule(transition));
+
+        // all cells should change following the rule
+        for (TreeTentCell c : cells) {
+            // logically follows
+            Assert.assertNull(RULE.checkRuleAt(transition, c));
+        }
+    }
+    /**
+     * 3x3 TreeTent puzzle with a tent at (1,1)
+     * Tests FinishWithGrassDirectRule on GRASS tiles surrounding the tent
+     * at (1,0), (0,1), (2,1), and (1,2)
+     * 
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void MiddleTentTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/MiddleTent", treetent);
+        TreeNode rootNode = treetent.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        // get board state
+        TreeTentBoard board = (TreeTentBoard) transition.getBoard();
+
+        // change the board's cells considering the FinishWithGrass rule
+        TreeTentCell cell1 = board.getCell(1, 0);
+        TreeTentCell cell2 = board.getCell(0, 1);
+        TreeTentCell cell3 = board.getCell(2, 1);
+        TreeTentCell cell4 = board.getCell(1, 2);
+
+        cell1.setData(TreeTentType.GRASS);
+        cell2.setData(TreeTentType.GRASS);
+        cell3.setData(TreeTentType.GRASS);
+        cell4.setData(TreeTentType.GRASS);
+
+        board.addModifiedData(cell1);
+        board.addModifiedData(cell2);
+        board.addModifiedData(cell3);
+        board.addModifiedData(cell4);
+
+        // confirm there is a logical following of the EmptyField rule
+        Assert.assertNull(RULE.checkRule(transition));
+
+        // only the cell above should change following the rule
+        TreeTentCell c;
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                c = board.getCell(k, i);
+                if (c.getLocation().equals(cell1.getLocation()) ||
+                    c.getLocation().equals(cell2.getLocation()) ||
+                    c.getLocation().equals(cell3.getLocation()) ||
+                    c.getLocation().equals(cell4.getLocation())) {
+                    // logically follows
+                    Assert.assertNull(RULE.checkRuleAt(transition, c));
+                }
+                else {
+                    // does not use the rule to logically follow
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, c));
+                }
+            }
+        }
+    }
+
+    /**
+     * 3x3 TreeTent puzzle with missing tents
+     * Tests FinishWithGrassDirectRule on GRASS tiles filling the puzzle
+     * all GRASS tiles should fail the FinishWithGrassDirectRule
+     * 
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void FailTentTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/FailTent", treetent);
+        TreeNode rootNode = treetent.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        // get board state
+        TreeTentBoard board = (TreeTentBoard) transition.getBoard();
+
+        // change the board's cells not following the FinishWithGrass rule
+        List<TreeTentCell> cells = new ArrayList<TreeTentCell>();
+        for (int i = 0; i < board.getWidth(); i++) {
+            for (int k = 0; k < board.getHeight(); k++) {
+                TreeTentCell c = board.getCell(i, k);
+                c.setData(TreeTentType.GRASS);
+                cells.add(c);
+            }
+        }
+
+        for (TreeTentCell c : cells) {
+            board.addModifiedData(c);
+        }
+
+        // confirm there is a logical following of the EmptyField rule
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        // all cells should fail the rule test
+        for (TreeTentCell c : cells) {
+            // does not use the rule to logically follow
+            Assert.assertNotNull(RULE.checkRuleAt(transition, c));
+        }
+    }
+    /**
+     * 7x7 TreeTent puzzle with multiple tents spaced out
+     * Tests FinishWithGrassDirectRule on GRASS tiles between the tents
+     * at (0,3), (2,3), (4,3), and (6,3)
+     * 
+     * @throws InvalidFileFormatException
+     */
+    @Test
+    public void SpacedOutTentTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/treetent/rules/FinishWithGrassDirectRule/SpacedOutTent", treetent);
+        TreeNode rootNode = treetent.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        // get board state
+        TreeTentBoard board = (TreeTentBoard) transition.getBoard();
+
+        // change the board's cells considering the FinishWithGrass rule
+        TreeTentCell cell1 = board.getCell(0, 3);
+        TreeTentCell cell2 = board.getCell(2, 3);
+        TreeTentCell cell3 = board.getCell(4, 3);
+        TreeTentCell cell4 = board.getCell(6, 3);
+
+        cell1.setData(TreeTentType.GRASS);
+        cell2.setData(TreeTentType.GRASS);
+        cell3.setData(TreeTentType.GRASS);
+        cell4.setData(TreeTentType.GRASS);
+
+        board.addModifiedData(cell1);
+        board.addModifiedData(cell2);
+        board.addModifiedData(cell3);
+        board.addModifiedData(cell4);
+
+        // confirm there is a logical following of the EmptyField rule
+        Assert.assertNull(RULE.checkRule(transition));
+
+        // only the cell above should change following the rule
+        TreeTentCell c;
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                c = board.getCell(k, i);
+                if (c.getLocation().equals(cell1.getLocation()) ||
+                    c.getLocation().equals(cell2.getLocation()) ||
+                    c.getLocation().equals(cell3.getLocation()) ||
+                    c.getLocation().equals(cell4.getLocation())) {
+                    // logically follows
+                    Assert.assertNull(RULE.checkRuleAt(transition, c));
+                }
+                else {
+                    // does not use the rule to logically follow
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, c));
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAnd b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAnd
new file mode 100644
index 000000000..f6f60abc3
--- /dev/null
+++ b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAnd
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<Legup version="3.0.0">
+    <saved/>
+    <puzzle name="ShortTruthTable">
+        <board>
+            <data>
+                <statement representation="B^C" row_index="0"/>
+                <cell char_index="1" row_index="0" type="FALSE"/>
+            </data>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="2023-10-17 16:17:56"/>
+</Legup>
diff --git a/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownFalse b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownFalse
new file mode 100644
index 000000000..d8edf4a76
--- /dev/null
+++ b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownFalse
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<Legup version="3.0.0">
+    <saved/>
+    <puzzle name="ShortTruthTable">
+        <board>
+            <data>
+                <statement representation="B^C" row_index="0"/>
+                <cell char_index="0" row_index="0" type="FALSE"/>
+                <cell char_index="1" row_index="0" type="FALSE"/>
+            </data>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="2023-10-17 16:57:05"/>
+</Legup>
diff --git a/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownTrue b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownTrue
new file mode 100644
index 000000000..364d8faf6
--- /dev/null
+++ b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/FalseAndWithKnownTrue
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<Legup version="3.0.0">
+    <saved/>
+    <puzzle name="ShortTruthTable">
+        <board>
+            <data>
+                <statement representation="B^C" row_index="0"/>
+                <cell char_index="0" row_index="0" type="TRUE"/>
+                <cell char_index="1" row_index="0" type="FALSE"/>
+            </data>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="2023-10-17 16:57:05"/>
+</Legup>
diff --git a/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/TrueAnd b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/TrueAnd
new file mode 100644
index 000000000..307f6d14a
--- /dev/null
+++ b/src/test/resources/puzzles/shorttruthtable/rules/AndEliminationDirectRule/TrueAnd
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<Legup version="3.0.0">
+    <saved/>
+    <puzzle name="ShortTruthTable">
+        <board>
+            <data>
+                <statement representation="B^C" row_index="0"/>
+                <cell char_index="1" row_index="0" type="TRUE"/>
+            </data>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="2023-10-17 16:17:56"/>
+</Legup>
diff --git a/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/FinishWithGrass b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/CornerTent
similarity index 92%
rename from src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/FinishWithGrass
rename to src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/CornerTent
index 3e293d22f..daba3648e 100644
--- a/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/FinishWithGrass
+++ b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/CornerTent
@@ -10,7 +10,7 @@
                 <clue index="C" value="0"/>
             </axis>
             <axis side="south">
-                <clue index="1" value="0"/>
+                <clue index="1" value="1"/>
                 <clue index="2" value="0"/>
                 <clue index="3" value="0"/>
             </axis>
diff --git a/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/FailTent b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/FailTent
new file mode 100644
index 000000000..9fa14ebe4
--- /dev/null
+++ b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/FailTent
@@ -0,0 +1,19 @@
+<Legup>
+    <puzzle name="TreeTent">
+        <board height="3" width="3">
+            <cells>
+            </cells>
+            <axis side="east">
+                <clue index="A" value="1"/>
+                <clue index="B" value="1"/>
+                <clue index="C" value="1"/>
+            </axis>
+            <axis side="south">
+                <clue index="1" value="1"/>
+                <clue index="2" value="1"/>
+                <clue index="3" value="1"/>
+            </axis>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="--"/>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/MiddleTent b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/MiddleTent
new file mode 100644
index 000000000..8f71a57f9
--- /dev/null
+++ b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/MiddleTent
@@ -0,0 +1,20 @@
+<Legup>
+    <puzzle name="TreeTent">
+        <board height="3" width="3">
+            <cells>
+                <cell value="3" x="1" y="1"/>
+            </cells>
+            <axis side="east">
+                <clue index="A" value="0"/>
+                <clue index="B" value="1"/>
+                <clue index="C" value="0"/>
+            </axis>
+            <axis side="south">
+                <clue index="1" value="0"/>
+                <clue index="2" value="1"/>
+                <clue index="3" value="0"/>
+            </axis>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="--"/>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/NoTent b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/NoTent
new file mode 100644
index 000000000..a13c7cc55
--- /dev/null
+++ b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/NoTent
@@ -0,0 +1,19 @@
+<Legup>
+    <puzzle name="TreeTent">
+        <board height="3" width="3">
+            <cells>
+            </cells>
+            <axis side="east">
+                <clue index="A" value="0"/>
+                <clue index="B" value="0"/>
+                <clue index="C" value="0"/>
+            </axis>
+            <axis side="south">
+                <clue index="1" value="0"/>
+                <clue index="2" value="0"/>
+                <clue index="3" value="0"/>
+            </axis>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="--"/>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/SpacedOutTent b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/SpacedOutTent
new file mode 100644
index 000000000..f7b523b0a
--- /dev/null
+++ b/src/test/resources/puzzles/treetent/rules/FinishWithGrassDirectRule/SpacedOutTent
@@ -0,0 +1,30 @@
+<Legup>
+    <puzzle name="TreeTent">
+        <board height="7" width="7">
+            <cells>
+                <cell value="3" x="1" y="3"/>
+                <cell value="3" x="3" y="3"/>
+                <cell value="3" x="5" y="3"/>
+            </cells>
+            <axis side="east">
+                <clue index="A" value="0"/>
+                <clue index="B" value="0"/>
+                <clue index="C" value="0"/>
+                <clue index="D" value="3"/>
+                <clue index="E" value="0"/>
+                <clue index="F" value="0"/>
+                <clue index="G" value="0"/>
+            </axis>
+            <axis side="south">
+                <clue index="1" value="0"/>
+                <clue index="2" value="1"/>
+                <clue index="3" value="0"/>
+                <clue index="4" value="1"/>
+                <clue index="5" value="0"/>
+                <clue index="6" value="1"/>
+                <clue index="7" value="0"/>
+            </axis>
+        </board>
+    </puzzle>
+    <solved isSolved="false" lastSaved="--"/>
+</Legup>
\ No newline at end of file