Tests für step out und step over hinzugefügt

src/processor/PseudoCodeProcessor.java

@@ -36,8 +36,8 @@ public class PseudoCodeProcessor extends Thread {
     private LayeredGraphNode graph;
     private String currentDebugOutput;
     private Memory mem;
-    private PseudoCodeNode programPointer;
-    private Stack<ControlFlow> controlStack;
+    protected PseudoCodeNode programPointer;
+    protected Stack<ControlFlow> controlStack;
     private boolean skip = false;
     private boolean renderImage = true;
     private JFrame view;
@@ -216,9 +216,15 @@ public class PseudoCodeProcessor extends Thread {
         return CodeStatus.UNFINISHED;
     }
     
+    protected PseudoCodeNode getLastProgramPointer() {
+        if( controlStack.isEmpty() )
+            return null;
+        return controlStack.peek().getJumpBack();
+    }
+    
     protected CodeStatus backwardStep()
     {
-        if( programPointer == null || controlStack.isEmpty() )
+        if( controlStack.isEmpty() )
             return CodeStatus.FINISHED;
         ControlFlow cf = controlStack.pop();
         PseudoCodeNode nextPC = cf.getJumpBack();

src/test/RandomProcessor.java

@@ -0,0 +1,59 @@
+package test;
+
+import javax.swing.JFrame;
+
+import graph.LayeredGraphNode;
+import processor.PseudoCodeNode;
+import processor.PseudoCodeProcessor;
+
+public class RandomProcessor extends PseudoCodeProcessor {
+
+    private static final double STEP_OVER = 0.1;
+    private static final double STEP_OUT = 0.1;
+    private static final int ITERATIONS = 1000;
+    
+    public RandomProcessor(PseudoCodeNode start, LayeredGraphNode graph, JFrame view) {
+        super(start, graph, view);
+    }
+    
+    @Override
+    public void run()
+    {
+        try {
+            System.out.println( "Start Random Tests." );
+            for( int i = 0; i < ITERATIONS; i++ )
+            {
+                int actions = 0;
+                CodeStatus status = null;
+                while( status != CodeStatus.FINISHED )
+                {
+                    if( Math.random() < STEP_OVER )
+                        status = forwardStepOver();
+                    else if( Math.random() < STEP_OUT )
+                        status = forwardStepOut();
+                    else
+                        status = forwardStep();
+                    actions++;
+                }
+                status = null;
+                while( status != CodeStatus.FINISHED )
+                {
+                    if( Math.random() < STEP_OVER )
+                        status = backwardStepOver();
+                    else if( Math.random() < STEP_OUT )
+                        status = backwardStepOut();
+                    else
+                        status = backwardStep();
+                    actions++;
+                }
+                System.out.println( actions + " Actions done.");
+                if( !controlStack.isEmpty() )
+                    throw new IllegalStateException( "There are too manny Objects in the control Stack." );
+                System.out.println( "Random Iteration " + i + " finisted successfully." );
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return;
+        }
+    }
+}

src/test/StepInProcessor.java

@@ -37,6 +37,7 @@ public class StepInProcessor extends PseudoCodeProcessor{
                 break;
             }
         }
+        System.out.println( controlStack.size() + " Actions done.");
         while( true )
         {
             CodeStatus status = null;
@@ -59,5 +60,7 @@ public class StepInProcessor extends PseudoCodeProcessor{
                 break;
             }
         }
+        if( !controlStack.isEmpty() )
+            throw new IllegalStateException( "There are too manny Objects in the control Stack." );
     }
 }

src/test/StepOverProcessor.java

@@ -0,0 +1,86 @@
+package test;
+
+import javax.swing.JFrame;
+
+import graph.LayeredGraphNode;
+import processor.PseudoCodeNode;
+import processor.PseudoCodeProcessor;
+
+public class StepOverProcessor extends PseudoCodeProcessor {
+
+    public StepOverProcessor(PseudoCodeNode start, LayeredGraphNode graph, JFrame view) {
+        super(start, graph, view);
+    }
+    
+    private CodeStatus doStepForward() 
+    {
+        PseudoCodeNode oldPP = programPointer;
+        if( programPointer.getChildCount() > 0 ) {
+            if( forwardStep() == CodeStatus.FINISHED )
+                return CodeStatus.FINISHED;
+            while( oldPP != programPointer && oldPP.isNodeChild( programPointer ) )
+                doStepForward();
+            if( backwardStepOver() == CodeStatus.FINISHED )
+                return CodeStatus.FINISHED;
+            return forwardStepOver();
+        }
+        else
+            return forwardStepOver();
+    }
+    
+    private CodeStatus doStepBackward() 
+    {
+        if( controlStack.isEmpty() )
+            return CodeStatus.FINISHED;
+        PseudoCodeNode oldPP = getLastProgramPointer();
+        if( oldPP.getChildCount() > 0 ) {
+            if( backwardStep() == CodeStatus.FINISHED )
+                return CodeStatus.FINISHED;
+            while( oldPP != getLastProgramPointer() && getLastProgramPointer() != null && oldPP.isNodeChild( getLastProgramPointer() ) )
+                doStepBackward();
+            if( forwardStepOver() == CodeStatus.FINISHED )
+                return CodeStatus.FINISHED;
+            return backwardStepOver();
+        }
+        else
+            return backwardStepOver();
+    }
+
+    @Override
+    public void run()
+    {
+        while( true )
+        {
+            CodeStatus status = null;
+            try {
+                status = doStepForward();
+            } catch (Exception e) {
+                e.printStackTrace();
+                return;
+            }
+            if( status == CodeStatus.FINISHED )
+            {
+                System.out.println( "Step Over works in forward direction.");
+                break;
+            }
+        }
+        System.out.println( controlStack.size() + " Actions done.");
+        while( true )
+        {
+            CodeStatus status = null;
+            try {
+                status = doStepBackward();
+            } catch (Exception e) {
+                e.printStackTrace();
+                return;
+            }
+            if( status == CodeStatus.FINISHED )
+            {
+                System.out.println( "Step Over works in backward direction.");
+                break;
+            }
+        }
+        if( !controlStack.isEmpty() )
+            throw new IllegalStateException( "There are too manny Objects in the control Stack." );
+    }
+}

src/test/TestProcessor.java

@@ -8,11 +8,12 @@ import graph.LayeredGraphNode;
 import graph.io.Reader;
 import lib.SimpleNodePlacement;
 import processor.PseudoCodeNode;
+import processor.PseudoCodeProcessor;
 
 class TestProcessor {
     
-    public static void main(String[] args) {
-        Reader r = new Reader( "logo.json" );
+    public static void main(String[] args) throws InterruptedException {
+        Reader r = new Reader( "papergraph.json" );
         LayeredGraphNode graph = r.readInputGraph();
         SimpleNodePlacement.placeNodes( graph );
 
@@ -20,7 +21,15 @@ class TestProcessor {
         JTree pseudoTree = new JTree();
         PseudoCodeNode tree = algorithm.createPseudocodeTree( pseudoTree );
         JFrame frame = new JFrame( "NodeShuffler" );
-        StepInProcessor processor = new StepInProcessor( tree, graph, frame );
+        PseudoCodeProcessor processor = new StepInProcessor( tree, graph, frame );
         processor.start();
+        processor.join();
+        processor = new StepOverProcessor( tree, graph, frame );
+        processor.start();
+        processor.join();
+        processor = new RandomProcessor( tree, graph, frame );
+        processor.start();
+        processor.join();
+        System.out.println( "Tests Finished." );
     }
 }