add running initial "unit-test" for GePlanner

src/main/java/lib/gecom/GeAgent.java

@@ -72,9 +72,12 @@ public void Update() {
         final GeWorldStates agentsBelieves = GeWorld.getInstance().getWorldStates();
         if (currentActionStack.isEmpty()) {
             for (GeSubgoal subgoal : prioritizedSubgoals) {
-                currentActionStack.addAll(planner.plan(possibleActions, subgoal.getStatesToReach(), agentsBelieves));
-                currentGoal = subgoal;
-                break;
+                final Optional<Queue<GeAction>> plan = planner.plan(possibleActions, subgoal.getStatesToReach(), agentsBelieves);
+                if (plan.isPresent()) {
+                    currentActionStack.addAll(plan.get());
+                    currentGoal = subgoal;
+                    break;
+                }
             }
         }
 

src/main/java/lib/gecom/GeNullTarget.java

@@ -1,7 +1,17 @@
 package lib.gecom;
 
 import lombok.NoArgsConstructor;
+import lombok.NonNull;
+
+import java.util.Optional;
 
 @NoArgsConstructor
 public class GeNullTarget implements GeTargetable {
+
+    @NonNull
+    @Override
+    public Optional<Object> getTargetPosition() {
+        return Optional.empty();
+    }
+
 }

src/main/java/lib/gecom/GePlanner.java

@@ -3,15 +3,15 @@
 
 import lombok.Getter;
 import lombok.NonNull;
+import org.springframework.lang.Nullable;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
 public class GePlanner {
 
-    //@TODO priority queue? compare by costs?
     @NonNull
-    public Queue<GeAction> plan(
+    public Optional<Queue<GeAction>> plan(
             @NonNull final List<GeAction> possibleActions,
             @NonNull final HashMap<String, Integer> goal, // @TODO do we have state objects? what are those Maps?????
             @NonNull final GeWorldStates worldStates
@@ -31,7 +31,7 @@ public Queue<GeAction> plan(
         if (!success) {
             System.out.println("No solution found!");
             // @TODO throw exception? and log!
-            return null;
+            return Optional.empty();
         }
 
         // TODO look to dijkstra's algorithm.... for the following:
@@ -57,7 +57,7 @@ public Queue<GeAction> plan(
         Collections.reverse(result); // TEST THAT
 
         // could return a PriorityQueue with nodes; it is then sorted
-        return new LinkedList<GeAction>(result);
+        return Optional.of(new LinkedList<GeAction>(result));
     }
 
     private boolean buildGraph(
@@ -125,19 +125,19 @@ private List<GeAction> subsetOfActions(
     //@TODO can we use our old node?
     @Getter
     public class GeNode {
-        @NonNull
+        @Nullable
         public final GeNode parent;
         @NonNull
         public final HashMap<String, Integer> state;
-        @NonNull
+        @Nullable
         public final GeAction action;
         @NonNull
         public Float cost;
 
         public GeNode(
-                @NonNull final GeNode parent,
+                @Nullable final GeNode parent,
                 @NonNull final HashMap<String, Integer> state,
-                @NonNull final GeAction action,
+                @Nullable final GeAction action,
                 @NonNull final Float cost
         ) {
             this.parent = parent;

src/main/java/lib/gecom/GeTargetable.java

@@ -1,5 +1,12 @@
 package lib.gecom;
 
+import lombok.NonNull;
+
+import java.util.Optional;
+
 public interface GeTargetable {
-    Object getTargetPosition();
+
+    @NonNull
+    Optional<Object> getTargetPosition();
+
 }

src/test/java/lib/gecom/GePlannerTest.java

@@ -0,0 +1,27 @@
+package lib.gecom;
+
+import lombok.NonNull;
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GePlannerTest {
+
+    @Test
+    void plan() {
+        // Arrange
+        final GePlanner planner = new GePlanner();
+        @NonNull final List<GeAction> possibleActions = new ArrayList<>();
+        @NonNull final HashMap<String, Integer> goal = new HashMap<>();
+        @NonNull final GeWorldStates worldStates = new GeWorldStates();
+
+        // Act
+        final Optional<Queue<GeAction>> planToTest = planner.plan(possibleActions, goal, worldStates);
+
+        // Assert
+        assertTrue(planToTest.isEmpty());
+    }
+
+}