diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
index a55e7a179..f23d52492 100644
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -1,5 +1,5 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default copy" />
   </state>
 </component>
\ No newline at end of file
diff --git a/bin/main/edu/rpi/legup/log4j2.properties b/bin/main/edu/rpi/legup/log4j2.properties
index de1fa02ed..4f2556c2d 100644
--- a/bin/main/edu/rpi/legup/log4j2.properties
+++ b/bin/main/edu/rpi/legup/log4j2.properties
@@ -1,15 +1,15 @@
-# Logging level
-# Root logger option
-log4j.rootLogger=DEBUG, stdout, file
-# Redirect log messages to console
-log4j.appender.stdout=org.apache.log4j.ConsoleAppender
-log4j.appender.stdout.Target=System.out
-log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
-log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p     %c{1}:%L - %m%n
-# Redirect log messages to a log file, support file rolling.
-log4j.appender.file=org.apache.log4j.RollingFileAppender
-log4j.appender.file.File=Legup.log
-log4j.appender.file.MaxFileSize=5MB
-log4j.appender.file.MaxBackupIndex=10
-log4j.appender.file.layout=org.apache.log4j.PatternLayout
+# Logging level
+# Root logger option
+log4j.rootLogger=DEBUG, stdout, file
+# Redirect log messages to console
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p     %c{1}:%L - %m%n
+# Redirect log messages to a log file, support file rolling.
+log4j.appender.file=org.apache.log4j.RollingFileAppender
+log4j.appender.file.File=Legup.log
+log4j.appender.file.MaxFileSize=5MB
+log4j.appender.file.MaxBackupIndex=10
+log4j.appender.file.layout=org.apache.log4j.PatternLayout
 log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
\ No newline at end of file
diff --git a/src/test/java/puzzles/nurikabe/rules/BlackBetweenRegionsDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/BlackBetweenRegionsDirectRuleTest.java
index b32ce23ce..7e8b5eb83 100644
--- a/src/test/java/puzzles/nurikabe/rules/BlackBetweenRegionsDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/BlackBetweenRegionsDirectRuleTest.java
@@ -30,6 +30,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Black Between Regions direct rule for regions that are diagonal to each other (diagonal going from top left to bottom right)
+     */
     @Test
     public void BlackBetweenRegionsDirectRule_DiagonalBlackBetweenRegions1Test() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/DiagonalBlackBetweenRegions1", nurikabe);
@@ -62,6 +65,9 @@ public void BlackBetweenRegionsDirectRule_DiagonalBlackBetweenRegions1Test() thr
         }
     }
 
+    /**
+     * Tests the Black Between Regions direct rule for regions that are diagonal to each other (diagonal going from bottom left to top right)
+     */
     @Test
     public void BlackBetweenRegionsDirectRule_DiagonalBlackBetweenRegions2Test() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/DiagonalBlackBetweenRegions2", nurikabe);
@@ -94,6 +100,9 @@ public void BlackBetweenRegionsDirectRule_DiagonalBlackBetweenRegions2Test() thr
         }
     }
 
+    /**
+     * Tests the Black Between Regions direct rule for regions that are horizontally opposite each other
+     */
     @Test
     public void BlackBetweenRegionsDirectRule_HorizontalBlackBetweenRegionsTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/HorizontalBlackBetweenRegions", nurikabe);
@@ -123,6 +132,9 @@ public void BlackBetweenRegionsDirectRule_HorizontalBlackBetweenRegionsTest() th
         }
     }
 
+    /**
+     * Tests the Black Between Regions direct rule for regions that are vertically opposite each other
+     */
     @Test
     public void BlackBetweenRegionsDirectRule_VerticalBlackBetweenRegionsTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/VerticalBlackBetweenRegions", nurikabe);
@@ -151,4 +163,28 @@ public void BlackBetweenRegionsDirectRule_VerticalBlackBetweenRegionsTest() thro
             }
         }
     }
+
+    /**
+     * Tests the Black Between Regions direct rule for a false application of the rule, where a black tile is enclosed by one region
+     */
+    @Test
+    public void BlackBetweenRegionsDirectRule_FalseBlackBetweenRegionsTest() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/FalseBlackBetweenRegions",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell = board.getCell(1,1);
+        cell.setData(NurikabeType.BLACK.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        for(int i=0; i<board.getHeight(); i++){
+            for(int k=0; k<board.getWidth(); k++){
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/BlackBottleNeckDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/BlackBottleNeckDirectRuleTest.java
index 91dcec802..3fe58d164 100644
--- a/src/test/java/puzzles/nurikabe/rules/BlackBottleNeckDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/BlackBottleNeckDirectRuleTest.java
@@ -27,6 +27,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Black BottleNeck direct rule for a bottleneck in the center of the board
+     */
     @Test
     public void BlackBottleNeckDirectRule_TwoSurroundBlackTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBottleNeckDirectRule/SimpleBlackBottleNeck", nurikabe);
@@ -54,4 +57,64 @@ public void BlackBottleNeckDirectRule_TwoSurroundBlackTest() throws InvalidFileF
             }
         }
     }
+
+
+    /**
+     * Tests the Black BottleNeck direct rule for a bottleneck in the corner of the board
+     */
+    @Test
+    public void BlackBottleNeckDirectRule_CornerBottleneck() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBottleNeckDirectRule/CornerBottleNeck", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard)transition.getBoard();
+        NurikabeCell cell = board.getCell(0,1);
+        cell.setData(NurikabeType.BLACK.toValue());
+
+        board.addModifiedData(cell);
+
+        Assert.assertNull(RULE.checkRule(transition));
+
+        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(cell.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+                }
+                else {
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Tests the Black BottleNeck direct rule for a false bottleneck
+     */
+    @Test
+    public void BlackBottleNeckDirectRule_FalseBottleneck() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackBottleNeckDirectRule/FalseBottleNeck", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard)transition.getBoard();
+        NurikabeCell cell = board.getCell(0,1);
+        cell.setData(NurikabeType.BLACK.toValue());
+
+        board.addModifiedData(cell);
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        for(int i = 0; i < board.getHeight(); i++){
+            for(int k = 0; k < board.getWidth(); k++){
+                Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+            }
+        }
+    }
 }
+
+
diff --git a/src/test/java/puzzles/nurikabe/rules/BlackOrWhiteCaseRuleTest.java b/src/test/java/puzzles/nurikabe/rules/BlackOrWhiteCaseRuleTest.java
index d270204ac..755b166cd 100644
--- a/src/test/java/puzzles/nurikabe/rules/BlackOrWhiteCaseRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/BlackOrWhiteCaseRuleTest.java
@@ -1,6 +1,10 @@
 package puzzles.nurikabe.rules;
 
+import edu.rpi.legup.model.gameboard.Board;
 import edu.rpi.legup.puzzle.nurikabe.NurikabeBoard;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeCell;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeType;
+import edu.rpi.legup.puzzle.nurikabe.rules.BlackOrWhiteCaseRule;
 import legup.MockGameBoardFacade;
 import legup.TestUtilities;
 import edu.rpi.legup.model.tree.TreeNode;
@@ -12,11 +16,13 @@
 import edu.rpi.legup.puzzle.nurikabe.rules.TooFewSpacesContradictionRule;
 import edu.rpi.legup.save.InvalidFileFormatException;
 
+import java.util.ArrayList;
+
 import java.awt.*;
 
 public class BlackOrWhiteCaseRuleTest {
 
-    private static final TooFewSpacesContradictionRule RULE = new TooFewSpacesContradictionRule();
+    private static final BlackOrWhiteCaseRule RULE = new BlackOrWhiteCaseRule();
     private static Nurikabe nurikabe;
 
     @BeforeClass
@@ -25,27 +31,45 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Black Or White case rule by ensuring that it results in two  children, that contain a modified cell that is either black or white
+     */
     @Test
     public void TooFewSpacesContradictionRule_TwoSurroundBlackTest() throws InvalidFileFormatException {
-        TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooFewSpacesContradictionRule/TwoSurroundBlack", nurikabe);
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackOrWhiteCaseRule/SimpleBlackOrWhite", nurikabe);
         TreeNode rootNode = nurikabe.getTree().getRootNode();
         TreeTransition transition = rootNode.getChildren().get(0);
         transition.setRule(RULE);
 
-        Assert.assertNull(RULE.checkContradiction((NurikabeBoard) transition.getBoard()));
-
         NurikabeBoard board = (NurikabeBoard) transition.getBoard();
-        Point location = new Point(1, 1);
-        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(location)) {
-                    Assert.assertNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
-                }
-                else {
-                    Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+        NurikabeCell cell = board.getCell(0,0);
+        ArrayList<Board> cases = RULE.getCases(board,cell);
+
+        Assert.assertEquals(2,cases.size());
+
+        NurikabeBoard caseBoard = (NurikabeBoard) cases.get(0);
+        NurikabeBoard caseBoard2 = (NurikabeBoard) cases.get(1);
+
+        NurikabeType board1Type = caseBoard.getCell(0,0).getType();
+        NurikabeType board2Type = caseBoard2.getCell(0,0).getType();
+
+        Assert.assertTrue((board1Type.equals(NurikabeType.BLACK) || board1Type.equals(NurikabeType.WHITE)) &&
+                (board2Type.equals(NurikabeType.BLACK) || board2Type.equals(NurikabeType.WHITE)));
+        Assert.assertFalse(board1Type.equals(board2Type));
+
+        Assert.assertEquals(caseBoard.getHeight(),caseBoard2.getHeight(), board.getHeight());
+        Assert.assertEquals(caseBoard.getWidth(),caseBoard2.getWidth(), board.getWidth());
+
+        for(int i=0; i<caseBoard.getHeight(); i++){
+            for(int k=0; k<caseBoard.getWidth(); k++){
+                Point point = new Point(k,i);
+                if(point.equals(caseBoard.getCell(k,i).getLocation())){
+                    continue;
                 }
+                Assert.assertTrue(caseBoard.getCell(k,i).equals(caseBoard2.getCell(k,i)));
             }
         }
+
+
     }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/BlackSquareContradictionRuleTest.java b/src/test/java/puzzles/nurikabe/rules/BlackSquareContradictionRuleTest.java
index 7c0a00dd5..b06d0e32c 100644
--- a/src/test/java/puzzles/nurikabe/rules/BlackSquareContradictionRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/BlackSquareContradictionRuleTest.java
@@ -25,6 +25,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Black Square contradiction rule for a black square in the middle of the board
+     */
     @Test
     public void BlackSquareContradictionRule_TwoSurroundBlackTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackSquareContradictionRule/SimpleBlackSquare", nurikabe);
@@ -53,4 +56,56 @@ public void BlackSquareContradictionRule_TwoSurroundBlackTest() throws InvalidFi
             }
         }
     }
+
+    /**
+     * Tests the Black Square contradiction rule for a square in the corner of the board
+     */
+    @Test
+    public void BlackSquareContradictionRule_CornerSquareTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackSquareContradictionRule/CornerBlackSquare",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell1 = board.getCell(2,2);
+        NurikabeCell cell2 = board.getCell(2,3);
+        NurikabeCell cell3 = board.getCell(3,2);
+        NurikabeCell cell4 = board.getCell(3,3);
+
+        Assert.assertNull(RULE.checkContradiction((NurikabeBoard) transition.getBoard()));
+        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()) ||
+                        point.equals(cell3.getLocation()) || point.equals(cell4.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Black Square contradiction rule for a false contradiction
+     */
+    @Test
+    public void BlackSquareContradictionRule_FalseBlackSquareTest() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/BlackSquareContradictionRule/FalseBlackSquare", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+
+        Assert.assertNotNull(RULE.checkContradiction((NurikabeBoard) transition.getBoard()));
+
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/CannotReachCellDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/CannotReachCellDirectRuleTest.java
new file mode 100644
index 000000000..267f57f6d
--- /dev/null
+++ b/src/test/java/puzzles/nurikabe/rules/CannotReachCellDirectRuleTest.java
@@ -0,0 +1,94 @@
+package puzzles.nurikabe.rules;
+
+import legup.MockGameBoardFacade;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.Assert;
+import edu.rpi.legup.puzzle.nurikabe.Nurikabe;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeBoard;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeCell;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeType;
+import edu.rpi.legup.puzzle.nurikabe.rules.CannotReachCellDirectRule;
+import edu.rpi.legup.save.InvalidFileFormatException;
+import legup.TestUtilities;
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import java.awt.*;
+
+public class CannotReachCellDirectRuleTest {
+
+    private static final CannotReachCellDirectRule RULE = new CannotReachCellDirectRule();
+    private static Nurikabe nurikabe;
+
+    @BeforeClass
+    public static void setUp() {
+        MockGameBoardFacade.getInstance();
+        nurikabe = new Nurikabe();
+    }
+
+    /**
+     * Tests the Cannot Reach Cell direct rule for a simple unreachable cell
+     */
+    @Test
+    public void CannotReachCellDirectRule_SimpleUnreachableCell() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/CannotReachCellDirectRule/SimpleUnreachableCell", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+
+        NurikabeBoard board = (NurikabeBoard)transition.getBoard();
+        NurikabeCell cell = board.getCell(0,0);
+        cell.setData(NurikabeType.BLACK.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNull(RULE.checkRule(transition));
+
+        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(cell.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Cannot Reach Cell direct rule for a more complex board with all cells reachable
+     */
+    @Test
+    public void CannotReachCellDirectRule_AllCellsReachable() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/CannotReachCellDirectRule/AllCellsReachable", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+
+        NurikabeBoard board = (NurikabeBoard)transition.getBoard();
+
+        NurikabeCell cell1 = board.getCell(2,3);
+        NurikabeCell cell2 = board.getCell(0,1);
+        NurikabeCell cell3 = board.getCell(4,1);
+
+
+        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()) || point.equals(cell3.getLocation()))){
+                    NurikabeCell newCell = board.getCell(k, i);
+                    newCell.setData(NurikabeType.BLACK.toValue());
+                    board.addModifiedData(newCell);
+                }
+            }
+        }
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        for(int i=0; i<board.getHeight(); i++){
+            for(int k=0; k<board.getWidth(); k++){
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
+}
diff --git a/src/test/java/puzzles/nurikabe/rules/CornerBlackDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/CornerBlackDirectRuleTest.java
index 0ee3c247b..df8a3d44e 100644
--- a/src/test/java/puzzles/nurikabe/rules/CornerBlackDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/CornerBlackDirectRuleTest.java
@@ -28,9 +28,12 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Corner Black direct rule for a simple corner black tile
+     */
     @Test
     public void CornerBlackContradictionRule_SimpleCornerBlackTest() throws InvalidFileFormatException {
-        TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooFewSpacesContradictionRule/TwoSurroundBlack", nurikabe);
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/CornerBlackDirectRule/SimpleCornerBlack", nurikabe);
         TreeNode rootNode = nurikabe.getTree().getRootNode();
         TreeTransition transition = rootNode.getChildren().get(0);
         NurikabeBoard board = (NurikabeBoard) transition.getBoard();
@@ -40,12 +43,12 @@ public void CornerBlackContradictionRule_SimpleCornerBlackTest() throws InvalidF
         cell.setData(NurikabeType.BLACK.toValue());
         board.addModifiedData(cell);
 
-        Assert.assertNotNull(RULE.checkRule(transition));
+        Assert.assertNull(RULE.checkRule(transition));
 
         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(cell)) {
+                if(point.equals(cell.getLocation())) {
                     Assert.assertNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
                 }
                 else {
@@ -54,4 +57,28 @@ public void CornerBlackContradictionRule_SimpleCornerBlackTest() throws InvalidF
             }
         }
     }
+
+    /**
+     * Tests the Corner Black direct rule for a false application of the rule
+     */
+    @Test
+    public void CornerBlackContradictionRule_FalseCornerBlackTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/CornerBlackDirectRule/FalseCornerBlack", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        transition.setRule(RULE);
+
+        NurikabeCell cell = board.getCell(2, 0);
+        cell.setData(NurikabeType.BLACK.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        for(int i = 0; i < board.getHeight(); i++) {
+            for(int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/FillinBlackDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/FillinBlackDirectRuleTest.java
index a1c8f58bc..41bccb82d 100644
--- a/src/test/java/puzzles/nurikabe/rules/FillinBlackDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/FillinBlackDirectRuleTest.java
@@ -1,11 +1,13 @@
 package puzzles.nurikabe.rules;
 
+import edu.rpi.legup.model.gameboard.Board;
 import legup.MockGameBoardFacade;
 import legup.TestUtilities;
 import edu.rpi.legup.model.tree.TreeNode;
 import edu.rpi.legup.model.tree.TreeTransition;
 import org.junit.Assert;
 import org.junit.BeforeClass;
+import org.junit.Rule;
 import org.junit.Test;
 import edu.rpi.legup.puzzle.nurikabe.Nurikabe;
 import edu.rpi.legup.puzzle.nurikabe.NurikabeBoard;
@@ -27,6 +29,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Fillin Black direct rule for a square surrounded by black in the middle of the board
+     */
     @Test
     public void FillinBlackDirectRule_UnknownSurroundBlackTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinBlackDirectRule/UnknownSurroundBlack", nurikabe);
@@ -54,4 +59,85 @@ public void FillinBlackDirectRule_UnknownSurroundBlackTest() throws InvalidFileF
             }
         }
     }
+
+    /**
+     * Tests the Fillin Black direct rule for a square surrounded by black in the top left corner of the board
+     */
+    @Test
+    public void FillinBlackDirectRule_CornerTest1() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack1",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell = board.getCell(0,0);
+        cell.setData(NurikabeType.BLACK.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNull(RULE.checkRule(transition));
+        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(cell.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Fillin Black direct rule for a square surrounded by black in the bottom right corner of the board
+     */
+    @Test
+    public void FillinBlackDirectRule_CornerTest2() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack2",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell = board.getCell(2,2);
+        cell.setData(NurikabeType.BLACK.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNull(RULE.checkRule(transition));
+        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(cell.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Fillin Black direct rule for a false application of the rule
+     */
+    @Test
+    public void FillinBlackDirectRule_FalseTest() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinBlackDirectRule/FalseFillinBlack", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell = board.getCell(1, 1);
+        cell.setData(NurikabeType.BLACK.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+        for(int i=0; i<board.getHeight(); i++){
+            for(int k=0; k<board.getWidth(); k++){
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/FillinWhiteDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/FillinWhiteDirectRuleTest.java
index 4acc54f98..47accdf17 100644
--- a/src/test/java/puzzles/nurikabe/rules/FillinWhiteDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/FillinWhiteDirectRuleTest.java
@@ -27,6 +27,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Fillin White direct rule for a square surrounded by white in the middle of the board
+     */
     @Test
     public void FillinWhiteDirectRule_UnknownSurroundWhiteTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinWhiteDirectRule/UnknownSurroundWhite", nurikabe);
@@ -54,4 +57,88 @@ public void FillinWhiteDirectRule_UnknownSurroundWhiteTest() throws InvalidFileF
             }
         }
     }
+
+    /**
+     * Tests the Fillin White direct rule for a square surrounded by white in the top left corner of the board
+     */
+    @Test
+    public void FillinWhiteDirectRule_CornerTest1() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite1",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell = board.getCell(0,0);
+        cell.setData(NurikabeType.WHITE.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNull(RULE.checkRule(transition));
+        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(cell.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Fillin White direct rule for a square surrounded by white in the bottom right corner of the board
+     */
+    @Test
+    public void FillinWhiteDirectRule_CornerTest2() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite2",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell = board.getCell(2,2);
+        cell.setData(NurikabeType.WHITE.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNull(RULE.checkRule(transition));
+        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(cell.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Fillin White direct rule for a false application of the rule
+     */
+    @Test
+    public void FillinWhiteDirectRule_FalseTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/FillinWhiteDirectRule/FalseFillinWhite", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell = board.getCell(1,1);
+        cell.setData(NurikabeType.WHITE.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        Point location = new Point(1, 1);
+        for(int i = 0; i < board.getHeight(); i++) {
+            for(int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
+
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/IsolateBlackContradictionRuleTest.java b/src/test/java/puzzles/nurikabe/rules/IsolateBlackContradictionRuleTest.java
index 11a5e8f7d..26216fde1 100644
--- a/src/test/java/puzzles/nurikabe/rules/IsolateBlackContradictionRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/IsolateBlackContradictionRuleTest.java
@@ -1,6 +1,7 @@
 package puzzles.nurikabe.rules;
 
 import edu.rpi.legup.puzzle.nurikabe.NurikabeBoard;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeCell;
 import legup.MockGameBoardFacade;
 import legup.TestUtilities;
 import edu.rpi.legup.model.tree.TreeNode;
@@ -25,25 +26,83 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Isolate Black contradiction rule for a black square in the corner, separated by a diagonal of white squares
+     */
     @Test
     public void IsolateBlackContradictionRule_SimpleIsolateBlackTest() throws InvalidFileFormatException {
-//        TestUtilities.importTestBoard("puzzles/nurikabe/rules/IsolateBlackContradictionRule/SimpleIsolateBlack", nurikabe);
-//        TreeNode rootNode = nurikabe.getTree().getRootNode();
-//        TreeTransition transition = rootNode.getChildren().get(0);
-//        transition.setRule(RULE);
-//
-//        Assert.assertNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
-//
-//        NurikabeBoard board = (NurikabeBoard)transition.getBoard();
-//        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(new Point(0, 0)) || point.equals(new Point(3, 3))) {
-//                    Assert.assertNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
-//                } else {
-//                    Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
-//                }
-//            }
-//        }
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/IsolateBlackContradictionRule/SimpleIsolateBlack", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell1 = board.getCell(0,0);
+        NurikabeCell cell2 = board.getCell(2,2);
+
+        Assert.assertNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+
+        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)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Isolate Black contradiction rule for diagonally connected black squares
+     */
+    @Test
+    public void IsolateBlackContradictionRule_DiagonalBlackTest() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/IsolateBlackContradictionRule/DiagonalIsolateBlack", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell1 = board.getCell(0,0);
+        NurikabeCell cell2 = board.getCell(1,1);
+        NurikabeCell cell3 = board.getCell(2,2);
+
+        Assert.assertNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+
+        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()) ||
+                        point.equals(cell3.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Isolate Black contradiction rule for a false contradiction
+     */
+    @Test
+    public void IsolateBlackContradictionRule_FalseIsolateBlackTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/IsolateBlackContradictionRule/FalseIsolateBlack",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+        for(int i=0; i<board.getHeight(); i++){
+            for(int k=0; k<board.getWidth(); k++){
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
     }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/MultipleNumbersContradictionRuleTest.java b/src/test/java/puzzles/nurikabe/rules/MultipleNumbersContradictionRuleTest.java
index 5d855ce40..67995bffc 100644
--- a/src/test/java/puzzles/nurikabe/rules/MultipleNumbersContradictionRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/MultipleNumbersContradictionRuleTest.java
@@ -1,6 +1,7 @@
 package puzzles.nurikabe.rules;
 
 import edu.rpi.legup.puzzle.nurikabe.NurikabeBoard;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeCell;
 import legup.MockGameBoardFacade;
 import legup.TestUtilities;
 import edu.rpi.legup.model.tree.TreeNode;
@@ -25,6 +26,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Multiple Numbers contradiction rule for a single region with multiple numbers
+     */
     @Test
     public void MultipleNumbersContradictionRule_TwoSurroundBlackTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/MultipleNumbersContradictionRule/MultipleNumbers", nurikabe);
@@ -47,4 +51,57 @@ public void MultipleNumbersContradictionRule_TwoSurroundBlackTest() throws Inval
             }
         }
     }
+
+    /**
+     * Tests the Multiple Numbers contradiction rule for a more complex regions with multiple numbers
+     */
+    @Test
+    public void MultipleNumbersContradictionRule_ComplexRegion() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/MultipleNumbersContradictionRule/ComplexRegion",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell1 = board.getCell(0,0);
+        NurikabeCell cell2 = board.getCell(2,0);
+        NurikabeCell cell3 = board.getCell(4,0);
+        NurikabeCell cell4 = board.getCell(2,3);
+        NurikabeCell cell5 = board.getCell(4,4);
+
+        Assert.assertNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+        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()) || point.equals(cell3.getLocation())
+                   || point.equals(cell4.getLocation()) || point.equals(cell5.getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Multiple Numbers contradiction rule for two regions with one number each, separated diagonally
+     */
+    @Test
+    public void MultipleNumbersContradictionRule_FalseContradiction() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/MultipleNumbersContradictionRule/FalseContradiction", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        Assert.assertNotNull(RULE.checkContradiction((NurikabeBoard) transition.getBoard()));
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
+
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/NoNumbersContradictionRuleTest.java b/src/test/java/puzzles/nurikabe/rules/NoNumbersContradictionRuleTest.java
index 2852f3400..ebba034d1 100644
--- a/src/test/java/puzzles/nurikabe/rules/NoNumbersContradictionRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/NoNumbersContradictionRuleTest.java
@@ -5,6 +5,7 @@
 import legup.TestUtilities;
 import edu.rpi.legup.model.tree.TreeNode;
 import edu.rpi.legup.model.tree.TreeTransition;
+import org.codehaus.jackson.annotate.JsonTypeInfo;
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -25,9 +26,12 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the No Number contradiction rule for a white region enclosed by black squares
+     */
     @Test
     public void NoNumberContradictionRule_NoNumberSurroundBlack() throws InvalidFileFormatException {
-        TestUtilities.importTestBoard("puzzles/nurikabe/rules/NoNumberContradictionRule/NoNumberSurroundBlack", nurikabe);
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/NoNumberContradictionRule/SimpleNoNumber", nurikabe);
         TreeNode rootNode = nurikabe.getTree().getRootNode();
         TreeTransition transition = rootNode.getChildren().get(0);
         transition.setRule(RULE);
@@ -49,14 +53,33 @@ public void NoNumberContradictionRule_NoNumberSurroundBlack() throws InvalidFile
         }
     }
 
-    //    Checks if a transition produces a room without a number.
+    /**
+     * Tests the No Number contradiction rule for a false contradiction
+     */
     @Test
-    public void NoNumberContradictionRule_NoNumberReachable() throws InvalidFileFormatException {
-        TestUtilities.importTestBoard("puzzles/nurikabe/rules/NoNumberContradictionRule/NoNumberReachable", nurikabe);
+    public void NoNumberContradictionRule_FalseNoNumber() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/NoNumberContradictionRule/FalseNoNumber", nurikabe);
         TreeNode rootNode = nurikabe.getTree().getRootNode();
         TreeTransition transition = rootNode.getChildren().get(0);
         transition.setRule(RULE);
 
+        Assert.assertNotNull(RULE.checkRule(transition));
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+            }
+        }
+    }
+
+    @Test
+    public void NoNumberContradictionRule_FalseNoNumber2() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/NoNumberContradictionRule/FalseNoNumber2", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        Assert.assertNotNull(RULE.checkRule(transition));
         NurikabeBoard board = (NurikabeBoard) transition.getBoard();
         for (int i = 0; i < board.getHeight(); i++) {
             for (int k = 0; k < board.getWidth(); k++) {
diff --git a/src/test/java/puzzles/nurikabe/rules/PreventBlackSquareDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/PreventBlackSquareDirectRuleTest.java
index 6d0b72063..474db1728 100644
--- a/src/test/java/puzzles/nurikabe/rules/PreventBlackSquareDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/PreventBlackSquareDirectRuleTest.java
@@ -27,6 +27,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Prevent Black Square direct rule for a black square with the bottom left corner missing
+     */
     @Test
     public void PreventBlackSquareDirectRule_BottomLeftWhiteBlackSquareTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/PreventBlackSquareDirectRule/BottomLeftWhiteBlackSquare", nurikabe);
@@ -54,6 +57,9 @@ public void PreventBlackSquareDirectRule_BottomLeftWhiteBlackSquareTest() throws
         }
     }
 
+    /**
+     * Tests the Prevent Black Square direct rule for a black square with the bottom right corner missing
+     */
     @Test
     public void PreventBlackSquareDirectRule_BottomRightWhiteBlackSquareTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/PreventBlackSquareDirectRule/BottomRightWhiteBlackSquare", nurikabe);
@@ -81,6 +87,9 @@ public void PreventBlackSquareDirectRule_BottomRightWhiteBlackSquareTest() throw
         }
     }
 
+    /**
+     * Tests the Prevent Black Square direct rule for a black square with the top left corner missing
+     */
     @Test
     public void PreventBlackSquareDirectRule_TopLeftWhiteBlackSquareTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/PreventBlackSquareDirectRule/TopLeftWhiteBlackSquare", nurikabe);
@@ -108,6 +117,9 @@ public void PreventBlackSquareDirectRule_TopLeftWhiteBlackSquareTest() throws In
         }
     }
 
+    /**
+     * Tests the Prevent Black Square direct rule for a black square with the top right corner missing
+     */
     @Test
     public void PreventBlackSquareDirectRule_TopRightWhiteBlackSquareTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/PreventBlackSquareDirectRule/TopRightWhiteBlackSquare", nurikabe);
@@ -134,4 +146,24 @@ public void PreventBlackSquareDirectRule_TopRightWhiteBlackSquareTest() throws I
             }
         }
     }
+
+    /**
+     * Tests the Prevent Black Square direct rule for a false contradiction
+     */
+    @Test
+    public void PreventBlackSquareDirectRule_FalseTest() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/PreventBlackSquareDirectRule/FalseBlackSquare", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+
+
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/SurroundRegionDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/SurroundRegionDirectRuleTest.java
index ce89daea6..240c0b3f2 100644
--- a/src/test/java/puzzles/nurikabe/rules/SurroundRegionDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/SurroundRegionDirectRuleTest.java
@@ -27,6 +27,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Surround Region direct rule for a white square in the middle of the board
+     */
     @Test
     public void SurroundRegionDirectRule_SurroundRegionBlackTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/SurroundRegionDirectRule/SurroundRegionBlack", nurikabe);
@@ -64,6 +67,9 @@ public void SurroundRegionDirectRule_SurroundRegionBlackTest() throws InvalidFil
         }
     }
 
+    /**
+     * Tests the Surround Region direct rule for a white square in the corner of the board
+     */
     @Test
     public void SurroundRegionDirectRule_SurroundRegionBlackInCornerTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/SurroundRegionDirectRule/SurroundRegionBlackInCorner", nurikabe);
@@ -93,4 +99,26 @@ public void SurroundRegionDirectRule_SurroundRegionBlackInCornerTest() throws In
             }
         }
     }
+
+
+    /**
+     * Tests the Surround Region direct rule for a false application of the rule
+     */
+    @Test
+    public void SurroundRegionDirectRule_FalseSurroundRegionBlackTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/SurroundRegionDirectRule/FalseSurroundRegion", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
+
+
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/TooFewSpacesContradictionRuleTest.java b/src/test/java/puzzles/nurikabe/rules/TooFewSpacesContradictionRuleTest.java
index b97daa6b5..02d7af6bd 100644
--- a/src/test/java/puzzles/nurikabe/rules/TooFewSpacesContradictionRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/TooFewSpacesContradictionRuleTest.java
@@ -1,6 +1,7 @@
 package puzzles.nurikabe.rules;
 
 import edu.rpi.legup.puzzle.nurikabe.NurikabeBoard;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeCell;
 import legup.MockGameBoardFacade;
 import legup.TestUtilities;
 import edu.rpi.legup.model.tree.TreeNode;
@@ -25,6 +26,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Too Few Spaces contradiction rule for an isolated completely enclosed number
+     */
     @Test
     public void TooFewSpacesContradictionRule_TwoSurroundBlackTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooFewSpacesContradictionRule/TwoSurroundBlack", nurikabe);
@@ -47,4 +51,57 @@ public void TooFewSpacesContradictionRule_TwoSurroundBlackTest() throws InvalidF
             }
         }
     }
+
+    /**
+     * Tests the Too Few Spaces contradiction rule for a region with insufficient space
+     */
+    @Test
+    public void TooFewSpacesContradictionRule_InsufficientSpaceTest() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooFewSpacesContradictionRule/TwoSurroundBlack", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell1 = board.getCell(1,1);
+
+
+        Assert.assertNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+
+
+        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())) {
+                    Assert.assertNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+                }
+                else {
+                    Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Too Few Spaces contradiction rule for a false contradiction
+     */
+    @Test
+    public void TooFewSpacesContradictionRule_FalseTooFewSpaces() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooFewSpacesContradictionRule/FalseTooFewSpaces", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell1 = board.getCell(1,1);
+
+
+        Assert.assertNotNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+        for(int i=0; i<board.getHeight(); i++){
+            for(int k=0; k<board.getWidth(); k++){
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+
+    }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/TooManySpacesContradictionRuleTest.java b/src/test/java/puzzles/nurikabe/rules/TooManySpacesContradictionRuleTest.java
index 48979d886..7e3c5b708 100644
--- a/src/test/java/puzzles/nurikabe/rules/TooManySpacesContradictionRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/TooManySpacesContradictionRuleTest.java
@@ -5,6 +5,7 @@
 import legup.TestUtilities;
 import edu.rpi.legup.model.tree.TreeNode;
 import edu.rpi.legup.model.tree.TreeTransition;
+import org.codehaus.jackson.annotate.JsonTypeInfo;
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -25,6 +26,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the Too Many Spaces contradiction rule for a 2 in the center surrounded by 4 white squares
+     */
     @Test
     public void TooManySpacesContradictionRule_TwoSurroundBlackTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooManySpacesContradictionRule/TwoSurroundWhite", nurikabe);
@@ -49,4 +53,49 @@ public void TooManySpacesContradictionRule_TwoSurroundBlackTest() throws Invalid
             }
         }
     }
+
+    /**
+     * Tests the Too Many Spaces contradiction rule for an extra diagonal space
+     */
+    @Test
+    public void TooManySpacesContradictionRule_ExtraDiagonalSpace() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooManySpacesContradictionRule/ExtraDiagonalSpace", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        Assert.assertNotNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+
+        NurikabeBoard board = (NurikabeBoard)transition.getBoard();
+
+        for(int i = 0; i < board.getHeight(); i++) {
+            for(int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+            }
+        }
+    }
+
+    /**
+     * Tests the Too Many Spaces contradiction rule for a contradiction.with multiple numbers, wherein one of the numbers is larger than the region
+     */
+    @Test
+    public void TooManySpacesContradictionRule_MultipleNumberRegion() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/TooManySpacesContradictionRule/MultipleNumberRegion", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+
+        Assert.assertNull(RULE.checkContradiction(board));
+        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(board.getCell(2,1).getLocation())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+
+    }
 }
diff --git a/src/test/java/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRuleTest.java b/src/test/java/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRuleTest.java
new file mode 100644
index 000000000..4401f8d15
--- /dev/null
+++ b/src/test/java/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRuleTest.java
@@ -0,0 +1,79 @@
+package puzzles.nurikabe.rules;
+
+import edu.rpi.legup.puzzle.nurikabe.NurikabeBoard;
+import edu.rpi.legup.puzzle.nurikabe.NurikabeCell;
+import legup.MockGameBoardFacade;
+import legup.TestUtilities;
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import edu.rpi.legup.puzzle.nurikabe.Nurikabe;
+import edu.rpi.legup.puzzle.nurikabe.rules.UnreachableWhiteCellContradictionRule;
+import edu.rpi.legup.save.InvalidFileFormatException;
+
+import java.awt.*;
+
+public class UnreachableWhiteCellContradictionRuleTest {
+
+    private static final UnreachableWhiteCellContradictionRule RULE = new UnreachableWhiteCellContradictionRule();
+    private static Nurikabe nurikabe;
+
+    @BeforeClass
+    public static void setUp() {
+        MockGameBoardFacade.getInstance();
+        nurikabe = new Nurikabe();
+    }
+
+    /**
+     * Tests the Unreachable White Cell contradiction rule for a simple case of an unreachable white cell
+     */
+    @Test
+    public void UnreachableWhiteCellContradictionRule_SimpleTest() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/SimpleUnreachableTest",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        Assert.assertNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        NurikabeCell cell1 = board.getCell(2,2);
+
+        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())){
+                    Assert.assertNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+                else{
+                    Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests the Unreachable White Cell contradiction rule for a variety of white square that should all be reachable in some manner
+     */
+    @Test
+    public void UnreachableWhiteCellContradictionRule_AllCellsReachable() throws InvalidFileFormatException{
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/AllCellsReachable",nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        transition.setRule(RULE);
+
+        Assert.assertNotNull(RULE.checkContradiction((NurikabeBoard)transition.getBoard()));
+
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+
+        for(int i=0; i<board.getHeight(); i++){
+            for(int k=0; k<board.getWidth(); k++){
+                Assert.assertNotNull(RULE.checkRuleAt(transition,board.getCell(k,i)));
+            }
+        }
+    }
+
+}
diff --git a/src/test/java/puzzles/nurikabe/rules/WhiteBottleNeckDirectRuleTest.java b/src/test/java/puzzles/nurikabe/rules/WhiteBottleNeckDirectRuleTest.java
index 79f2a3804..cf3d9226b 100644
--- a/src/test/java/puzzles/nurikabe/rules/WhiteBottleNeckDirectRuleTest.java
+++ b/src/test/java/puzzles/nurikabe/rules/WhiteBottleNeckDirectRuleTest.java
@@ -27,6 +27,9 @@ public static void setUp() {
         nurikabe = new Nurikabe();
     }
 
+    /**
+     * Tests the White BottleNeck direct rule for a bottleneck in the middle of the board
+     */
     @Test
     public void WhiteBottleNeckDirectRule_SimpleWhiteBottleNeckTest() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/WhiteBottleNeckDirectRule/SimpleWhiteBottleNeck", nurikabe);
@@ -54,6 +57,9 @@ public void WhiteBottleNeckDirectRule_SimpleWhiteBottleNeckTest() throws Invalid
         }
     }
 
+    /**
+     * Tests the White BottleNeck direct rule for a more complex board
+     */
     @Test
     public void WhiteBottleNeckDirectRule_NurikabeBoard1Test() throws InvalidFileFormatException {
         TestUtilities.importTestBoard("puzzles/nurikabe/rules/WhiteBottleNeckDirectRule/NurikabeBoard1", nurikabe);
@@ -74,4 +80,30 @@ public void WhiteBottleNeckDirectRule_NurikabeBoard1Test() throws InvalidFileFor
             }
         }
     }
+
+    /**
+     * Tests the White BottleNeck direct rule for a more false bottle neck
+     */
+    @Test
+    public void WhiteBottleNeckDirectRule_FalseBottleNeck() throws InvalidFileFormatException {
+        TestUtilities.importTestBoard("puzzles/nurikabe/rules/WhiteBottleNeckDirectRule/FalseBottleNeck", nurikabe);
+        TreeNode rootNode = nurikabe.getTree().getRootNode();
+        TreeTransition transition = rootNode.getChildren().get(0);
+        NurikabeBoard board = (NurikabeBoard) transition.getBoard();
+        transition.setRule(RULE);
+
+        NurikabeCell cell = board.getCell(2, 1);
+        cell.setData(NurikabeType.WHITE.toValue());
+        board.addModifiedData(cell);
+
+        Assert.assertNotNull(RULE.checkRule(transition));
+
+        for (int i = 0; i < board.getHeight(); i++) {
+            for (int k = 0; k < board.getWidth(); k++) {
+                Assert.assertNotNull(RULE.checkRuleAt(transition, board.getCell(k, i)));
+            }
+        }
+    }
+
+
 }
diff --git a/src/test/resources/puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/FalseBlackBetweenRegions b/src/test/resources/puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/FalseBlackBetweenRegions
new file mode 100644
index 000000000..5aecd1575
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/BlackBetweenRegionsDirectRule/FalseBlackBetweenRegions
@@ -0,0 +1,13 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="5" x="0" y="0"/>
+                <cell value="0" x="1" y="0"/>
+                <cell value="0" x="2" y="0"/>
+                <cell value="0" x="0" y="1"/>
+                <cell value="0" x="2" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/BlackBottleNeckDirectRule/CornerBottleNeck b/src/test/resources/puzzles/nurikabe/rules/BlackBottleNeckDirectRule/CornerBottleNeck
new file mode 100644
index 000000000..77f38d5d4
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/BlackBottleNeckDirectRule/CornerBottleNeck
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="0" y="0"/>
+                <cell value="0" x="1" y="0"/>
+                <cell value="-1" x="2" y="0"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/BlackBottleNeckDirectRule/FalseBottleNeck b/src/test/resources/puzzles/nurikabe/rules/BlackBottleNeckDirectRule/FalseBottleNeck
new file mode 100644
index 000000000..3e3d7610a
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/BlackBottleNeckDirectRule/FalseBottleNeck
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="0" y="0"/>
+                <cell value="0" x="1" y="0"/>
+                <cell value="0" x="1" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/BlackOrWhiteCaseRule/SimpleBlackOrWhite b/src/test/resources/puzzles/nurikabe/rules/BlackOrWhiteCaseRule/SimpleBlackOrWhite
new file mode 100644
index 000000000..fb5e45218
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/BlackOrWhiteCaseRule/SimpleBlackOrWhite
@@ -0,0 +1,8 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/BlackSquareContradictionRule/CornerBlackSquare b/src/test/resources/puzzles/nurikabe/rules/BlackSquareContradictionRule/CornerBlackSquare
new file mode 100644
index 000000000..98a01d8b5
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/BlackSquareContradictionRule/CornerBlackSquare
@@ -0,0 +1,12 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="4" height="4">
+            <cells>
+                <cell value="-1" x="2" y="2"/>
+                <cell value="-1" x="2" y="3"/>
+                <cell value="-1" x="3" y="2"/>
+                <cell value="-1" x="3" y="3"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/BlackSquareContradictionRule/FalseBlackSquare b/src/test/resources/puzzles/nurikabe/rules/BlackSquareContradictionRule/FalseBlackSquare
new file mode 100644
index 000000000..813114443
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/BlackSquareContradictionRule/FalseBlackSquare
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="4" height="4">
+            <cells>
+                <cell value="-1" x="1" y="1"/>
+                <cell value="-1" x="1" y="2"/>
+                <cell value="-1" x="2" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/CannotReachCellDirectRule/AllCellsReachable b/src/test/resources/puzzles/nurikabe/rules/CannotReachCellDirectRule/AllCellsReachable
new file mode 100644
index 000000000..63e38d25f
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/CannotReachCellDirectRule/AllCellsReachable
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="5" height="5">
+            <cells>
+                <cell value="5" x="2" y="3"/>
+                <cell value="2" x="0" y="1"/>
+                <cell value="2" x="4" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/CannotReachCellDirectRule/SimpleUnreachableCell b/src/test/resources/puzzles/nurikabe/rules/CannotReachCellDirectRule/SimpleUnreachableCell
new file mode 100644
index 000000000..e11487564
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/CannotReachCellDirectRule/SimpleUnreachableCell
@@ -0,0 +1,9 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="4" x="2" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/CornerBlackDirectRule/FalseCornerBlack b/src/test/resources/puzzles/nurikabe/rules/CornerBlackDirectRule/FalseCornerBlack
new file mode 100644
index 000000000..0599fdfa4
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/CornerBlackDirectRule/FalseCornerBlack
@@ -0,0 +1,12 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="0" y="0"/>
+                <cell value="-1" x="0" y="1"/>
+                <cell value="2" x="1" y="1"/>
+                <cell value="-1" x="0" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack1 b/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack1
new file mode 100644
index 000000000..ae078229e
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack1
@@ -0,0 +1,10 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="1" y="0"/>
+                <cell value="-1" x="0" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack2 b/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack2
new file mode 100644
index 000000000..f274fc774
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/CornerBlack2
@@ -0,0 +1,10 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="2" y="1"/>
+                <cell value="-1" x="1" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/FalseFillinBlack b/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/FalseFillinBlack
new file mode 100644
index 000000000..731e2dc74
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/FillinBlackDirectRule/FalseFillinBlack
@@ -0,0 +1,12 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="1" y="0"/>
+                <cell value="-1" x="1" y="2"/>
+                <cell value="-1" x="0" y="1"/>
+                <cell value="2" x="2" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite1 b/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite1
new file mode 100644
index 000000000..de0ca4f71
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite1
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="0" x="1" y="0"/>
+                <cell value="0" x="0" y="1"/>
+                <cell value="-1" x="1" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite2 b/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite2
new file mode 100644
index 000000000..9fc228483
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/CornerWhite2
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="0" x="2" y="1"/>
+                <cell value="0" x="1" y="2"/>
+                <cell value="-1" x="1" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/FalseFillinWhite b/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/FalseFillinWhite
new file mode 100644
index 000000000..f2599c71f
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/FillinWhiteDirectRule/FalseFillinWhite
@@ -0,0 +1,12 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="0" x="1" y="0"/>
+                <cell value="0" x="2" y="1"/>
+                <cell value="0" x="0" y="1"/>
+                <cell value="2" x="0" y="0"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/IsolateBlackContradictionRule/DiagonalIsolateBlack b/src/test/resources/puzzles/nurikabe/rules/IsolateBlackContradictionRule/DiagonalIsolateBlack
new file mode 100644
index 000000000..7ff5dcf24
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/IsolateBlackContradictionRule/DiagonalIsolateBlack
@@ -0,0 +1,15 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="0" y="0"/>
+                <cell value="0" x="1" y="0"/>
+                <cell value="0" x="0" y="1"/>
+                <cell value="-1" x="1" y="1"/>
+                <cell value="0" x="2" y="1"/>
+                <cell value="0" x="1" y="2"/>
+                <cell value="-1" x="2" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/IsolateBlackContradictionRule/FalseIsolateBlack b/src/test/resources/puzzles/nurikabe/rules/IsolateBlackContradictionRule/FalseIsolateBlack
new file mode 100644
index 000000000..b4eb09302
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/IsolateBlackContradictionRule/FalseIsolateBlack
@@ -0,0 +1,10 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="0" y="0"/>
+                <cell value="-1" x="2" y="0"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/MultipleNumbersContradictionRule/ComplexRegion b/src/test/resources/puzzles/nurikabe/rules/MultipleNumbersContradictionRule/ComplexRegion
new file mode 100644
index 000000000..5f8e607fe
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/MultipleNumbersContradictionRule/ComplexRegion
@@ -0,0 +1,19 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="5" height="5">
+            <cells>
+                <cell value="6" x="0" y="0"/>
+                <cell value="0" x="1" y="0"/>
+                <cell value="6" x="2" y="0"/>
+                <cell value="0" x="3" y="0"/>
+                <cell value="6" x="4" y="0"/>
+                <cell value="0" x="2" y="1"/>
+                <cell value="5" x="2" y="3"/>
+                <cell value="0" x="3" y="3"/>
+                <cell value="0" x="2" y="4"/>
+                <cell value="0" x="3" y="4"/>
+                <cell value="5" x="4" y="4"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/MultipleNumbersContradictionRule/FalseContradiction b/src/test/resources/puzzles/nurikabe/rules/MultipleNumbersContradictionRule/FalseContradiction
new file mode 100644
index 000000000..0f14d6916
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/MultipleNumbersContradictionRule/FalseContradiction
@@ -0,0 +1,16 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="4" height="4">
+            <cells>
+                <cell value="4" x="0" y="0"/>
+                <cell value="0" x="1" y="0"/>
+                <cell value="0" x="0" y="1"/>
+                <cell value="0" x="1" y="1"/>
+                <cell value="4" x="2" y="2"/>
+                <cell value="0" x="3" y="2"/>
+                <cell value="0" x="2" y="3"/>
+                <cell value="0" x="3" y="3"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/NoNumberReachable b/src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/FalseNoNumber
similarity index 100%
rename from src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/NoNumberReachable
rename to src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/FalseNoNumber
diff --git a/src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/FalseNoNumber2 b/src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/FalseNoNumber2
new file mode 100644
index 000000000..be1fc64f7
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/FalseNoNumber2
@@ -0,0 +1,18 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="4" height="4">
+            <cells>
+                <cell value="0" x="1" y="1"/>
+                <cell value="3" x="2" y="2"/>
+                <cell value="-1" x="1" y="0"/>
+                <cell value="-1" x="2" y="0"/>
+                <cell value="-1" x="1" y="3"/>
+                <cell value="-1" x="2" y="3"/>
+                <cell value="-1" x="0" y="1"/>
+                <cell value="-1" x="0" y="2"/>
+                <cell value="-1" x="3" y="1"/>
+                <cell value="-1" x="3" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/NoNumberSurroundBlack b/src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/SimpleNoNumber
similarity index 100%
rename from src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/NoNumberSurroundBlack
rename to src/test/resources/puzzles/nurikabe/rules/NoNumberContradictionRule/SimpleNoNumber
diff --git a/src/test/resources/puzzles/nurikabe/rules/PreventBlackSquareDirectRule/FalseBlackSquare b/src/test/resources/puzzles/nurikabe/rules/PreventBlackSquareDirectRule/FalseBlackSquare
new file mode 100644
index 000000000..2fd8e7d35
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/PreventBlackSquareDirectRule/FalseBlackSquare
@@ -0,0 +1,10 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="0" y="0"/>
+                <cell value="-1" x="1" y="0"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/SurroundRegionDirectRule/FalseSurroundRegion b/src/test/resources/puzzles/nurikabe/rules/SurroundRegionDirectRule/FalseSurroundRegion
new file mode 100644
index 000000000..5e0b04f68
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/SurroundRegionDirectRule/FalseSurroundRegion
@@ -0,0 +1,10 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="1" x="1" y="1"/>
+
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/TooFewSpacesContradictionRule/FalseTooFewSpaces b/src/test/resources/puzzles/nurikabe/rules/TooFewSpacesContradictionRule/FalseTooFewSpaces
new file mode 100644
index 000000000..ca3e9be84
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/TooFewSpacesContradictionRule/FalseTooFewSpaces
@@ -0,0 +1,17 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="5" height="5">
+            <cells>
+                <cell value="-1" x="1" y="0"/>
+                <cell value="-1" x="0" y="1"/>
+                <cell value="2" x="1" y="1"/>
+                <cell value="-1" x="2" y="1"/>
+                <cell value="-1" x="0" y="2"/>
+                <cell value="0" x="1" y="2"/>
+                <cell value="-1" x="2" y="2"/>
+                <cell value="4" x="4" y="2"/>
+                <cell value="-1" x="1" y="3"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/TooFewSpacesContradictionRule/InsufficientSpace b/src/test/resources/puzzles/nurikabe/rules/TooFewSpacesContradictionRule/InsufficientSpace
new file mode 100644
index 000000000..22163947a
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/TooFewSpacesContradictionRule/InsufficientSpace
@@ -0,0 +1,17 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="-1" x="0" y="0"/>
+                <cell value="-1" x="1" y="0"/>
+                <cell value="-1" x="2" y="0"/>
+                <cell value="0" x="0" y="1"/>
+                <cell value="4" x="1" y="1"/>
+                <cell value="0" x="2" y="1"/>
+                <cell value="-1" x="0" y="2"/>
+                <cell value="-1" x="1" y="2"/>
+                <cell value="-1" x="2" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/TooManySpacesContradictionRule/ExtraDiagonalSpace b/src/test/resources/puzzles/nurikabe/rules/TooManySpacesContradictionRule/ExtraDiagonalSpace
new file mode 100644
index 000000000..5d9ad70e1
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/TooManySpacesContradictionRule/ExtraDiagonalSpace
@@ -0,0 +1,14 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="2" x="0" y="0"/>
+                <cell value="0" x="1" y="0"/>
+                <cell value="-1" x="2" y="0"/>
+                <cell value="-1" x="0" y="1"/>
+                <cell value="-1" x="1" y="1"/>
+                <cell value="0" x="2" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/TooManySpacesContradictionRule/MultipleNumberRegion b/src/test/resources/puzzles/nurikabe/rules/TooManySpacesContradictionRule/MultipleNumberRegion
new file mode 100644
index 000000000..3ec126199
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/TooManySpacesContradictionRule/MultipleNumberRegion
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="3" x="0" y="1"/>
+                <cell value="0" x="1" y="1"/>
+                <cell value="2" x="2" y="1"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/AllCellsReachable b/src/test/resources/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/AllCellsReachable
new file mode 100644
index 000000000..dbc5fadb2
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/AllCellsReachable
@@ -0,0 +1,13 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="5" height="5">
+            <cells>
+                <cell value="3" x="0" y="0"/>
+                <cell value="0" x="4" y="0"/>
+                <cell value="0" x="0" y="1"/>
+                <cell value="3" x="4" y="2"/>
+                <cell value="0" x="3" y="3"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/SimpleUnreachableTest b/src/test/resources/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/SimpleUnreachableTest
new file mode 100644
index 000000000..3d456bdb0
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/UnreachableWhiteCellContradictionRule/SimpleUnreachableTest
@@ -0,0 +1,10 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="4" x="0" y="0"/>
+                <cell value="0" x="2" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file
diff --git a/src/test/resources/puzzles/nurikabe/rules/WhiteBottleNeckDirectRule/FalseBottleNeck b/src/test/resources/puzzles/nurikabe/rules/WhiteBottleNeckDirectRule/FalseBottleNeck
new file mode 100644
index 000000000..521576aeb
--- /dev/null
+++ b/src/test/resources/puzzles/nurikabe/rules/WhiteBottleNeckDirectRule/FalseBottleNeck
@@ -0,0 +1,11 @@
+<Legup>
+    <puzzle name="Nurikabe">
+        <board width="3" height="3">
+            <cells>
+                <cell value="2" x="1" y="1"/>
+                <cell value="-1" x="1" y="0"/>
+                <cell value="-1" x="1" y="2"/>
+            </cells>
+        </board>
+    </puzzle>
+</Legup>
\ No newline at end of file