@@ -20,20 +20,27 @@ public class OneWayGridNavigator {
 
     public static void main(String[] args) {
         //Hardcode length and height for now
-        final int LENGTH = 5;
-        final int HEIGHT = 6;
+        final int LENGTH = 1;
+        final int HEIGHT = 1;
 
-        List<Character> pathArray = new ArrayList<Character>();
+        int numPaths = findPaths(LENGTH, HEIGHT);
+        
+        System.out.println("Number of paths " + numPaths);
+    }
 
+    static int findPaths(final int LENGTH, final int HEIGHT) {
+        List<Character> pathArray = new ArrayList<Character>();
+        
         OneWayGridNavigator op = new OneWayGridNavigator();
 
         String simplestPath = constructSimplestPath(LENGTH, HEIGHT);
 
-        Set<String> permutations = op.permute(simplestPath, 0, simplestPath.length() - 1);
-        System.out.println(permutations.size());
+        Set<String> permutations = op.permute(simplestPath);
+        
         for (String w : permutations) {
             System.out.println(w);
         }
+        return permutations.size();
     }
 
     /**
@@ -42,7 +49,8 @@ public static void main(String[] args) {
      * lt)
      */
     private Set<String> permute(String word) {
-        return permute(word, 0, word.length() - 1);
+        Set<String> results = new HashSet<String>();
+        return permute(word, 0, word.length() - 1, results);
     }
 
     /**
@@ -52,14 +60,14 @@ private Set<String> permute(String word) {
      * Idea : Fix a letter, bring it to the front. Recursively permute the 
      * remaining letters. Swap back the fixed letter. Repeat for all letters.
      */
-    private Set<String> permute(String word, int st, int lt) {
-        Set<String> results = new HashSet<String>();
+    private Set<String> permute(String word, int st, int lt, Set<String> results) {
+        //Set<String> results = new HashSet<String>();
         if (st == lt) {
             results.add(word);
         }
         for (int i = st; i <= lt; i++) {
             word = swap(word, st, i);
-            permute(word, st + 1, lt);
+            permute(word, st + 1, lt, results);
             word = swap(word, st, i);
         }
         return results;
@@ -71,6 +79,9 @@ private Set<String> permute(String word, int st, int lt) {
      * Returns a String with the path.
      */
     private static String constructSimplestPath(final int LENGTH, final int HEIGHT) {
+        //Added to clear one side 0 lenght test case
+        if (LENGTH * HEIGHT == 0) return "";
+                
         StringBuffer sb = new StringBuffer();
         for (int i = 0; i < LENGTH; i++) {
             sb.append("R");
 
@@ -0,0 +1,90 @@
+/*
+ * Test class for one way grid problem
+ */
+package miscproblems;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Adarsh V
+ */
+public class OneWayGridNavigatorTest {
+    
+    public OneWayGridNavigatorTest() {
+    }
+    
+    @BeforeClass
+    public static void setUpClass() {
+        
+    }
+    
+    @AfterClass
+    public static void tearDownClass() {
+    }
+    
+    @Before
+    public void setUp() {
+    }
+    
+    @After
+    public void tearDown() {
+    }
+
+    /**
+     * Test with 0 input, of class OneWayGridNavigator.
+     */
+    @Test
+    public void testWithBoth0() {
+        int expected = 0;
+        int length = 0;
+        int height = 0;
+        assertEquals(expected,OneWayGridNavigator.findPaths(length, height));
+    }
+    
+    /**
+     * Test input with either length or heigh as 0
+     */
+    @Test
+    public void testWithOneSide0() {
+        int expected = 0;
+        int length = 0;
+        int height = 1;
+        assertEquals(expected,OneWayGridNavigator.findPaths(length, height));
+        
+        length = 10;
+        height = 0;
+        assertEquals(expected,OneWayGridNavigator.findPaths(length, height));
+        
+    }
+    
+    /**
+     * Test input with either length and height as 1
+     */
+    @Test
+    public void testWithLength1() {
+        int expected = 2;
+        int length = 1;
+        int height = 1;
+        assertEquals(expected,OneWayGridNavigator.findPaths(length, height));
+        
+    }
+    
+    /**
+     * Test input with either length and height as 1
+     */
+    @Test
+    public void testWithReasonableLength() {
+        int expected = 126;
+        int length = 4;
+        int height = 5;
+        assertEquals(expected,OneWayGridNavigator.findPaths(length, height));
+        
+    }
+    
+}