Add tests on pathfinder

src/main/java/info/hkzlab/dupal/analyzer/palanalisys/explorers/OSExplorer.java

@@ -1,6 +1,5 @@
 package info.hkzlab.dupal.analyzer.palanalisys.explorers;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -36,13 +35,13 @@ public class OSExplorer {
             // If we ended up in a state where all the links have already been explored...
             if(curState.isStateFull()) {
                 logger.info("exploreOutStates() -> " + curState + " is full.");
-                ArrayList<GraphLink> linkPath = PathFinder.findPathToNearestUnfilledState(curState);
-                if(linkPath != null && !linkPath.isEmpty()) {
+                GraphLink[] linkPath = PathFinder.findPathToNearestUnfilledState(curState);
+                if(linkPath != null && linkPath.length > 0) {
                     for(GraphLink l : linkPath) {
                         logger.info("exploreOutStates() -> Walking link " + l);
                         dpci.write(l.getLinkInputs()); // Walk the path to the new state
                     }
-                    curState = (OutState) (linkPath.get(linkPath.size() - 1)).getDestinationState();
+                    curState = (OutState) (linkPath[linkPath.length-1].getDestinationState());
                     logger.info("exploreOutStates() -> walked path to state " + curState);
 
                     // Do some doublechecking

src/main/java/info/hkzlab/dupal/analyzer/palanalisys/graph/OutLink.java

@@ -22,6 +22,20 @@ public class OutLink implements GraphLink {
         return hash;
     }
 
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o)
+            return true;
+        if (o == null)
+            return false;
+        if (this.getClass() != o.getClass())
+            return false;
+
+        return  (this.src.equals(((OutLink)o).src)) &&
+                (this.dest.equals(((OutLink)o).dest)) &&
+                (this.inputs == ((OutLink)o).inputs);
+    }
+
     @Override
     public String toString() {
         return "("+src+")->OL["+String.format("%06X", inputs)+"]->("+dest+")";

src/main/java/info/hkzlab/dupal/analyzer/palanalisys/graph/PathFinder.java

@@ -10,7 +10,7 @@ public class PathFinder {
    private PathFinder() {};
 
    @SuppressWarnings("unchecked")
-   public static ArrayList<GraphLink> findPathToNearestUnfilledState(GraphState start) {
+   public static GraphLink[] findPathToNearestUnfilledState(GraphState start) {
        Map<Integer, ArrayList<GraphLink>> pathMap = new HashMap<>();
        Queue<GraphState> statesQueue = new LinkedList<>();
        ArrayList<GraphLink> linkStack = null;
@@ -20,7 +20,7 @@ public class PathFinder {
 
        while(currentState != null) {
            linkStack = pathMap.get(currentState.hashCode()); // Get the map to the current state
-           if(!currentState.isStateFull()) return linkStack; // Ok, we found a state where we need to map other links
+           if(!currentState.isStateFull()) return linkStack.toArray(new GraphLink[linkStack.size()]); // Ok, we found a state where we need to map other links
        
            GraphLink[] stateLinks = currentState.getLinks(); // Get links present in the current state
 

src/test/java/info/hkzlab/dupal/analyzer/PathFinderTest.java

@@ -1,13 +1,16 @@
 package info.hkzlab.dupal.analyzer;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
+
 
 import org.junit.Test;
 
 import info.hkzlab.dupal.analyzer.exceptions.DuPALAnalyzerException;
+import info.hkzlab.dupal.analyzer.palanalisys.graph.GraphLink;
 import info.hkzlab.dupal.analyzer.palanalisys.graph.OutLink;
 import info.hkzlab.dupal.analyzer.palanalisys.graph.OutState;
 import info.hkzlab.dupal.analyzer.palanalisys.graph.OutStatePins;
+import info.hkzlab.dupal.analyzer.palanalisys.graph.PathFinder;
 
 public class PathFinderTest {
     @Test
@@ -23,10 +26,58 @@ public class PathFinderTest {
         os_a.addOutLink(new OutLink(os_a, os_c, 0x30));
 
         os_b.addOutLink(new OutLink(os_b, os_a, 0x10));
-        os_b.addOutLink(new OutLink(os_b, os_b, 0x20));
-        os_b.addOutLink(new OutLink(os_b, os_c, 0x30));
+        os_b.addOutLink(new OutLink(os_b, os_e, 0x20));
+        os_b.addOutLink(new OutLink(os_b, os_d, 0x30));
+        
+        os_c.addOutLink(new OutLink(os_c, os_a, 0x10));
+        os_c.addOutLink(new OutLink(os_c, os_b, 0x20));
+        os_c.addOutLink(new OutLink(os_c, os_d, 0x30));
+        
+        os_d.addOutLink(new OutLink(os_d, os_c, 0x10));
+        os_d.addOutLink(new OutLink(os_d, os_b, 0x20));
+        os_d.addOutLink(new OutLink(os_d, os_e, 0x30));
+
+        // 'e' is incomplete
+        os_e.addOutLink(new OutLink(os_e, os_a, 0x10));
+        os_e.addOutLink(new OutLink(os_e, os_d, 0x20));
+
+        GraphLink[] path = PathFinder.findPathToNearestUnfilledState(os_a);
+        GraphLink[] expectedPath = new GraphLink[] { new OutLink(os_a, os_b, 0x20), new OutLink(os_b, os_e, 0x20) }; // a->b->e
+
+        assertArrayEquals("PathFinder should find the shortest path between a node and an incomplete one", expectedPath, path);
+    }
+
+       @Test
+    public void PathFinderShouldProvideNoPathIfAllNodesAreComplete() throws DuPALAnalyzerException {
+        OutState os_a = new OutState(new OutStatePins(0x00, 0x00), 3);
+        OutState os_b = new OutState(new OutStatePins(0x01, 0x00), 3);
+        OutState os_c = new OutState(new OutStatePins(0x02, 0x00), 3);
+        OutState os_d = new OutState(new OutStatePins(0x03, 0x00), 3);
+        OutState os_e = new OutState(new OutStatePins(0x04, 0x00), 3);
+
+        os_a.addOutLink(new OutLink(os_a, os_a, 0x10));
+        os_a.addOutLink(new OutLink(os_a, os_b, 0x20));
+        os_a.addOutLink(new OutLink(os_a, os_c, 0x30));
+
+        os_b.addOutLink(new OutLink(os_b, os_a, 0x10));
+        os_b.addOutLink(new OutLink(os_b, os_e, 0x20));
+        os_b.addOutLink(new OutLink(os_b, os_d, 0x30));
+        
+        os_c.addOutLink(new OutLink(os_c, os_a, 0x10));
+        os_c.addOutLink(new OutLink(os_c, os_b, 0x20));
+        os_c.addOutLink(new OutLink(os_c, os_d, 0x30));
+        
+        os_d.addOutLink(new OutLink(os_d, os_c, 0x10));
+        os_d.addOutLink(new OutLink(os_d, os_b, 0x20));
+        os_d.addOutLink(new OutLink(os_d, os_e, 0x30));
+
+        // 'e' is incomplete
+        os_e.addOutLink(new OutLink(os_e, os_a, 0x10));
+        os_e.addOutLink(new OutLink(os_e, os_d, 0x20));
+        os_e.addOutLink(new OutLink(os_e, os_e, 0x20));
 
+        GraphLink[] path = PathFinder.findPathToNearestUnfilledState(os_a);
         
-        assertEquals("PathFinder should find the shortest path to an incomplete State", true, true);
+        assertArrayEquals("PathFinder should return null if no incomplete node exists", null, path);
     }
 }