Tests for History states

plugins/org.yakindu.sct.model.sexec/src/org/yakindu/sct/model/sexec/transformation/SequenceBuilder.xtend

@@ -283,11 +283,11 @@ class SequenceBuilder {
 				val seq = sexec.factory.createSequence
 				seq.name = "enterSequence"
 				seq.comment = "enterSequence with history in child " + child.name+" for leaf "+childLeaf.name
-				if (execChild.entryAction != null ) seq.steps += execChild.entryAction.newCall
-				if ( _addTraceSteps ) seq.steps += execChild.newTraceStateEntered
 				if ( execChild.leaf ) {
-					seq.steps += execChild.newEnterStateStep
+					seq.steps += execChild.enterSequence.newCall
 				} else {
+					if (execChild.entryAction != null ) seq.steps += execChild.entryAction.newCall
+					if ( _addTraceSteps ) seq.steps += execChild.newTraceStateEntered
 					for (childRegion : child.regions) {
 						seq.steps += childRegion.defineDeepHistorySwitch(historyRegion)
 					}

plugins/org.yakindu.sct.model.sexec/xtend-gen/org/yakindu/sct/model/sexec/transformation/SequenceBuilder.java

@@ -562,30 +562,33 @@ public class SequenceBuilder {
             String _name_2 = childLeaf.getName();
             String _operator_plus_3 = StringExtensions.operator_plus(_operator_plus_2, _name_2);
             seq.setComment(_operator_plus_3);
-            Step _entryAction = execChild.getEntryAction();
-            boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_entryAction, null);
-            if (_operator_notEquals) {
-              EList<Step> _steps = seq.getSteps();
-              Step _entryAction_1 = execChild.getEntryAction();
-              Call _newCall = this.mapping.newCall(_entryAction_1);
-              CollectionExtensions.<Step>operator_add(_steps, _newCall);
-            }
-            if (this._addTraceSteps) {
-              EList<Step> _steps_1 = seq.getSteps();
-              TraceStateEntered _newTraceStateEntered = this.trace.newTraceStateEntered(execChild);
-              CollectionExtensions.<Step>operator_add(_steps_1, _newTraceStateEntered);
-            }
             boolean _isLeaf = execChild.isLeaf();
             if (_isLeaf) {
-              EList<Step> _steps_2 = seq.getSteps();
-              EnterState _newEnterStateStep = this.sexec.newEnterStateStep(execChild);
-              CollectionExtensions.<Step>operator_add(_steps_2, _newEnterStateStep);
+              EList<Step> _steps = seq.getSteps();
+              Sequence _enterSequence = execChild.getEnterSequence();
+              Call _newCall = this.mapping.newCall(_enterSequence);
+              CollectionExtensions.<Step>operator_add(_steps, _newCall);
             } else {
-              EList<Region> _regions = child.getRegions();
-              for (final Region childRegion : _regions) {
-                EList<Step> _steps_3 = seq.getSteps();
-                StateSwitch _defineDeepHistorySwitch = this.defineDeepHistorySwitch(childRegion, historyRegion);
-                CollectionExtensions.<Step>operator_add(_steps_3, _defineDeepHistorySwitch);
+              {
+                Step _entryAction = execChild.getEntryAction();
+                boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_entryAction, null);
+                if (_operator_notEquals) {
+                  EList<Step> _steps_1 = seq.getSteps();
+                  Step _entryAction_1 = execChild.getEntryAction();
+                  Call _newCall_1 = this.mapping.newCall(_entryAction_1);
+                  CollectionExtensions.<Step>operator_add(_steps_1, _newCall_1);
+                }
+                if (this._addTraceSteps) {
+                  EList<Step> _steps_2 = seq.getSteps();
+                  TraceStateEntered _newTraceStateEntered = this.trace.newTraceStateEntered(execChild);
+                  CollectionExtensions.<Step>operator_add(_steps_2, _newTraceStateEntered);
+                }
+                EList<Region> _regions = child.getRegions();
+                for (final Region childRegion : _regions) {
+                  EList<Step> _steps_3 = seq.getSteps();
+                  StateSwitch _defineDeepHistorySwitch = this.defineDeepHistorySwitch(childRegion, historyRegion);
+                  CollectionExtensions.<Step>operator_add(_steps_3, _defineDeepHistorySwitch);
+                }
               }
             }
             EList<StateCase> _cases = sSwitch.getCases();

test-plugins/org.yakindu.sct.model.sexec.test/src/org/yakindu/sct/model/sexec/transformation/test/Assert.java

@@ -10,18 +10,24 @@ import java.sql.CallableStatement;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 import org.yakindu.sct.model.sexec.Call;
 import org.yakindu.sct.model.sexec.Execution;
 import org.yakindu.sct.model.sexec.ExecutionFlow;
 import org.yakindu.sct.model.sexec.ExecutionState;
 import org.yakindu.sct.model.sexec.ExitState;
+import org.yakindu.sct.model.sexec.HistoryEntry;
+import org.yakindu.sct.model.sexec.Reaction;
+import org.yakindu.sct.model.sexec.SaveHistory;
 import org.yakindu.sct.model.sexec.Sequence;
 import org.yakindu.sct.model.sexec.StateCase;
 import org.yakindu.sct.model.sexec.StateSwitch;
 import org.yakindu.sct.model.sexec.Step;
 import org.yakindu.sct.model.sexec.Trace;
+import org.yakindu.sct.model.sexec.transformation.test.Assert.StepNode;
 import org.yakindu.sct.model.sgraph.State;
 import org.yakindu.sct.model.stext.stext.Assignment;
 import org.yakindu.sct.model.stext.stext.AssignmentOperator;
@@ -184,8 +190,14 @@ public class Assert {
 		return step.toString();
 	}
 
+	public static void assertClass(Class<?> clazz, Object actual) {
+		assertTrue(clazz.getSimpleName() + " expected, but got "
+				+ actual.getClass().getSimpleName(), clazz.isInstance(actual));
+
+	}
+
 	public static void assertedOrder(Step step,
-			List<? extends ExecutionState> currentStates,
+			Collection<? extends ExecutionState> currentStates,
 			List<? extends StepNode> requiredSteps) {
 		assertedOrder_intern(step, currentStates, requiredSteps);
 		if (!requiredSteps.isEmpty()) {
@@ -194,53 +206,78 @@ public class Assert {
 	}
 
 	private static void assertedOrder_intern(Step step,
-			List<? extends ExecutionState> currentStates,
+			Collection<? extends ExecutionState> currentStates,
 			List<? extends StepNode> requiredSteps) {
 		if (requiredSteps.isEmpty()) {
 			return;
 		}
 		boolean found = false;
 
-		if (step == requiredSteps.get(0).step) {
+		Iterable<Step> next = null;
+		if (requiredSteps.get(0).matches(step)) {
 			found = true;
-			StepNode removed = requiredSteps.remove(0);
-			if (removed instanceof StepLeaf) {
+			StepNode matched = requiredSteps.remove(0);
+			if (matched.isLeaf()) {
 				return;
 			}
+			next = matched.next();
 		}
-		if (step instanceof Sequence) {
-			for (Step subStep : ((Sequence) step).getSteps()) {
-				assertedOrder_intern(subStep, currentStates, requiredSteps);
+		if (next == null) {
+			next = findNext(step, currentStates, requiredSteps);
+		}
+		if (next != null) {
+			for (Step s : next) {
+				assertedOrder_intern(s, currentStates, requiredSteps);
 			}
+		} else if (found == false) {
+			fail("Step without match: " + step);
+		}
+	}
+
+	protected static Iterable<Step> findNext(Step step,
+			Collection<? extends ExecutionState> currentStates,
+			List<? extends StepNode> requiredSteps) {
+		if (step instanceof Sequence) {
+			return ((Sequence) step).getSteps();
 		} else if (step instanceof Call) {
-			assertedOrder_intern(((Call) step).getStep(), currentStates,
-					requiredSteps);
+			return Collections.singleton(((Call) step).getStep());
 		} else if (step instanceof StateSwitch) {
 			StateCase stateCase = null;
 			StringBuilder sb = new StringBuilder();
 			for (StateCase caze : ((StateSwitch) step).getCases()) {
 				sb.append(", " + caze.getState().getName());
 				if (stateCase == null
-						&& caze.getState() == currentStates.get(0)) {
-					currentStates.remove(0);
+						&& currentStates.contains(caze.getState())) {
 					stateCase = caze;
 				}
 			}
 			assertNotNull("No state case found for " + currentStates + " in "
 					+ sb.toString(), stateCase);
-			assertedOrder_intern(stateCase.getStep(), currentStates,
-					requiredSteps);
-		} else if (found == false) {
-			fail("Step without match: " + step);
+			return Collections.singleton(stateCase.getStep());
 		}
+		return null;
 	}
 
 	public static class StepNode {
 		public final Step step;
+		protected boolean leaf;
+
+		public boolean matches(Step s) {
+			return s == step;
+		}
+
+		public boolean isLeaf() {
+			return leaf;
+		}
+
+		public Iterable<Step> next() {
+			return null;
+		}
 
 		public StepNode(Step step) {
 			assertNotNull(step);
 			this.step = step;
+			leaf = false;
 		}
 
 		@Override
@@ -252,6 +289,29 @@ public class Assert {
 	public static class StepLeaf extends StepNode {
 		public StepLeaf(Step step) {
 			super(step);
+			leaf = true;
+		}
+	}
+
+	public static class StepHistory extends StepNode {
+		private final boolean history;
+
+		public StepHistory(Step step, boolean withHistory) {
+			super(step);
+			this.history = withHistory;
+			leaf = false;
+			assertClass(HistoryEntry.class, step);
+		}
+
+		@Override
+		public Iterable<Step> next() {
+			if (history) {
+				return Collections.singleton(((HistoryEntry) step)
+						.getHistoryStep());
+			} else {
+				return Collections.singleton(((HistoryEntry) step)
+						.getInitialStep());
+			}
 		}
 	}
 }

test-plugins/org.yakindu.sct.model.sexec.test/src/org/yakindu/sct/model/sexec/transformation/test/HistoryTest.java

@@ -0,0 +1,279 @@
+package org.yakindu.sct.model.sexec.transformation.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.TYPE_INTEGER;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createEntry;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createEntryAssignment;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createInterfaceScope;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createRegion;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createState;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createStatechart;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createTransition;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._createVariableDefinition;
+import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.findState;
+
+import java.util.ArrayList;
+
+import org.eclipse.emf.common.util.EList;
+import org.junit.Test;
+import org.yakindu.sct.model.sexec.ExecutionEntry;
+import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.model.sexec.ExecutionNode;
+import org.yakindu.sct.model.sexec.ExecutionRegion;
+import org.yakindu.sct.model.sexec.ExecutionState;
+import org.yakindu.sct.model.sexec.HistoryEntry;
+import org.yakindu.sct.model.sexec.Reaction;
+import org.yakindu.sct.model.sexec.SaveHistory;
+import org.yakindu.sct.model.sexec.Sequence;
+import org.yakindu.sct.model.sexec.Step;
+import org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.MinimalTSC;
+import org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.InitializingTSC;
+import org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.OrthogonalFlatTSC;
+import org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.SimpleFlatTSC;
+import org.yakindu.sct.model.sgraph.Entry;
+import org.yakindu.sct.model.sgraph.EntryKind;
+import org.yakindu.sct.model.sgraph.Region;
+import org.yakindu.sct.model.sgraph.State;
+import org.yakindu.sct.model.sgraph.Statechart;
+import org.yakindu.sct.model.sgraph.Transition;
+import org.yakindu.sct.model.stext.stext.AssignmentOperator;
+import org.yakindu.sct.model.stext.stext.InterfaceScope;
+import org.yakindu.sct.model.stext.stext.VariableDefinition;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+public class HistoryTest extends ModelSequencerTest {
+
+	@Test
+	public void testTransitionSave() {
+		Statechart sc = _createStatechart("sc");
+		{
+			InterfaceScope s_scope = _createInterfaceScope("Interface", sc);
+			VariableDefinition v1 = _createVariableDefinition("v1",
+					TYPE_INTEGER, s_scope);
+			Region r = _createRegion("r", sc);
+			{
+				Entry r_entry = _createEntry(EntryKind.INITIAL, null, r);
+				State s1 = _createState("s1", r);
+				State s2 = _createState("s2", r);
+				{
+					_createEntryAssignment(v1, s2, 3);
+					Region r2 = _createRegion("r2", s2);
+					{
+						Entry e = _createEntry(EntryKind.INITIAL, null, r2);
+						Entry history = _createEntry(EntryKind.SHALLOW_HISTORY,
+								"history", r2);
+
+						State s3 = _createState("s3", r2);
+						{
+							_createEntryAssignment(v1, s3, 4);
+						}
+						State s4 = _createState("s4", r2);
+						{
+							Region r4 = _createRegion("r4", s4);
+							{
+								Entry e4 = _createEntry(EntryKind.INITIAL,
+										null, r2);
+								State s5 = _createState("s5", r4);
+								_createTransition(e4, s5);
+								_createTransition(s5, s1);
+							}
+						}
+						_createTransition(e, s3);
+						_createTransition(history, s3);
+						_createTransition(s3, s4);
+						_createTransition(s1, history);
+					}
+				}
+				_createTransition(r_entry, s1);
+				_createTransition(s1, s2);
+			}
+		}
+
+		ExecutionFlow flow = sequencer.transform(sc);
+
+		ExecutionState _s2 = flow.getStates().get(1);
+		assertEquals("sc.r.s2", _s2.getName());
+		ExecutionState _s3 = flow.getStates().get(2);
+		assertEquals("sc.r.s2.r2.s3", _s3.getName());
+		ExecutionState _s4 = flow.getStates().get(3);
+		assertEquals("sc.r.s2.r2.s4", _s4.getName());
+		ExecutionState _s5 = flow.getStates().get(4);
+		assertEquals("sc.r.s2.r2.s4.r4.s5", _s5.getName());
+		ExecutionNode e = flow.getNodes().get(2);
+		assertTrue(e.eClass().getName(), e instanceof ExecutionEntry);
+		Reaction regionLeave = _s5.getReactions().get(0);
+		Sequence sequence = assertedSequence(regionLeave.getEffect());
+		assertCall(sequence, 0, _s2.getExitSequence());
+		assertClass(SaveHistory.class, _s3.getSuperScope().getExitSequence()
+				.getSteps().get(0));
+
+	}
+
+	@Test
+	public void testShallowHistory() {
+		Statechart sc = _createStatechart("sc");
+		{
+			InterfaceScope s_scope = _createInterfaceScope("Interface", sc);
+			VariableDefinition v1 = _createVariableDefinition("v1",
+					TYPE_INTEGER, s_scope);
+			Region r = _createRegion("r", sc);
+			{
+				Entry r_entry = _createEntry(EntryKind.INITIAL, null, r);
+				State s1 = _createState("s1", r);
+				State s2 = _createState("s2", r);
+				{
+					_createEntryAssignment(v1, s2, 3);
+					Region r2 = _createRegion("r2", s2);
+					{
+						Entry e = _createEntry(EntryKind.INITIAL, null, r2);
+						Entry history = _createEntry(EntryKind.SHALLOW_HISTORY,
+								"history", r2);
+
+						State s3 = _createState("s3", r2);
+						{
+							_createEntryAssignment(v1, s3, 4);
+						}
+						State s4 = _createState("s4", r2);
+						{
+							Region r4 = _createRegion("r4", s4);
+							{
+								Entry e4 = _createEntry(EntryKind.INITIAL,
+										null, r2);
+								State s5 = _createState("s5", r4);
+								_createTransition(e4, s5);
+								_createTransition(s5, s1);
+							}
+						}
+						_createTransition(e, s3);
+						_createTransition(history, s3);
+						_createTransition(s3, s4);
+						_createTransition(s1, history);
+					}
+				}
+				_createTransition(r_entry, s1);
+				_createTransition(s1, s2);
+			}
+		}
+
+		ExecutionFlow flow = sequencer.transform(sc);
+
+		ExecutionState _s3 = flow.getStates().get(2);
+		assertEquals("sc.r.s2.r2.s3", _s3.getName());
+		ExecutionState _s4 = flow.getStates().get(3);
+		assertEquals("sc.r.s2.r2.s4", _s4.getName());
+		ExecutionState _s5 = flow.getStates().get(4);
+		assertEquals("sc.r.s2.r2.s4.r4.s5", _s5.getName());
+		ExecutionNode e = flow.getNodes().get(2);
+		assertTrue(e.eClass().getName(), e instanceof ExecutionEntry);
+
+		Sequence reactSequence = e.getReactSequence();
+
+		assertEquals(
+				"Default react sequence for shallow history entry history",
+				reactSequence.getComment());
+		Step historyEntry = reactSequence.getSteps().get(0);
+		assertTrue(historyEntry.eClass().getName(),
+				historyEntry instanceof HistoryEntry);
+
+		assertedOrder(reactSequence, Sets.newHashSet(_s3), Lists.newArrayList(//
+				new StepHistory(historyEntry, false), //
+				new StepLeaf(_s3.getEnterSequence()) //
+				));
+		assertedOrder(reactSequence, Sets.newHashSet(_s3), Lists.newArrayList(//
+				new StepHistory(historyEntry, true), //
+				new StepLeaf(_s3.getEnterSequence()) //
+				));
+		assertedOrder(reactSequence, Sets.newHashSet(_s5), Lists.newArrayList(//
+				new StepHistory(historyEntry, true), //
+				new StepLeaf(_s4.getEnterSequence()) //
+				));
+	}
+
+	@Test
+	public void testDeepHistory() {
+		Statechart sc = _createStatechart("sc");
+		{
+			InterfaceScope s_scope = _createInterfaceScope("Interface", sc);
+			VariableDefinition v1 = _createVariableDefinition("v1",
+					TYPE_INTEGER, s_scope);
+			Region r = _createRegion("r", sc);
+			{
+				Entry r_entry = _createEntry(EntryKind.INITIAL, null, r);
+				State s1 = _createState("s1", r);
+				State s2 = _createState("s2", r);
+				{
+					_createEntryAssignment(v1, s2, 3);
+					Region r2 = _createRegion("r2", s2);
+					{
+						Entry e = _createEntry(EntryKind.INITIAL, null, r2);
+						Entry history = _createEntry(EntryKind.DEEP_HISTORY,
+								"history", r2);
+
+						State s3 = _createState("s3", r2);
+						{
+							_createEntryAssignment(v1, s3, 4);
+						}
+						State s4 = _createState("s4", r2);
+						{
+							_createEntryAssignment(v1, s4, 6);
+							Region r4 = _createRegion("r4", s4);
+							{
+								Entry e4 = _createEntry(EntryKind.INITIAL,
+										null, r2);
+								State s5 = _createState("s5", r4);
+								_createTransition(e4, s5);
+							}
+						}
+						_createTransition(e, s3);
+						_createTransition(history, s3);
+						_createTransition(s3, s4);
+						_createTransition(s1, history);
+					}
+				}
+				_createTransition(r_entry, s1);
+				_createTransition(s1, s2);
+			}
+		}
+
+		ExecutionFlow flow = sequencer.transform(sc);
+
+		ExecutionState _s3 = flow.getStates().get(2);
+		assertEquals("sc.r.s2.r2.s3", _s3.getName());
+		ExecutionState _s4 = flow.getStates().get(3);
+		assertEquals("sc.r.s2.r2.s4", _s4.getName());
+		ExecutionState _s5 = flow.getStates().get(4);
+		assertEquals("sc.r.s2.r2.s4.r4.s5", _s5.getName());
+		ExecutionNode e = flow.getNodes().get(2);
+		assertTrue(e.eClass().getName(), e instanceof ExecutionEntry);
+
+		Sequence reactSequence = e.getReactSequence();
+
+		assertEquals("Default react sequence for deep history entry history",
+				reactSequence.getComment());
+		Step historyEntry = reactSequence.getSteps().get(0);
+		assertTrue(historyEntry.eClass().getName(),
+				historyEntry instanceof HistoryEntry);
+
+		assertedOrder(reactSequence, Sets.newHashSet(_s3), Lists.newArrayList(//
+				new StepHistory(historyEntry, false), //
+				new StepLeaf(_s3.getEnterSequence()) //
+				));
+		assertedOrder(reactSequence, Sets.newHashSet(_s3), Lists.newArrayList(//
+				new StepHistory(historyEntry, true), //
+				new StepLeaf(_s3.getEnterSequence()) //
+				));
+		assertedOrder(reactSequence, Sets.newHashSet(_s5), Lists.newArrayList(//
+				new StepHistory(historyEntry, true), //
+				new StepLeaf(_s4.getEntryAction()),//
+				new StepLeaf(_s5.getEnterSequence()) //
+				));
+		// assertCall(assertedSequence(tr0.getEffect()), 0,
+		// _s2.getEnterSequence());
+	}
+
+}

test-plugins/org.yakindu.sct.model.sexec.test/src/org/yakindu/sct/model/sexec/transformation/test/ModelSequencerOrthogonalityTest.java

@@ -22,6 +22,7 @@ import org.yakindu.sct.model.stext.stext.InterfaceScope;
 import org.yakindu.sct.model.stext.stext.VariableDefinition;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 
 public class ModelSequencerOrthogonalityTest extends ModelSequencerTest {
 
@@ -1219,7 +1220,7 @@ public class ModelSequencerOrthogonalityTest extends ModelSequencerTest {
 		assertEquals("wrong steps: " + stepListAsString(_exit), 2, _exit
 				.getSteps().size());
 
-		assertedOrder(_exit, Lists.newArrayList(_s1a1a1a, _s1a1a2a, _s1a2a1a,
+		assertedOrder(_exit, Sets.newHashSet(_s1a1a1a, _s1a1a2a, _s1a2a1a,
 				_s1a2a2a, _s2a1a1a, _s2a1a2a, _s2a2a1a, _s2a2a2a),
 				Lists.newArrayList(new StepLeaf(_s1a1a1a.getExitSequence()),
 						new StepLeaf(_s1a1a2a.getExitSequence()), //