Split statemachine in task and solution.

statemachine.task/src/test/java/de/tudresden/inf/st/statemachine/AnalysisTest.java

+package de.tudresden.inf.st.statemachine;
+
+import beaver.Parser;
+import de.tudresden.inf.st.statemachine.jastadd.model.State;
+import de.tudresden.inf.st.statemachine.jastadd.model.StateMachine;
+import de.tudresden.inf.st.statemachine.jastadd.model.Transition;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Testing analysis attributes.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class AnalysisTest {
+
+  @Test
+  public void test1() throws IOException, Parser.Exception {
+    StateMachine stateMachine = ParserUtils.load(Paths.get("src", "test", "resources", "machine_one.sm"));
+    State s = stateMachine.globallyResolveStateByToken("S");
+    State a = stateMachine.globallyResolveStateByToken("A");
+    State e = stateMachine.globallyResolveStateByToken("E");
+
+    assertEquals(0, s.minDistTo(s));
+    assertEquals(1, s.minDistTo(a));
+    assertEquals(2, s.minDistTo(e));
+    assertEquals(1, a.minDistTo(e));
+    assertEquals(1, a.minDistTo(s));
+    assertEquals(0, a.minDistTo(a));
+    assertEquals(-1, e.minDistTo(s));
+    assertEquals(-1, e.minDistTo(a));
+    assertEquals(0, e.minDistTo(e));
+  }
+
+  @Test
+  public void testEmpty() throws IOException, Parser.Exception {
+    StateMachine stateMachine = ParserUtils.load(Paths.get("src", "test", "resources", "empty.sm"));
+
+    State s = stateMachine.globallyResolveStateByToken("S");
+    State a = stateMachine.globallyResolveStateByToken("A");
+    State e = stateMachine.globallyResolveStateByToken("E");
+
+    assertEquals(0, s.minDistTo(s));
+    assertEquals(1, s.minDistTo(a));
+    assertEquals(2, s.minDistTo(e));
+    assertEquals(1, a.minDistTo(e));
+    assertEquals(1, a.minDistTo(s));
+    assertEquals(0, a.minDistTo(a));
+    assertEquals(-1, e.minDistTo(s));
+    assertEquals(-1, e.minDistTo(a));
+    assertEquals(0, e.minDistTo(e));
+
+    // change some things
+    Transition t5 = new Transition();
+    t5.setFrom(a);
+    t5.setTo(e);
+    stateMachine.addElement(t5);
+
+    System.out.println(stateMachine.prettyPrint());
+
+    assertEquals(0, s.minDistTo(s));
+    assertEquals(1, s.minDistTo(a));
+    assertEquals(1, s.minDistTo(e));
+    assertEquals(0, a.minDistTo(e));
+    assertEquals(1, a.minDistTo(s));
+    assertEquals(0, a.minDistTo(a));
+    assertEquals(-1, e.minDistTo(s));
+    assertEquals(-1, e.minDistTo(a));
+    assertEquals(0, e.minDistTo(e));
+
+    Set<Transition> epsilons = stateMachine.epsilonTransitions();
+    assertEquals(2, epsilons.size());
+
+    for (Transition eps : epsilons) {
+      removeEpsilonTransition(stateMachine, eps);
+    }
+
+    State ae = stateMachine.globallyResolveStateByToken("A+E");
+    Transition t6 = new Transition();
+    t6.setFrom(s);
+    t6.setTo(ae);
+    stateMachine.addElement(t6);
+
+    System.out.println(stateMachine.prettyPrint());
+
+    epsilons = stateMachine.epsilonTransitions();
+    assertEquals(1, epsilons.size());
+
+    for (Transition eps : epsilons) {
+      removeEpsilonTransition(stateMachine, eps);
+    }
+  }
+
+  private void removeEpsilonTransition(StateMachine stateMachine, Transition eps) {
+    System.out.print("removing epsilon transition " + eps.prettyPrint());
+    System.out.println("Minimal distances before:");
+    initialToFinalDists(stateMachine);
+    stateMachine.removeEpsilonTransition(eps);
+    System.out.println("Minimal distances after:");
+    initialToFinalDists(stateMachine);
+    System.out.println("StateMachine after");
+    System.out.println(stateMachine.prettyPrint());
+  }
+
+  private void initialToFinalDists(StateMachine stateMachine) {
+    for (State finalState : stateMachine.getFinalList()) {
+      System.out.println("initial state "+ stateMachine.getInitial() + " to " + finalState + " in " +
+          stateMachine.getInitial().minDistTo(finalState) + " step(s)");
+    }
+  }
+}

statemachine.task/src/test/java/de/tudresden/inf/st/statemachine/ParserTest.java

+package de.tudresden.inf.st.statemachine;
+
+import beaver.Parser;
+import de.tudresden.inf.st.statemachine.jastadd.model.State;
+import de.tudresden.inf.st.statemachine.jastadd.model.StateMachine;
+import de.tudresden.inf.st.statemachine.jastadd.model.Transition;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.junit.Assert.*;
+
+/**
+ * Testing the statemachine parser.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class ParserTest {
+
+  @Test
+  public void test1() throws IOException, Parser.Exception {
+    StateMachine stateMachine = ParserUtils.load(Paths.get("src", "test", "resources", "machine_one.sm"));
+
+    assertEquals(6, stateMachine.getNumElement());
+    assertEquals(3, stateMachine.states().size());
+    assertEquals(3, stateMachine.transitions().size());
+
+    State s = stateMachine.globallyResolveStateByToken("S");
+    State a = stateMachine.globallyResolveStateByToken("A");
+    State e = stateMachine.globallyResolveStateByToken("E");
+    Transition t1 = stateMachine.globallyResolveTransitionByToken("t1");
+    Transition t2 = stateMachine.globallyResolveTransitionByToken("t2");
+    Transition t3 = stateMachine.globallyResolveTransitionByToken("t3");
+
+    assertNotNull(s);
+    assertNotNull(a);
+    assertNotNull(e);
+
+    assertEquals(s, stateMachine.getInitial());
+    assertEquals(1, stateMachine.getFinalList().size());
+    assertThat("E is not final", stateMachine.getFinalList(), hasItem(e));
+
+    assertNotNull(t1);
+    assertNotNull(t2);
+    assertNotNull(t3);
+
+    // t1: s -> a
+    assertEquals(s, t1.getFrom());
+    assertEquals(a, t1.getTo());
+    // t2: a -> s
+    assertEquals(a, t2.getFrom());
+    assertEquals(s, t2.getTo());
+    // t3: a -> e
+    assertEquals(a, t3.getFrom());
+    assertEquals(e, t3.getTo());
+
+    List<State> outgoingFromS = outgoingConnectedStates(s);
+    List<State> outgoingFromA = outgoingConnectedStates(a);
+    assertThat(outgoingFromS, not(empty()));
+    assertThat(outgoingFromA, not(empty()));
+    assertEquals(1, outgoingFromS.size());
+    assertThat("Transition S -> A missing", outgoingFromS, hasItem(a));
+    assertEquals(2, outgoingFromA.size());
+    assertThat("Transitions A -> S or A -> E missing", outgoingFromA, hasItems(s, e));
+    assertThat(outgoingConnectedStates(e), empty());
+
+    String printedForm = "initial state S;\n" +
+        "state A;\n" +
+        "final state E;\n" +
+        "trans S -> A : t1;\n" +
+        "trans A -> S : t2;\n" +
+        "trans A -> E : t3;\n";
+    assertEquals(printedForm, stateMachine.prettyPrint());
+  }
+
+  private List<State> outgoingConnectedStates(State s) {
+    return s.getOutgoingList().stream().map(Transition::getTo).collect(Collectors.toList());
+  }
+
+}

statemachine.task/src/test/resources/empty.sm

+initial state S;
+state A;
+final state E;
+trans S -> A : t1;
+trans A -> S : t2;
+trans A -> A;
+trans A -> E : t3;

statemachine.task/src/test/resources/machine_one.sm

+initial state S;
+state A;
+final state E;
+trans S -> A : t1;
+trans A -> S : t2;
+trans A -> E : t3;

statemachine.task/src/test/resources/telephone.sm

+initial state start;
+state onHook;
+state dialing;
+state ringing;
+state waitingForConnection;
+state communicating;
+state onHold;
+final state end;
+
+trans start -> onHook : start ;
+trans onHook -> dialing : startDialing ;
+trans dialing -> onHook : hangUp ;
+trans onHook -> ringing : incomingCall ;
+trans ringing -> onHook : otherPartyHangUp ;
+trans dialing -> waitingForConnection : completeNumber ;
+trans waitingForConnection -> onHook : hangUp ;
+trans waitingForConnection -> onHook : timeOut ;
+trans waitingForConnection -> communicating : otherPartyPickUp ;
+trans ringing -> communicating : pickUp ;
+trans communicating -> onHook : hangUp ;
+trans communicating -> onHold : putOnHold ;
+trans onHold -> communicating : takeOffHold ;
+trans communicating -> end : otherPartyHangUp ;
+trans onHold -> end : otherPartyHangUp ;
+trans onHold -> end : hangUp ;